From 3f0a93ac1d411f64ef312101b030f8a5413c6278 Mon Sep 17 00:00:00 2001 From: mojianjjun Date: Wed, 11 Nov 2026 14:38:15 +0800 Subject: [PATCH] feat(db-connector): add read-only MySQL/PostgreSQL/MongoDB connector plugin --- external_plugins/db-connector/.mcp.json | 8 + .../db-connector/.zcode-plugin/plugin.json | 16 + external_plugins/db-connector/LICENSE | 201 + external_plugins/db-connector/README.md | 141 + external_plugins/db-connector/README_CN.md | 141 + .../mcp/dist/db-connect-server.bundle.cjs | 59177 ++++++++++++++++ .../db-connector/mcp/package-lock.json | 959 + .../db-connector/mcp/package.json | 26 + .../db-connector/mcp/src/config.ts | 420 + .../db-connector/mcp/src/db-connect-server.ts | 111 + .../db-connector/mcp/src/drivers.ts | 372 + .../db-connector/mcp/src/sqlguard.ts | 133 + .../db-connector/mcp/src/tools.ts | 343 + .../mcp/test/check-official-rules.py | 127 + .../db-connector/mcp/test/real-mysql.mjs | 226 + .../db-connector/mcp/test/smoke.mjs | 192 + .../db-connector/mcp/tsconfig.json | 17 + .../db-connector/skills/db-connector/SKILL.md | 55 + marketplace.json | 22 + 19 files changed, 62687 insertions(+) create mode 100644 external_plugins/db-connector/.mcp.json create mode 100644 external_plugins/db-connector/.zcode-plugin/plugin.json create mode 100644 external_plugins/db-connector/LICENSE create mode 100644 external_plugins/db-connector/README.md create mode 100644 external_plugins/db-connector/README_CN.md create mode 100644 external_plugins/db-connector/mcp/dist/db-connect-server.bundle.cjs create mode 100644 external_plugins/db-connector/mcp/package-lock.json create mode 100644 external_plugins/db-connector/mcp/package.json create mode 100644 external_plugins/db-connector/mcp/src/config.ts create mode 100644 external_plugins/db-connector/mcp/src/db-connect-server.ts create mode 100644 external_plugins/db-connector/mcp/src/drivers.ts create mode 100644 external_plugins/db-connector/mcp/src/sqlguard.ts create mode 100644 external_plugins/db-connector/mcp/src/tools.ts create mode 100644 external_plugins/db-connector/mcp/test/check-official-rules.py create mode 100644 external_plugins/db-connector/mcp/test/real-mysql.mjs create mode 100644 external_plugins/db-connector/mcp/test/smoke.mjs create mode 100644 external_plugins/db-connector/mcp/tsconfig.json create mode 100644 external_plugins/db-connector/skills/db-connector/SKILL.md diff --git a/external_plugins/db-connector/.mcp.json b/external_plugins/db-connector/.mcp.json new file mode 100644 index 00000000..5b97622b --- /dev/null +++ b/external_plugins/db-connector/.mcp.json @@ -0,0 +1,8 @@ +{ + "mcpServers": { + "db-connector": { + "command": "node", + "args": ["${ZCODE_PLUGIN_ROOT}/mcp/dist/db-connect-server.bundle.cjs"] + } + } +} diff --git a/external_plugins/db-connector/.zcode-plugin/plugin.json b/external_plugins/db-connector/.zcode-plugin/plugin.json new file mode 100644 index 00000000..ba04d30f --- /dev/null +++ b/external_plugins/db-connector/.zcode-plugin/plugin.json @@ -0,0 +1,16 @@ +{ + "name": "db-connector", + "version": "0.1.2", + "description": "Read-only access to MySQL/PostgreSQL/MongoDB: multi-environment connections, parameter-bound safe queries and schema browsing", + "description_i18n": { + "en": "Read-only access to MySQL/PostgreSQL/MongoDB: multi-environment connections, parameter-bound safe queries and schema browsing", + "zh-CN": "只读连接 MySQL/PostgreSQL/MongoDB：多环境多连接配置、参数绑定安全查询与结构浏览" + }, + "author": { "name": "mojianjjun" }, + "license": "Apache-2.0", + "repository": "https://github.com/mojianjjun/zcode-plugins", + "homepage": "https://github.com/mojianjjun/zcode-plugins/tree/main/db-connector", + "keywords": ["database", "mysql", "postgresql", "mongodb", "readonly", "mcp"], + "mcpServers": "./.mcp.json", + "skills": "./skills" +} diff --git a/external_plugins/db-connector/LICENSE b/external_plugins/db-connector/LICENSE new file mode 100644 index 00000000..e588f4db --- /dev/null +++ b/external_plugins/db-connector/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2026 mojianjjun + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/external_plugins/db-connector/README.md b/external_plugins/db-connector/README.md new file mode 100644 index 00000000..91a5c500 --- /dev/null +++ b/external_plugins/db-connector/README.md @@ -0,0 +1,141 @@ +# db-connector + +English | [简体中文](README_CN.md) + +A ZCode plugin that lets the AI safely connect to databases in the session for **read-only** queries and schema browsing. + +- Databases: **MySQL / MariaDB, PostgreSQL, MongoDB** +- Composition: MCP server (10 tools) + a Skill with usage guidance +- Multi-environment, multi-connection: group connections by environment (dev/test/prod...), mixing database types freely +- Security: strict read-only statement whitelist, mandatory parameter binding, passwords stored only as environment-variable references, row/time limits +- Self-contained: the MCP server ships as a single bundled file — no `npm install` needed after installation + +## Installation + +Install via the plugin marketplace (requires Node.js ≥ 18; ZCode launches it as an MCP server). + +## Quick Start + +Just talk to the AI after installation, for example: + +> "Use db-connector to add a MySQL connection: environment dev, name mysql-main, database shop, password in the DB_DEV_PW environment variable." +> +> "List all tables in the dev environment." +> +> "Count daily orders for last month." + +## Connection Configuration + +### Option 1: conversational setup (recommended) + +The AI calls `db_add_connection` for you. Passwords accept a **variable name only** (written as a `${VAR}` reference; plaintext passwords are rejected). Variables are defined in `.env` files (system environment variables are never read): + +```bash +# Location: workspace .env or user-level ~/.zcode/db-connector/.env +DB_DEV_PW=your-password +DB_PROD_PW="quote passwords containing spaces or # characters" +``` + +`${VAR}` resolution order: **workspace `.env` > user-level `.env`**. The `.env` files are re-read on every tool call — saving is enough, no restart needed. Remember to gitignore the workspace `.env`. + +### Option 2: edit the config file directly + +Workspace-level `/db-connections.json` (per project) or user-level `~/.zcode/db-connector/connections.json` (across projects). Both may coexist; they are merged by "environment name + connection name" with the workspace taking precedence: + +```json +{ + "configVersion": 1, + "activeEnvironment": "dev", + "defaults": { "rowLimit": 200, "maxRowLimit": 1000, "timeoutMs": 10000 }, + "environments": { + "dev": { + "description": "local development", + "connections": { + "mysql-main": { + "type": "mysql", "host": "localhost", "port": 3306, + "user": "root", "password": "${DB_DEV_PW}", "database": "shop" + }, + "pg-analytics": { + "type": "postgres", + "url": "postgresql://report:${DB_PG_PW}@10.0.0.8:5432/analytics" + }, + "logs-mongo": { + "type": "mongodb", + "url": "mongodb://user:${DB_MONGO_PW}@host:27017/logs" + } + } + }, + "prod": { + "description": "production", + "protected": true, + "connections": { + "mysql-main": { "type": "mysql", "host": "10.0.0.2", "user": "ro_user", + "password": "${DB_PROD_PW}", "database": "shop" } + } + } + } +} +``` + +- Connection references: `"mysql-main"` (active environment) or `"prod/mysql-main"` (explicit cross-environment) +- Queries against `protected: true` environments carry a prominent protected-environment banner +- Password `${VAR}` resolution order: workspace `.env` > `~/.zcode/db-connector/.env` (system environment variables are not read) + +## MCP Tools + +| Category | Tool | Description | +|----------|------|-------------| +| Config | `db_list_connections` | List connections by environment (masked) | +| Config | `db_add_connection` | Add a connection (password accepts a variable name only) | +| Config | `db_remove_connection` | Remove a connection | +| Config | `db_set_active_environment` | Switch the active environment | +| Query | `db_test_connection` | Connectivity test | +| Query | `db_list_tables` | Table/collection listing with row estimates | +| Query | `db_describe_table` | Columns/types/keys/indexes (inferred by sampling for Mongo) | +| Query | `db_query` | Read-only SQL (MySQL `?` / PG `$1` parameter binding) | +| Query | `db_find` | MongoDB read-only queries | +| Query | `db_aggregate` | MongoDB aggregation ($out/$merge rejected) | + +## Security Model + +1. **Read-only whitelist**: only single `SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / DESC` statements pass; write/DDL keywords, multi-statements, locking clauses and dangerous functions (file access/delays/cross-database execution) are rejected even inside subqueries or comments +2. **Mandatory parameter binding**: query values go through `params` only; the server never concatenates values into SQL +3. **No secrets at rest**: configs store only `${ENV_VAR}` references; tool output and logs are masked throughout +4. **Resource protection**: row limits and timeouts are configurable at three levels (`defaults` → connection → query parameter), with a hard `maxRowLimit` ceiling +5. For best results, use **read-only database accounts** for every environment + +## Row Limit & Timeout Configuration + +| Level | Location | Default | +|-------|----------|---------| +| Global default | `defaults.rowLimit` / `defaults.timeoutMs` | 200 / 10000ms | +| Connection override | `rowLimit` / `timeoutMs` in a connection object | inherits global | +| Per-query | tool parameter `limit` | capped by `maxRowLimit` (default 1000) | + +## Known Limitations + +- Query-only by design; no write/DDL capability at all +- The keyword whitelist may occasionally reject a legitimate query whose column names contain reserved words (e.g. a column named `set`); quote/alias the column and retry +- Large result sets are buffered by the driver then truncated; `timeoutMs` is the final backstop + +## Disclosure + +- **Network**: outbound connections are made only to the database hosts the user configures (MySQL/PostgreSQL/MongoDB ports); the plugin makes no other network calls +- **Process**: ZCode starts one MCP server process via `node mcp/dist/db-connect-server.bundle.cjs` (stdio) +- **File writes**: only `~/.zcode/db-connector/connections.json`, `~/.zcode/db-connector/.env`, and the workspace-level `db-connections.json` / `.env`; nothing else is written +- **Secrets**: passwords are never stored in plaintext — only `${ENV_VAR}` references resolved from `.env` files at call time +- **Third-party code**: the bundle embeds [mysql2](https://github.com/sidorares/node-mysql2) (MIT), [node-postgres](https://github.com/brianc/node-postgres) (MIT) and the [MongoDB Node driver](https://github.com/mongodb/node-mongodb-native) (Apache-2.0); their license notices are kept inline in the bundled file + +## Development + +```bash +cd mcp +npm install +npm run build # tsc compile to dist/ +npm run bundle # rebuild the self-contained dist/db-connect-server.bundle.cjs +npm test # smoke tests (no real database needed) +``` + +## License + +[Apache-2.0](LICENSE) diff --git a/external_plugins/db-connector/README_CN.md b/external_plugins/db-connector/README_CN.md new file mode 100644 index 00000000..ea6ec1a9 --- /dev/null +++ b/external_plugins/db-connector/README_CN.md @@ -0,0 +1,141 @@ +# db-connector + +[English](README.md) | 简体中文 + +ZCode 插件：让 AI 在会话中安全连接数据库，执行**只读**查询与结构浏览。 + +- 支持数据库：**MySQL / MariaDB、PostgreSQL、MongoDB** +- 插件形式：MCP 服务器（10 个工具）+ Skill 使用指导 +- 多环境多连接：dev/test/prod 等环境分组，每个环境可混合多种数据库 +- 安全：严格只读白名单校验、参数绑定强制、密码仅环境变量引用、行数/超时上限 +- 自包含：MCP 服务器以单文件 bundle 分发，安装后**无需 npm install** + +## 安装 + +通过插件市场安装本插件（依赖 Node.js ≥ 18，由 ZCode 作为 MCP 服务器启动）。 + +## 快速开始 + +安装后直接对话即可，例如： + +> "用 db-connector 帮我添加一个 MySQL 连接：环境 dev、名字 mysql-main、库 shop，密码放环境变量 DB_DEV_PW。" +> +> "列出 dev 环境所有的表。" +> +> "统计上个月每天的订单量。" + +## 连接配置 + +### 方式一：对话配置（推荐） + +AI 调用 `db_add_connection` 完成配置。密码只接受**变量名**（写入为 `${VAR}` 引用，插件拒绝明文密码），变量统一在 `.env` 文件中定义（系统环境变量不参与解析）： + +```bash +# 位置：工作区 .env 或用户级 ~/.zcode/db-connector/.env +DB_DEV_PW=你的密码 +DB_PROD_PW="带空格 或 #符号 的密码请加引号" +``` + +`${VAR}` 解析优先级：**工作区 `.env` > 用户级 `.env`**。`.env` 每次工具调用都会重新读取、保存即生效；工作区 `.env` 记得加入 `.gitignore`。 + +### 方式二：直接编辑配置文件 + +工作区级 `/db-connections.json`（项目相关）或用户级 `~/.zcode/db-connector/connections.json`（跨项目），两者可并存，按"环境名+连接名"合并，工作区优先： + +```json +{ + "configVersion": 1, + "activeEnvironment": "dev", + "defaults": { "rowLimit": 200, "maxRowLimit": 1000, "timeoutMs": 10000 }, + "environments": { + "dev": { + "description": "本地开发", + "connections": { + "mysql-main": { + "type": "mysql", "host": "localhost", "port": 3306, + "user": "root", "password": "${DB_DEV_PW}", "database": "shop" + }, + "pg-analytics": { + "type": "postgres", + "url": "postgresql://report:${DB_PG_PW}@10.0.0.8:5432/analytics" + }, + "logs-mongo": { + "type": "mongodb", + "url": "mongodb://user:${DB_MONGO_PW}@host:27017/logs" + } + } + }, + "prod": { + "description": "生产环境", + "protected": true, + "connections": { + "mysql-main": { "type": "mysql", "host": "10.0.0.2", "user": "ro_user", + "password": "${DB_PROD_PW}", "database": "shop" } + } + } + } +} +``` + +- 工具的连接引用：`"mysql-main"`（活动环境）或 `"prod/mysql-main"`（显式跨环境） +- `protected: true` 环境的查询结果会附带醒目的受保护环境提示 +- 密码 `${VAR}` 引用的解析优先级：工作区 `.env` > `~/.zcode/db-connector/.env`（不读取系统环境变量） + +## MCP 工具 + +| 类别 | 工具 | 说明 | +|------|------|------| +| 配置 | `db_list_connections` | 按环境列出连接（脱敏） | +| 配置 | `db_add_connection` | 新增连接（密码只收环境变量名） | +| 配置 | `db_remove_connection` | 删除连接 | +| 配置 | `db_set_active_environment` | 切换活动环境 | +| 查询 | `db_test_connection` | 连通性测试 | +| 查询 | `db_list_tables` | 表/集合列表与行数估计 | +| 查询 | `db_describe_table` | 列/类型/键/索引（Mongo 采样推断） | +| 查询 | `db_query` | 只读 SQL（MySQL `?` / PG `$1` 参数绑定） | +| 查询 | `db_find` | MongoDB 只读查询 | +| 查询 | `db_aggregate` | MongoDB 聚合（拒绝 $out/$merge） | + +## 安全模型 + +1. **只读白名单**：仅放行单条 `SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / DESC`；写/DDL 关键词、多语句、锁定子句、危险函数（文件读写/延时/跨库执行）即使出现在子查询或注释中也被拒绝 +2. **参数绑定强制**：查询值只能经 `params` 传入，服务器代码不做任何 SQL 值拼接 +3. **凭证不落盘**：配置只存 `${ENV_VAR}` 引用；工具输出与日志全程脱敏 +4. **资源保护**：行数与超时三层可配置（`defaults` → 连接级 → 查询参数），`maxRowLimit` 硬上限 +5. 建议为每个环境使用**只读数据库账号**，效果最佳 + +## 行数与超时配置 + +| 层级 | 位置 | 缺省 | +|------|------|------| +| 全局默认 | `defaults.rowLimit` / `defaults.timeoutMs` | 200 / 10000ms | +| 连接覆盖 | 连接对象内 `rowLimit` / `timeoutMs` | 继承全局 | +| 查询临时 | 工具参数 `limit` | 受 `maxRowLimit`（缺省 1000）封顶 | + +## 已知限制 + +- 仅查询数据，不含任何写入/DDL 能力（设计如此） +- 关键词白名单可能误伤个别含保留词列名的合法查询（如名为 `set` 的列），可给列名加引号别名后重试 +- 大结果集会在驱动层缓冲后截断，超时由 `timeoutMs` 兜底 + +## 副作用披露 + +- **网络**：仅向用户配置的数据库地址（MySQL/PostgreSQL/MongoDB 端口）发起出站连接，不访问任何其他网络 +- **进程**：ZCode 通过 `node mcp/dist/db-connect-server.bundle.cjs` 启动一个 MCP 服务器进程（stdio） +- **文件写入**：仅写入 `~/.zcode/db-connector/connections.json`、`~/.zcode/db-connector/.env` 及工作区级 `db-connections.json` / `.env`，不写其他任何文件 +- **凭证**：密码永不以明文存储——仅存 `${ENV_VAR}` 引用，调用时从 `.env` 解析 +- **第三方代码**：bundle 内联了 [mysql2](https://github.com/sidorares/node-mysql2)（MIT）、[node-postgres](https://github.com/brianc/node-postgres)（MIT）与 [MongoDB Node 驱动](https://github.com/mongodb/node-mongodb-native)（Apache-2.0），许可证声明保留在 bundle 文件内 + +## 开发 + +```bash +cd mcp +npm install +npm run build # tsc 编译到 dist/ +npm run bundle # 重新生成自包含的 dist/db-connect-server.bundle.cjs +npm test # 冒烟测试（无需真实数据库） +``` + +## 许可 + +[Apache-2.0](LICENSE) diff --git a/external_plugins/db-connector/mcp/dist/db-connect-server.bundle.cjs b/external_plugins/db-connector/mcp/dist/db-connect-server.bundle.cjs new file mode 100644 index 00000000..b12c8bb2 --- /dev/null +++ b/external_plugins/db-connector/mcp/dist/db-connect-server.bundle.cjs @@ -0,0 +1,59177 @@ +"use strict"; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __commonJS = (cb, mod) => function __require() { + try { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + } catch (e) { + throw mod = 0, e; + } +}; + +// dist/config.js +var require_config = __commonJS({ + "dist/config.js"(exports2) { + "use strict"; + var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]); + } + __setModuleDefault2(result, mod); + return result; + }; + })(); + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DEFAULT_TIMEOUT_MS = exports2.DEFAULT_MAX_ROW_LIMIT = exports2.DEFAULT_ROW_LIMIT = exports2.DB_TYPES = void 0; + exports2.emptyConfigFile = emptyConfigFile; + exports2.findWorkspaceConfigPath = findWorkspaceConfigPath; + exports2.userConfigPath = userConfigPath; + exports2.parseEnvFile = parseEnvFile; + exports2.findWorkspaceEnvPath = findWorkspaceEnvPath; + exports2.userEnvPath = userEnvPath; + exports2.loadEnvVars = loadEnvVars; + exports2.mergeConfigFiles = mergeConfigFiles; + exports2.loadMergedConfig = loadMergedConfig; + exports2.resolveEnvPlaceholders = resolveEnvPlaceholders; + exports2.resolveConnectionRef = resolveConnectionRef; + exports2.validateIdentifier = validateIdentifier; + exports2.sanitizeConnectionForWrite = sanitizeConnectionForWrite; + exports2.persistAddConnection = persistAddConnection; + exports2.persistRemoveConnection = persistRemoveConnection; + exports2.persistSetActiveEnvironment = persistSetActiveEnvironment; + exports2.maskConnection = maskConnection; + var fs = __importStar2(require("fs")); + var path = __importStar2(require("path")); + var os = __importStar2(require("os")); + exports2.DB_TYPES = ["mysql", "postgres", "mongodb"]; + exports2.DEFAULT_ROW_LIMIT = 200; + exports2.DEFAULT_MAX_ROW_LIMIT = 1e3; + exports2.DEFAULT_TIMEOUT_MS = 1e4; + var ENV_REF_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/; + function emptyConfigFile() { + return { configVersion: 1, environments: {} }; + } + function findWorkspaceConfigPath(startDir = process.cwd()) { + let dir = path.resolve(startDir); + for (let i = 0; i < 4; i++) { + const candidate = path.join(dir, "db-connections.json"); + if (fs.existsSync(candidate)) + return candidate; + const parent = path.dirname(dir); + if (parent === dir) + break; + dir = parent; + } + return path.join(path.resolve(startDir), "db-connections.json"); + } + function userConfigPath() { + return path.join(os.homedir(), ".zcode", "db-connector", "connections.json"); + } + function parseEnvFile(content) { + const out = {}; + for (let line of content.split(/\r?\n/)) { + line = line.trim(); + if (!line || line.startsWith("#")) + continue; + if (line.startsWith("export ")) + line = line.slice(7).trim(); + const eq = line.indexOf("="); + if (eq <= 0) + continue; + const key = line.slice(0, eq).trim(); + if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) + continue; + let value = line.slice(eq + 1).trim(); + if (value.startsWith('"') && value.endsWith('"') && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) { + value = value.slice(1, -1); + } else { + const hash = value.indexOf(" #"); + if (hash >= 0) + value = value.slice(0, hash).trimEnd(); + } + out[key] = value; + } + return out; + } + function findWorkspaceEnvPath(startDir = process.cwd()) { + let dir = path.resolve(startDir); + for (let i = 0; i < 4; i++) { + const candidate = path.join(dir, ".env"); + if (fs.existsSync(candidate)) + return candidate; + const parent = path.dirname(dir); + if (parent === dir) + break; + dir = parent; + } + return null; + } + function userEnvPath() { + return path.join(os.homedir(), ".zcode", "db-connector", ".env"); + } + function loadEnvVars(startDir = process.cwd()) { + const sources = []; + const vars = {}; + for (const file of [userEnvPath(), findWorkspaceEnvPath(startDir)]) { + if (!file || !fs.existsSync(file)) + continue; + try { + Object.assign(vars, parseEnvFile(fs.readFileSync(file, "utf8"))); + sources.push(file); + } catch { + } + } + return { vars, sources }; + } + function readFileIfExists(file) { + if (!fs.existsSync(file)) + return null; + let raw; + try { + raw = fs.readFileSync(file, "utf8"); + } catch (e) { + throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file}\uFF1A${e.message}`); + } + if (!raw.trim()) + return null; + try { + const parsed = JSON.parse(raw); + if (!parsed || typeof parsed !== "object" || typeof parsed.environments !== "object" || parsed.environments === null) { + throw new Error("\u7F3A\u5C11 environments \u5BF9\u8C61"); + } + return parsed; + } catch (e) { + throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${file} \u4E0D\u662F\u5408\u6CD5 JSON \u6216\u7ED3\u6784\u4E0D\u7B26\uFF1A${e.message}`); + } + } + function atomicWrite(file, data) { + const dir = path.dirname(file); + fs.mkdirSync(dir, { recursive: true }); + const tmp = path.join(dir, `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`); + fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", "utf8"); + fs.renameSync(tmp, file); + } + function mergeDefaults(ws, us) { + const d = { ...us, ...ws }; + return { + rowLimit: d.rowLimit ?? exports2.DEFAULT_ROW_LIMIT, + maxRowLimit: d.maxRowLimit ?? exports2.DEFAULT_MAX_ROW_LIMIT, + timeoutMs: d.timeoutMs ?? exports2.DEFAULT_TIMEOUT_MS + }; + } + function mergeConfigFiles(ws, us) { + const environments = {}; + for (const [name, env] of Object.entries(us?.environments ?? {})) { + environments[name] = { ...env, connections: { ...env.connections } }; + } + for (const [name, env] of Object.entries(ws?.environments ?? {})) { + const base = environments[name] ?? { connections: {} }; + environments[name] = { + ...base, + ...env, + connections: { ...base.connections, ...env.connections } + }; + } + const activeEnvironment = ws?.activeEnvironment ?? us?.activeEnvironment; + return { activeEnvironment, defaults: mergeDefaults(ws?.defaults, us?.defaults), environments }; + } + function loadMergedConfig(startDir = process.cwd()) { + const workspacePath = findWorkspaceConfigPath(startDir); + const userPath = userConfigPath(); + const workspaceFile = readFileIfExists(workspacePath); + const userFile = readFileIfExists(userPath); + const merged = mergeConfigFiles(workspaceFile, userFile); + const { vars, sources } = loadEnvVars(startDir); + return { workspacePath, userPath, workspaceFile, userFile, ...merged, env: vars, envSources: sources }; + } + function resolveEnvPlaceholders(value, env) { + const missing = /* @__PURE__ */ new Set(); + const walk = (v) => { + if (typeof v === "string") { + return v.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => { + const val = env[name]; + if (val === void 0) { + missing.add(name); + return ""; + } + return val; + }); + } + if (Array.isArray(v)) + return v.map(walk); + if (v !== null && typeof v === "object") { + const out = {}; + for (const k of Object.keys(v)) { + out[k] = walk(v[k]); + } + return out; + } + return v; + }; + const result = walk(value); + if (missing.size > 0) { + throw new Error(`\u5BC6\u7801\u53D8\u91CF\u672A\u5B9A\u4E49\uFF1A${[...missing].join(", ")}\u3002\u8BF7\u5728 .env \u6587\u4EF6\u4E2D\u5B9A\u4E49\uFF08\u5DE5\u4F5C\u533A .env \u6216 ~/.zcode/db-connector/.env\uFF0C\u4FDD\u5B58\u5373\u751F\u6548\u65E0\u9700\u91CD\u542F\uFF1B\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF\u4E0D\u53C2\u4E0E\u89E3\u6790\uFF09`); + } + return result; + } + function resolveConnectionRef(merged, ref) { + if (typeof ref !== "string" || !ref.trim()) { + throw new Error("connection \u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A"); + } + let envName; + let connName; + const slash = ref.indexOf("/"); + if (slash >= 0) { + envName = ref.slice(0, slash); + connName = ref.slice(slash + 1); + } else { + envName = merged.activeEnvironment ?? ""; + connName = ref; + if (!envName) { + throw new Error('\u672A\u8BBE\u7F6E\u6D3B\u52A8\u73AF\u5883\uFF1A\u8BF7\u5728\u914D\u7F6E\u4E2D\u8BBE\u7F6E activeEnvironment\uFF0C\u6216\u4F7F\u7528 "\u73AF\u5883\u540D/\u8FDE\u63A5\u540D" \u7684\u5B8C\u6574\u5199\u6CD5\uFF08\u5982 prod/mysql-main\uFF09'); + } + } + const env = merged.environments[envName]; + if (!env) { + throw new Error(`\u73AF\u5883 "${envName}" \u4E0D\u5B58\u5728\u3002\u53EF\u7528\u73AF\u5883\uFF1A${Object.keys(merged.environments).join(", ") || "\uFF08\u65E0\uFF09"}`); + } + const conn = env.connections[connName]; + if (!conn) { + const available = Object.keys(env.connections).join(", ") || "\uFF08\u65E0\uFF09"; + throw new Error(`\u8FDE\u63A5 "${connName}" \u5728\u73AF\u5883 "${envName}" \u4E2D\u4E0D\u5B58\u5728\u3002\u53EF\u7528\u8FDE\u63A5\uFF1A${available}`); + } + const effective = { + rowLimit: conn.rowLimit ?? merged.defaults.rowLimit, + maxRowLimit: conn.maxRowLimit ?? merged.defaults.maxRowLimit, + timeoutMs: conn.timeoutMs ?? merged.defaults.timeoutMs + }; + return { environment: envName, name: connName, config: conn, envProtected: !!env.protected, effective }; + } + function validateIdentifier(kind, value) { + if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(value)) { + throw new Error(`${kind} "${value}" \u4E0D\u5408\u6CD5\uFF1A\u9700\u4EE5\u5B57\u6BCD\u6216\u6570\u5B57\u5F00\u5934\uFF0C\u4EC5\u542B\u5B57\u6BCD/\u6570\u5B57/-/_\uFF0C\u6700\u957F 64 \u5B57\u7B26`); + } + } + function sanitizeConnectionForWrite(input, passwordEnvVar) { + const warnings = []; + const cfg = { ...input }; + if (passwordEnvVar !== void 0) { + if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(passwordEnvVar)) { + throw new Error(`passwordEnvVar "${passwordEnvVar}" \u4E0D\u662F\u5408\u6CD5\u7684\u73AF\u5883\u53D8\u91CF\u540D`); + } + cfg.password = `\${${passwordEnvVar}}`; + } + if (cfg.type !== void 0 && !exports2.DB_TYPES.includes(cfg.type)) { + throw new Error(`type \u5FC5\u987B\u662F ${exports2.DB_TYPES.join(" / ")} \u4E4B\u4E00`); + } + if (cfg.type === void 0) { + throw new Error("\u7F3A\u5C11 type \u5B57\u6BB5\uFF08mysql / postgres / mongodb\uFF09"); + } + if (cfg.password !== void 0 && cfg.password !== null) { + const pw = String(cfg.password); + if (!ENV_REF_PATTERN.test(pw)) { + throw new Error('\u62D2\u7EDD\u5199\u5165\u660E\u6587\u5BC6\u7801\uFF1A\u8BF7\u6539\u7528 passwordEnvVar \u53C2\u6570\u4F20\u5165\u5BC6\u7801\u53D8\u91CF\u540D\uFF08\u5728 .env \u6587\u4EF6\u4E2D\u5B9A\u4E49\uFF0C\u5199\u5165\u4E3A ${VAR} \u5F15\u7528\uFF09\uFF0C\u6216\u624B\u5DE5\u7F16\u8F91\u6587\u4EF6\u65F6\u5199\u6210 "${VAR}"'); + } + } + const url = typeof cfg.url === "string" ? cfg.url : void 0; + if (url) { + const inline = url.match(/:\/\/[^/@\s:]+:([^/@\s]*)@/); + if (inline && !ENV_REF_PATTERN.test(inline[1] || "")) { + warnings.push("URL \u4E2D\u5305\u542B\u5185\u8054\u5BC6\u7801\uFF1A\u5EFA\u8BAE\u6539\u7528 ${ENV_VAR} \u5360\u4F4D\u7B26\uFF08\u5982 mongodb://user:${DB_PW}@host\uFF09\uFF0C\u5F53\u524D\u5199\u6CD5\u5C06\u660E\u6587\u51ED\u8BC1\u4FDD\u5B58\u5728\u914D\u7F6E\u6587\u4EF6\u91CC"); + } + } + delete cfg.passwordEnvVar; + return { config: cfg, warnings }; + } + function persistAddConnection(scope, merged, envName, connName, config) { + const file = scope === "workspace" ? merged.workspacePath : merged.userPath; + const current = readFileIfExists(file) ?? emptyConfigFile(); + if (!current.environments[envName]) { + current.environments[envName] = { connections: {} }; + } + if (current.environments[envName].connections[connName]) { + throw new Error(`\u8FDE\u63A5 "${envName}/${connName}" \u5DF2\u5B58\u5728\u4E8E ${file}\uFF0C\u5982\u9700\u8986\u76D6\u8BF7\u5148\u5220\u9664`); + } + current.environments[envName].connections[connName] = config; + atomicWrite(file, current); + return { file }; + } + function persistRemoveConnection(merged, envName, connName) { + for (const file of [merged.workspacePath, merged.userPath]) { + const current = readFileIfExists(file); + if (!current) + continue; + const env = current.environments[envName]; + if (env && env.connections && env.connections[connName]) { + delete env.connections[connName]; + if (Object.keys(env.connections).length === 0 && !env.description && !env.protected) { + delete current.environments[envName]; + } + atomicWrite(file, current); + return { file }; + } + } + throw new Error(`\u8FDE\u63A5 "${envName}/${connName}" \u4E0D\u5B58\u5728\uFF0C\u672A\u505A\u4EFB\u4F55\u4FEE\u6539`); + } + function persistSetActiveEnvironment(merged, envName) { + if (!merged.environments[envName]) { + throw new Error(`\u73AF\u5883 "${envName}" \u4E0D\u5B58\u5728\u3002\u53EF\u7528\u73AF\u5883\uFF1A${Object.keys(merged.environments).join(", ") || "\uFF08\u65E0\uFF09"}`); + } + const file = merged.workspaceFile ? merged.workspacePath : merged.userPath; + const current = readFileIfExists(file) ?? emptyConfigFile(); + current.activeEnvironment = envName; + atomicWrite(file, current); + return { file }; + } + function maskConnection(conn) { + const out = { type: conn.type }; + if (conn.database) + out.database = conn.database; + if (conn.host) + out.host = conn.host; + if (conn.port) + out.port = conn.port; + if (conn.user) + out.user = conn.user; + if (conn.url) { + out.url = conn.url.replace(/(:[^/@\s]*)@/, ":***@").replace(/\$\{[^}]+\}/g, "${\u2026}"); + } + if (conn.password) + out.password = "${\u2026}"; + return out; + } + } +}); + +// dist/sqlguard.js +var require_sqlguard = __commonJS({ + "dist/sqlguard.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SqlRejectedError = void 0; + exports2.validateReadOnlySql = validateReadOnlySql; + exports2.validateMongoStages = validateMongoStages; + exports2.validateMongoReadDocument = validateMongoReadDocument; + var SqlRejectedError = class extends Error { + constructor(reason) { + super(`SQL \u88AB\u53EA\u8BFB\u6821\u9A8C\u62D2\u7EDD\uFF1A${reason}`); + this.name = "SqlRejectedError"; + } + }; + exports2.SqlRejectedError = SqlRejectedError; + var ALLOWED_STARTERS = /^\s*(select|with|explain(\s+analyze|\s+analyse)?|show|describe|desc)\b/i; + var FORBIDDEN_KEYWORDS = [ + "insert", + "update", + "delete", + "drop", + "alter", + "create", + "truncate", + "grant", + "revoke", + "replace", + "merge", + "call", + "execute", + "exec", + "lock", + "unlock", + "load", + "rename", + "use", + "set", + "into", + "outfile", + "dumpfile", + "prepare", + "handler", + "do", + "copy", + "vacuum", + "reindex", + "cluster", + "listen", + "notify", + "refresh", + "attach", + "detach", + "checkpoint", + "kill", + "reset", + "flush", + "optimize", + "repair", + "shutdown", + "purge", + "start", + "begin", + "commit", + "rollback", + "savepoint" + ]; + var FORBIDDEN_FUNCTIONS = [ + "load_file", + "get_lock", + "release_lock", + "benchmark", + "sleep", + "sys_eval", + "sys_exec", + "pg_sleep", + "pg_read_file", + "pg_read_binary_file", + "pg_ls_dir", + "pg_stat_file", + "pg_terminate_backend", + "pg_cancel_backend", + "dblink", + "lo_import", + "lo_export", + "pg_switch_wal", + "pg_ls_waldir" + ]; + var LOCK_CLAUSE = /\bfor\s+(update|share|no\s+key\s+update|key\s+share)\b/i; + function escapeRegExp(s) { + return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + var forbiddenKeywordRegex = FORBIDDEN_KEYWORDS.map((w) => new RegExp(`(^|[^a-zA-Z0-9_])${escapeRegExp(w)}([^a-zA-Z0-9_]|$)`, "i")); + var forbiddenFunctionRegex = FORBIDDEN_FUNCTIONS.map((w) => new RegExp(`(^|[^a-zA-Z0-9_])${escapeRegExp(w)}\\s*\\(`, "i")); + function validateReadOnlySql(rawSql) { + if (typeof rawSql !== "string") { + throw new SqlRejectedError("sql \u5FC5\u987B\u662F\u5B57\u7B26\u4E32"); + } + const trimmed = rawSql.trim(); + const stripped = trimmed.replace(/;+\s*$/, ""); + if (!stripped) { + throw new SqlRejectedError("SQL \u4E3A\u7A7A"); + } + if (stripped.includes(";")) { + throw new SqlRejectedError("\u4E0D\u5141\u8BB8\u4E00\u6B21\u6267\u884C\u591A\u6761\u8BED\u53E5\uFF08\u68C0\u6D4B\u5230\u5206\u53F7\uFF09"); + } + if (!ALLOWED_STARTERS.test(stripped)) { + throw new SqlRejectedError("\u4EC5\u5141\u8BB8 SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / DESC \u5F00\u5934\u7684\u5355\u6761\u53EA\u8BFB\u8BED\u53E5"); + } + for (let i = 0; i < FORBIDDEN_KEYWORDS.length; i++) { + if (forbiddenKeywordRegex[i].test(stripped)) { + throw new SqlRejectedError(`\u68C0\u6D4B\u5230\u7981\u6B62\u7684\u5173\u952E\u8BCD "${FORBIDDEN_KEYWORDS[i].toUpperCase()}"\uFF08\u542B\u5B50\u67E5\u8BE2/\u6CE8\u91CA\u4E2D\u7684\u51FA\u73B0\uFF09`); + } + } + for (let i = 0; i < FORBIDDEN_FUNCTIONS.length; i++) { + if (forbiddenFunctionRegex[i].test(stripped)) { + throw new SqlRejectedError(`\u68C0\u6D4B\u5230\u7981\u6B62\u7684\u51FD\u6570 "${FORBIDDEN_FUNCTIONS[i]}"`); + } + } + if (LOCK_CLAUSE.test(stripped)) { + throw new SqlRejectedError("\u68C0\u6D4B\u5230\u9501\u5B9A\u5B50\u53E5\uFF08FOR UPDATE/FOR SHARE \u7B49\uFF09\uFF0C\u53EA\u8BFB\u6A21\u5F0F\u4E0D\u5141\u8BB8"); + } + return stripped; + } + var FORBIDDEN_MONGO_KEYS = [ + "$out", + "$merge", + "$load", + "$where", + "$function", + "$accumulator", + "$db", + "$eval" + ]; + function validateMongoStages(pipeline) { + if (!Array.isArray(pipeline)) { + throw new SqlRejectedError("pipeline \u5FC5\u987B\u662F\u6570\u7EC4"); + } + for (const stage of pipeline) { + scanMongoObject(stage, "pipeline \u9636\u6BB5"); + } + } + function validateMongoReadDocument(doc, what) { + scanMongoObject(doc, what); + } + function scanMongoObject(value, where, depth = 0) { + if (depth > 30) { + throw new SqlRejectedError(`${where} \u5D4C\u5957\u8FC7\u6DF1`); + } + if (value === null || value === void 0) + return; + if (typeof value === "function") { + throw new SqlRejectedError(`${where} \u4E0D\u5141\u8BB8\u5305\u542B\u51FD\u6570`); + } + if (Array.isArray(value)) { + for (const item of value) + scanMongoObject(item, where, depth + 1); + return; + } + if (typeof value === "object") { + for (const key of Object.keys(value)) { + if (FORBIDDEN_MONGO_KEYS.includes(key)) { + throw new SqlRejectedError(`${where} \u68C0\u6D4B\u5230\u7981\u6B62\u7684\u8FD0\u7B97\u7B26 "${key}"`); + } + scanMongoObject(value[key], where, depth + 1); + } + } + } + } +}); + +// node_modules/sql-escaper/lib/index.js +var require_lib = __commonJS({ + "node_modules/sql-escaper/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.raw = exports2.format = exports2.escape = exports2.arrayToList = exports2.bufferToString = exports2.objectToValues = exports2.escapeId = exports2.temporalToString = exports2.dateToString = void 0; + var buffer_1 = require("buffer"); + var CONTEXT_TRIGGER = new Uint8Array(128); + var SET_CLAUSE_TERMINATORS_BY_FIRST = {}; + var SET_CLAUSE_TERMINATORS = [ + "where", + "order", + "group", + "having", + "limit", + "union", + "returning", + "into", + "for", + "lock", + "offset", + "window", + "procedure", + "on" + ]; + var regex = { + backtick: /`/g, + dot: /\./g, + timezone: /([+\-\s])(\d\d):?(\d\d)?/, + escapeChars: /[\0\b\t\n\r\x1a"'\\]/g + }; + var charCode = { + singleQuote: 39, + backtick: 96, + backslash: 92, + dash: 45, + slash: 47, + asterisk: 42, + exclamation: 33, + plus: 43, + questionMark: 63, + comma: 44, + openParen: 40, + closeParen: 41, + semicolon: 59, + newline: 10, + space: 32, + tab: 9, + carriageReturn: 13 + }; + CONTEXT_TRIGGER[charCode.singleQuote] = 1; + CONTEXT_TRIGGER[charCode.backtick] = 1; + CONTEXT_TRIGGER[charCode.dash] = 1; + CONTEXT_TRIGGER[charCode.slash] = 1; + for (const word of SET_CLAUSE_TERMINATORS) { + const first = word.charCodeAt(0); + const bucket = SET_CLAUSE_TERMINATORS_BY_FIRST[first]; + if (bucket) + bucket.push(word); + else + SET_CLAUSE_TERMINATORS_BY_FIRST[first] = [word]; + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Set) && !(value instanceof Map); + var isWordChar = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95; + var isWhitespace = (code) => code === charCode.space || code === charCode.tab || code === charCode.newline || code === charCode.carriageReturn; + var toLower = (code) => code | 32; + var matchesWord = (sql, position, word, length) => { + const wordLength = word.length; + for (let offset = 0; offset < wordLength; offset++) + if (toLower(sql.charCodeAt(position + offset)) !== word.charCodeAt(offset)) + return false; + return (position === 0 || !isWordChar(sql.charCodeAt(position - 1))) && (position + wordLength >= length || !isWordChar(sql.charCodeAt(position + wordLength))); + }; + var skipSqlContext = (sql, position) => { + const currentChar = sql.charCodeAt(position); + const nextChar = sql.charCodeAt(position + 1); + if (currentChar === charCode.singleQuote) { + for (let cursor = position + 1; cursor < sql.length; cursor++) { + if (sql.charCodeAt(cursor) === charCode.backslash) + cursor++; + else if (sql.charCodeAt(cursor) === charCode.singleQuote) + return cursor + 1; + } + return sql.length; + } + if (currentChar === charCode.backtick) { + const length = sql.length; + for (let cursor = position + 1; cursor < length; cursor++) { + if (sql.charCodeAt(cursor) !== charCode.backtick) + continue; + if (sql.charCodeAt(cursor + 1) === charCode.backtick) { + cursor++; + continue; + } + return cursor + 1; + } + return length; + } + if (currentChar === charCode.dash && nextChar === charCode.dash) { + const afterDash = sql.charCodeAt(position + 2); + if (Number.isNaN(afterDash) || afterDash <= charCode.space) { + const lineBreak = sql.indexOf("\n", position + 2); + return lineBreak === -1 ? sql.length : lineBreak + 1; + } + return -1; + } + if (currentChar === charCode.slash && nextChar === charCode.asterisk) { + const markerChar = sql.charCodeAt(position + 2); + if (markerChar === charCode.exclamation || markerChar === charCode.plus) + return -1; + const commentEnd = sql.indexOf("*/", position + 2); + return commentEnd === -1 ? sql.length : commentEnd + 2; + } + return -1; + }; + var findNextPlaceholder = (sql, start) => { + const sqlLength = sql.length; + for (let position = start; position < sqlLength; position++) { + const code = sql.charCodeAt(position); + if (code === charCode.questionMark) + return position; + if (code < 128 && CONTEXT_TRIGGER[code]) { + const contextEnd = skipSqlContext(sql, position); + if (contextEnd !== -1) + position = contextEnd - 1; + } + } + return -1; + }; + var isInSetAssignmentList = (sql, setEnd, placeholderPosition) => { + const length = sql.length; + let depth = 0; + let sawContent = false; + let lastWasComma = false; + for (let i = setEnd; i < placeholderPosition; ) { + const code = sql.charCodeAt(i); + if (code < 128 && CONTEXT_TRIGGER[code]) { + const contextEnd = skipSqlContext(sql, i); + if (contextEnd !== -1) { + i = contextEnd; + sawContent = true; + lastWasComma = false; + continue; + } + } + if (isWhitespace(code)) { + i++; + continue; + } + if (code === charCode.openParen) { + depth++; + sawContent = true; + lastWasComma = false; + i++; + continue; + } + if (code === charCode.closeParen) { + if (--depth < 0) + return false; + sawContent = true; + lastWasComma = false; + i++; + continue; + } + if (isWordChar(code)) { + if (depth === 0 && !(code >= 48 && code <= 57)) { + const bucket = SET_CLAUSE_TERMINATORS_BY_FIRST[code | 32]; + if (bucket) { + for (let t = 0; t < bucket.length; t++) + if (matchesWord(sql, i, bucket[t], length)) + return false; + } + } + do { + i++; + } while (i < placeholderPosition && isWordChar(sql.charCodeAt(i))); + sawContent = true; + lastWasComma = false; + continue; + } + if (depth === 0) { + if (code === charCode.semicolon) + return false; + if (code === charCode.comma) { + lastWasComma = true; + sawContent = true; + i++; + continue; + } + } + sawContent = true; + lastWasComma = false; + i++; + } + return depth === 0 && (!sawContent || lastWasComma); + }; + var findSetKeyword = (sql, startFrom = 0) => { + const length = sql.length; + for (let position = startFrom; position < length; position++) { + const code = sql.charCodeAt(position); + if (code < 128 && CONTEXT_TRIGGER[code]) { + const contextEnd = skipSqlContext(sql, position); + if (contextEnd !== -1) { + position = contextEnd - 1; + continue; + } + } + const lower = code | 32; + if (lower === 115 && matchesWord(sql, position, "set", length)) + return position + 3; + if (lower === 107 && matchesWord(sql, position, "key", length)) { + let cursor = position + 3; + while (cursor < length && isWhitespace(sql.charCodeAt(cursor))) + cursor++; + if (matchesWord(sql, cursor, "update", length)) + return cursor + 6; + } + } + return -1; + }; + var isDate = (value) => Object.prototype.toString.call(value) === "[object Date]"; + var isTemporal = (value) => Object.prototype.toString.call(value).startsWith("[object Temporal."); + var hasSqlString = (value) => typeof value === "object" && value !== null && "toSqlString" in value && typeof value.toSqlString === "function"; + var escapeString = (value) => { + const escapeChars = regex.escapeChars; + escapeChars.lastIndex = 0; + const first = escapeChars.exec(value); + if (first === null) + return `'${value}'`; + const length = value.length; + let result = "'" + value.slice(0, first.index); + let chunkStart = first.index; + for (let i = first.index; i < length; i++) { + let escaped; + switch (value.charCodeAt(i)) { + case 0: + escaped = "\\0"; + break; + case 8: + escaped = "\\b"; + break; + case 9: + escaped = "\\t"; + break; + case 10: + escaped = "\\n"; + break; + case 13: + escaped = "\\r"; + break; + case 26: + escaped = "\\Z"; + break; + case 34: + escaped = '\\"'; + break; + case 39: + escaped = "\\'"; + break; + case 92: + escaped = "\\\\"; + break; + default: + continue; + } + result += value.slice(chunkStart, i) + escaped; + chunkStart = i + 1; + } + return result + value.slice(chunkStart) + "'"; + }; + var pad2 = (value) => value < 10 ? "0" + value : "" + value; + var pad3 = (value) => value < 10 ? "00" + value : value < 100 ? "0" + value : "" + value; + var pad4 = (value) => value < 10 ? "000" + value : value < 100 ? "00" + value : value < 1e3 ? "0" + value : "" + value; + var convertTimezone = (tz) => { + if (tz === "Z") + return 0; + const timezoneMatch = tz.match(regex.timezone); + if (timezoneMatch) + return (timezoneMatch[1] === "-" ? -1 : 1) * (Number.parseInt(timezoneMatch[2], 10) + (timezoneMatch[3] ? Number.parseInt(timezoneMatch[3], 10) : 0) / 60) * 60; + return false; + }; + var dateToString = (date, timezone) => { + if (Number.isNaN(date.getTime())) + return "NULL"; + let year; + let month; + let day; + let hour; + let minute; + let second; + let millisecond; + if (timezone === "local") { + year = date.getFullYear(); + month = date.getMonth() + 1; + day = date.getDate(); + hour = date.getHours(); + minute = date.getMinutes(); + second = date.getSeconds(); + millisecond = date.getMilliseconds(); + } else { + const timezoneOffsetMinutes = convertTimezone(timezone); + let time = date.getTime(); + if (timezoneOffsetMinutes !== false && timezoneOffsetMinutes !== 0) + time += timezoneOffsetMinutes * 6e4; + const adjustedDate = new Date(time); + year = adjustedDate.getUTCFullYear(); + month = adjustedDate.getUTCMonth() + 1; + day = adjustedDate.getUTCDate(); + hour = adjustedDate.getUTCHours(); + minute = adjustedDate.getUTCMinutes(); + second = adjustedDate.getUTCSeconds(); + millisecond = adjustedDate.getUTCMilliseconds(); + } + return escapeString(pad4(year) + "-" + pad2(month) + "-" + pad2(day) + " " + pad2(hour) + ":" + pad2(minute) + ":" + pad2(second) + "." + pad3(millisecond)); + }; + exports2.dateToString = dateToString; + var temporalToString = (value, timezone) => { + if (typeof value.epochMilliseconds === "number") + return (0, exports2.dateToString)(new Date(value.epochMilliseconds), timezone || "local"); + if (value[Symbol.toStringTag] === "Temporal.PlainDateTime") + return escapeString(value.toString().replace("T", " ")); + return escapeString(value.toString()); + }; + exports2.temporalToString = temporalToString; + var escapeId = (value, forbidQualified) => { + if (Array.isArray(value)) { + const length = value.length; + let sql = ""; + for (let i = 0; i < length; i++) { + if (i > 0) + sql += ", "; + sql += (0, exports2.escapeId)(value[i], forbidQualified); + } + return sql; + } + const identifier = String(value); + const hasJsonOperator = !forbidQualified && identifier.indexOf("->") !== -1; + if (forbidQualified || hasJsonOperator) { + if (identifier.indexOf("`") === -1) + return `\`${identifier}\``; + return `\`${identifier.replace(regex.backtick, "``")}\``; + } + if (identifier.indexOf("`") === -1 && identifier.indexOf(".") === -1) + return `\`${identifier}\``; + return `\`${identifier.replace(regex.backtick, "``").replace(regex.dot, "`.`")}\``; + }; + exports2.escapeId = escapeId; + var objectToValues = (object, timezone) => { + let sql = ""; + if (object instanceof Map) { + for (const [key, value] of object) { + if (typeof value === "function") + continue; + if (sql.length > 0) + sql += ", "; + sql += (0, exports2.escapeId)(String(key)); + sql += " = "; + sql += (0, exports2.escape)(value, true, timezone); + } + return sql; + } + for (const key in object) { + if (!hasOwnProperty.call(object, key)) + continue; + const value = object[key]; + if (typeof value === "function") + continue; + if (sql.length > 0) + sql += ", "; + sql += (0, exports2.escapeId)(key); + sql += " = "; + sql += (0, exports2.escape)(value, true, timezone); + } + return sql; + }; + exports2.objectToValues = objectToValues; + var bufferToString = (buffer) => `X${escapeString(buffer.toString("hex"))}`; + exports2.bufferToString = bufferToString; + var arrayToList = (array, timezone) => { + const length = array.length; + let sql = ""; + for (let i = 0; i < length; i++) { + if (i > 0) + sql += ", "; + const value = array[i]; + if (Array.isArray(value)) + sql += `(${(0, exports2.arrayToList)(value, timezone)})`; + else if (value instanceof Set) + sql += `(${(0, exports2.arrayToList)(Array.from(value), timezone)})`; + else + sql += (0, exports2.escape)(value, true, timezone); + } + return sql; + }; + exports2.arrayToList = arrayToList; + var escape = (value, stringifyObjects, timezone) => { + if (value === void 0 || value === null) + return "NULL"; + switch (typeof value) { + case "boolean": + return value ? "true" : "false"; + case "number": + case "bigint": + return value + ""; + case "object": { + if (isDate(value)) + return (0, exports2.dateToString)(value, timezone || "local"); + if (isTemporal(value)) + return (0, exports2.temporalToString)(value, timezone); + if (Array.isArray(value)) + return (0, exports2.arrayToList)(value, timezone); + if (value instanceof Set) + return (0, exports2.arrayToList)(Array.from(value), timezone); + if (buffer_1.Buffer.isBuffer(value)) + return (0, exports2.bufferToString)(value); + if (value instanceof Uint8Array) + return (0, exports2.bufferToString)(buffer_1.Buffer.from(value)); + if (hasSqlString(value)) + return String(value.toSqlString()); + if (!(stringifyObjects === void 0 || stringifyObjects === null)) + return escapeString(String(value)); + if (isRecord(value) || value instanceof Map) + return (0, exports2.objectToValues)(value, timezone); + return escapeString(String(value)); + } + case "string": + return escapeString(value); + default: + return escapeString(String(value)); + } + }; + exports2.escape = escape; + var format = (sql, values, stringifyObjects, timezone) => { + if (values === void 0 || values === null) + return sql; + const valuesArray = Array.isArray(values) ? values : [values]; + const length = valuesArray.length; + let setIndex = -2; + let nextSetIndex = -1; + let result = ""; + let chunkIndex = 0; + let valuesIndex = 0; + let placeholderPosition = findNextPlaceholder(sql, 0); + while (valuesIndex < length && placeholderPosition !== -1) { + let placeholderEnd = placeholderPosition + 1; + let escapedValue; + while (sql.charCodeAt(placeholderEnd) === 63) + placeholderEnd++; + const placeholderLength = placeholderEnd - placeholderPosition; + const currentValue = valuesArray[valuesIndex]; + if (placeholderLength > 2) { + placeholderPosition = findNextPlaceholder(sql, placeholderEnd); + continue; + } + if (placeholderLength === 2) + escapedValue = (0, exports2.escapeId)(currentValue); + else if (typeof currentValue === "number" || typeof currentValue === "bigint") + escapedValue = `${currentValue}`; + else if (typeof currentValue === "object" && currentValue !== null && !stringifyObjects) { + const expandable = !(Array.isArray(currentValue) || currentValue instanceof Uint8Array || currentValue instanceof Date || hasSqlString(currentValue) || isDate(currentValue)) && (isRecord(currentValue) || currentValue instanceof Map); + if (expandable) { + let previous = placeholderPosition - 1; + while (previous >= chunkIndex && isWhitespace(sql.charCodeAt(previous))) + previous--; + const previousChar = previous >= chunkIndex ? toLower(sql.charCodeAt(previous)) : 0; + if ((previousChar < 97 || previousChar > 122) && previousChar !== charCode.comma) + escapedValue = (0, exports2.escape)(currentValue, true, timezone); + else { + if (setIndex === -2) { + setIndex = findSetKeyword(sql); + nextSetIndex = setIndex === -1 ? -1 : findSetKeyword(sql, setIndex); + } + while (nextSetIndex !== -1 && nextSetIndex <= placeholderPosition) { + setIndex = nextSetIndex; + nextSetIndex = findSetKeyword(sql, nextSetIndex); + } + if (setIndex !== -1 && setIndex <= placeholderPosition && isInSetAssignmentList(sql, setIndex, placeholderPosition)) + escapedValue = (0, exports2.objectToValues)(currentValue, timezone); + else + escapedValue = (0, exports2.escape)(currentValue, true, timezone); + } + } else + escapedValue = (0, exports2.escape)(currentValue, true, timezone); + } else + escapedValue = (0, exports2.escape)(currentValue, stringifyObjects, timezone); + result += sql.slice(chunkIndex, placeholderPosition); + result += escapedValue; + chunkIndex = placeholderEnd; + valuesIndex++; + placeholderPosition = findNextPlaceholder(sql, placeholderEnd); + } + if (chunkIndex === 0) + return sql; + if (chunkIndex < sql.length) + return result + sql.slice(chunkIndex); + return result; + }; + exports2.format = format; + var raw = (sql) => { + if (typeof sql !== "string") + throw new TypeError("argument sql must be a string"); + return { + toSqlString: () => sql + }; + }; + exports2.raw = raw; + } +}); + +// node_modules/lru.min/lib/index.js +var require_lib2 = __commonJS({ + "node_modules/lru.min/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.createLRU = void 0; + var createLRU = (options) => { + let { max } = options; + if (!(Number.isInteger(max) && max > 0)) + throw new TypeError("`max` must be a positive integer"); + let size = 0; + let head = 0; + let tail = 0; + let free = []; + const { onEviction } = options; + const keyMap = /* @__PURE__ */ new Map(); + const keyList = new Array(max).fill(void 0); + const valList = new Array(max).fill(void 0); + const next = new Array(max).fill(0); + const prev = new Array(max).fill(0); + const linkTail = (index) => { + next[tail] = index; + prev[index] = tail; + next[index] = 0; + tail = index; + }; + const moveToTail = (index) => { + if (index === tail) + return; + const nextIndex = next[index]; + const prevIndex = prev[index]; + if (index === head) + head = nextIndex; + else + next[prevIndex] = nextIndex; + prev[nextIndex] = prevIndex; + linkTail(index); + }; + const _shrink = (newMax) => { + let current = tail; + const preserve = Math.min(size, newMax); + const remove = size - preserve; + const newKeyList = new Array(preserve); + const newValList = new Array(preserve); + for (let i = 0; i < remove; i++) { + const key = keyList[head]; + onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[head]); + keyMap.delete(key); + head = next[head]; + } + for (let i = preserve - 1; i >= 0; i--) { + newKeyList[i] = keyList[current]; + newValList[i] = valList[current]; + keyMap.set(keyList[current], i); + current = prev[current]; + } + head = 0; + tail = preserve - 1; + size = preserve; + keyList.length = newMax; + valList.length = newMax; + next.length = newMax; + prev.length = newMax; + for (let i = 0; i < preserve; i++) { + keyList[i] = newKeyList[i]; + valList[i] = newValList[i]; + next[i] = i + 1; + prev[i] = i - 1; + } + free = []; + for (let i = preserve; i < newMax; i++) { + keyList[i] = void 0; + valList[i] = void 0; + free.push(i); + } + }; + const _grow = (newMax) => { + keyList.length = newMax; + valList.length = newMax; + next.length = newMax; + prev.length = newMax; + keyList.fill(void 0, max); + valList.fill(void 0, max); + next.fill(0, max); + prev.fill(0, max); + }; + return { + /** Adds a key-value pair to the cache. Updates the value if the key already exists. */ + set(key, value) { + if (key === void 0) + return; + let index = keyMap.get(key); + if (index === void 0) { + if (size === max) { + index = head; + const evictKey = keyList[index]; + onEviction === null || onEviction === void 0 ? void 0 : onEviction(evictKey, valList[index]); + keyMap.delete(evictKey); + head = next[index]; + prev[head] = 0; + } else { + index = free.length > 0 ? free.pop() : size; + size++; + } + keyMap.set(key, index); + keyList[index] = key; + valList[index] = value; + if (size === 1) + head = tail = index; + else + linkTail(index); + } else { + onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]); + valList[index] = value; + moveToTail(index); + } + }, + /** Retrieves the value for a given key and moves the key to the most recent position. */ + get(key) { + const index = keyMap.get(key); + if (index === void 0) + return; + if (index !== tail) + moveToTail(index); + return valList[index]; + }, + /** Retrieves the value for a given key without changing its position. */ + peek: (key) => { + const index = keyMap.get(key); + return index !== void 0 ? valList[index] : void 0; + }, + /** Checks if a key exists in the cache. */ + has: (key) => keyMap.has(key), + /** Iterates over all keys in the cache, from most recent to least recent. */ + *keys() { + let current = tail; + for (let i = 0; i < size; i++) { + yield keyList[current]; + current = prev[current]; + } + }, + /** Iterates over all values in the cache, from most recent to least recent. */ + *values() { + let current = tail; + for (let i = 0; i < size; i++) { + yield valList[current]; + current = prev[current]; + } + }, + /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */ + *entries() { + let current = tail; + for (let i = 0; i < size; i++) { + yield [keyList[current], valList[current]]; + current = prev[current]; + } + }, + /** Iterates over each value-key pair in the cache, from most recent to least recent. */ + forEach: (callback) => { + let current = tail; + for (let i = 0; i < size; i++) { + const key = keyList[current]; + const value = valList[current]; + callback(value, key); + current = prev[current]; + } + }, + /** Deletes a key-value pair from the cache. */ + delete(key) { + const index = keyMap.get(key); + if (index === void 0) + return false; + onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]); + keyMap.delete(key); + free.push(index); + keyList[index] = void 0; + valList[index] = void 0; + const prevIndex = prev[index]; + const nextIndex = next[index]; + if (index === head) + head = nextIndex; + else + next[prevIndex] = nextIndex; + if (index === tail) + tail = prevIndex; + else + prev[nextIndex] = prevIndex; + size--; + return true; + }, + /** Evicts the oldest item or the specified number of the oldest items from the cache. */ + evict: (number) => { + let toPrune = Math.min(number, size); + while (toPrune > 0) { + const evictHead = head; + const key = keyList[evictHead]; + onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[evictHead]); + keyMap.delete(key); + keyList[evictHead] = void 0; + valList[evictHead] = void 0; + head = next[evictHead]; + prev[head] = 0; + size--; + free.push(evictHead); + toPrune--; + } + if (size === 0) + head = tail = 0; + }, + /** Clears all key-value pairs from the cache. */ + clear() { + if (onEviction) { + let current = head; + for (let i = 0; i < size; i++) { + onEviction(keyList[current], valList[current]); + current = next[current]; + } + } + keyMap.clear(); + keyList.fill(void 0); + valList.fill(void 0); + free = []; + size = 0; + head = tail = 0; + }, + /** Resizes the cache to a new maximum size, evicting items if necessary. */ + resize: (newMax) => { + if (!(Number.isInteger(newMax) && newMax > 0)) + throw new TypeError("`max` must be a positive integer"); + if (newMax === max) + return; + if (newMax < max) + _shrink(newMax); + else + _grow(newMax); + max = newMax; + }, + /** Returns the maximum number of items that can be stored in the cache. */ + get max() { + return max; + }, + /** Returns the number of items currently stored in the cache. */ + get size() { + return size; + }, + /** Returns the number of currently available slots in the cache before reaching the maximum size. */ + get available() { + return max - size; + } + }; + }; + exports2.createLRU = createLRU; + } +}); + +// node_modules/mysql2/lib/parsers/parser_cache.js +var require_parser_cache = __commonJS({ + "node_modules/mysql2/lib/parsers/parser_cache.js"(exports2, module2) { + "use strict"; + var { createLRU } = require_lib2(); + var parserCache = createLRU({ + max: 15e3 + }); + var TYPE_CAST_FALSE = 1; + var TYPE_CAST_FUNCTION = 2; + var TYPE_CAST_DEFAULT = 3; + function typeCastKind(typeCast) { + if (typeCast === false) { + return TYPE_CAST_FALSE; + } + if (typeof typeCast === "function") { + return TYPE_CAST_FUNCTION; + } + return TYPE_CAST_DEFAULT; + } + function dateStringsKey(dateStrings) { + if (Array.isArray(dateStrings)) { + return dateStrings.map(String); + } + return Boolean(dateStrings); + } + function nestTablesKey(nestTables) { + if (typeof nestTables === "string") { + return nestTables; + } + return Boolean(nestTables); + } + function optionBits(type, options, config, nestTables, dateStrings) { + return (type === "binary" ? 1 : 0) | (options.rowsAsArray ? 2 : 0) | (options.supportBigNumbers || config.supportBigNumbers ? 4 : 0) | (options.bigNumberStrings || config.bigNumberStrings ? 8 : 0) | typeCastKind(options.typeCast) << 4 | (options.decimalNumbers ? 64 : 0) | (config.jsonStrings ? 128 : 0) | (nestTables === true ? 256 : 0) | (typeof nestTables === "string" ? 512 : 0) | (dateStrings === true ? 1024 : 0) | (Array.isArray(dateStrings) ? 2048 : 0); + } + function mixNumber(hash, value) { + return Math.imul(hash ^ (value | 0), 2654435761) | 0; + } + function mixString(hash, string) { + if (typeof string !== "string") { + return mixNumber(hash, string === void 0 ? -1 : -2); + } + hash = mixNumber(hash, string.length); + for (let i = 0; i < string.length; ++i) { + hash = Math.imul(hash, 31) + string.charCodeAt(i) | 0; + } + return hash; + } + function hashKey(type, fields, options, config) { + const nestTables = nestTablesKey(options.nestTables); + const dateStrings = dateStringsKey(options.dateStrings || config.dateStrings); + const includeTable = nestTables !== false; + let hash = mixNumber( + 2166136261, + optionBits(type, options, config, nestTables, dateStrings) + ); + hash = mixString(hash, String(options.timezone || config.timezone)); + if (typeof nestTables === "string") { + hash = mixString(hash, nestTables); + } + if (Array.isArray(dateStrings)) { + for (let i = 0; i < dateStrings.length; ++i) { + hash = mixString(hash, dateStrings[i]); + } + } + hash = mixNumber(hash, fields.length); + for (let i = 0; i < fields.length; ++i) { + const field = fields[i]; + hash = mixNumber( + hash, + field.columnType | field.characterSet << 8 | field.decimals << 24 + ); + hash = mixNumber(hash, field.flags); + hash = mixString(hash, field.name); + if (field.extendedTypeName !== void 0) { + hash = mixString(hash, field.extendedTypeName); + } + if (field.extendedFormat !== void 0) { + hash = mixString(hash, field.extendedFormat); + } + if (includeTable) { + hash = mixString(hash, field.table); + } + } + return hash & 1073741823; + } + function sameList(a, b) { + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; ++i) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + var Entry = class { + constructor(parser, type, fields, options, config) { + this.parser = parser; + this.nestTables = nestTablesKey(options.nestTables); + this.dateStrings = dateStringsKey( + options.dateStrings || config.dateStrings + ); + this.optionBits = optionBits( + type, + options, + config, + this.nestTables, + this.dateStrings + ); + this.timezone = String(options.timezone || config.timezone); + const count = fields.length; + this.columnTypes = new Array(count); + this.characterSets = new Array(count); + this.flags = new Array(count); + this.decimals = new Array(count); + this.names = new Array(count); + this.extendedTypeNames = new Array(count); + this.extendedFormats = new Array(count); + this.tables = this.nestTables === false ? null : new Array(count); + for (let i = 0; i < count; ++i) { + const field = fields[i]; + this.columnTypes[i] = field.columnType; + this.characterSets[i] = field.characterSet; + this.flags[i] = field.flags; + this.decimals[i] = field.decimals; + this.names[i] = field.name; + this.extendedTypeNames[i] = field.extendedTypeName; + this.extendedFormats[i] = field.extendedFormat; + if (this.tables !== null) { + this.tables[i] = field.table; + } + } + } + matches(type, fields, options, config) { + const nestTables = nestTablesKey(options.nestTables); + const dateStrings = dateStringsKey( + options.dateStrings || config.dateStrings + ); + if (this.optionBits !== optionBits(type, options, config, nestTables, dateStrings) || this.nestTables !== nestTables || this.timezone !== String(options.timezone || config.timezone) || this.names.length !== fields.length) { + return false; + } + if (Array.isArray(dateStrings) && !sameList(this.dateStrings, dateStrings)) { + return false; + } + for (let i = 0; i < fields.length; ++i) { + const field = fields[i]; + if (this.columnTypes[i] !== field.columnType || this.characterSets[i] !== field.characterSet || this.flags[i] !== field.flags || this.decimals[i] !== field.decimals || this.names[i] !== field.name || this.extendedTypeNames[i] !== field.extendedTypeName || this.extendedFormats[i] !== field.extendedFormat || this.tables !== null && this.tables[i] !== field.table) { + return false; + } + } + return true; + } + }; + function getParser(type, fields, options, config, compiler) { + const hash = hashKey(type, fields, options, config); + let entries = parserCache.get(hash); + if (entries !== void 0) { + for (let i = 0; i < entries.length; ++i) { + if (entries[i].matches(type, fields, options, config)) { + return entries[i].parser; + } + } + } + const parser = compiler(fields, options, config); + if (entries === void 0) { + entries = []; + parserCache.set(hash, entries); + } + entries.push(new Entry(parser, type, fields, options, config)); + return parser; + } + function setMaxCache(max) { + parserCache.resize(max); + } + function clearCache() { + parserCache.clear(); + } + module2.exports = { + getParser, + setMaxCache, + clearCache, + _hashKey: hashKey, + _Entry: Entry + }; + } +}); + +// node_modules/mysql2/lib/ring_queue.js +var require_ring_queue = __commonJS({ + "node_modules/mysql2/lib/ring_queue.js"(exports2, module2) { + "use strict"; + var MIN_SHRINK_TAIL = 1e4; + var RingQueue = class { + constructor() { + this._list = new Array(4); + this._mask = 3; + this._head = 0; + this._tail = 0; + } + get length() { + return this._tail - this._head & this._mask; + } + size() { + return this.length; + } + isEmpty() { + return this._head === this._tail; + } + push(item) { + if (arguments.length === 0) { + return this.length; + } + this._list[this._tail] = item; + this._tail = this._tail + 1 & this._mask; + if (this._tail === this._head) { + this._grow(); + } + return this.length; + } + unshift(item) { + if (arguments.length === 0) { + return this.length; + } + this._head = this._head - 1 & this._mask; + this._list[this._head] = item; + if (this._tail === this._head) { + this._grow(); + } + return this.length; + } + shift() { + const head = this._head; + if (head === this._tail) { + return void 0; + } + const item = this._list[head]; + this._list[head] = void 0; + this._head = head + 1 & this._mask; + if (head < 2 && this._tail > MIN_SHRINK_TAIL && this._tail <= this._list.length >>> 2) { + this._shrink(); + } + return item; + } + pop() { + const tail = this._tail; + if (tail === this._head) { + return void 0; + } + const capacity = this._list.length; + this._tail = tail - 1 & this._mask; + const item = this._list[this._tail]; + this._list[this._tail] = void 0; + if (this._head < 2 && tail > MIN_SHRINK_TAIL && tail <= capacity >>> 2) { + this._shrink(); + } + return item; + } + peekAt(index) { + if (index !== (index | 0)) { + return void 0; + } + if (index >= 0) { + if (index >= this.length) { + return void 0; + } + return this._list[this._head + index & this._mask]; + } + const size = this.length; + if (index < -size) { + return void 0; + } + return this._list[this._head + index + size & this._mask]; + } + get(index) { + return this.peekAt(index); + } + peek() { + if (this._head === this._tail) { + return void 0; + } + return this._list[this._head]; + } + peekFront() { + return this.peek(); + } + peekBack() { + return this.peekAt(-1); + } + removeOne(index) { + if (index !== (index | 0)) { + return void 0; + } + const size = this.length; + if (index >= size || index < -size) { + return void 0; + } + if (index < 0) { + index += size; + } + const mask = this._mask; + let slot = this._head + index & mask; + const item = this._list[slot]; + const isCloserToHead = index < size / 2; + if (isCloserToHead) { + for (let moves = index; moves > 0; moves--) { + const previous = slot - 1 & mask; + this._list[slot] = this._list[previous]; + slot = previous; + } + this._list[slot] = void 0; + this._head = this._head + 1 & mask; + } else { + for (let moves = size - 1 - index; moves > 0; moves--) { + const next = slot + 1 & mask; + this._list[slot] = this._list[next]; + slot = next; + } + this._list[slot] = void 0; + this._tail = this._tail - 1 & mask; + } + return item; + } + remove(index, count) { + if (index !== (index | 0)) { + return void 0; + } + if (this._head === this._tail) { + return void 0; + } + const size = this.length; + if (index >= size || index < -size || count < 1) { + return void 0; + } + if (index < 0) { + index += size; + } + if (count === 1 || !count) { + return [this.removeOne(index)]; + } + if (count !== (count | 0)) { + return void 0; + } + if (index + count > size) { + count = size - index; + } + const items = this.toArray(); + const removed = items.splice(index, count); + this._rebuild(items); + return removed; + } + splice(index, count, ...newItems) { + if (index !== (index | 0)) { + return void 0; + } + const size = this.length; + if (index < 0) { + index += size; + } + if (index > size) { + return void 0; + } + if (newItems.length === 0) { + return this.remove(index, count); + } + if (index < 0) { + return void 0; + } + const removalCount = count === void 0 ? 1 : count; + if (removalCount !== (removalCount | 0) || removalCount < 0) { + return void 0; + } + const items = this.toArray(); + let removed; + if (removalCount === 0) { + removed = []; + items.splice(index, 0, ...newItems); + } else if (index >= size) { + removed = void 0; + items.splice(index, 0, ...newItems); + } else { + removed = items.splice(index, removalCount, ...newItems); + } + this._rebuild(items); + return removed; + } + clear() { + this._list = new Array(this._list.length); + this._head = 0; + this._tail = 0; + } + toArray() { + const head = this._head; + const tail = this._tail; + if (head <= tail) { + return this._list.slice(head, tail); + } + const capacity = this._list.length; + const items = new Array(this.length); + let count = 0; + for (let slot = head; slot < capacity; slot++) { + items[count++] = this._list[slot]; + } + for (let slot = 0; slot < tail; slot++) { + items[count++] = this._list[slot]; + } + return items; + } + _grow() { + const list = this._list; + const capacity = list.length; + if (this._head === 0) { + this._tail = capacity; + list.length = capacity << 1; + } else { + const grown = new Array(capacity << 1); + let count = 0; + for (let slot = this._head; slot < capacity; slot++) { + grown[count++] = list[slot]; + } + for (let slot = 0; slot < this._tail; slot++) { + grown[count++] = list[slot]; + } + this._list = grown; + this._head = 0; + this._tail = capacity; + } + this._mask = this._mask << 1 | 1; + } + _shrink() { + this._list.length >>>= 1; + this._mask >>>= 1; + } + _rebuild(items) { + let capacity = this._list.length; + while (items.length >= capacity) { + capacity <<= 1; + } + this._list = new Array(capacity); + this._mask = capacity - 1; + this._head = 0; + this._tail = items.length; + for (let i = 0; i < items.length; i++) { + this._list[i] = items[i]; + } + } + }; + module2.exports = RingQueue; + } +}); + +// node_modules/mysql2/lib/constants/errors.js +var require_errors = __commonJS({ + "node_modules/mysql2/lib/constants/errors.js"(exports2) { + "use strict"; + exports2.EE_CANTCREATEFILE = 1; + exports2.EE_READ = 2; + exports2.EE_WRITE = 3; + exports2.EE_BADCLOSE = 4; + exports2.EE_OUTOFMEMORY = 5; + exports2.EE_DELETE = 6; + exports2.EE_LINK = 7; + exports2.EE_EOFERR = 9; + exports2.EE_CANTLOCK = 10; + exports2.EE_CANTUNLOCK = 11; + exports2.EE_DIR = 12; + exports2.EE_STAT = 13; + exports2.EE_CANT_CHSIZE = 14; + exports2.EE_CANT_OPEN_STREAM = 15; + exports2.EE_GETWD = 16; + exports2.EE_SETWD = 17; + exports2.EE_LINK_WARNING = 18; + exports2.EE_OPEN_WARNING = 19; + exports2.EE_DISK_FULL = 20; + exports2.EE_CANT_MKDIR = 21; + exports2.EE_UNKNOWN_CHARSET = 22; + exports2.EE_OUT_OF_FILERESOURCES = 23; + exports2.EE_CANT_READLINK = 24; + exports2.EE_CANT_SYMLINK = 25; + exports2.EE_REALPATH = 26; + exports2.EE_SYNC = 27; + exports2.EE_UNKNOWN_COLLATION = 28; + exports2.EE_FILENOTFOUND = 29; + exports2.EE_FILE_NOT_CLOSED = 30; + exports2.EE_CHANGE_OWNERSHIP = 31; + exports2.EE_CHANGE_PERMISSIONS = 32; + exports2.EE_CANT_SEEK = 33; + exports2.EE_CAPACITY_EXCEEDED = 34; + exports2.EE_DISK_FULL_WITH_RETRY_MSG = 35; + exports2.EE_FAILED_TO_CREATE_TIMER = 36; + exports2.EE_FAILED_TO_DELETE_TIMER = 37; + exports2.EE_FAILED_TO_CREATE_TIMER_QUEUE = 38; + exports2.EE_FAILED_TO_START_TIMER_NOTIFY_THREAD = 39; + exports2.EE_FAILED_TO_CREATE_TIMER_NOTIFY_THREAD_INTERRUPT_EVENT = 40; + exports2.EE_EXITING_TIMER_NOTIFY_THREAD = 41; + exports2.EE_WIN_LIBRARY_LOAD_FAILED = 42; + exports2.EE_WIN_RUN_TIME_ERROR_CHECK = 43; + exports2.EE_FAILED_TO_DETERMINE_LARGE_PAGE_SIZE = 44; + exports2.EE_FAILED_TO_KILL_ALL_THREADS = 45; + exports2.EE_FAILED_TO_CREATE_IO_COMPLETION_PORT = 46; + exports2.EE_FAILED_TO_OPEN_DEFAULTS_FILE = 47; + exports2.EE_FAILED_TO_HANDLE_DEFAULTS_FILE = 48; + exports2.EE_WRONG_DIRECTIVE_IN_CONFIG_FILE = 49; + exports2.EE_SKIPPING_DIRECTIVE_DUE_TO_MAX_INCLUDE_RECURSION = 50; + exports2.EE_INCORRECT_GRP_DEFINITION_IN_CONFIG_FILE = 51; + exports2.EE_OPTION_WITHOUT_GRP_IN_CONFIG_FILE = 52; + exports2.EE_CONFIG_FILE_PERMISSION_ERROR = 53; + exports2.EE_IGNORE_WORLD_WRITABLE_CONFIG_FILE = 54; + exports2.EE_USING_DISABLED_OPTION = 55; + exports2.EE_USING_DISABLED_SHORT_OPTION = 56; + exports2.EE_USING_PASSWORD_ON_CLI_IS_INSECURE = 57; + exports2.EE_UNKNOWN_SUFFIX_FOR_VARIABLE = 58; + exports2.EE_SSL_ERROR_FROM_FILE = 59; + exports2.EE_SSL_ERROR = 60; + exports2.EE_NET_SEND_ERROR_IN_BOOTSTRAP = 61; + exports2.EE_PACKETS_OUT_OF_ORDER = 62; + exports2.EE_UNKNOWN_PROTOCOL_OPTION = 63; + exports2.EE_FAILED_TO_LOCATE_SERVER_PUBLIC_KEY = 64; + exports2.EE_PUBLIC_KEY_NOT_IN_PEM_FORMAT = 65; + exports2.EE_DEBUG_INFO = 66; + exports2.EE_UNKNOWN_VARIABLE = 67; + exports2.EE_UNKNOWN_OPTION = 68; + exports2.EE_UNKNOWN_SHORT_OPTION = 69; + exports2.EE_OPTION_WITHOUT_ARGUMENT = 70; + exports2.EE_OPTION_REQUIRES_ARGUMENT = 71; + exports2.EE_SHORT_OPTION_REQUIRES_ARGUMENT = 72; + exports2.EE_OPTION_IGNORED_DUE_TO_INVALID_VALUE = 73; + exports2.EE_OPTION_WITH_EMPTY_VALUE = 74; + exports2.EE_FAILED_TO_ASSIGN_MAX_VALUE_TO_OPTION = 75; + exports2.EE_INCORRECT_BOOLEAN_VALUE_FOR_OPTION = 76; + exports2.EE_FAILED_TO_SET_OPTION_VALUE = 77; + exports2.EE_INCORRECT_INT_VALUE_FOR_OPTION = 78; + exports2.EE_INCORRECT_UINT_VALUE_FOR_OPTION = 79; + exports2.EE_ADJUSTED_SIGNED_VALUE_FOR_OPTION = 80; + exports2.EE_ADJUSTED_UNSIGNED_VALUE_FOR_OPTION = 81; + exports2.EE_ADJUSTED_ULONGLONG_VALUE_FOR_OPTION = 82; + exports2.EE_ADJUSTED_DOUBLE_VALUE_FOR_OPTION = 83; + exports2.EE_INVALID_DECIMAL_VALUE_FOR_OPTION = 84; + exports2.EE_COLLATION_PARSER_ERROR = 85; + exports2.EE_FAILED_TO_RESET_BEFORE_PRIMARY_IGNORABLE_CHAR = 86; + exports2.EE_FAILED_TO_RESET_BEFORE_TERTIARY_IGNORABLE_CHAR = 87; + exports2.EE_SHIFT_CHAR_OUT_OF_RANGE = 88; + exports2.EE_RESET_CHAR_OUT_OF_RANGE = 89; + exports2.EE_UNKNOWN_LDML_TAG = 90; + exports2.EE_FAILED_TO_RESET_BEFORE_SECONDARY_IGNORABLE_CHAR = 91; + exports2.EE_FAILED_PROCESSING_DIRECTIVE = 92; + exports2.EE_PTHREAD_KILL_FAILED = 93; + exports2.HA_ERR_KEY_NOT_FOUND = 120; + exports2.HA_ERR_FOUND_DUPP_KEY = 121; + exports2.HA_ERR_INTERNAL_ERROR = 122; + exports2.HA_ERR_RECORD_CHANGED = 123; + exports2.HA_ERR_WRONG_INDEX = 124; + exports2.HA_ERR_ROLLED_BACK = 125; + exports2.HA_ERR_CRASHED = 126; + exports2.HA_ERR_WRONG_IN_RECORD = 127; + exports2.HA_ERR_OUT_OF_MEM = 128; + exports2.HA_ERR_NOT_A_TABLE = 130; + exports2.HA_ERR_WRONG_COMMAND = 131; + exports2.HA_ERR_OLD_FILE = 132; + exports2.HA_ERR_NO_ACTIVE_RECORD = 133; + exports2.HA_ERR_RECORD_DELETED = 134; + exports2.HA_ERR_RECORD_FILE_FULL = 135; + exports2.HA_ERR_INDEX_FILE_FULL = 136; + exports2.HA_ERR_END_OF_FILE = 137; + exports2.HA_ERR_UNSUPPORTED = 138; + exports2.HA_ERR_TOO_BIG_ROW = 139; + exports2.HA_WRONG_CREATE_OPTION = 140; + exports2.HA_ERR_FOUND_DUPP_UNIQUE = 141; + exports2.HA_ERR_UNKNOWN_CHARSET = 142; + exports2.HA_ERR_WRONG_MRG_TABLE_DEF = 143; + exports2.HA_ERR_CRASHED_ON_REPAIR = 144; + exports2.HA_ERR_CRASHED_ON_USAGE = 145; + exports2.HA_ERR_LOCK_WAIT_TIMEOUT = 146; + exports2.HA_ERR_LOCK_TABLE_FULL = 147; + exports2.HA_ERR_READ_ONLY_TRANSACTION = 148; + exports2.HA_ERR_LOCK_DEADLOCK = 149; + exports2.HA_ERR_CANNOT_ADD_FOREIGN = 150; + exports2.HA_ERR_NO_REFERENCED_ROW = 151; + exports2.HA_ERR_ROW_IS_REFERENCED = 152; + exports2.HA_ERR_NO_SAVEPOINT = 153; + exports2.HA_ERR_NON_UNIQUE_BLOCK_SIZE = 154; + exports2.HA_ERR_NO_SUCH_TABLE = 155; + exports2.HA_ERR_TABLE_EXIST = 156; + exports2.HA_ERR_NO_CONNECTION = 157; + exports2.HA_ERR_NULL_IN_SPATIAL = 158; + exports2.HA_ERR_TABLE_DEF_CHANGED = 159; + exports2.HA_ERR_NO_PARTITION_FOUND = 160; + exports2.HA_ERR_RBR_LOGGING_FAILED = 161; + exports2.HA_ERR_DROP_INDEX_FK = 162; + exports2.HA_ERR_FOREIGN_DUPLICATE_KEY = 163; + exports2.HA_ERR_TABLE_NEEDS_UPGRADE = 164; + exports2.HA_ERR_TABLE_READONLY = 165; + exports2.HA_ERR_AUTOINC_READ_FAILED = 166; + exports2.HA_ERR_AUTOINC_ERANGE = 167; + exports2.HA_ERR_GENERIC = 168; + exports2.HA_ERR_RECORD_IS_THE_SAME = 169; + exports2.HA_ERR_LOGGING_IMPOSSIBLE = 170; + exports2.HA_ERR_CORRUPT_EVENT = 171; + exports2.HA_ERR_NEW_FILE = 172; + exports2.HA_ERR_ROWS_EVENT_APPLY = 173; + exports2.HA_ERR_INITIALIZATION = 174; + exports2.HA_ERR_FILE_TOO_SHORT = 175; + exports2.HA_ERR_WRONG_CRC = 176; + exports2.HA_ERR_TOO_MANY_CONCURRENT_TRXS = 177; + exports2.HA_ERR_NOT_IN_LOCK_PARTITIONS = 178; + exports2.HA_ERR_INDEX_COL_TOO_LONG = 179; + exports2.HA_ERR_INDEX_CORRUPT = 180; + exports2.HA_ERR_UNDO_REC_TOO_BIG = 181; + exports2.HA_FTS_INVALID_DOCID = 182; + exports2.HA_ERR_TABLE_IN_FK_CHECK = 183; + exports2.HA_ERR_TABLESPACE_EXISTS = 184; + exports2.HA_ERR_TOO_MANY_FIELDS = 185; + exports2.HA_ERR_ROW_IN_WRONG_PARTITION = 186; + exports2.HA_ERR_INNODB_READ_ONLY = 187; + exports2.HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT = 188; + exports2.HA_ERR_TEMP_FILE_WRITE_FAILURE = 189; + exports2.HA_ERR_INNODB_FORCED_RECOVERY = 190; + exports2.HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE = 191; + exports2.HA_ERR_FK_DEPTH_EXCEEDED = 192; + exports2.HA_MISSING_CREATE_OPTION = 193; + exports2.HA_ERR_SE_OUT_OF_MEMORY = 194; + exports2.HA_ERR_TABLE_CORRUPT = 195; + exports2.HA_ERR_QUERY_INTERRUPTED = 196; + exports2.HA_ERR_TABLESPACE_MISSING = 197; + exports2.HA_ERR_TABLESPACE_IS_NOT_EMPTY = 198; + exports2.HA_ERR_WRONG_FILE_NAME = 199; + exports2.HA_ERR_NOT_ALLOWED_COMMAND = 200; + exports2.HA_ERR_COMPUTE_FAILED = 201; + exports2.HA_ERR_ROW_FORMAT_CHANGED = 202; + exports2.HA_ERR_NO_WAIT_LOCK = 203; + exports2.HA_ERR_DISK_FULL_NOWAIT = 204; + exports2.HA_ERR_NO_SESSION_TEMP = 205; + exports2.HA_ERR_WRONG_TABLE_NAME = 206; + exports2.HA_ERR_TOO_LONG_PATH = 207; + exports2.HA_ERR_SAMPLING_INIT_FAILED = 208; + exports2.HA_ERR_FTS_TOO_MANY_NESTED_EXP = 209; + exports2.ER_HASHCHK = 1e3; + exports2.ER_NISAMCHK = 1001; + exports2.ER_NO = 1002; + exports2.ER_YES = 1003; + exports2.ER_CANT_CREATE_FILE = 1004; + exports2.ER_CANT_CREATE_TABLE = 1005; + exports2.ER_CANT_CREATE_DB = 1006; + exports2.ER_DB_CREATE_EXISTS = 1007; + exports2.ER_DB_DROP_EXISTS = 1008; + exports2.ER_DB_DROP_DELETE = 1009; + exports2.ER_DB_DROP_RMDIR = 1010; + exports2.ER_CANT_DELETE_FILE = 1011; + exports2.ER_CANT_FIND_SYSTEM_REC = 1012; + exports2.ER_CANT_GET_STAT = 1013; + exports2.ER_CANT_GET_WD = 1014; + exports2.ER_CANT_LOCK = 1015; + exports2.ER_CANT_OPEN_FILE = 1016; + exports2.ER_FILE_NOT_FOUND = 1017; + exports2.ER_CANT_READ_DIR = 1018; + exports2.ER_CANT_SET_WD = 1019; + exports2.ER_CHECKREAD = 1020; + exports2.ER_DISK_FULL = 1021; + exports2.ER_DUP_KEY = 1022; + exports2.ER_ERROR_ON_CLOSE = 1023; + exports2.ER_ERROR_ON_READ = 1024; + exports2.ER_ERROR_ON_RENAME = 1025; + exports2.ER_ERROR_ON_WRITE = 1026; + exports2.ER_FILE_USED = 1027; + exports2.ER_FILSORT_ABORT = 1028; + exports2.ER_FORM_NOT_FOUND = 1029; + exports2.ER_GET_ERRNO = 1030; + exports2.ER_ILLEGAL_HA = 1031; + exports2.ER_KEY_NOT_FOUND = 1032; + exports2.ER_NOT_FORM_FILE = 1033; + exports2.ER_NOT_KEYFILE = 1034; + exports2.ER_OLD_KEYFILE = 1035; + exports2.ER_OPEN_AS_READONLY = 1036; + exports2.ER_OUTOFMEMORY = 1037; + exports2.ER_OUT_OF_SORTMEMORY = 1038; + exports2.ER_UNEXPECTED_EOF = 1039; + exports2.ER_CON_COUNT_ERROR = 1040; + exports2.ER_OUT_OF_RESOURCES = 1041; + exports2.ER_BAD_HOST_ERROR = 1042; + exports2.ER_HANDSHAKE_ERROR = 1043; + exports2.ER_DBACCESS_DENIED_ERROR = 1044; + exports2.ER_ACCESS_DENIED_ERROR = 1045; + exports2.ER_NO_DB_ERROR = 1046; + exports2.ER_UNKNOWN_COM_ERROR = 1047; + exports2.ER_BAD_NULL_ERROR = 1048; + exports2.ER_BAD_DB_ERROR = 1049; + exports2.ER_TABLE_EXISTS_ERROR = 1050; + exports2.ER_BAD_TABLE_ERROR = 1051; + exports2.ER_NON_UNIQ_ERROR = 1052; + exports2.ER_SERVER_SHUTDOWN = 1053; + exports2.ER_BAD_FIELD_ERROR = 1054; + exports2.ER_WRONG_FIELD_WITH_GROUP = 1055; + exports2.ER_WRONG_GROUP_FIELD = 1056; + exports2.ER_WRONG_SUM_SELECT = 1057; + exports2.ER_WRONG_VALUE_COUNT = 1058; + exports2.ER_TOO_LONG_IDENT = 1059; + exports2.ER_DUP_FIELDNAME = 1060; + exports2.ER_DUP_KEYNAME = 1061; + exports2.ER_DUP_ENTRY = 1062; + exports2.ER_WRONG_FIELD_SPEC = 1063; + exports2.ER_PARSE_ERROR = 1064; + exports2.ER_EMPTY_QUERY = 1065; + exports2.ER_NONUNIQ_TABLE = 1066; + exports2.ER_INVALID_DEFAULT = 1067; + exports2.ER_MULTIPLE_PRI_KEY = 1068; + exports2.ER_TOO_MANY_KEYS = 1069; + exports2.ER_TOO_MANY_KEY_PARTS = 1070; + exports2.ER_TOO_LONG_KEY = 1071; + exports2.ER_KEY_COLUMN_DOES_NOT_EXITS = 1072; + exports2.ER_BLOB_USED_AS_KEY = 1073; + exports2.ER_TOO_BIG_FIELDLENGTH = 1074; + exports2.ER_WRONG_AUTO_KEY = 1075; + exports2.ER_READY = 1076; + exports2.ER_NORMAL_SHUTDOWN = 1077; + exports2.ER_GOT_SIGNAL = 1078; + exports2.ER_SHUTDOWN_COMPLETE = 1079; + exports2.ER_FORCING_CLOSE = 1080; + exports2.ER_IPSOCK_ERROR = 1081; + exports2.ER_NO_SUCH_INDEX = 1082; + exports2.ER_WRONG_FIELD_TERMINATORS = 1083; + exports2.ER_BLOBS_AND_NO_TERMINATED = 1084; + exports2.ER_TEXTFILE_NOT_READABLE = 1085; + exports2.ER_FILE_EXISTS_ERROR = 1086; + exports2.ER_LOAD_INFO = 1087; + exports2.ER_ALTER_INFO = 1088; + exports2.ER_WRONG_SUB_KEY = 1089; + exports2.ER_CANT_REMOVE_ALL_FIELDS = 1090; + exports2.ER_CANT_DROP_FIELD_OR_KEY = 1091; + exports2.ER_INSERT_INFO = 1092; + exports2.ER_UPDATE_TABLE_USED = 1093; + exports2.ER_NO_SUCH_THREAD = 1094; + exports2.ER_KILL_DENIED_ERROR = 1095; + exports2.ER_NO_TABLES_USED = 1096; + exports2.ER_TOO_BIG_SET = 1097; + exports2.ER_NO_UNIQUE_LOGFILE = 1098; + exports2.ER_TABLE_NOT_LOCKED_FOR_WRITE = 1099; + exports2.ER_TABLE_NOT_LOCKED = 1100; + exports2.ER_BLOB_CANT_HAVE_DEFAULT = 1101; + exports2.ER_WRONG_DB_NAME = 1102; + exports2.ER_WRONG_TABLE_NAME = 1103; + exports2.ER_TOO_BIG_SELECT = 1104; + exports2.ER_UNKNOWN_ERROR = 1105; + exports2.ER_UNKNOWN_PROCEDURE = 1106; + exports2.ER_WRONG_PARAMCOUNT_TO_PROCEDURE = 1107; + exports2.ER_WRONG_PARAMETERS_TO_PROCEDURE = 1108; + exports2.ER_UNKNOWN_TABLE = 1109; + exports2.ER_FIELD_SPECIFIED_TWICE = 1110; + exports2.ER_INVALID_GROUP_FUNC_USE = 1111; + exports2.ER_UNSUPPORTED_EXTENSION = 1112; + exports2.ER_TABLE_MUST_HAVE_COLUMNS = 1113; + exports2.ER_RECORD_FILE_FULL = 1114; + exports2.ER_UNKNOWN_CHARACTER_SET = 1115; + exports2.ER_TOO_MANY_TABLES = 1116; + exports2.ER_TOO_MANY_FIELDS = 1117; + exports2.ER_TOO_BIG_ROWSIZE = 1118; + exports2.ER_STACK_OVERRUN = 1119; + exports2.ER_WRONG_OUTER_JOIN = 1120; + exports2.ER_NULL_COLUMN_IN_INDEX = 1121; + exports2.ER_CANT_FIND_UDF = 1122; + exports2.ER_CANT_INITIALIZE_UDF = 1123; + exports2.ER_UDF_NO_PATHS = 1124; + exports2.ER_UDF_EXISTS = 1125; + exports2.ER_CANT_OPEN_LIBRARY = 1126; + exports2.ER_CANT_FIND_DL_ENTRY = 1127; + exports2.ER_FUNCTION_NOT_DEFINED = 1128; + exports2.ER_HOST_IS_BLOCKED = 1129; + exports2.ER_HOST_NOT_PRIVILEGED = 1130; + exports2.ER_PASSWORD_ANONYMOUS_USER = 1131; + exports2.ER_PASSWORD_NOT_ALLOWED = 1132; + exports2.ER_PASSWORD_NO_MATCH = 1133; + exports2.ER_UPDATE_INFO = 1134; + exports2.ER_CANT_CREATE_THREAD = 1135; + exports2.ER_WRONG_VALUE_COUNT_ON_ROW = 1136; + exports2.ER_CANT_REOPEN_TABLE = 1137; + exports2.ER_INVALID_USE_OF_NULL = 1138; + exports2.ER_REGEXP_ERROR = 1139; + exports2.ER_MIX_OF_GROUP_FUNC_AND_FIELDS = 1140; + exports2.ER_NONEXISTING_GRANT = 1141; + exports2.ER_TABLEACCESS_DENIED_ERROR = 1142; + exports2.ER_COLUMNACCESS_DENIED_ERROR = 1143; + exports2.ER_ILLEGAL_GRANT_FOR_TABLE = 1144; + exports2.ER_GRANT_WRONG_HOST_OR_USER = 1145; + exports2.ER_NO_SUCH_TABLE = 1146; + exports2.ER_NONEXISTING_TABLE_GRANT = 1147; + exports2.ER_NOT_ALLOWED_COMMAND = 1148; + exports2.ER_SYNTAX_ERROR = 1149; + exports2.ER_UNUSED1 = 1150; + exports2.ER_UNUSED2 = 1151; + exports2.ER_ABORTING_CONNECTION = 1152; + exports2.ER_NET_PACKET_TOO_LARGE = 1153; + exports2.ER_NET_READ_ERROR_FROM_PIPE = 1154; + exports2.ER_NET_FCNTL_ERROR = 1155; + exports2.ER_NET_PACKETS_OUT_OF_ORDER = 1156; + exports2.ER_NET_UNCOMPRESS_ERROR = 1157; + exports2.ER_NET_READ_ERROR = 1158; + exports2.ER_NET_READ_INTERRUPTED = 1159; + exports2.ER_NET_ERROR_ON_WRITE = 1160; + exports2.ER_NET_WRITE_INTERRUPTED = 1161; + exports2.ER_TOO_LONG_STRING = 1162; + exports2.ER_TABLE_CANT_HANDLE_BLOB = 1163; + exports2.ER_TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164; + exports2.ER_UNUSED3 = 1165; + exports2.ER_WRONG_COLUMN_NAME = 1166; + exports2.ER_WRONG_KEY_COLUMN = 1167; + exports2.ER_WRONG_MRG_TABLE = 1168; + exports2.ER_DUP_UNIQUE = 1169; + exports2.ER_BLOB_KEY_WITHOUT_LENGTH = 1170; + exports2.ER_PRIMARY_CANT_HAVE_NULL = 1171; + exports2.ER_TOO_MANY_ROWS = 1172; + exports2.ER_REQUIRES_PRIMARY_KEY = 1173; + exports2.ER_NO_RAID_COMPILED = 1174; + exports2.ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175; + exports2.ER_KEY_DOES_NOT_EXITS = 1176; + exports2.ER_CHECK_NO_SUCH_TABLE = 1177; + exports2.ER_CHECK_NOT_IMPLEMENTED = 1178; + exports2.ER_CANT_DO_THIS_DURING_AN_TRANSACTION = 1179; + exports2.ER_ERROR_DURING_COMMIT = 1180; + exports2.ER_ERROR_DURING_ROLLBACK = 1181; + exports2.ER_ERROR_DURING_FLUSH_LOGS = 1182; + exports2.ER_ERROR_DURING_CHECKPOINT = 1183; + exports2.ER_NEW_ABORTING_CONNECTION = 1184; + exports2.ER_DUMP_NOT_IMPLEMENTED = 1185; + exports2.ER_FLUSH_MASTER_BINLOG_CLOSED = 1186; + exports2.ER_INDEX_REBUILD = 1187; + exports2.ER_SOURCE = 1188; + exports2.ER_SOURCE_NET_READ = 1189; + exports2.ER_SOURCE_NET_WRITE = 1190; + exports2.ER_FT_MATCHING_KEY_NOT_FOUND = 1191; + exports2.ER_LOCK_OR_ACTIVE_TRANSACTION = 1192; + exports2.ER_UNKNOWN_SYSTEM_VARIABLE = 1193; + exports2.ER_CRASHED_ON_USAGE = 1194; + exports2.ER_CRASHED_ON_REPAIR = 1195; + exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK = 1196; + exports2.ER_TRANS_CACHE_FULL = 1197; + exports2.ER_SLAVE_MUST_STOP = 1198; + exports2.ER_REPLICA_NOT_RUNNING = 1199; + exports2.ER_BAD_REPLICA = 1200; + exports2.ER_CONNECTION_METADATA = 1201; + exports2.ER_REPLICA_THREAD = 1202; + exports2.ER_TOO_MANY_USER_CONNECTIONS = 1203; + exports2.ER_SET_CONSTANTS_ONLY = 1204; + exports2.ER_LOCK_WAIT_TIMEOUT = 1205; + exports2.ER_LOCK_TABLE_FULL = 1206; + exports2.ER_READ_ONLY_TRANSACTION = 1207; + exports2.ER_DROP_DB_WITH_READ_LOCK = 1208; + exports2.ER_CREATE_DB_WITH_READ_LOCK = 1209; + exports2.ER_WRONG_ARGUMENTS = 1210; + exports2.ER_NO_PERMISSION_TO_CREATE_USER = 1211; + exports2.ER_UNION_TABLES_IN_DIFFERENT_DIR = 1212; + exports2.ER_LOCK_DEADLOCK = 1213; + exports2.ER_TABLE_CANT_HANDLE_FT = 1214; + exports2.ER_CANNOT_ADD_FOREIGN = 1215; + exports2.ER_NO_REFERENCED_ROW = 1216; + exports2.ER_ROW_IS_REFERENCED = 1217; + exports2.ER_CONNECT_TO_SOURCE = 1218; + exports2.ER_QUERY_ON_MASTER = 1219; + exports2.ER_ERROR_WHEN_EXECUTING_COMMAND = 1220; + exports2.ER_WRONG_USAGE = 1221; + exports2.ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222; + exports2.ER_CANT_UPDATE_WITH_READLOCK = 1223; + exports2.ER_MIXING_NOT_ALLOWED = 1224; + exports2.ER_DUP_ARGUMENT = 1225; + exports2.ER_USER_LIMIT_REACHED = 1226; + exports2.ER_SPECIFIC_ACCESS_DENIED_ERROR = 1227; + exports2.ER_LOCAL_VARIABLE = 1228; + exports2.ER_GLOBAL_VARIABLE = 1229; + exports2.ER_NO_DEFAULT = 1230; + exports2.ER_WRONG_VALUE_FOR_VAR = 1231; + exports2.ER_WRONG_TYPE_FOR_VAR = 1232; + exports2.ER_VAR_CANT_BE_READ = 1233; + exports2.ER_CANT_USE_OPTION_HERE = 1234; + exports2.ER_NOT_SUPPORTED_YET = 1235; + exports2.ER_SOURCE_FATAL_ERROR_READING_BINLOG = 1236; + exports2.ER_REPLICA_IGNORED_TABLE = 1237; + exports2.ER_INCORRECT_GLOBAL_LOCAL_VAR = 1238; + exports2.ER_WRONG_FK_DEF = 1239; + exports2.ER_KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240; + exports2.ER_OPERAND_COLUMNS = 1241; + exports2.ER_SUBQUERY_NO_1_ROW = 1242; + exports2.ER_UNKNOWN_STMT_HANDLER = 1243; + exports2.ER_CORRUPT_HELP_DB = 1244; + exports2.ER_CYCLIC_REFERENCE = 1245; + exports2.ER_AUTO_CONVERT = 1246; + exports2.ER_ILLEGAL_REFERENCE = 1247; + exports2.ER_DERIVED_MUST_HAVE_ALIAS = 1248; + exports2.ER_SELECT_REDUCED = 1249; + exports2.ER_TABLENAME_NOT_ALLOWED_HERE = 1250; + exports2.ER_NOT_SUPPORTED_AUTH_MODE = 1251; + exports2.ER_SPATIAL_CANT_HAVE_NULL = 1252; + exports2.ER_COLLATION_CHARSET_MISMATCH = 1253; + exports2.ER_SLAVE_WAS_RUNNING = 1254; + exports2.ER_SLAVE_WAS_NOT_RUNNING = 1255; + exports2.ER_TOO_BIG_FOR_UNCOMPRESS = 1256; + exports2.ER_ZLIB_Z_MEM_ERROR = 1257; + exports2.ER_ZLIB_Z_BUF_ERROR = 1258; + exports2.ER_ZLIB_Z_DATA_ERROR = 1259; + exports2.ER_CUT_VALUE_GROUP_CONCAT = 1260; + exports2.ER_WARN_TOO_FEW_RECORDS = 1261; + exports2.ER_WARN_TOO_MANY_RECORDS = 1262; + exports2.ER_WARN_NULL_TO_NOTNULL = 1263; + exports2.ER_WARN_DATA_OUT_OF_RANGE = 1264; + exports2.WARN_DATA_TRUNCATED = 1265; + exports2.ER_WARN_USING_OTHER_HANDLER = 1266; + exports2.ER_CANT_AGGREGATE_2COLLATIONS = 1267; + exports2.ER_DROP_USER = 1268; + exports2.ER_REVOKE_GRANTS = 1269; + exports2.ER_CANT_AGGREGATE_3COLLATIONS = 1270; + exports2.ER_CANT_AGGREGATE_NCOLLATIONS = 1271; + exports2.ER_VARIABLE_IS_NOT_STRUCT = 1272; + exports2.ER_UNKNOWN_COLLATION = 1273; + exports2.ER_REPLICA_IGNORED_SSL_PARAMS = 1274; + exports2.ER_SERVER_IS_IN_SECURE_AUTH_MODE = 1275; + exports2.ER_WARN_FIELD_RESOLVED = 1276; + exports2.ER_BAD_REPLICA_UNTIL_COND = 1277; + exports2.ER_MISSING_SKIP_REPLICA = 1278; + exports2.ER_UNTIL_COND_IGNORED = 1279; + exports2.ER_WRONG_NAME_FOR_INDEX = 1280; + exports2.ER_WRONG_NAME_FOR_CATALOG = 1281; + exports2.ER_WARN_QC_RESIZE = 1282; + exports2.ER_BAD_FT_COLUMN = 1283; + exports2.ER_UNKNOWN_KEY_CACHE = 1284; + exports2.ER_WARN_HOSTNAME_WONT_WORK = 1285; + exports2.ER_UNKNOWN_STORAGE_ENGINE = 1286; + exports2.ER_WARN_DEPRECATED_SYNTAX = 1287; + exports2.ER_NON_UPDATABLE_TABLE = 1288; + exports2.ER_FEATURE_DISABLED = 1289; + exports2.ER_OPTION_PREVENTS_STATEMENT = 1290; + exports2.ER_DUPLICATED_VALUE_IN_TYPE = 1291; + exports2.ER_TRUNCATED_WRONG_VALUE = 1292; + exports2.ER_TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293; + exports2.ER_INVALID_ON_UPDATE = 1294; + exports2.ER_UNSUPPORTED_PS = 1295; + exports2.ER_GET_ERRMSG = 1296; + exports2.ER_GET_TEMPORARY_ERRMSG = 1297; + exports2.ER_UNKNOWN_TIME_ZONE = 1298; + exports2.ER_WARN_INVALID_TIMESTAMP = 1299; + exports2.ER_INVALID_CHARACTER_STRING = 1300; + exports2.ER_WARN_ALLOWED_PACKET_OVERFLOWED = 1301; + exports2.ER_CONFLICTING_DECLARATIONS = 1302; + exports2.ER_SP_NO_RECURSIVE_CREATE = 1303; + exports2.ER_SP_ALREADY_EXISTS = 1304; + exports2.ER_SP_DOES_NOT_EXIST = 1305; + exports2.ER_SP_DROP_FAILED = 1306; + exports2.ER_SP_STORE_FAILED = 1307; + exports2.ER_SP_LILABEL_MISMATCH = 1308; + exports2.ER_SP_LABEL_REDEFINE = 1309; + exports2.ER_SP_LABEL_MISMATCH = 1310; + exports2.ER_SP_UNINIT_VAR = 1311; + exports2.ER_SP_BADSELECT = 1312; + exports2.ER_SP_BADRETURN = 1313; + exports2.ER_SP_BADSTATEMENT = 1314; + exports2.ER_UPDATE_LOG_DEPRECATED_IGNORED = 1315; + exports2.ER_UPDATE_LOG_DEPRECATED_TRANSLATED = 1316; + exports2.ER_QUERY_INTERRUPTED = 1317; + exports2.ER_SP_WRONG_NO_OF_ARGS = 1318; + exports2.ER_SP_COND_MISMATCH = 1319; + exports2.ER_SP_NORETURN = 1320; + exports2.ER_SP_NORETURNEND = 1321; + exports2.ER_SP_BAD_CURSOR_QUERY = 1322; + exports2.ER_SP_BAD_CURSOR_SELECT = 1323; + exports2.ER_SP_CURSOR_MISMATCH = 1324; + exports2.ER_SP_CURSOR_ALREADY_OPEN = 1325; + exports2.ER_SP_CURSOR_NOT_OPEN = 1326; + exports2.ER_SP_UNDECLARED_VAR = 1327; + exports2.ER_SP_WRONG_NO_OF_FETCH_ARGS = 1328; + exports2.ER_SP_FETCH_NO_DATA = 1329; + exports2.ER_SP_DUP_PARAM = 1330; + exports2.ER_SP_DUP_VAR = 1331; + exports2.ER_SP_DUP_COND = 1332; + exports2.ER_SP_DUP_CURS = 1333; + exports2.ER_SP_CANT_ALTER = 1334; + exports2.ER_SP_SUBSELECT_NYI = 1335; + exports2.ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336; + exports2.ER_SP_VARCOND_AFTER_CURSHNDLR = 1337; + exports2.ER_SP_CURSOR_AFTER_HANDLER = 1338; + exports2.ER_SP_CASE_NOT_FOUND = 1339; + exports2.ER_FPARSER_TOO_BIG_FILE = 1340; + exports2.ER_FPARSER_BAD_HEADER = 1341; + exports2.ER_FPARSER_EOF_IN_COMMENT = 1342; + exports2.ER_FPARSER_ERROR_IN_PARAMETER = 1343; + exports2.ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344; + exports2.ER_VIEW_NO_EXPLAIN = 1345; + exports2.ER_FRM_UNKNOWN_TYPE = 1346; + exports2.ER_WRONG_OBJECT = 1347; + exports2.ER_NONUPDATEABLE_COLUMN = 1348; + exports2.ER_VIEW_SELECT_DERIVED = 1349; + exports2.ER_VIEW_SELECT_CLAUSE = 1350; + exports2.ER_VIEW_SELECT_VARIABLE = 1351; + exports2.ER_VIEW_SELECT_TMPTABLE = 1352; + exports2.ER_VIEW_WRONG_LIST = 1353; + exports2.ER_WARN_VIEW_MERGE = 1354; + exports2.ER_WARN_VIEW_WITHOUT_KEY = 1355; + exports2.ER_VIEW_INVALID = 1356; + exports2.ER_SP_NO_DROP_SP = 1357; + exports2.ER_SP_GOTO_IN_HNDLR = 1358; + exports2.ER_TRG_ALREADY_EXISTS = 1359; + exports2.ER_TRG_DOES_NOT_EXIST = 1360; + exports2.ER_TRG_ON_VIEW_OR_TEMP_TABLE = 1361; + exports2.ER_TRG_CANT_CHANGE_ROW = 1362; + exports2.ER_TRG_NO_SUCH_ROW_IN_TRG = 1363; + exports2.ER_NO_DEFAULT_FOR_FIELD = 1364; + exports2.ER_DIVISION_BY_ZERO = 1365; + exports2.ER_TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366; + exports2.ER_ILLEGAL_VALUE_FOR_TYPE = 1367; + exports2.ER_VIEW_NONUPD_CHECK = 1368; + exports2.ER_VIEW_CHECK_FAILED = 1369; + exports2.ER_PROCACCESS_DENIED_ERROR = 1370; + exports2.ER_RELAY_LOG_FAIL = 1371; + exports2.ER_PASSWD_LENGTH = 1372; + exports2.ER_UNKNOWN_TARGET_BINLOG = 1373; + exports2.ER_IO_ERR_LOG_INDEX_READ = 1374; + exports2.ER_BINLOG_PURGE_PROHIBITED = 1375; + exports2.ER_FSEEK_FAIL = 1376; + exports2.ER_BINLOG_PURGE_FATAL_ERR = 1377; + exports2.ER_LOG_IN_USE = 1378; + exports2.ER_LOG_PURGE_UNKNOWN_ERR = 1379; + exports2.ER_RELAY_LOG_INIT = 1380; + exports2.ER_NO_BINARY_LOGGING = 1381; + exports2.ER_RESERVED_SYNTAX = 1382; + exports2.ER_WSAS_FAILED = 1383; + exports2.ER_DIFF_GROUPS_PROC = 1384; + exports2.ER_NO_GROUP_FOR_PROC = 1385; + exports2.ER_ORDER_WITH_PROC = 1386; + exports2.ER_LOGGING_PROHIBIT_CHANGING_OF = 1387; + exports2.ER_NO_FILE_MAPPING = 1388; + exports2.ER_WRONG_MAGIC = 1389; + exports2.ER_PS_MANY_PARAM = 1390; + exports2.ER_KEY_PART_0 = 1391; + exports2.ER_VIEW_CHECKSUM = 1392; + exports2.ER_VIEW_MULTIUPDATE = 1393; + exports2.ER_VIEW_NO_INSERT_FIELD_LIST = 1394; + exports2.ER_VIEW_DELETE_MERGE_VIEW = 1395; + exports2.ER_CANNOT_USER = 1396; + exports2.ER_XAER_NOTA = 1397; + exports2.ER_XAER_INVAL = 1398; + exports2.ER_XAER_RMFAIL = 1399; + exports2.ER_XAER_OUTSIDE = 1400; + exports2.ER_XAER_RMERR = 1401; + exports2.ER_XA_RBROLLBACK = 1402; + exports2.ER_NONEXISTING_PROC_GRANT = 1403; + exports2.ER_PROC_AUTO_GRANT_FAIL = 1404; + exports2.ER_PROC_AUTO_REVOKE_FAIL = 1405; + exports2.ER_DATA_TOO_LONG = 1406; + exports2.ER_SP_BAD_SQLSTATE = 1407; + exports2.ER_STARTUP = 1408; + exports2.ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409; + exports2.ER_CANT_CREATE_USER_WITH_GRANT = 1410; + exports2.ER_WRONG_VALUE_FOR_TYPE = 1411; + exports2.ER_TABLE_DEF_CHANGED = 1412; + exports2.ER_SP_DUP_HANDLER = 1413; + exports2.ER_SP_NOT_VAR_ARG = 1414; + exports2.ER_SP_NO_RETSET = 1415; + exports2.ER_CANT_CREATE_GEOMETRY_OBJECT = 1416; + exports2.ER_FAILED_ROUTINE_BREAK_BINLOG = 1417; + exports2.ER_BINLOG_UNSAFE_ROUTINE = 1418; + exports2.ER_BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419; + exports2.ER_EXEC_STMT_WITH_OPEN_CURSOR = 1420; + exports2.ER_STMT_HAS_NO_OPEN_CURSOR = 1421; + exports2.ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422; + exports2.ER_NO_DEFAULT_FOR_VIEW_FIELD = 1423; + exports2.ER_SP_NO_RECURSION = 1424; + exports2.ER_TOO_BIG_SCALE = 1425; + exports2.ER_TOO_BIG_PRECISION = 1426; + exports2.ER_M_BIGGER_THAN_D = 1427; + exports2.ER_WRONG_LOCK_OF_SYSTEM_TABLE = 1428; + exports2.ER_CONNECT_TO_FOREIGN_DATA_SOURCE = 1429; + exports2.ER_QUERY_ON_FOREIGN_DATA_SOURCE = 1430; + exports2.ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431; + exports2.ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432; + exports2.ER_FOREIGN_DATA_STRING_INVALID = 1433; + exports2.ER_CANT_CREATE_FEDERATED_TABLE = 1434; + exports2.ER_TRG_IN_WRONG_SCHEMA = 1435; + exports2.ER_STACK_OVERRUN_NEED_MORE = 1436; + exports2.ER_TOO_LONG_BODY = 1437; + exports2.ER_WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438; + exports2.ER_TOO_BIG_DISPLAYWIDTH = 1439; + exports2.ER_XAER_DUPID = 1440; + exports2.ER_DATETIME_FUNCTION_OVERFLOW = 1441; + exports2.ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442; + exports2.ER_VIEW_PREVENT_UPDATE = 1443; + exports2.ER_PS_NO_RECURSION = 1444; + exports2.ER_SP_CANT_SET_AUTOCOMMIT = 1445; + exports2.ER_MALFORMED_DEFINER = 1446; + exports2.ER_VIEW_FRM_NO_USER = 1447; + exports2.ER_VIEW_OTHER_USER = 1448; + exports2.ER_NO_SUCH_USER = 1449; + exports2.ER_FORBID_SCHEMA_CHANGE = 1450; + exports2.ER_ROW_IS_REFERENCED_2 = 1451; + exports2.ER_NO_REFERENCED_ROW_2 = 1452; + exports2.ER_SP_BAD_VAR_SHADOW = 1453; + exports2.ER_TRG_NO_DEFINER = 1454; + exports2.ER_OLD_FILE_FORMAT = 1455; + exports2.ER_SP_RECURSION_LIMIT = 1456; + exports2.ER_SP_PROC_TABLE_CORRUPT = 1457; + exports2.ER_SP_WRONG_NAME = 1458; + exports2.ER_TABLE_NEEDS_UPGRADE = 1459; + exports2.ER_SP_NO_AGGREGATE = 1460; + exports2.ER_MAX_PREPARED_STMT_COUNT_REACHED = 1461; + exports2.ER_VIEW_RECURSIVE = 1462; + exports2.ER_NON_GROUPING_FIELD_USED = 1463; + exports2.ER_TABLE_CANT_HANDLE_SPKEYS = 1464; + exports2.ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465; + exports2.ER_REMOVED_SPACES = 1466; + exports2.ER_AUTOINC_READ_FAILED = 1467; + exports2.ER_USERNAME = 1468; + exports2.ER_HOSTNAME = 1469; + exports2.ER_WRONG_STRING_LENGTH = 1470; + exports2.ER_NON_INSERTABLE_TABLE = 1471; + exports2.ER_ADMIN_WRONG_MRG_TABLE = 1472; + exports2.ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT = 1473; + exports2.ER_NAME_BECOMES_EMPTY = 1474; + exports2.ER_AMBIGUOUS_FIELD_TERM = 1475; + exports2.ER_FOREIGN_SERVER_EXISTS = 1476; + exports2.ER_FOREIGN_SERVER_DOESNT_EXIST = 1477; + exports2.ER_ILLEGAL_HA_CREATE_OPTION = 1478; + exports2.ER_PARTITION_REQUIRES_VALUES_ERROR = 1479; + exports2.ER_PARTITION_WRONG_VALUES_ERROR = 1480; + exports2.ER_PARTITION_MAXVALUE_ERROR = 1481; + exports2.ER_PARTITION_SUBPARTITION_ERROR = 1482; + exports2.ER_PARTITION_SUBPART_MIX_ERROR = 1483; + exports2.ER_PARTITION_WRONG_NO_PART_ERROR = 1484; + exports2.ER_PARTITION_WRONG_NO_SUBPART_ERROR = 1485; + exports2.ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR = 1486; + exports2.ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR = 1487; + exports2.ER_FIELD_NOT_FOUND_PART_ERROR = 1488; + exports2.ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR = 1489; + exports2.ER_INCONSISTENT_PARTITION_INFO_ERROR = 1490; + exports2.ER_PARTITION_FUNC_NOT_ALLOWED_ERROR = 1491; + exports2.ER_PARTITIONS_MUST_BE_DEFINED_ERROR = 1492; + exports2.ER_RANGE_NOT_INCREASING_ERROR = 1493; + exports2.ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR = 1494; + exports2.ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR = 1495; + exports2.ER_PARTITION_ENTRY_ERROR = 1496; + exports2.ER_MIX_HANDLER_ERROR = 1497; + exports2.ER_PARTITION_NOT_DEFINED_ERROR = 1498; + exports2.ER_TOO_MANY_PARTITIONS_ERROR = 1499; + exports2.ER_SUBPARTITION_ERROR = 1500; + exports2.ER_CANT_CREATE_HANDLER_FILE = 1501; + exports2.ER_BLOB_FIELD_IN_PART_FUNC_ERROR = 1502; + exports2.ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF = 1503; + exports2.ER_NO_PARTS_ERROR = 1504; + exports2.ER_PARTITION_MGMT_ON_NONPARTITIONED = 1505; + exports2.ER_FOREIGN_KEY_ON_PARTITIONED = 1506; + exports2.ER_DROP_PARTITION_NON_EXISTENT = 1507; + exports2.ER_DROP_LAST_PARTITION = 1508; + exports2.ER_COALESCE_ONLY_ON_HASH_PARTITION = 1509; + exports2.ER_REORG_HASH_ONLY_ON_SAME_NO = 1510; + exports2.ER_REORG_NO_PARAM_ERROR = 1511; + exports2.ER_ONLY_ON_RANGE_LIST_PARTITION = 1512; + exports2.ER_ADD_PARTITION_SUBPART_ERROR = 1513; + exports2.ER_ADD_PARTITION_NO_NEW_PARTITION = 1514; + exports2.ER_COALESCE_PARTITION_NO_PARTITION = 1515; + exports2.ER_REORG_PARTITION_NOT_EXIST = 1516; + exports2.ER_SAME_NAME_PARTITION = 1517; + exports2.ER_NO_BINLOG_ERROR = 1518; + exports2.ER_CONSECUTIVE_REORG_PARTITIONS = 1519; + exports2.ER_REORG_OUTSIDE_RANGE = 1520; + exports2.ER_PARTITION_FUNCTION_FAILURE = 1521; + exports2.ER_PART_STATE_ERROR = 1522; + exports2.ER_LIMITED_PART_RANGE = 1523; + exports2.ER_PLUGIN_IS_NOT_LOADED = 1524; + exports2.ER_WRONG_VALUE = 1525; + exports2.ER_NO_PARTITION_FOR_GIVEN_VALUE = 1526; + exports2.ER_FILEGROUP_OPTION_ONLY_ONCE = 1527; + exports2.ER_CREATE_FILEGROUP_FAILED = 1528; + exports2.ER_DROP_FILEGROUP_FAILED = 1529; + exports2.ER_TABLESPACE_AUTO_EXTEND_ERROR = 1530; + exports2.ER_WRONG_SIZE_NUMBER = 1531; + exports2.ER_SIZE_OVERFLOW_ERROR = 1532; + exports2.ER_ALTER_FILEGROUP_FAILED = 1533; + exports2.ER_BINLOG_ROW_LOGGING_FAILED = 1534; + exports2.ER_BINLOG_ROW_WRONG_TABLE_DEF = 1535; + exports2.ER_BINLOG_ROW_RBR_TO_SBR = 1536; + exports2.ER_EVENT_ALREADY_EXISTS = 1537; + exports2.ER_EVENT_STORE_FAILED = 1538; + exports2.ER_EVENT_DOES_NOT_EXIST = 1539; + exports2.ER_EVENT_CANT_ALTER = 1540; + exports2.ER_EVENT_DROP_FAILED = 1541; + exports2.ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG = 1542; + exports2.ER_EVENT_ENDS_BEFORE_STARTS = 1543; + exports2.ER_EVENT_EXEC_TIME_IN_THE_PAST = 1544; + exports2.ER_EVENT_OPEN_TABLE_FAILED = 1545; + exports2.ER_EVENT_NEITHER_M_EXPR_NOR_M_AT = 1546; + exports2.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED = 1547; + exports2.ER_CANNOT_LOAD_FROM_TABLE = 1548; + exports2.ER_EVENT_CANNOT_DELETE = 1549; + exports2.ER_EVENT_COMPILE_ERROR = 1550; + exports2.ER_EVENT_SAME_NAME = 1551; + exports2.ER_EVENT_DATA_TOO_LONG = 1552; + exports2.ER_DROP_INDEX_FK = 1553; + exports2.ER_WARN_DEPRECATED_SYNTAX_WITH_VER = 1554; + exports2.ER_CANT_WRITE_LOCK_LOG_TABLE = 1555; + exports2.ER_CANT_LOCK_LOG_TABLE = 1556; + exports2.ER_FOREIGN_DUPLICATE_KEY = 1557; + exports2.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE = 1558; + exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR = 1559; + exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1560; + exports2.ER_NDB_CANT_SWITCH_BINLOG_FORMAT = 1561; + exports2.ER_PARTITION_NO_TEMPORARY = 1562; + exports2.ER_PARTITION_CONST_DOMAIN_ERROR = 1563; + exports2.ER_PARTITION_FUNCTION_IS_NOT_ALLOWED = 1564; + exports2.ER_DDL_LOG_ERROR = 1565; + exports2.ER_NULL_IN_VALUES_LESS_THAN = 1566; + exports2.ER_WRONG_PARTITION_NAME = 1567; + exports2.ER_CANT_CHANGE_TX_CHARACTERISTICS = 1568; + exports2.ER_DUP_ENTRY_AUTOINCREMENT_CASE = 1569; + exports2.ER_EVENT_MODIFY_QUEUE_ERROR = 1570; + exports2.ER_EVENT_SET_VAR_ERROR = 1571; + exports2.ER_PARTITION_MERGE_ERROR = 1572; + exports2.ER_CANT_ACTIVATE_LOG = 1573; + exports2.ER_RBR_NOT_AVAILABLE = 1574; + exports2.ER_BASE64_DECODE_ERROR = 1575; + exports2.ER_EVENT_RECURSION_FORBIDDEN = 1576; + exports2.ER_EVENTS_DB_ERROR = 1577; + exports2.ER_ONLY_INTEGERS_ALLOWED = 1578; + exports2.ER_UNSUPORTED_LOG_ENGINE = 1579; + exports2.ER_BAD_LOG_STATEMENT = 1580; + exports2.ER_CANT_RENAME_LOG_TABLE = 1581; + exports2.ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT = 1582; + exports2.ER_WRONG_PARAMETERS_TO_NATIVE_FCT = 1583; + exports2.ER_WRONG_PARAMETERS_TO_STORED_FCT = 1584; + exports2.ER_NATIVE_FCT_NAME_COLLISION = 1585; + exports2.ER_DUP_ENTRY_WITH_KEY_NAME = 1586; + exports2.ER_BINLOG_PURGE_EMFILE = 1587; + exports2.ER_EVENT_CANNOT_CREATE_IN_THE_PAST = 1588; + exports2.ER_EVENT_CANNOT_ALTER_IN_THE_PAST = 1589; + exports2.ER_SLAVE_INCIDENT = 1590; + exports2.ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT = 1591; + exports2.ER_BINLOG_UNSAFE_STATEMENT = 1592; + exports2.ER_BINLOG_FATAL_ERROR = 1593; + exports2.ER_SLAVE_RELAY_LOG_READ_FAILURE = 1594; + exports2.ER_SLAVE_RELAY_LOG_WRITE_FAILURE = 1595; + exports2.ER_SLAVE_CREATE_EVENT_FAILURE = 1596; + exports2.ER_SLAVE_MASTER_COM_FAILURE = 1597; + exports2.ER_BINLOG_LOGGING_IMPOSSIBLE = 1598; + exports2.ER_VIEW_NO_CREATION_CTX = 1599; + exports2.ER_VIEW_INVALID_CREATION_CTX = 1600; + exports2.ER_SR_INVALID_CREATION_CTX = 1601; + exports2.ER_TRG_CORRUPTED_FILE = 1602; + exports2.ER_TRG_NO_CREATION_CTX = 1603; + exports2.ER_TRG_INVALID_CREATION_CTX = 1604; + exports2.ER_EVENT_INVALID_CREATION_CTX = 1605; + exports2.ER_TRG_CANT_OPEN_TABLE = 1606; + exports2.ER_CANT_CREATE_SROUTINE = 1607; + exports2.ER_NEVER_USED = 1608; + exports2.ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT = 1609; + exports2.ER_REPLICA_CORRUPT_EVENT = 1610; + exports2.ER_LOAD_DATA_INVALID_COLUMN = 1611; + exports2.ER_LOG_PURGE_NO_FILE = 1612; + exports2.ER_XA_RBTIMEOUT = 1613; + exports2.ER_XA_RBDEADLOCK = 1614; + exports2.ER_NEED_REPREPARE = 1615; + exports2.ER_DELAYED_NOT_SUPPORTED = 1616; + exports2.WARN_NO_CONNECTION_METADATA = 1617; + exports2.WARN_OPTION_IGNORED = 1618; + exports2.ER_PLUGIN_DELETE_BUILTIN = 1619; + exports2.WARN_PLUGIN_BUSY = 1620; + exports2.ER_VARIABLE_IS_READONLY = 1621; + exports2.ER_WARN_ENGINE_TRANSACTION_ROLLBACK = 1622; + exports2.ER_SLAVE_HEARTBEAT_FAILURE = 1623; + exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624; + exports2.ER_NDB_REPLICATION_SCHEMA_ERROR = 1625; + exports2.ER_CONFLICT_FN_PARSE_ERROR = 1626; + exports2.ER_EXCEPTIONS_WRITE_ERROR = 1627; + exports2.ER_TOO_LONG_TABLE_COMMENT = 1628; + exports2.ER_TOO_LONG_FIELD_COMMENT = 1629; + exports2.ER_FUNC_INEXISTENT_NAME_COLLISION = 1630; + exports2.ER_DATABASE_NAME = 1631; + exports2.ER_TABLE_NAME = 1632; + exports2.ER_PARTITION_NAME = 1633; + exports2.ER_SUBPARTITION_NAME = 1634; + exports2.ER_TEMPORARY_NAME = 1635; + exports2.ER_RENAMED_NAME = 1636; + exports2.ER_TOO_MANY_CONCURRENT_TRXS = 1637; + exports2.WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED = 1638; + exports2.ER_DEBUG_SYNC_TIMEOUT = 1639; + exports2.ER_DEBUG_SYNC_HIT_LIMIT = 1640; + exports2.ER_DUP_SIGNAL_SET = 1641; + exports2.ER_SIGNAL_WARN = 1642; + exports2.ER_SIGNAL_NOT_FOUND = 1643; + exports2.ER_SIGNAL_EXCEPTION = 1644; + exports2.ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER = 1645; + exports2.ER_SIGNAL_BAD_CONDITION_TYPE = 1646; + exports2.WARN_COND_ITEM_TRUNCATED = 1647; + exports2.ER_COND_ITEM_TOO_LONG = 1648; + exports2.ER_UNKNOWN_LOCALE = 1649; + exports2.ER_REPLICA_IGNORE_SERVER_IDS = 1650; + exports2.ER_QUERY_CACHE_DISABLED = 1651; + exports2.ER_SAME_NAME_PARTITION_FIELD = 1652; + exports2.ER_PARTITION_COLUMN_LIST_ERROR = 1653; + exports2.ER_WRONG_TYPE_COLUMN_VALUE_ERROR = 1654; + exports2.ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR = 1655; + exports2.ER_MAXVALUE_IN_VALUES_IN = 1656; + exports2.ER_TOO_MANY_VALUES_ERROR = 1657; + exports2.ER_ROW_SINGLE_PARTITION_FIELD_ERROR = 1658; + exports2.ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD = 1659; + exports2.ER_PARTITION_FIELDS_TOO_LONG = 1660; + exports2.ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE = 1661; + exports2.ER_BINLOG_ROW_MODE_AND_STMT_ENGINE = 1662; + exports2.ER_BINLOG_UNSAFE_AND_STMT_ENGINE = 1663; + exports2.ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE = 1664; + exports2.ER_BINLOG_STMT_MODE_AND_ROW_ENGINE = 1665; + exports2.ER_BINLOG_ROW_INJECTION_AND_STMT_MODE = 1666; + exports2.ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1667; + exports2.ER_BINLOG_UNSAFE_LIMIT = 1668; + exports2.ER_UNUSED4 = 1669; + exports2.ER_BINLOG_UNSAFE_SYSTEM_TABLE = 1670; + exports2.ER_BINLOG_UNSAFE_AUTOINC_COLUMNS = 1671; + exports2.ER_BINLOG_UNSAFE_UDF = 1672; + exports2.ER_BINLOG_UNSAFE_SYSTEM_VARIABLE = 1673; + exports2.ER_BINLOG_UNSAFE_SYSTEM_FUNCTION = 1674; + exports2.ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS = 1675; + exports2.ER_MESSAGE_AND_STATEMENT = 1676; + exports2.ER_SLAVE_CONVERSION_FAILED = 1677; + exports2.ER_REPLICA_CANT_CREATE_CONVERSION = 1678; + exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1679; + exports2.ER_PATH_LENGTH = 1680; + exports2.ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT = 1681; + exports2.ER_WRONG_NATIVE_TABLE_STRUCTURE = 1682; + exports2.ER_WRONG_PERFSCHEMA_USAGE = 1683; + exports2.ER_WARN_I_S_SKIPPED_TABLE = 1684; + exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1685; + exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1686; + exports2.ER_SPATIAL_MUST_HAVE_GEOM_COL = 1687; + exports2.ER_TOO_LONG_INDEX_COMMENT = 1688; + exports2.ER_LOCK_ABORTED = 1689; + exports2.ER_DATA_OUT_OF_RANGE = 1690; + exports2.ER_WRONG_SPVAR_TYPE_IN_LIMIT = 1691; + exports2.ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1692; + exports2.ER_BINLOG_UNSAFE_MIXED_STATEMENT = 1693; + exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1694; + exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1695; + exports2.ER_FAILED_READ_FROM_PAR_FILE = 1696; + exports2.ER_VALUES_IS_NOT_INT_TYPE_ERROR = 1697; + exports2.ER_ACCESS_DENIED_NO_PASSWORD_ERROR = 1698; + exports2.ER_SET_PASSWORD_AUTH_PLUGIN = 1699; + exports2.ER_GRANT_PLUGIN_USER_EXISTS = 1700; + exports2.ER_TRUNCATE_ILLEGAL_FK = 1701; + exports2.ER_PLUGIN_IS_PERMANENT = 1702; + exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703; + exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704; + exports2.ER_STMT_CACHE_FULL = 1705; + exports2.ER_MULTI_UPDATE_KEY_CONFLICT = 1706; + exports2.ER_TABLE_NEEDS_REBUILD = 1707; + exports2.WARN_OPTION_BELOW_LIMIT = 1708; + exports2.ER_INDEX_COLUMN_TOO_LONG = 1709; + exports2.ER_ERROR_IN_TRIGGER_BODY = 1710; + exports2.ER_ERROR_IN_UNKNOWN_TRIGGER_BODY = 1711; + exports2.ER_INDEX_CORRUPT = 1712; + exports2.ER_UNDO_RECORD_TOO_BIG = 1713; + exports2.ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT = 1714; + exports2.ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE = 1715; + exports2.ER_BINLOG_UNSAFE_REPLACE_SELECT = 1716; + exports2.ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT = 1717; + exports2.ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT = 1718; + exports2.ER_BINLOG_UNSAFE_UPDATE_IGNORE = 1719; + exports2.ER_PLUGIN_NO_UNINSTALL = 1720; + exports2.ER_PLUGIN_NO_INSTALL = 1721; + exports2.ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT = 1722; + exports2.ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC = 1723; + exports2.ER_BINLOG_UNSAFE_INSERT_TWO_KEYS = 1724; + exports2.ER_TABLE_IN_FK_CHECK = 1725; + exports2.ER_UNSUPPORTED_ENGINE = 1726; + exports2.ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST = 1727; + exports2.ER_CANNOT_LOAD_FROM_TABLE_V2 = 1728; + exports2.ER_SOURCE_DELAY_VALUE_OUT_OF_RANGE = 1729; + exports2.ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT = 1730; + exports2.ER_PARTITION_EXCHANGE_DIFFERENT_OPTION = 1731; + exports2.ER_PARTITION_EXCHANGE_PART_TABLE = 1732; + exports2.ER_PARTITION_EXCHANGE_TEMP_TABLE = 1733; + exports2.ER_PARTITION_INSTEAD_OF_SUBPARTITION = 1734; + exports2.ER_UNKNOWN_PARTITION = 1735; + exports2.ER_TABLES_DIFFERENT_METADATA = 1736; + exports2.ER_ROW_DOES_NOT_MATCH_PARTITION = 1737; + exports2.ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX = 1738; + exports2.ER_WARN_INDEX_NOT_APPLICABLE = 1739; + exports2.ER_PARTITION_EXCHANGE_FOREIGN_KEY = 1740; + exports2.ER_NO_SUCH_KEY_VALUE = 1741; + exports2.ER_RPL_INFO_DATA_TOO_LONG = 1742; + exports2.ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE = 1743; + exports2.ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE = 1744; + exports2.ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX = 1745; + exports2.ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT = 1746; + exports2.ER_PARTITION_CLAUSE_ON_NONPARTITIONED = 1747; + exports2.ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET = 1748; + exports2.ER_NO_SUCH_PARTITION = 1749; + exports2.ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE = 1750; + exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE = 1751; + exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE = 1752; + exports2.ER_MTA_FEATURE_IS_NOT_SUPPORTED = 1753; + exports2.ER_MTA_UPDATED_DBS_GREATER_MAX = 1754; + exports2.ER_MTA_CANT_PARALLEL = 1755; + exports2.ER_MTA_INCONSISTENT_DATA = 1756; + exports2.ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING = 1757; + exports2.ER_DA_INVALID_CONDITION_NUMBER = 1758; + exports2.ER_INSECURE_PLAIN_TEXT = 1759; + exports2.ER_INSECURE_CHANGE_SOURCE = 1760; + exports2.ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO = 1761; + exports2.ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO = 1762; + exports2.ER_SQLTHREAD_WITH_SECURE_REPLICA = 1763; + exports2.ER_TABLE_HAS_NO_FT = 1764; + exports2.ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER = 1765; + exports2.ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION = 1766; + exports2.ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST = 1767; + exports2.ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION = 1768; + exports2.ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION = 1769; + exports2.ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL = 1770; + exports2.ER_SKIPPING_LOGGED_TRANSACTION = 1771; + exports2.ER_MALFORMED_GTID_SET_SPECIFICATION = 1772; + exports2.ER_MALFORMED_GTID_SET_ENCODING = 1773; + exports2.ER_MALFORMED_GTID_SPECIFICATION = 1774; + exports2.ER_GNO_EXHAUSTED = 1775; + exports2.ER_BAD_REPLICA_AUTO_POSITION = 1776; + exports2.ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF = 1777; + exports2.ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET = 1778; + exports2.ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON = 1779; + exports2.ER_GTID_MODE_REQUIRES_BINLOG = 1780; + exports2.ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF = 1781; + exports2.ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON = 1782; + exports2.ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF = 1783; + exports2.ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF = 1784; + exports2.ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE = 1785; + exports2.ER_GTID_UNSAFE_CREATE_SELECT = 1786; + exports2.ER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRANSACTION = 1787; + exports2.ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME = 1788; + exports2.ER_SOURCE_HAS_PURGED_REQUIRED_GTIDS = 1789; + exports2.ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID = 1790; + exports2.ER_UNKNOWN_EXPLAIN_FORMAT = 1791; + exports2.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION = 1792; + exports2.ER_TOO_LONG_TABLE_PARTITION_COMMENT = 1793; + exports2.ER_REPLICA_CONFIGURATION = 1794; + exports2.ER_INNODB_FT_LIMIT = 1795; + exports2.ER_INNODB_NO_FT_TEMP_TABLE = 1796; + exports2.ER_INNODB_FT_WRONG_DOCID_COLUMN = 1797; + exports2.ER_INNODB_FT_WRONG_DOCID_INDEX = 1798; + exports2.ER_INNODB_ONLINE_LOG_TOO_BIG = 1799; + exports2.ER_UNKNOWN_ALTER_ALGORITHM = 1800; + exports2.ER_UNKNOWN_ALTER_LOCK = 1801; + exports2.ER_MTA_CHANGE_SOURCE_CANT_RUN_WITH_GAPS = 1802; + exports2.ER_MTA_RECOVERY_FAILURE = 1803; + exports2.ER_MTA_RESET_WORKERS = 1804; + exports2.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 = 1805; + exports2.ER_REPLICA_SILENT_RETRY_TRANSACTION = 1806; + exports2.ER_DISCARD_FK_CHECKS_RUNNING = 1807; + exports2.ER_TABLE_SCHEMA_MISMATCH = 1808; + exports2.ER_TABLE_IN_SYSTEM_TABLESPACE = 1809; + exports2.ER_IO_READ_ERROR = 1810; + exports2.ER_IO_WRITE_ERROR = 1811; + exports2.ER_TABLESPACE_MISSING = 1812; + exports2.ER_TABLESPACE_EXISTS = 1813; + exports2.ER_TABLESPACE_DISCARDED = 1814; + exports2.ER_INTERNAL_ERROR = 1815; + exports2.ER_INNODB_IMPORT_ERROR = 1816; + exports2.ER_INNODB_INDEX_CORRUPT = 1817; + exports2.ER_INVALID_YEAR_COLUMN_LENGTH = 1818; + exports2.ER_NOT_VALID_PASSWORD = 1819; + exports2.ER_MUST_CHANGE_PASSWORD = 1820; + exports2.ER_FK_NO_INDEX_CHILD = 1821; + exports2.ER_FK_NO_INDEX_PARENT = 1822; + exports2.ER_FK_FAIL_ADD_SYSTEM = 1823; + exports2.ER_FK_CANNOT_OPEN_PARENT = 1824; + exports2.ER_FK_INCORRECT_OPTION = 1825; + exports2.ER_FK_DUP_NAME = 1826; + exports2.ER_PASSWORD_FORMAT = 1827; + exports2.ER_FK_COLUMN_CANNOT_DROP = 1828; + exports2.ER_FK_COLUMN_CANNOT_DROP_CHILD = 1829; + exports2.ER_FK_COLUMN_NOT_NULL = 1830; + exports2.ER_DUP_INDEX = 1831; + exports2.ER_FK_COLUMN_CANNOT_CHANGE = 1832; + exports2.ER_FK_COLUMN_CANNOT_CHANGE_CHILD = 1833; + exports2.ER_UNUSED5 = 1834; + exports2.ER_MALFORMED_PACKET = 1835; + exports2.ER_READ_ONLY_MODE = 1836; + exports2.ER_GTID_NEXT_TYPE_UNDEFINED_GTID = 1837; + exports2.ER_VARIABLE_NOT_SETTABLE_IN_SP = 1838; + exports2.ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF = 1839; + exports2.ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY = 1840; + exports2.ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY = 1841; + exports2.ER_GTID_PURGED_WAS_CHANGED = 1842; + exports2.ER_GTID_EXECUTED_WAS_CHANGED = 1843; + exports2.ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES = 1844; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED = 1845; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON = 1846; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY = 1847; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION = 1848; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME = 1849; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE = 1850; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK = 1851; + exports2.ER_UNUSED6 = 1852; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK = 1853; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC = 1854; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS = 1855; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS = 1856; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS = 1857; + exports2.ER_SQL_REPLICA_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858; + exports2.ER_DUP_UNKNOWN_IN_INDEX = 1859; + exports2.ER_IDENT_CAUSES_TOO_LONG_PATH = 1860; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL = 1861; + exports2.ER_MUST_CHANGE_PASSWORD_LOGIN = 1862; + exports2.ER_ROW_IN_WRONG_PARTITION = 1863; + exports2.ER_MTA_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX = 1864; + exports2.ER_INNODB_NO_FT_USES_PARSER = 1865; + exports2.ER_BINLOG_LOGICAL_CORRUPTION = 1866; + exports2.ER_WARN_PURGE_LOG_IN_USE = 1867; + exports2.ER_WARN_PURGE_LOG_IS_ACTIVE = 1868; + exports2.ER_AUTO_INCREMENT_CONFLICT = 1869; + exports2.WARN_ON_BLOCKHOLE_IN_RBR = 1870; + exports2.ER_REPLICA_CM_INIT_REPOSITORY = 1871; + exports2.ER_REPLICA_AM_INIT_REPOSITORY = 1872; + exports2.ER_ACCESS_DENIED_CHANGE_USER_ERROR = 1873; + exports2.ER_INNODB_READ_ONLY = 1874; + exports2.ER_STOP_REPLICA_SQL_THREAD_TIMEOUT = 1875; + exports2.ER_STOP_REPLICA_IO_THREAD_TIMEOUT = 1876; + exports2.ER_TABLE_CORRUPT = 1877; + exports2.ER_TEMP_FILE_WRITE_FAILURE = 1878; + exports2.ER_INNODB_FT_AUX_NOT_HEX_ID = 1879; + exports2.ER_OLD_TEMPORALS_UPGRADED = 1880; + exports2.ER_INNODB_FORCED_RECOVERY = 1881; + exports2.ER_AES_INVALID_IV = 1882; + exports2.ER_PLUGIN_CANNOT_BE_UNINSTALLED = 1883; + exports2.ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_ASSIGNED_GTID = 1884; + exports2.ER_REPLICA_HAS_MORE_GTIDS_THAN_SOURCE = 1885; + exports2.ER_MISSING_KEY = 1886; + exports2.WARN_NAMED_PIPE_ACCESS_EVERYONE = 1887; + exports2.ER_FILE_CORRUPT = 3e3; + exports2.ER_ERROR_ON_SOURCE = 3001; + exports2.ER_INCONSISTENT_ERROR = 3002; + exports2.ER_STORAGE_ENGINE_NOT_LOADED = 3003; + exports2.ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER = 3004; + exports2.ER_WARN_LEGACY_SYNTAX_CONVERTED = 3005; + exports2.ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN = 3006; + exports2.ER_CANNOT_DISCARD_TEMPORARY_TABLE = 3007; + exports2.ER_FK_DEPTH_EXCEEDED = 3008; + exports2.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2 = 3009; + exports2.ER_WARN_TRIGGER_DOESNT_HAVE_CREATED = 3010; + exports2.ER_REFERENCED_TRG_DOES_NOT_EXIST = 3011; + exports2.ER_EXPLAIN_NOT_SUPPORTED = 3012; + exports2.ER_INVALID_FIELD_SIZE = 3013; + exports2.ER_MISSING_HA_CREATE_OPTION = 3014; + exports2.ER_ENGINE_OUT_OF_MEMORY = 3015; + exports2.ER_PASSWORD_EXPIRE_ANONYMOUS_USER = 3016; + exports2.ER_REPLICA_SQL_THREAD_MUST_STOP = 3017; + exports2.ER_NO_FT_MATERIALIZED_SUBQUERY = 3018; + exports2.ER_INNODB_UNDO_LOG_FULL = 3019; + exports2.ER_INVALID_ARGUMENT_FOR_LOGARITHM = 3020; + exports2.ER_REPLICA_CHANNEL_IO_THREAD_MUST_STOP = 3021; + exports2.ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO = 3022; + exports2.ER_WARN_ONLY_SOURCE_LOG_FILE_NO_POS = 3023; + exports2.ER_QUERY_TIMEOUT = 3024; + exports2.ER_NON_RO_SELECT_DISABLE_TIMER = 3025; + exports2.ER_DUP_LIST_ENTRY = 3026; + exports2.ER_SQL_MODE_NO_EFFECT = 3027; + exports2.ER_AGGREGATE_ORDER_FOR_UNION = 3028; + exports2.ER_AGGREGATE_ORDER_NON_AGG_QUERY = 3029; + exports2.ER_REPLICA_WORKER_STOPPED_PREVIOUS_THD_ERROR = 3030; + exports2.ER_DONT_SUPPORT_REPLICA_PRESERVE_COMMIT_ORDER = 3031; + exports2.ER_SERVER_OFFLINE_MODE = 3032; + exports2.ER_GIS_DIFFERENT_SRIDS = 3033; + exports2.ER_GIS_UNSUPPORTED_ARGUMENT = 3034; + exports2.ER_GIS_UNKNOWN_ERROR = 3035; + exports2.ER_GIS_UNKNOWN_EXCEPTION = 3036; + exports2.ER_GIS_INVALID_DATA = 3037; + exports2.ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION = 3038; + exports2.ER_BOOST_GEOMETRY_CENTROID_EXCEPTION = 3039; + exports2.ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION = 3040; + exports2.ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION = 3041; + exports2.ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION = 3042; + exports2.ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION = 3043; + exports2.ER_STD_BAD_ALLOC_ERROR = 3044; + exports2.ER_STD_DOMAIN_ERROR = 3045; + exports2.ER_STD_LENGTH_ERROR = 3046; + exports2.ER_STD_INVALID_ARGUMENT = 3047; + exports2.ER_STD_OUT_OF_RANGE_ERROR = 3048; + exports2.ER_STD_OVERFLOW_ERROR = 3049; + exports2.ER_STD_RANGE_ERROR = 3050; + exports2.ER_STD_UNDERFLOW_ERROR = 3051; + exports2.ER_STD_LOGIC_ERROR = 3052; + exports2.ER_STD_RUNTIME_ERROR = 3053; + exports2.ER_STD_UNKNOWN_EXCEPTION = 3054; + exports2.ER_GIS_DATA_WRONG_ENDIANESS = 3055; + exports2.ER_CHANGE_SOURCE_PASSWORD_LENGTH = 3056; + exports2.ER_USER_LOCK_WRONG_NAME = 3057; + exports2.ER_USER_LOCK_DEADLOCK = 3058; + exports2.ER_REPLACE_INACCESSIBLE_ROWS = 3059; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS = 3060; + exports2.ER_ILLEGAL_USER_VAR = 3061; + exports2.ER_GTID_MODE_OFF = 3062; + exports2.ER_UNSUPPORTED_BY_REPLICATION_THREAD = 3063; + exports2.ER_INCORRECT_TYPE = 3064; + exports2.ER_FIELD_IN_ORDER_NOT_SELECT = 3065; + exports2.ER_AGGREGATE_IN_ORDER_NOT_SELECT = 3066; + exports2.ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN = 3067; + exports2.ER_NET_OK_PACKET_TOO_LARGE = 3068; + exports2.ER_INVALID_JSON_DATA = 3069; + exports2.ER_INVALID_GEOJSON_MISSING_MEMBER = 3070; + exports2.ER_INVALID_GEOJSON_WRONG_TYPE = 3071; + exports2.ER_INVALID_GEOJSON_UNSPECIFIED = 3072; + exports2.ER_DIMENSION_UNSUPPORTED = 3073; + exports2.ER_REPLICA_CHANNEL_DOES_NOT_EXIST = 3074; + exports2.ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT = 3075; + exports2.ER_REPLICA_CHANNEL_NAME_INVALID_OR_TOO_LONG = 3076; + exports2.ER_REPLICA_NEW_CHANNEL_WRONG_REPOSITORY = 3077; + exports2.ER_SLAVE_CHANNEL_DELETE = 3078; + exports2.ER_REPLICA_MULTIPLE_CHANNELS_CMD = 3079; + exports2.ER_REPLICA_MAX_CHANNELS_EXCEEDED = 3080; + exports2.ER_REPLICA_CHANNEL_MUST_STOP = 3081; + exports2.ER_REPLICA_CHANNEL_NOT_RUNNING = 3082; + exports2.ER_REPLICA_CHANNEL_WAS_RUNNING = 3083; + exports2.ER_REPLICA_CHANNEL_WAS_NOT_RUNNING = 3084; + exports2.ER_REPLICA_CHANNEL_SQL_THREAD_MUST_STOP = 3085; + exports2.ER_REPLICA_CHANNEL_SQL_SKIP_COUNTER = 3086; + exports2.ER_WRONG_FIELD_WITH_GROUP_V2 = 3087; + exports2.ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2 = 3088; + exports2.ER_WARN_DEPRECATED_SYSVAR_UPDATE = 3089; + exports2.ER_WARN_DEPRECATED_SQLMODE = 3090; + exports2.ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID = 3091; + exports2.ER_GROUP_REPLICATION_CONFIGURATION = 3092; + exports2.ER_GROUP_REPLICATION_RUNNING = 3093; + exports2.ER_GROUP_REPLICATION_APPLIER_INIT_ERROR = 3094; + exports2.ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT = 3095; + exports2.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR = 3096; + exports2.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR = 3097; + exports2.ER_BEFORE_DML_VALIDATION_ERROR = 3098; + exports2.ER_PREVENTS_VARIABLE_WITHOUT_RBR = 3099; + exports2.ER_RUN_HOOK_ERROR = 3100; + exports2.ER_TRANSACTION_ROLLBACK_DURING_COMMIT = 3101; + exports2.ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED = 3102; + exports2.ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN = 3103; + exports2.ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN = 3104; + exports2.ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN = 3105; + exports2.ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN = 3106; + exports2.ER_GENERATED_COLUMN_NON_PRIOR = 3107; + exports2.ER_DEPENDENT_BY_GENERATED_COLUMN = 3108; + exports2.ER_GENERATED_COLUMN_REF_AUTO_INC = 3109; + exports2.ER_FEATURE_NOT_AVAILABLE = 3110; + exports2.ER_CANT_SET_GTID_MODE = 3111; + exports2.ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF = 3112; + exports2.ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION = 3113; + exports2.ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON = 3114; + exports2.ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF = 3115; + exports2.ER_CANT_ENFORCE_GTID_CONSISTENCY_WITH_ONGOING_GTID_VIOLATING_TX = 3116; + exports2.ER_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TX = 3117; + exports2.ER_ACCOUNT_HAS_BEEN_LOCKED = 3118; + exports2.ER_WRONG_TABLESPACE_NAME = 3119; + exports2.ER_TABLESPACE_IS_NOT_EMPTY = 3120; + exports2.ER_WRONG_FILE_NAME = 3121; + exports2.ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION = 3122; + exports2.ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR = 3123; + exports2.ER_WARN_BAD_MAX_EXECUTION_TIME = 3124; + exports2.ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME = 3125; + exports2.ER_WARN_CONFLICTING_HINT = 3126; + exports2.ER_WARN_UNKNOWN_QB_NAME = 3127; + exports2.ER_UNRESOLVED_HINT_NAME = 3128; + exports2.ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE = 3129; + exports2.ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED = 3130; + exports2.ER_LOCKING_SERVICE_WRONG_NAME = 3131; + exports2.ER_LOCKING_SERVICE_DEADLOCK = 3132; + exports2.ER_LOCKING_SERVICE_TIMEOUT = 3133; + exports2.ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED = 3134; + exports2.ER_SQL_MODE_MERGED = 3135; + exports2.ER_VTOKEN_PLUGIN_TOKEN_MISMATCH = 3136; + exports2.ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND = 3137; + exports2.ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID = 3138; + exports2.ER_REPLICA_CHANNEL_OPERATION_NOT_ALLOWED = 3139; + exports2.ER_INVALID_JSON_TEXT = 3140; + exports2.ER_INVALID_JSON_TEXT_IN_PARAM = 3141; + exports2.ER_INVALID_JSON_BINARY_DATA = 3142; + exports2.ER_INVALID_JSON_PATH = 3143; + exports2.ER_INVALID_JSON_CHARSET = 3144; + exports2.ER_INVALID_JSON_CHARSET_IN_FUNCTION = 3145; + exports2.ER_INVALID_TYPE_FOR_JSON = 3146; + exports2.ER_INVALID_CAST_TO_JSON = 3147; + exports2.ER_INVALID_JSON_PATH_CHARSET = 3148; + exports2.ER_INVALID_JSON_PATH_WILDCARD = 3149; + exports2.ER_JSON_VALUE_TOO_BIG = 3150; + exports2.ER_JSON_KEY_TOO_BIG = 3151; + exports2.ER_JSON_USED_AS_KEY = 3152; + exports2.ER_JSON_VACUOUS_PATH = 3153; + exports2.ER_JSON_BAD_ONE_OR_ALL_ARG = 3154; + exports2.ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE = 3155; + exports2.ER_INVALID_JSON_VALUE_FOR_CAST = 3156; + exports2.ER_JSON_DOCUMENT_TOO_DEEP = 3157; + exports2.ER_JSON_DOCUMENT_NULL_KEY = 3158; + exports2.ER_SECURE_TRANSPORT_REQUIRED = 3159; + exports2.ER_NO_SECURE_TRANSPORTS_CONFIGURED = 3160; + exports2.ER_DISABLED_STORAGE_ENGINE = 3161; + exports2.ER_USER_DOES_NOT_EXIST = 3162; + exports2.ER_USER_ALREADY_EXISTS = 3163; + exports2.ER_AUDIT_API_ABORT = 3164; + exports2.ER_INVALID_JSON_PATH_ARRAY_CELL = 3165; + exports2.ER_BUFPOOL_RESIZE_INPROGRESS = 3166; + exports2.ER_FEATURE_DISABLED_SEE_DOC = 3167; + exports2.ER_SERVER_ISNT_AVAILABLE = 3168; + exports2.ER_SESSION_WAS_KILLED = 3169; + exports2.ER_CAPACITY_EXCEEDED = 3170; + exports2.ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER = 3171; + exports2.ER_TABLE_NEEDS_UPG_PART = 3172; + exports2.ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID = 3173; + exports2.ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL = 3174; + exports2.ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT = 3175; + exports2.ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE = 3176; + exports2.ER_LOCK_REFUSED_BY_ENGINE = 3177; + exports2.ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN = 3178; + exports2.ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE = 3179; + exports2.ER_MASTER_KEY_ROTATION_ERROR_BY_SE = 3180; + exports2.ER_MASTER_KEY_ROTATION_BINLOG_FAILED = 3181; + exports2.ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE = 3182; + exports2.ER_TABLESPACE_CANNOT_ENCRYPT = 3183; + exports2.ER_INVALID_ENCRYPTION_OPTION = 3184; + exports2.ER_CANNOT_FIND_KEY_IN_KEYRING = 3185; + exports2.ER_CAPACITY_EXCEEDED_IN_PARSER = 3186; + exports2.ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE = 3187; + exports2.ER_KEYRING_UDF_KEYRING_SERVICE_ERROR = 3188; + exports2.ER_USER_COLUMN_OLD_LENGTH = 3189; + exports2.ER_CANT_RESET_SOURCE = 3190; + exports2.ER_GROUP_REPLICATION_MAX_GROUP_SIZE = 3191; + exports2.ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED = 3192; + exports2.ER_TABLE_REFERENCED = 3193; + exports2.ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE = 3194; + exports2.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO = 3195; + exports2.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID = 3196; + exports2.ER_XA_RETRY = 3197; + exports2.ER_KEYRING_AWS_UDF_AWS_KMS_ERROR = 3198; + exports2.ER_BINLOG_UNSAFE_XA = 3199; + exports2.ER_UDF_ERROR = 3200; + exports2.ER_KEYRING_MIGRATION_FAILURE = 3201; + exports2.ER_KEYRING_ACCESS_DENIED_ERROR = 3202; + exports2.ER_KEYRING_MIGRATION_STATUS = 3203; + exports2.ER_PLUGIN_FAILED_TO_OPEN_TABLES = 3204; + exports2.ER_PLUGIN_FAILED_TO_OPEN_TABLE = 3205; + exports2.ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED = 3206; + exports2.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET = 3207; + exports2.ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY = 3208; + exports2.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED = 3209; + exports2.ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED = 3210; + exports2.ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE = 3211; + exports2.ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED = 3212; + exports2.ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS = 3213; + exports2.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE = 3214; + exports2.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT = 3215; + exports2.ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED = 3216; + exports2.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE = 3217; + exports2.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE = 3218; + exports2.ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR = 3219; + exports2.ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY = 3220; + exports2.ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY = 3221; + exports2.ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS = 3222; + exports2.ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC = 3223; + exports2.ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER = 3224; + exports2.ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER = 3225; + exports2.WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP = 3226; + exports2.ER_XA_REPLICATION_FILTERS = 3227; + exports2.ER_CANT_OPEN_ERROR_LOG = 3228; + exports2.ER_GROUPING_ON_TIMESTAMP_IN_DST = 3229; + exports2.ER_CANT_START_SERVER_NAMED_PIPE = 3230; + exports2.ER_WRITE_SET_EXCEEDS_LIMIT = 3231; + exports2.ER_DEPRECATED_TLS_VERSION_SESSION_57 = 3232; + exports2.ER_WARN_DEPRECATED_TLS_VERSION_57 = 3233; + exports2.ER_WARN_WRONG_NATIVE_TABLE_STRUCTURE = 3234; + exports2.ER_AES_INVALID_KDF_NAME = 3235; + exports2.ER_AES_INVALID_KDF_ITERATIONS = 3236; + exports2.WARN_AES_KEY_SIZE = 3237; + exports2.ER_AES_INVALID_KDF_OPTION_SIZE = 3238; + exports2.ER_UNSUPPORT_COMPRESSED_TEMPORARY_TABLE = 3500; + exports2.ER_ACL_OPERATION_FAILED = 3501; + exports2.ER_UNSUPPORTED_INDEX_ALGORITHM = 3502; + exports2.ER_NO_SUCH_DB = 3503; + exports2.ER_TOO_BIG_ENUM = 3504; + exports2.ER_TOO_LONG_SET_ENUM_VALUE = 3505; + exports2.ER_INVALID_DD_OBJECT = 3506; + exports2.ER_UPDATING_DD_TABLE = 3507; + exports2.ER_INVALID_DD_OBJECT_ID = 3508; + exports2.ER_INVALID_DD_OBJECT_NAME = 3509; + exports2.ER_TABLESPACE_MISSING_WITH_NAME = 3510; + exports2.ER_TOO_LONG_ROUTINE_COMMENT = 3511; + exports2.ER_SP_LOAD_FAILED = 3512; + exports2.ER_INVALID_BITWISE_OPERANDS_SIZE = 3513; + exports2.ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE = 3514; + exports2.ER_WARN_UNSUPPORTED_HINT = 3515; + exports2.ER_UNEXPECTED_GEOMETRY_TYPE = 3516; + exports2.ER_SRS_PARSE_ERROR = 3517; + exports2.ER_SRS_PROJ_PARAMETER_MISSING = 3518; + exports2.ER_WARN_SRS_NOT_FOUND = 3519; + exports2.ER_SRS_NOT_CARTESIAN = 3520; + exports2.ER_SRS_NOT_CARTESIAN_UNDEFINED = 3521; + exports2.ER_PK_INDEX_CANT_BE_INVISIBLE = 3522; + exports2.ER_UNKNOWN_AUTHID = 3523; + exports2.ER_FAILED_ROLE_GRANT = 3524; + exports2.ER_OPEN_ROLE_TABLES = 3525; + exports2.ER_FAILED_DEFAULT_ROLES = 3526; + exports2.ER_COMPONENTS_NO_SCHEME = 3527; + exports2.ER_COMPONENTS_NO_SCHEME_SERVICE = 3528; + exports2.ER_COMPONENTS_CANT_LOAD = 3529; + exports2.ER_ROLE_NOT_GRANTED = 3530; + exports2.ER_FAILED_REVOKE_ROLE = 3531; + exports2.ER_RENAME_ROLE = 3532; + exports2.ER_COMPONENTS_CANT_ACQUIRE_SERVICE_IMPLEMENTATION = 3533; + exports2.ER_COMPONENTS_CANT_SATISFY_DEPENDENCY = 3534; + exports2.ER_COMPONENTS_LOAD_CANT_REGISTER_SERVICE_IMPLEMENTATION = 3535; + exports2.ER_COMPONENTS_LOAD_CANT_INITIALIZE = 3536; + exports2.ER_COMPONENTS_UNLOAD_NOT_LOADED = 3537; + exports2.ER_COMPONENTS_UNLOAD_CANT_DEINITIALIZE = 3538; + exports2.ER_COMPONENTS_CANT_RELEASE_SERVICE = 3539; + exports2.ER_COMPONENTS_UNLOAD_CANT_UNREGISTER_SERVICE = 3540; + exports2.ER_COMPONENTS_CANT_UNLOAD = 3541; + exports2.ER_WARN_UNLOAD_THE_NOT_PERSISTED = 3542; + exports2.ER_COMPONENT_TABLE_INCORRECT = 3543; + exports2.ER_COMPONENT_MANIPULATE_ROW_FAILED = 3544; + exports2.ER_COMPONENTS_UNLOAD_DUPLICATE_IN_GROUP = 3545; + exports2.ER_CANT_SET_GTID_PURGED_DUE_SETS_CONSTRAINTS = 3546; + exports2.ER_CANNOT_LOCK_USER_MANAGEMENT_CACHES = 3547; + exports2.ER_SRS_NOT_FOUND = 3548; + exports2.ER_VARIABLE_NOT_PERSISTED = 3549; + exports2.ER_IS_QUERY_INVALID_CLAUSE = 3550; + exports2.ER_UNABLE_TO_STORE_STATISTICS = 3551; + exports2.ER_NO_SYSTEM_SCHEMA_ACCESS = 3552; + exports2.ER_NO_SYSTEM_TABLESPACE_ACCESS = 3553; + exports2.ER_NO_SYSTEM_TABLE_ACCESS = 3554; + exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_DICTIONARY_TABLE = 3555; + exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_SYSTEM_TABLE = 3556; + exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_TABLE = 3557; + exports2.ER_INVALID_OPTION_KEY = 3558; + exports2.ER_INVALID_OPTION_VALUE = 3559; + exports2.ER_INVALID_OPTION_KEY_VALUE_PAIR = 3560; + exports2.ER_INVALID_OPTION_START_CHARACTER = 3561; + exports2.ER_INVALID_OPTION_END_CHARACTER = 3562; + exports2.ER_INVALID_OPTION_CHARACTERS = 3563; + exports2.ER_DUPLICATE_OPTION_KEY = 3564; + exports2.ER_WARN_SRS_NOT_FOUND_AXIS_ORDER = 3565; + exports2.ER_NO_ACCESS_TO_NATIVE_FCT = 3566; + exports2.ER_RESET_SOURCE_TO_VALUE_OUT_OF_RANGE = 3567; + exports2.ER_UNRESOLVED_TABLE_LOCK = 3568; + exports2.ER_DUPLICATE_TABLE_LOCK = 3569; + exports2.ER_BINLOG_UNSAFE_SKIP_LOCKED = 3570; + exports2.ER_BINLOG_UNSAFE_NOWAIT = 3571; + exports2.ER_LOCK_NOWAIT = 3572; + exports2.ER_CTE_RECURSIVE_REQUIRES_UNION = 3573; + exports2.ER_CTE_RECURSIVE_REQUIRES_NONRECURSIVE_FIRST = 3574; + exports2.ER_CTE_RECURSIVE_FORBIDS_AGGREGATION = 3575; + exports2.ER_CTE_RECURSIVE_FORBIDDEN_JOIN_ORDER = 3576; + exports2.ER_CTE_RECURSIVE_REQUIRES_SINGLE_REFERENCE = 3577; + exports2.ER_SWITCH_TMP_ENGINE = 3578; + exports2.ER_WINDOW_NO_SUCH_WINDOW = 3579; + exports2.ER_WINDOW_CIRCULARITY_IN_WINDOW_GRAPH = 3580; + exports2.ER_WINDOW_NO_CHILD_PARTITIONING = 3581; + exports2.ER_WINDOW_NO_INHERIT_FRAME = 3582; + exports2.ER_WINDOW_NO_REDEFINE_ORDER_BY = 3583; + exports2.ER_WINDOW_FRAME_START_ILLEGAL = 3584; + exports2.ER_WINDOW_FRAME_END_ILLEGAL = 3585; + exports2.ER_WINDOW_FRAME_ILLEGAL = 3586; + exports2.ER_WINDOW_RANGE_FRAME_ORDER_TYPE = 3587; + exports2.ER_WINDOW_RANGE_FRAME_TEMPORAL_TYPE = 3588; + exports2.ER_WINDOW_RANGE_FRAME_NUMERIC_TYPE = 3589; + exports2.ER_WINDOW_RANGE_BOUND_NOT_CONSTANT = 3590; + exports2.ER_WINDOW_DUPLICATE_NAME = 3591; + exports2.ER_WINDOW_ILLEGAL_ORDER_BY = 3592; + exports2.ER_WINDOW_INVALID_WINDOW_FUNC_USE = 3593; + exports2.ER_WINDOW_INVALID_WINDOW_FUNC_ALIAS_USE = 3594; + exports2.ER_WINDOW_NESTED_WINDOW_FUNC_USE_IN_WINDOW_SPEC = 3595; + exports2.ER_WINDOW_ROWS_INTERVAL_USE = 3596; + exports2.ER_WINDOW_NO_GROUP_ORDER = 3597; + exports2.ER_WINDOW_EXPLAIN_JSON = 3598; + exports2.ER_WINDOW_FUNCTION_IGNORES_FRAME = 3599; + exports2.ER_WL9236_NOW = 3600; + exports2.ER_INVALID_NO_OF_ARGS = 3601; + exports2.ER_FIELD_IN_GROUPING_NOT_GROUP_BY = 3602; + exports2.ER_TOO_LONG_TABLESPACE_COMMENT = 3603; + exports2.ER_ENGINE_CANT_DROP_TABLE = 3604; + exports2.ER_ENGINE_CANT_DROP_MISSING_TABLE = 3605; + exports2.ER_TABLESPACE_DUP_FILENAME = 3606; + exports2.ER_DB_DROP_RMDIR2 = 3607; + exports2.ER_IMP_NO_FILES_MATCHED = 3608; + exports2.ER_IMP_SCHEMA_DOES_NOT_EXIST = 3609; + exports2.ER_IMP_TABLE_ALREADY_EXISTS = 3610; + exports2.ER_IMP_INCOMPATIBLE_MYSQLD_VERSION = 3611; + exports2.ER_IMP_INCOMPATIBLE_DD_VERSION = 3612; + exports2.ER_IMP_INCOMPATIBLE_SDI_VERSION = 3613; + exports2.ER_WARN_INVALID_HINT = 3614; + exports2.ER_VAR_DOES_NOT_EXIST = 3615; + exports2.ER_LONGITUDE_OUT_OF_RANGE = 3616; + exports2.ER_LATITUDE_OUT_OF_RANGE = 3617; + exports2.ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS = 3618; + exports2.ER_ILLEGAL_PRIVILEGE_LEVEL = 3619; + exports2.ER_NO_SYSTEM_VIEW_ACCESS = 3620; + exports2.ER_COMPONENT_FILTER_FLABBERGASTED = 3621; + exports2.ER_PART_EXPR_TOO_LONG = 3622; + exports2.ER_UDF_DROP_DYNAMICALLY_REGISTERED = 3623; + exports2.ER_UNABLE_TO_STORE_COLUMN_STATISTICS = 3624; + exports2.ER_UNABLE_TO_UPDATE_COLUMN_STATISTICS = 3625; + exports2.ER_UNABLE_TO_DROP_COLUMN_STATISTICS = 3626; + exports2.ER_UNABLE_TO_BUILD_HISTOGRAM = 3627; + exports2.ER_MANDATORY_ROLE = 3628; + exports2.ER_MISSING_TABLESPACE_FILE = 3629; + exports2.ER_PERSIST_ONLY_ACCESS_DENIED_ERROR = 3630; + exports2.ER_CMD_NEED_SUPER = 3631; + exports2.ER_PATH_IN_DATADIR = 3632; + exports2.ER_CLONE_DDL_IN_PROGRESS = 3633; + exports2.ER_CLONE_TOO_MANY_CONCURRENT_CLONES = 3634; + exports2.ER_APPLIER_LOG_EVENT_VALIDATION_ERROR = 3635; + exports2.ER_CTE_MAX_RECURSION_DEPTH = 3636; + exports2.ER_NOT_HINT_UPDATABLE_VARIABLE = 3637; + exports2.ER_CREDENTIALS_CONTRADICT_TO_HISTORY = 3638; + exports2.ER_WARNING_PASSWORD_HISTORY_CLAUSES_VOID = 3639; + exports2.ER_CLIENT_DOES_NOT_SUPPORT = 3640; + exports2.ER_I_S_SKIPPED_TABLESPACE = 3641; + exports2.ER_TABLESPACE_ENGINE_MISMATCH = 3642; + exports2.ER_WRONG_SRID_FOR_COLUMN = 3643; + exports2.ER_CANNOT_ALTER_SRID_DUE_TO_INDEX = 3644; + exports2.ER_WARN_BINLOG_PARTIAL_UPDATES_DISABLED = 3645; + exports2.ER_WARN_BINLOG_V1_ROW_EVENTS_DISABLED = 3646; + exports2.ER_WARN_BINLOG_PARTIAL_UPDATES_SUGGESTS_PARTIAL_IMAGES = 3647; + exports2.ER_COULD_NOT_APPLY_JSON_DIFF = 3648; + exports2.ER_CORRUPTED_JSON_DIFF = 3649; + exports2.ER_RESOURCE_GROUP_EXISTS = 3650; + exports2.ER_RESOURCE_GROUP_NOT_EXISTS = 3651; + exports2.ER_INVALID_VCPU_ID = 3652; + exports2.ER_INVALID_VCPU_RANGE = 3653; + exports2.ER_INVALID_THREAD_PRIORITY = 3654; + exports2.ER_DISALLOWED_OPERATION = 3655; + exports2.ER_RESOURCE_GROUP_BUSY = 3656; + exports2.ER_RESOURCE_GROUP_DISABLED = 3657; + exports2.ER_FEATURE_UNSUPPORTED = 3658; + exports2.ER_ATTRIBUTE_IGNORED = 3659; + exports2.ER_INVALID_THREAD_ID = 3660; + exports2.ER_RESOURCE_GROUP_BIND_FAILED = 3661; + exports2.ER_INVALID_USE_OF_FORCE_OPTION = 3662; + exports2.ER_GROUP_REPLICATION_COMMAND_FAILURE = 3663; + exports2.ER_SDI_OPERATION_FAILED = 3664; + exports2.ER_MISSING_JSON_TABLE_VALUE = 3665; + exports2.ER_WRONG_JSON_TABLE_VALUE = 3666; + exports2.ER_TF_MUST_HAVE_ALIAS = 3667; + exports2.ER_TF_FORBIDDEN_JOIN_TYPE = 3668; + exports2.ER_JT_VALUE_OUT_OF_RANGE = 3669; + exports2.ER_JT_MAX_NESTED_PATH = 3670; + exports2.ER_PASSWORD_EXPIRATION_NOT_SUPPORTED_BY_AUTH_METHOD = 3671; + exports2.ER_INVALID_GEOJSON_CRS_NOT_TOP_LEVEL = 3672; + exports2.ER_BAD_NULL_ERROR_NOT_IGNORED = 3673; + exports2.WARN_USELESS_SPATIAL_INDEX = 3674; + exports2.ER_DISK_FULL_NOWAIT = 3675; + exports2.ER_PARSE_ERROR_IN_DIGEST_FN = 3676; + exports2.ER_UNDISCLOSED_PARSE_ERROR_IN_DIGEST_FN = 3677; + exports2.ER_SCHEMA_DIR_EXISTS = 3678; + exports2.ER_SCHEMA_DIR_MISSING = 3679; + exports2.ER_SCHEMA_DIR_CREATE_FAILED = 3680; + exports2.ER_SCHEMA_DIR_UNKNOWN = 3681; + exports2.ER_ONLY_IMPLEMENTED_FOR_SRID_0_AND_4326 = 3682; + exports2.ER_BINLOG_EXPIRE_LOG_DAYS_AND_SECS_USED_TOGETHER = 3683; + exports2.ER_REGEXP_BUFFER_OVERFLOW = 3684; + exports2.ER_REGEXP_ILLEGAL_ARGUMENT = 3685; + exports2.ER_REGEXP_INDEX_OUTOFBOUNDS_ERROR = 3686; + exports2.ER_REGEXP_INTERNAL_ERROR = 3687; + exports2.ER_REGEXP_RULE_SYNTAX = 3688; + exports2.ER_REGEXP_BAD_ESCAPE_SEQUENCE = 3689; + exports2.ER_REGEXP_UNIMPLEMENTED = 3690; + exports2.ER_REGEXP_MISMATCHED_PAREN = 3691; + exports2.ER_REGEXP_BAD_INTERVAL = 3692; + exports2.ER_REGEXP_MAX_LT_MIN = 3693; + exports2.ER_REGEXP_INVALID_BACK_REF = 3694; + exports2.ER_REGEXP_LOOK_BEHIND_LIMIT = 3695; + exports2.ER_REGEXP_MISSING_CLOSE_BRACKET = 3696; + exports2.ER_REGEXP_INVALID_RANGE = 3697; + exports2.ER_REGEXP_STACK_OVERFLOW = 3698; + exports2.ER_REGEXP_TIME_OUT = 3699; + exports2.ER_REGEXP_PATTERN_TOO_BIG = 3700; + exports2.ER_CANT_SET_ERROR_LOG_SERVICE = 3701; + exports2.ER_EMPTY_PIPELINE_FOR_ERROR_LOG_SERVICE = 3702; + exports2.ER_COMPONENT_FILTER_DIAGNOSTICS = 3703; + exports2.ER_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS = 3704; + exports2.ER_NOT_IMPLEMENTED_FOR_PROJECTED_SRS = 3705; + exports2.ER_NONPOSITIVE_RADIUS = 3706; + exports2.ER_RESTART_SERVER_FAILED = 3707; + exports2.ER_SRS_MISSING_MANDATORY_ATTRIBUTE = 3708; + exports2.ER_SRS_MULTIPLE_ATTRIBUTE_DEFINITIONS = 3709; + exports2.ER_SRS_NAME_CANT_BE_EMPTY_OR_WHITESPACE = 3710; + exports2.ER_SRS_ORGANIZATION_CANT_BE_EMPTY_OR_WHITESPACE = 3711; + exports2.ER_SRS_ID_ALREADY_EXISTS = 3712; + exports2.ER_WARN_SRS_ID_ALREADY_EXISTS = 3713; + exports2.ER_CANT_MODIFY_SRID_0 = 3714; + exports2.ER_WARN_RESERVED_SRID_RANGE = 3715; + exports2.ER_CANT_MODIFY_SRS_USED_BY_COLUMN = 3716; + exports2.ER_SRS_INVALID_CHARACTER_IN_ATTRIBUTE = 3717; + exports2.ER_SRS_ATTRIBUTE_STRING_TOO_LONG = 3718; + exports2.ER_DEPRECATED_UTF8_ALIAS = 3719; + exports2.ER_DEPRECATED_NATIONAL = 3720; + exports2.ER_INVALID_DEFAULT_UTF8MB4_COLLATION = 3721; + exports2.ER_UNABLE_TO_COLLECT_LOG_STATUS = 3722; + exports2.ER_RESERVED_TABLESPACE_NAME = 3723; + exports2.ER_UNABLE_TO_SET_OPTION = 3724; + exports2.ER_REPLICA_POSSIBLY_DIVERGED_AFTER_DDL = 3725; + exports2.ER_SRS_NOT_GEOGRAPHIC = 3726; + exports2.ER_POLYGON_TOO_LARGE = 3727; + exports2.ER_SPATIAL_UNIQUE_INDEX = 3728; + exports2.ER_INDEX_TYPE_NOT_SUPPORTED_FOR_SPATIAL_INDEX = 3729; + exports2.ER_FK_CANNOT_DROP_PARENT = 3730; + exports2.ER_GEOMETRY_PARAM_LONGITUDE_OUT_OF_RANGE = 3731; + exports2.ER_GEOMETRY_PARAM_LATITUDE_OUT_OF_RANGE = 3732; + exports2.ER_FK_CANNOT_USE_VIRTUAL_COLUMN = 3733; + exports2.ER_FK_NO_COLUMN_PARENT = 3734; + exports2.ER_CANT_SET_ERROR_SUPPRESSION_LIST = 3735; + exports2.ER_SRS_GEOGCS_INVALID_AXES = 3736; + exports2.ER_SRS_INVALID_SEMI_MAJOR_AXIS = 3737; + exports2.ER_SRS_INVALID_INVERSE_FLATTENING = 3738; + exports2.ER_SRS_INVALID_ANGULAR_UNIT = 3739; + exports2.ER_SRS_INVALID_PRIME_MERIDIAN = 3740; + exports2.ER_TRANSFORM_SOURCE_SRS_NOT_SUPPORTED = 3741; + exports2.ER_TRANSFORM_TARGET_SRS_NOT_SUPPORTED = 3742; + exports2.ER_TRANSFORM_SOURCE_SRS_MISSING_TOWGS84 = 3743; + exports2.ER_TRANSFORM_TARGET_SRS_MISSING_TOWGS84 = 3744; + exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_SESSION_BINLOG_FORMAT = 3745; + exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT = 3746; + exports2.ER_RUNNING_APPLIER_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT = 3747; + exports2.ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR = 3748; + exports2.ER_XA_CANT_CREATE_MDL_BACKUP = 3749; + exports2.ER_TABLE_WITHOUT_PK = 3750; + exports2.ER_WARN_DATA_TRUNCATED_FUNCTIONAL_INDEX = 3751; + exports2.ER_WARN_DATA_OUT_OF_RANGE_FUNCTIONAL_INDEX = 3752; + exports2.ER_FUNCTIONAL_INDEX_ON_JSON_OR_GEOMETRY_FUNCTION = 3753; + exports2.ER_FUNCTIONAL_INDEX_REF_AUTO_INCREMENT = 3754; + exports2.ER_CANNOT_DROP_COLUMN_FUNCTIONAL_INDEX = 3755; + exports2.ER_FUNCTIONAL_INDEX_PRIMARY_KEY = 3756; + exports2.ER_FUNCTIONAL_INDEX_ON_LOB = 3757; + exports2.ER_FUNCTIONAL_INDEX_FUNCTION_IS_NOT_ALLOWED = 3758; + exports2.ER_FULLTEXT_FUNCTIONAL_INDEX = 3759; + exports2.ER_SPATIAL_FUNCTIONAL_INDEX = 3760; + exports2.ER_WRONG_KEY_COLUMN_FUNCTIONAL_INDEX = 3761; + exports2.ER_FUNCTIONAL_INDEX_ON_FIELD = 3762; + exports2.ER_GENERATED_COLUMN_NAMED_FUNCTION_IS_NOT_ALLOWED = 3763; + exports2.ER_GENERATED_COLUMN_ROW_VALUE = 3764; + exports2.ER_GENERATED_COLUMN_VARIABLES = 3765; + exports2.ER_DEPENDENT_BY_DEFAULT_GENERATED_VALUE = 3766; + exports2.ER_DEFAULT_VAL_GENERATED_NON_PRIOR = 3767; + exports2.ER_DEFAULT_VAL_GENERATED_REF_AUTO_INC = 3768; + exports2.ER_DEFAULT_VAL_GENERATED_FUNCTION_IS_NOT_ALLOWED = 3769; + exports2.ER_DEFAULT_VAL_GENERATED_NAMED_FUNCTION_IS_NOT_ALLOWED = 3770; + exports2.ER_DEFAULT_VAL_GENERATED_ROW_VALUE = 3771; + exports2.ER_DEFAULT_VAL_GENERATED_VARIABLES = 3772; + exports2.ER_DEFAULT_AS_VAL_GENERATED = 3773; + exports2.ER_UNSUPPORTED_ACTION_ON_DEFAULT_VAL_GENERATED = 3774; + exports2.ER_GTID_UNSAFE_ALTER_ADD_COL_WITH_DEFAULT_EXPRESSION = 3775; + exports2.ER_FK_CANNOT_CHANGE_ENGINE = 3776; + exports2.ER_WARN_DEPRECATED_USER_SET_EXPR = 3777; + exports2.ER_WARN_DEPRECATED_UTF8MB3_COLLATION = 3778; + exports2.ER_WARN_DEPRECATED_NESTED_COMMENT_SYNTAX = 3779; + exports2.ER_FK_INCOMPATIBLE_COLUMNS = 3780; + exports2.ER_GR_HOLD_WAIT_TIMEOUT = 3781; + exports2.ER_GR_HOLD_KILLED = 3782; + exports2.ER_GR_HOLD_MEMBER_STATUS_ERROR = 3783; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_FETCH_KEY = 3784; + exports2.ER_RPL_ENCRYPTION_KEY_NOT_FOUND = 3785; + exports2.ER_RPL_ENCRYPTION_KEYRING_INVALID_KEY = 3786; + exports2.ER_RPL_ENCRYPTION_HEADER_ERROR = 3787; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_ROTATE_LOGS = 3788; + exports2.ER_RPL_ENCRYPTION_KEY_EXISTS_UNEXPECTED = 3789; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_GENERATE_KEY = 3790; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_STORE_KEY = 3791; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_REMOVE_KEY = 3792; + exports2.ER_RPL_ENCRYPTION_UNABLE_TO_CHANGE_OPTION = 3793; + exports2.ER_RPL_ENCRYPTION_MASTER_KEY_RECOVERY_FAILED = 3794; + exports2.ER_SLOW_LOG_MODE_IGNORED_WHEN_NOT_LOGGING_TO_FILE = 3795; + exports2.ER_GRP_TRX_CONSISTENCY_NOT_ALLOWED = 3796; + exports2.ER_GRP_TRX_CONSISTENCY_BEFORE = 3797; + exports2.ER_GRP_TRX_CONSISTENCY_AFTER_ON_TRX_BEGIN = 3798; + exports2.ER_GRP_TRX_CONSISTENCY_BEGIN_NOT_ALLOWED = 3799; + exports2.ER_FUNCTIONAL_INDEX_ROW_VALUE_IS_NOT_ALLOWED = 3800; + exports2.ER_RPL_ENCRYPTION_FAILED_TO_ENCRYPT = 3801; + exports2.ER_PAGE_TRACKING_NOT_STARTED = 3802; + exports2.ER_PAGE_TRACKING_RANGE_NOT_TRACKED = 3803; + exports2.ER_PAGE_TRACKING_CANNOT_PURGE = 3804; + exports2.ER_RPL_ENCRYPTION_CANNOT_ROTATE_BINLOG_MASTER_KEY = 3805; + exports2.ER_BINLOG_MASTER_KEY_RECOVERY_OUT_OF_COMBINATION = 3806; + exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_OPERATE_KEY = 3807; + exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_ROTATE_LOGS = 3808; + exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG = 3809; + exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_UNUSED_KEYS = 3810; + exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_AUX_KEY = 3811; + exports2.ER_NON_BOOLEAN_EXPR_FOR_CHECK_CONSTRAINT = 3812; + exports2.ER_COLUMN_CHECK_CONSTRAINT_REFERENCES_OTHER_COLUMN = 3813; + exports2.ER_CHECK_CONSTRAINT_NAMED_FUNCTION_IS_NOT_ALLOWED = 3814; + exports2.ER_CHECK_CONSTRAINT_FUNCTION_IS_NOT_ALLOWED = 3815; + exports2.ER_CHECK_CONSTRAINT_VARIABLES = 3816; + exports2.ER_CHECK_CONSTRAINT_ROW_VALUE = 3817; + exports2.ER_CHECK_CONSTRAINT_REFERS_AUTO_INCREMENT_COLUMN = 3818; + exports2.ER_CHECK_CONSTRAINT_VIOLATED = 3819; + exports2.ER_CHECK_CONSTRAINT_REFERS_UNKNOWN_COLUMN = 3820; + exports2.ER_CHECK_CONSTRAINT_NOT_FOUND = 3821; + exports2.ER_CHECK_CONSTRAINT_DUP_NAME = 3822; + exports2.ER_CHECK_CONSTRAINT_CLAUSE_USING_FK_REFER_ACTION_COLUMN = 3823; + exports2.WARN_UNENCRYPTED_TABLE_IN_ENCRYPTED_DB = 3824; + exports2.ER_INVALID_ENCRYPTION_REQUEST = 3825; + exports2.ER_CANNOT_SET_TABLE_ENCRYPTION = 3826; + exports2.ER_CANNOT_SET_DATABASE_ENCRYPTION = 3827; + exports2.ER_CANNOT_SET_TABLESPACE_ENCRYPTION = 3828; + exports2.ER_TABLESPACE_CANNOT_BE_ENCRYPTED = 3829; + exports2.ER_TABLESPACE_CANNOT_BE_DECRYPTED = 3830; + exports2.ER_TABLESPACE_TYPE_UNKNOWN = 3831; + exports2.ER_TARGET_TABLESPACE_UNENCRYPTED = 3832; + exports2.ER_CANNOT_USE_ENCRYPTION_CLAUSE = 3833; + exports2.ER_INVALID_MULTIPLE_CLAUSES = 3834; + exports2.ER_UNSUPPORTED_USE_OF_GRANT_AS = 3835; + exports2.ER_UKNOWN_AUTH_ID_OR_ACCESS_DENIED_FOR_GRANT_AS = 3836; + exports2.ER_DEPENDENT_BY_FUNCTIONAL_INDEX = 3837; + exports2.ER_PLUGIN_NOT_EARLY = 3838; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_START_SUBDIR_PATH = 3839; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_START_TIMEOUT = 3840; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIRS_INVALID = 3841; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_LABEL_NOT_FOUND = 3842; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_EMPTY = 3843; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_NO_SUCH_DIR = 3844; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_CLASH = 3845; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_PERMISSIONS = 3846; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_FILE_CREATE = 3847; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_ACTIVE = 3848; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_INACTIVE = 3849; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_FAILED = 3850; + exports2.ER_INNODB_REDO_LOG_ARCHIVE_SESSION = 3851; + exports2.ER_STD_REGEX_ERROR = 3852; + exports2.ER_INVALID_JSON_TYPE = 3853; + exports2.ER_CANNOT_CONVERT_STRING = 3854; + exports2.ER_DEPENDENT_BY_PARTITION_FUNC = 3855; + exports2.ER_WARN_DEPRECATED_FLOAT_AUTO_INCREMENT = 3856; + exports2.ER_RPL_CANT_STOP_REPLICA_WHILE_LOCKED_BACKUP = 3857; + exports2.ER_WARN_DEPRECATED_FLOAT_DIGITS = 3858; + exports2.ER_WARN_DEPRECATED_FLOAT_UNSIGNED = 3859; + exports2.ER_WARN_DEPRECATED_INTEGER_DISPLAY_WIDTH = 3860; + exports2.ER_WARN_DEPRECATED_ZEROFILL = 3861; + exports2.ER_CLONE_DONOR = 3862; + exports2.ER_CLONE_PROTOCOL = 3863; + exports2.ER_CLONE_DONOR_VERSION = 3864; + exports2.ER_CLONE_OS = 3865; + exports2.ER_CLONE_PLATFORM = 3866; + exports2.ER_CLONE_CHARSET = 3867; + exports2.ER_CLONE_CONFIG = 3868; + exports2.ER_CLONE_SYS_CONFIG = 3869; + exports2.ER_CLONE_PLUGIN_MATCH = 3870; + exports2.ER_CLONE_LOOPBACK = 3871; + exports2.ER_CLONE_ENCRYPTION = 3872; + exports2.ER_CLONE_DISK_SPACE = 3873; + exports2.ER_CLONE_IN_PROGRESS = 3874; + exports2.ER_CLONE_DISALLOWED = 3875; + exports2.ER_CANNOT_GRANT_ROLES_TO_ANONYMOUS_USER = 3876; + exports2.ER_SECONDARY_ENGINE_PLUGIN = 3877; + exports2.ER_SECOND_PASSWORD_CANNOT_BE_EMPTY = 3878; + exports2.ER_DB_ACCESS_DENIED = 3879; + exports2.ER_DA_AUTH_ID_WITH_SYSTEM_USER_PRIV_IN_MANDATORY_ROLES = 3880; + exports2.ER_DA_RPL_GTID_TABLE_CANNOT_OPEN = 3881; + exports2.ER_GEOMETRY_IN_UNKNOWN_LENGTH_UNIT = 3882; + exports2.ER_DA_PLUGIN_INSTALL_ERROR = 3883; + exports2.ER_NO_SESSION_TEMP = 3884; + exports2.ER_DA_UNKNOWN_ERROR_NUMBER = 3885; + exports2.ER_COLUMN_CHANGE_SIZE = 3886; + exports2.ER_REGEXP_INVALID_CAPTURE_GROUP_NAME = 3887; + exports2.ER_DA_SSL_LIBRARY_ERROR = 3888; + exports2.ER_SECONDARY_ENGINE = 3889; + exports2.ER_SECONDARY_ENGINE_DDL = 3890; + exports2.ER_INCORRECT_CURRENT_PASSWORD = 3891; + exports2.ER_MISSING_CURRENT_PASSWORD = 3892; + exports2.ER_CURRENT_PASSWORD_NOT_REQUIRED = 3893; + exports2.ER_PASSWORD_CANNOT_BE_RETAINED_ON_PLUGIN_CHANGE = 3894; + exports2.ER_CURRENT_PASSWORD_CANNOT_BE_RETAINED = 3895; + exports2.ER_PARTIAL_REVOKES_EXIST = 3896; + exports2.ER_CANNOT_GRANT_SYSTEM_PRIV_TO_MANDATORY_ROLE = 3897; + exports2.ER_XA_REPLICATION_FILTERS = 3898; + exports2.ER_UNSUPPORTED_SQL_MODE = 3899; + exports2.ER_REGEXP_INVALID_FLAG = 3900; + exports2.ER_PARTIAL_REVOKE_AND_DB_GRANT_BOTH_EXISTS = 3901; + exports2.ER_UNIT_NOT_FOUND = 3902; + exports2.ER_INVALID_JSON_VALUE_FOR_FUNC_INDEX = 3903; + exports2.ER_JSON_VALUE_OUT_OF_RANGE_FOR_FUNC_INDEX = 3904; + exports2.ER_EXCEEDED_MV_KEYS_NUM = 3905; + exports2.ER_EXCEEDED_MV_KEYS_SPACE = 3906; + exports2.ER_FUNCTIONAL_INDEX_DATA_IS_TOO_LONG = 3907; + exports2.ER_WRONG_MVI_VALUE = 3908; + exports2.ER_WARN_FUNC_INDEX_NOT_APPLICABLE = 3909; + exports2.ER_GRP_RPL_UDF_ERROR = 3910; + exports2.ER_UPDATE_GTID_PURGED_WITH_GR = 3911; + exports2.ER_GROUPING_ON_TIMESTAMP_IN_DST = 3912; + exports2.ER_TABLE_NAME_CAUSES_TOO_LONG_PATH = 3913; + exports2.ER_AUDIT_LOG_INSUFFICIENT_PRIVILEGE = 3914; + exports2.ER_AUDIT_LOG_PASSWORD_HAS_BEEN_COPIED = 3915; + exports2.ER_DA_GRP_RPL_STARTED_AUTO_REJOIN = 3916; + exports2.ER_SYSVAR_CHANGE_DURING_QUERY = 3917; + exports2.ER_GLOBSTAT_CHANGE_DURING_QUERY = 3918; + exports2.ER_GRP_RPL_MESSAGE_SERVICE_INIT_FAILURE = 3919; + exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_CLIENT = 3920; + exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_LEVEL_CLIENT = 3921; + exports2.ER_WRONG_COMPRESSION_ALGORITHM_CLIENT = 3922; + exports2.ER_WRONG_COMPRESSION_LEVEL_CLIENT = 3923; + exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_LIST_CLIENT = 3924; + exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_CANNOT_BE_ANONYMOUS = 3925; + exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_DOES_NOT_EXIST = 3926; + exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_CORRUPT = 3927; + exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_NEEDS_RPL_APPLIER_PRIV = 3928; + exports2.ER_WARN_DA_PRIVILEGE_NOT_REGISTERED = 3929; + exports2.ER_CLIENT_KEYRING_UDF_KEY_INVALID = 3930; + exports2.ER_CLIENT_KEYRING_UDF_KEY_TYPE_INVALID = 3931; + exports2.ER_CLIENT_KEYRING_UDF_KEY_TOO_LONG = 3932; + exports2.ER_CLIENT_KEYRING_UDF_KEY_TYPE_TOO_LONG = 3933; + exports2.ER_JSON_SCHEMA_VALIDATION_ERROR_WITH_DETAILED_REPORT = 3934; + exports2.ER_DA_UDF_INVALID_CHARSET_SPECIFIED = 3935; + exports2.ER_DA_UDF_INVALID_CHARSET = 3936; + exports2.ER_DA_UDF_INVALID_COLLATION = 3937; + exports2.ER_DA_UDF_INVALID_EXTENSION_ARGUMENT_TYPE = 3938; + exports2.ER_MULTIPLE_CONSTRAINTS_WITH_SAME_NAME = 3939; + exports2.ER_CONSTRAINT_NOT_FOUND = 3940; + exports2.ER_ALTER_CONSTRAINT_ENFORCEMENT_NOT_SUPPORTED = 3941; + exports2.ER_TABLE_VALUE_CONSTRUCTOR_MUST_HAVE_COLUMNS = 3942; + exports2.ER_TABLE_VALUE_CONSTRUCTOR_CANNOT_HAVE_DEFAULT = 3943; + exports2.ER_CLIENT_QUERY_FAILURE_INVALID_NON_ROW_FORMAT = 3944; + exports2.ER_REQUIRE_ROW_FORMAT_INVALID_VALUE = 3945; + exports2.ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY = 3946; + exports2.ER_FAILED_TO_FETCH_MANDATORY_ROLE_LIST = 3947; + exports2.ER_CLIENT_LOCAL_FILES_DISABLED = 3948; + exports2.ER_IMP_INCOMPATIBLE_CFG_VERSION = 3949; + exports2.ER_DA_OOM = 3950; + exports2.ER_DA_UDF_INVALID_ARGUMENT_TO_SET_CHARSET = 3951; + exports2.ER_DA_UDF_INVALID_RETURN_TYPE_TO_SET_CHARSET = 3952; + exports2.ER_MULTIPLE_INTO_CLAUSES = 3953; + exports2.ER_MISPLACED_INTO = 3954; + exports2.ER_USER_ACCESS_DENIED_FOR_USER_ACCOUNT_BLOCKED_BY_PASSWORD_LOCK = 3955; + exports2.ER_WARN_DEPRECATED_YEAR_UNSIGNED = 3956; + exports2.ER_CLONE_NETWORK_PACKET = 3957; + exports2.ER_SDI_OPERATION_FAILED_MISSING_RECORD = 3958; + exports2.ER_DEPENDENT_BY_CHECK_CONSTRAINT = 3959; + exports2.ER_GRP_OPERATION_NOT_ALLOWED_GR_MUST_STOP = 3960; + exports2.ER_WARN_DEPRECATED_JSON_TABLE_ON_ERROR_ON_EMPTY = 3961; + exports2.ER_WARN_DEPRECATED_INNER_INTO = 3962; + exports2.ER_WARN_DEPRECATED_VALUES_FUNCTION_ALWAYS_NULL = 3963; + exports2.ER_WARN_DEPRECATED_SQL_CALC_FOUND_ROWS = 3964; + exports2.ER_WARN_DEPRECATED_FOUND_ROWS = 3965; + exports2.ER_MISSING_JSON_VALUE = 3966; + exports2.ER_MULTIPLE_JSON_VALUES = 3967; + exports2.ER_HOSTNAME_TOO_LONG = 3968; + exports2.ER_WARN_CLIENT_DEPRECATED_PARTITION_PREFIX_KEY = 3969; + exports2.ER_GROUP_REPLICATION_USER_EMPTY_MSG = 3970; + exports2.ER_GROUP_REPLICATION_USER_MANDATORY_MSG = 3971; + exports2.ER_GROUP_REPLICATION_PASSWORD_LENGTH = 3972; + exports2.ER_SUBQUERY_TRANSFORM_REJECTED = 3973; + exports2.ER_DA_GRP_RPL_RECOVERY_ENDPOINT_FORMAT = 3974; + exports2.ER_DA_GRP_RPL_RECOVERY_ENDPOINT_INVALID = 3975; + exports2.ER_WRONG_VALUE_FOR_VAR_PLUS_ACTIONABLE_PART = 3976; + exports2.ER_STATEMENT_NOT_ALLOWED_AFTER_START_TRANSACTION = 3977; + exports2.ER_FOREIGN_KEY_WITH_ATOMIC_CREATE_SELECT = 3978; + exports2.ER_NOT_ALLOWED_WITH_START_TRANSACTION = 3979; + exports2.ER_INVALID_JSON_ATTRIBUTE = 3980; + exports2.ER_ENGINE_ATTRIBUTE_NOT_SUPPORTED = 3981; + exports2.ER_INVALID_USER_ATTRIBUTE_JSON = 3982; + exports2.ER_INNODB_REDO_DISABLED = 3983; + exports2.ER_INNODB_REDO_ARCHIVING_ENABLED = 3984; + exports2.ER_MDL_OUT_OF_RESOURCES = 3985; + exports2.ER_IMPLICIT_COMPARISON_FOR_JSON = 3986; + exports2.ER_FUNCTION_DOES_NOT_SUPPORT_CHARACTER_SET = 3987; + exports2.ER_IMPOSSIBLE_STRING_CONVERSION = 3988; + exports2.ER_SCHEMA_READ_ONLY = 3989; + exports2.ER_RPL_ASYNC_RECONNECT_GTID_MODE_OFF = 3990; + exports2.ER_RPL_ASYNC_RECONNECT_AUTO_POSITION_OFF = 3991; + exports2.ER_DISABLE_GTID_MODE_REQUIRES_ASYNC_RECONNECT_OFF = 3992; + exports2.ER_DISABLE_AUTO_POSITION_REQUIRES_ASYNC_RECONNECT_OFF = 3993; + exports2.ER_INVALID_PARAMETER_USE = 3994; + exports2.ER_CHARACTER_SET_MISMATCH = 3995; + exports2.ER_WARN_VAR_VALUE_CHANGE_NOT_SUPPORTED = 3996; + exports2.ER_INVALID_TIME_ZONE_INTERVAL = 3997; + exports2.ER_INVALID_CAST = 3998; + exports2.ER_HYPERGRAPH_NOT_SUPPORTED_YET = 3999; + exports2.ER_WARN_HYPERGRAPH_EXPERIMENTAL = 4e3; + exports2.ER_DA_NO_ERROR_LOG_PARSER_CONFIGURED = 4001; + exports2.ER_DA_ERROR_LOG_TABLE_DISABLED = 4002; + exports2.ER_DA_ERROR_LOG_MULTIPLE_FILTERS = 4003; + exports2.ER_DA_CANT_OPEN_ERROR_LOG = 4004; + exports2.ER_USER_REFERENCED_AS_DEFINER = 4005; + exports2.ER_CANNOT_USER_REFERENCED_AS_DEFINER = 4006; + exports2.ER_REGEX_NUMBER_TOO_BIG = 4007; + exports2.ER_SPVAR_NONINTEGER_TYPE = 4008; + exports2.WARN_UNSUPPORTED_ACL_TABLES_READ = 4009; + exports2.ER_BINLOG_UNSAFE_ACL_TABLE_READ_IN_DML_DDL = 4010; + exports2.ER_STOP_REPLICA_MONITOR_IO_THREAD_TIMEOUT = 4011; + exports2.ER_STARTING_REPLICA_MONITOR_IO_THREAD = 4012; + exports2.ER_CANT_USE_ANONYMOUS_TO_GTID_WITH_GTID_MODE_NOT_ON = 4013; + exports2.ER_CANT_COMBINE_ANONYMOUS_TO_GTID_AND_AUTOPOSITION = 4014; + exports2.ER_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_REQUIRES_GTID_MODE_ON = 4015; + exports2.ER_SQL_REPLICA_SKIP_COUNTER_USED_WITH_GTID_MODE_ON = 4016; + exports2.ER_USING_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_AS_LOCAL_OR_UUID = 4017; + exports2.ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS = 4018; + exports2.ER_CANT_SET_SQL_AFTER_OR_BEFORE_GTIDS_WITH_ANONYMOUS_TO_GTID = 4019; + exports2.ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_GROUP_NAME = 4020; + exports2.ER_CANT_USE_SAME_UUID_AS_GROUP_NAME = 4021; + exports2.ER_GRP_RPL_RECOVERY_CHANNEL_STILL_RUNNING = 4022; + exports2.ER_INNODB_INVALID_AUTOEXTEND_SIZE_VALUE = 4023; + exports2.ER_INNODB_INCOMPATIBLE_WITH_TABLESPACE = 4024; + exports2.ER_INNODB_AUTOEXTEND_SIZE_OUT_OF_RANGE = 4025; + exports2.ER_CANNOT_USE_AUTOEXTEND_SIZE_CLAUSE = 4026; + exports2.ER_ROLE_GRANTED_TO_ITSELF = 4027; + exports2.ER_TABLE_MUST_HAVE_A_VISIBLE_COLUMN = 4028; + exports2.ER_INNODB_COMPRESSION_FAILURE = 4029; + exports2.ER_WARN_ASYNC_CONN_FAILOVER_NETWORK_NAMESPACE = 4030; + exports2.ER_CLIENT_INTERACTION_TIMEOUT = 4031; + exports2.ER_INVALID_CAST_TO_GEOMETRY = 4032; + exports2.ER_INVALID_CAST_POLYGON_RING_DIRECTION = 4033; + exports2.ER_GIS_DIFFERENT_SRIDS_AGGREGATION = 4034; + exports2.ER_RELOAD_KEYRING_FAILURE = 4035; + exports2.ER_SDI_GET_KEYS_INVALID_TABLESPACE = 4036; + exports2.ER_CHANGE_RPL_SRC_WRONG_COMPRESSION_ALGORITHM_SIZE = 4037; + exports2.ER_WARN_DEPRECATED_TLS_VERSION_FOR_CHANNEL_CLI = 4038; + exports2.ER_CANT_USE_SAME_UUID_AS_VIEW_CHANGE_UUID = 4039; + exports2.ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_VIEW_CHANGE_UUID = 4040; + exports2.ER_GRP_RPL_VIEW_CHANGE_UUID_FAIL_GET_VARIABLE = 4041; + exports2.ER_WARN_ADUIT_LOG_MAX_SIZE_AND_PRUNE_SECONDS = 4042; + exports2.ER_WARN_ADUIT_LOG_MAX_SIZE_CLOSE_TO_ROTATE_ON_SIZE = 4043; + exports2.ER_KERBEROS_CREATE_USER = 4044; + exports2.ER_INSTALL_PLUGIN_CONFLICT_CLIENT = 4045; + exports2.ER_DA_ERROR_LOG_COMPONENT_FLUSH_FAILED = 4046; + exports2.ER_WARN_SQL_AFTER_MTS_GAPS_GAP_NOT_CALCULATED = 4047; + exports2.ER_INVALID_ASSIGNMENT_TARGET = 4048; + exports2.ER_OPERATION_NOT_ALLOWED_ON_GR_SECONDARY = 4049; + exports2.ER_GRP_RPL_FAILOVER_CHANNEL_STATUS_PROPAGATION = 4050; + exports2.ER_WARN_AUDIT_LOG_FORMAT_UNIX_TIMESTAMP_ONLY_WHEN_JSON = 4051; + exports2.ER_INVALID_MFA_PLUGIN_SPECIFIED = 4052; + exports2.ER_IDENTIFIED_BY_UNSUPPORTED = 4053; + exports2.ER_INVALID_PLUGIN_FOR_REGISTRATION = 4054; + exports2.ER_PLUGIN_REQUIRES_REGISTRATION = 4055; + exports2.ER_MFA_METHOD_EXISTS = 4056; + exports2.ER_MFA_METHOD_NOT_EXISTS = 4057; + exports2.ER_AUTHENTICATION_POLICY_MISMATCH = 4058; + exports2.ER_PLUGIN_REGISTRATION_DONE = 4059; + exports2.ER_INVALID_USER_FOR_REGISTRATION = 4060; + exports2.ER_USER_REGISTRATION_FAILED = 4061; + exports2.ER_MFA_METHODS_INVALID_ORDER = 4062; + exports2.ER_MFA_METHODS_IDENTICAL = 4063; + exports2.ER_INVALID_MFA_OPERATIONS_FOR_PASSWORDLESS_USER = 4064; + exports2.ER_CHANGE_REPLICATION_SOURCE_NO_OPTIONS_FOR_GTID_ONLY = 4065; + exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_REQ_ROW_FORMAT_WITH_GTID_ONLY = 4066; + exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POSITION_WITH_GTID_ONLY = 4067; + exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_GTID_ONLY_WITHOUT_POSITIONS = 4068; + exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POS_WITHOUT_POSITIONS = 4069; + exports2.ER_CHANGE_REP_SOURCE_GR_CHANNEL_WITH_GTID_MODE_NOT_ON = 4070; + exports2.ER_CANT_USE_GTID_ONLY_WITH_GTID_MODE_NOT_ON = 4071; + exports2.ER_WARN_C_DISABLE_GTID_ONLY_WITH_SOURCE_AUTO_POS_INVALID_POS = 4072; + exports2.ER_DA_SSL_FIPS_MODE_ERROR = 4073; + exports2.ER_VALUE_OUT_OF_RANGE = 4074; + exports2.ER_FULLTEXT_WITH_ROLLUP = 4075; + exports2.ER_REGEXP_MISSING_RESOURCE = 4076; + exports2.ER_WARN_REGEXP_USING_DEFAULT = 4077; + exports2.ER_REGEXP_MISSING_FILE = 4078; + exports2.ER_WARN_DEPRECATED_COLLATION = 4079; + exports2.ER_CONCURRENT_PROCEDURE_USAGE = 4080; + exports2.ER_DA_GLOBAL_CONN_LIMIT = 4081; + exports2.ER_DA_CONN_LIMIT = 4082; + exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE_INSTANT = 4083; + exports2.ER_WARN_SF_UDF_NAME_COLLISION = 4084; + exports2.ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK = 4085; + exports2.ER_TOO_MANY_WINDOWS = 4086; + exports2.ER_MYSQLBACKUP_CLIENT_MSG = 4087; + exports2.ER_COMMENT_CONTAINS_INVALID_STRING = 4088; + exports2.ER_DEFINITION_CONTAINS_INVALID_STRING = 4089; + exports2.ER_CANT_EXECUTE_COMMAND_WITH_ASSIGNED_GTID_NEXT = 4090; + exports2.ER_XA_TEMP_TABLE = 4091; + exports2.ER_INNODB_MAX_ROW_VERSION = 4092; + exports2.ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_SIZE = 4093; + exports2.ER_OPERATION_NOT_ALLOWED_WHILE_PRIMARY_CHANGE_IS_RUNNING = 4094; + exports2.ER_WARN_DEPRECATED_DATETIME_DELIMITER = 4095; + exports2.ER_WARN_DEPRECATED_SUPERFLUOUS_DELIMITER = 4096; + exports2.ER_CANNOT_PERSIST_SENSITIVE_VARIABLES = 4097; + exports2.ER_WARN_CANNOT_SECURELY_PERSIST_SENSITIVE_VARIABLES = 4098; + exports2.ER_WARN_TRG_ALREADY_EXISTS = 4099; + exports2.ER_IF_NOT_EXISTS_UNSUPPORTED_TRG_EXISTS_ON_DIFFERENT_TABLE = 4100; + exports2.ER_IF_NOT_EXISTS_UNSUPPORTED_UDF_NATIVE_FCT_NAME_COLLISION = 4101; + exports2.ER_SET_PASSWORD_AUTH_PLUGIN_ERROR = 4102; + exports2.ER_REDUCED_DBLWR_FILE_CORRUPTED = 4103; + exports2.ER_REDUCED_DBLWR_PAGE_FOUND = 4104; + exports2.ER_SRS_INVALID_LATITUDE_OF_ORIGIN = 4105; + exports2.ER_SRS_INVALID_LONGITUDE_OF_ORIGIN = 4106; + exports2.ER_SRS_UNUSED_PROJ_PARAMETER_PRESENT = 4107; + exports2.ER_GIPK_COLUMN_EXISTS = 4108; + exports2.ER_GIPK_FAILED_AUTOINC_COLUMN_EXISTS = 4109; + exports2.ER_GIPK_COLUMN_ALTER_NOT_ALLOWED = 4110; + exports2.ER_DROP_PK_COLUMN_TO_DROP_GIPK = 4111; + exports2.ER_CREATE_SELECT_WITH_GIPK_DISALLOWED_IN_SBR = 4112; + exports2.ER_DA_EXPIRE_LOGS_DAYS_IGNORED = 4113; + exports2.ER_CTE_RECURSIVE_NOT_UNION = 4114; + exports2.ER_COMMAND_BACKEND_FAILED_TO_FETCH_SECURITY_CTX = 4115; + exports2.ER_COMMAND_SERVICE_BACKEND_FAILED = 4116; + exports2.ER_CLIENT_FILE_PRIVILEGE_FOR_REPLICATION_CHECKS = 4117; + exports2.ER_GROUP_REPLICATION_FORCE_MEMBERS_COMMAND_FAILURE = 4118; + exports2.ER_WARN_DEPRECATED_IDENT = 4119; + exports2.ER_INTERSECT_ALL_MAX_DUPLICATES_EXCEEDED = 4120; + exports2.ER_TP_QUERY_THRS_PER_GRP_EXCEEDS_TXN_THR_LIMIT = 4121; + exports2.ER_BAD_TIMESTAMP_FORMAT = 4122; + exports2.ER_SHAPE_PRIDICTION_UDF = 4123; + exports2.ER_SRS_INVALID_HEIGHT = 4124; + exports2.ER_SRS_INVALID_SCALING = 4125; + exports2.ER_SRS_INVALID_ZONE_WIDTH = 4126; + exports2.ER_SRS_INVALID_LATITUDE_POLAR_STERE_VAR_A = 4127; + exports2.ER_WARN_DEPRECATED_CLIENT_NO_SCHEMA_OPTION = 4128; + exports2.ER_TABLE_NOT_EMPTY = 4129; + exports2.ER_TABLE_NO_PRIMARY_KEY = 4130; + exports2.ER_TABLE_IN_SHARED_TABLESPACE = 4131; + exports2.ER_INDEX_OTHER_THAN_PK = 4132; + exports2.ER_LOAD_BULK_DATA_UNSORTED = 4133; + exports2.ER_BULK_EXECUTOR_ERROR = 4134; + exports2.ER_BULK_READER_LIBCURL_INIT_FAILED = 4135; + exports2.ER_BULK_READER_LIBCURL_ERROR = 4136; + exports2.ER_BULK_READER_SERVER_ERROR = 4137; + exports2.ER_BULK_READER_COMMUNICATION_ERROR = 4138; + exports2.ER_BULK_LOAD_DATA_FAILED = 4139; + exports2.ER_BULK_LOADER_COLUMN_TOO_BIG_FOR_LEFTOVER_BUFFER = 4140; + exports2.ER_BULK_LOADER_COMPONENT_ERROR = 4141; + exports2.ER_BULK_LOADER_FILE_CONTAINS_LESS_LINES_THAN_IGNORE_CLAUSE = 4142; + exports2.ER_BULK_PARSER_MISSING_ENCLOSED_BY = 4143; + exports2.ER_BULK_PARSER_ROW_BUFFER_MAX_TOTAL_COLS_EXCEEDED = 4144; + exports2.ER_BULK_PARSER_COPY_BUFFER_SIZE_EXCEEDED = 4145; + exports2.ER_BULK_PARSER_UNEXPECTED_END_OF_INPUT = 4146; + exports2.ER_BULK_PARSER_UNEXPECTED_ROW_TERMINATOR = 4147; + exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_ENDING_ENCLOSED_BY = 4148; + exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_NULL_ESCAPE = 4149; + exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_COLUMN_TERMINATOR = 4150; + exports2.ER_BULK_PARSER_INCOMPLETE_ESCAPE_SEQUENCE = 4151; + exports2.ER_LOAD_BULK_DATA_FAILED = 4152; + exports2.ER_LOAD_BULK_DATA_WRONG_VALUE_FOR_FIELD = 4153; + exports2.ER_LOAD_BULK_DATA_WARN_NULL_TO_NOTNULL = 4154; + exports2.ER_REQUIRE_TABLE_PRIMARY_KEY_CHECK_GENERATE_WITH_GR = 4155; + exports2.ER_CANT_CHANGE_SYS_VAR_IN_READ_ONLY_MODE = 4156; + exports2.ER_INNODB_INSTANT_ADD_DROP_NOT_SUPPORTED_MAX_SIZE = 4157; + exports2.ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_FIELDS = 4158; + exports2.ER_CANT_SET_PERSISTED = 4159; + exports2.ER_INSTALL_COMPONENT_SET_NULL_VALUE = 4160; + exports2.ER_INSTALL_COMPONENT_SET_UNUSED_VALUE = 4161; + exports2.ER_WARN_DEPRECATED_USER_DEFINED_COLLATIONS = 4162; + exports2[1] = "EE_CANTCREATEFILE"; + exports2[2] = "EE_READ"; + exports2[3] = "EE_WRITE"; + exports2[4] = "EE_BADCLOSE"; + exports2[5] = "EE_OUTOFMEMORY"; + exports2[6] = "EE_DELETE"; + exports2[7] = "EE_LINK"; + exports2[9] = "EE_EOFERR"; + exports2[10] = "EE_CANTLOCK"; + exports2[11] = "EE_CANTUNLOCK"; + exports2[12] = "EE_DIR"; + exports2[13] = "EE_STAT"; + exports2[14] = "EE_CANT_CHSIZE"; + exports2[15] = "EE_CANT_OPEN_STREAM"; + exports2[16] = "EE_GETWD"; + exports2[17] = "EE_SETWD"; + exports2[18] = "EE_LINK_WARNING"; + exports2[19] = "EE_OPEN_WARNING"; + exports2[20] = "EE_DISK_FULL"; + exports2[21] = "EE_CANT_MKDIR"; + exports2[22] = "EE_UNKNOWN_CHARSET"; + exports2[23] = "EE_OUT_OF_FILERESOURCES"; + exports2[24] = "EE_CANT_READLINK"; + exports2[25] = "EE_CANT_SYMLINK"; + exports2[26] = "EE_REALPATH"; + exports2[27] = "EE_SYNC"; + exports2[28] = "EE_UNKNOWN_COLLATION"; + exports2[29] = "EE_FILENOTFOUND"; + exports2[30] = "EE_FILE_NOT_CLOSED"; + exports2[31] = "EE_CHANGE_OWNERSHIP"; + exports2[32] = "EE_CHANGE_PERMISSIONS"; + exports2[33] = "EE_CANT_SEEK"; + exports2[34] = "EE_CAPACITY_EXCEEDED"; + exports2[35] = "EE_DISK_FULL_WITH_RETRY_MSG"; + exports2[36] = "EE_FAILED_TO_CREATE_TIMER"; + exports2[37] = "EE_FAILED_TO_DELETE_TIMER"; + exports2[38] = "EE_FAILED_TO_CREATE_TIMER_QUEUE"; + exports2[39] = "EE_FAILED_TO_START_TIMER_NOTIFY_THREAD"; + exports2[40] = "EE_FAILED_TO_CREATE_TIMER_NOTIFY_THREAD_INTERRUPT_EVENT"; + exports2[41] = "EE_EXITING_TIMER_NOTIFY_THREAD"; + exports2[42] = "EE_WIN_LIBRARY_LOAD_FAILED"; + exports2[43] = "EE_WIN_RUN_TIME_ERROR_CHECK"; + exports2[44] = "EE_FAILED_TO_DETERMINE_LARGE_PAGE_SIZE"; + exports2[45] = "EE_FAILED_TO_KILL_ALL_THREADS"; + exports2[46] = "EE_FAILED_TO_CREATE_IO_COMPLETION_PORT"; + exports2[47] = "EE_FAILED_TO_OPEN_DEFAULTS_FILE"; + exports2[48] = "EE_FAILED_TO_HANDLE_DEFAULTS_FILE"; + exports2[49] = "EE_WRONG_DIRECTIVE_IN_CONFIG_FILE"; + exports2[50] = "EE_SKIPPING_DIRECTIVE_DUE_TO_MAX_INCLUDE_RECURSION"; + exports2[51] = "EE_INCORRECT_GRP_DEFINITION_IN_CONFIG_FILE"; + exports2[52] = "EE_OPTION_WITHOUT_GRP_IN_CONFIG_FILE"; + exports2[53] = "EE_CONFIG_FILE_PERMISSION_ERROR"; + exports2[54] = "EE_IGNORE_WORLD_WRITABLE_CONFIG_FILE"; + exports2[55] = "EE_USING_DISABLED_OPTION"; + exports2[56] = "EE_USING_DISABLED_SHORT_OPTION"; + exports2[57] = "EE_USING_PASSWORD_ON_CLI_IS_INSECURE"; + exports2[58] = "EE_UNKNOWN_SUFFIX_FOR_VARIABLE"; + exports2[59] = "EE_SSL_ERROR_FROM_FILE"; + exports2[60] = "EE_SSL_ERROR"; + exports2[61] = "EE_NET_SEND_ERROR_IN_BOOTSTRAP"; + exports2[62] = "EE_PACKETS_OUT_OF_ORDER"; + exports2[63] = "EE_UNKNOWN_PROTOCOL_OPTION"; + exports2[64] = "EE_FAILED_TO_LOCATE_SERVER_PUBLIC_KEY"; + exports2[65] = "EE_PUBLIC_KEY_NOT_IN_PEM_FORMAT"; + exports2[66] = "EE_DEBUG_INFO"; + exports2[67] = "EE_UNKNOWN_VARIABLE"; + exports2[68] = "EE_UNKNOWN_OPTION"; + exports2[69] = "EE_UNKNOWN_SHORT_OPTION"; + exports2[70] = "EE_OPTION_WITHOUT_ARGUMENT"; + exports2[71] = "EE_OPTION_REQUIRES_ARGUMENT"; + exports2[72] = "EE_SHORT_OPTION_REQUIRES_ARGUMENT"; + exports2[73] = "EE_OPTION_IGNORED_DUE_TO_INVALID_VALUE"; + exports2[74] = "EE_OPTION_WITH_EMPTY_VALUE"; + exports2[75] = "EE_FAILED_TO_ASSIGN_MAX_VALUE_TO_OPTION"; + exports2[76] = "EE_INCORRECT_BOOLEAN_VALUE_FOR_OPTION"; + exports2[77] = "EE_FAILED_TO_SET_OPTION_VALUE"; + exports2[78] = "EE_INCORRECT_INT_VALUE_FOR_OPTION"; + exports2[79] = "EE_INCORRECT_UINT_VALUE_FOR_OPTION"; + exports2[80] = "EE_ADJUSTED_SIGNED_VALUE_FOR_OPTION"; + exports2[81] = "EE_ADJUSTED_UNSIGNED_VALUE_FOR_OPTION"; + exports2[82] = "EE_ADJUSTED_ULONGLONG_VALUE_FOR_OPTION"; + exports2[83] = "EE_ADJUSTED_DOUBLE_VALUE_FOR_OPTION"; + exports2[84] = "EE_INVALID_DECIMAL_VALUE_FOR_OPTION"; + exports2[85] = "EE_COLLATION_PARSER_ERROR"; + exports2[86] = "EE_FAILED_TO_RESET_BEFORE_PRIMARY_IGNORABLE_CHAR"; + exports2[87] = "EE_FAILED_TO_RESET_BEFORE_TERTIARY_IGNORABLE_CHAR"; + exports2[88] = "EE_SHIFT_CHAR_OUT_OF_RANGE"; + exports2[89] = "EE_RESET_CHAR_OUT_OF_RANGE"; + exports2[90] = "EE_UNKNOWN_LDML_TAG"; + exports2[91] = "EE_FAILED_TO_RESET_BEFORE_SECONDARY_IGNORABLE_CHAR"; + exports2[92] = "EE_FAILED_PROCESSING_DIRECTIVE"; + exports2[93] = "EE_PTHREAD_KILL_FAILED"; + exports2[120] = "HA_ERR_KEY_NOT_FOUND"; + exports2[121] = "HA_ERR_FOUND_DUPP_KEY"; + exports2[122] = "HA_ERR_INTERNAL_ERROR"; + exports2[123] = "HA_ERR_RECORD_CHANGED"; + exports2[124] = "HA_ERR_WRONG_INDEX"; + exports2[125] = "HA_ERR_ROLLED_BACK"; + exports2[126] = "HA_ERR_CRASHED"; + exports2[127] = "HA_ERR_WRONG_IN_RECORD"; + exports2[128] = "HA_ERR_OUT_OF_MEM"; + exports2[130] = "HA_ERR_NOT_A_TABLE"; + exports2[131] = "HA_ERR_WRONG_COMMAND"; + exports2[132] = "HA_ERR_OLD_FILE"; + exports2[133] = "HA_ERR_NO_ACTIVE_RECORD"; + exports2[134] = "HA_ERR_RECORD_DELETED"; + exports2[135] = "HA_ERR_RECORD_FILE_FULL"; + exports2[136] = "HA_ERR_INDEX_FILE_FULL"; + exports2[137] = "HA_ERR_END_OF_FILE"; + exports2[138] = "HA_ERR_UNSUPPORTED"; + exports2[139] = "HA_ERR_TOO_BIG_ROW"; + exports2[140] = "HA_WRONG_CREATE_OPTION"; + exports2[141] = "HA_ERR_FOUND_DUPP_UNIQUE"; + exports2[142] = "HA_ERR_UNKNOWN_CHARSET"; + exports2[143] = "HA_ERR_WRONG_MRG_TABLE_DEF"; + exports2[144] = "HA_ERR_CRASHED_ON_REPAIR"; + exports2[145] = "HA_ERR_CRASHED_ON_USAGE"; + exports2[146] = "HA_ERR_LOCK_WAIT_TIMEOUT"; + exports2[147] = "HA_ERR_LOCK_TABLE_FULL"; + exports2[148] = "HA_ERR_READ_ONLY_TRANSACTION"; + exports2[149] = "HA_ERR_LOCK_DEADLOCK"; + exports2[150] = "HA_ERR_CANNOT_ADD_FOREIGN"; + exports2[151] = "HA_ERR_NO_REFERENCED_ROW"; + exports2[152] = "HA_ERR_ROW_IS_REFERENCED"; + exports2[153] = "HA_ERR_NO_SAVEPOINT"; + exports2[154] = "HA_ERR_NON_UNIQUE_BLOCK_SIZE"; + exports2[155] = "HA_ERR_NO_SUCH_TABLE"; + exports2[156] = "HA_ERR_TABLE_EXIST"; + exports2[157] = "HA_ERR_NO_CONNECTION"; + exports2[158] = "HA_ERR_NULL_IN_SPATIAL"; + exports2[159] = "HA_ERR_TABLE_DEF_CHANGED"; + exports2[160] = "HA_ERR_NO_PARTITION_FOUND"; + exports2[161] = "HA_ERR_RBR_LOGGING_FAILED"; + exports2[162] = "HA_ERR_DROP_INDEX_FK"; + exports2[163] = "HA_ERR_FOREIGN_DUPLICATE_KEY"; + exports2[164] = "HA_ERR_TABLE_NEEDS_UPGRADE"; + exports2[165] = "HA_ERR_TABLE_READONLY"; + exports2[166] = "HA_ERR_AUTOINC_READ_FAILED"; + exports2[167] = "HA_ERR_AUTOINC_ERANGE"; + exports2[168] = "HA_ERR_GENERIC"; + exports2[169] = "HA_ERR_RECORD_IS_THE_SAME"; + exports2[170] = "HA_ERR_LOGGING_IMPOSSIBLE"; + exports2[171] = "HA_ERR_CORRUPT_EVENT"; + exports2[172] = "HA_ERR_NEW_FILE"; + exports2[173] = "HA_ERR_ROWS_EVENT_APPLY"; + exports2[174] = "HA_ERR_INITIALIZATION"; + exports2[175] = "HA_ERR_FILE_TOO_SHORT"; + exports2[176] = "HA_ERR_WRONG_CRC"; + exports2[177] = "HA_ERR_TOO_MANY_CONCURRENT_TRXS"; + exports2[178] = "HA_ERR_NOT_IN_LOCK_PARTITIONS"; + exports2[179] = "HA_ERR_INDEX_COL_TOO_LONG"; + exports2[180] = "HA_ERR_INDEX_CORRUPT"; + exports2[181] = "HA_ERR_UNDO_REC_TOO_BIG"; + exports2[182] = "HA_FTS_INVALID_DOCID"; + exports2[183] = "HA_ERR_TABLE_IN_FK_CHECK"; + exports2[184] = "HA_ERR_TABLESPACE_EXISTS"; + exports2[185] = "HA_ERR_TOO_MANY_FIELDS"; + exports2[186] = "HA_ERR_ROW_IN_WRONG_PARTITION"; + exports2[187] = "HA_ERR_INNODB_READ_ONLY"; + exports2[188] = "HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT"; + exports2[189] = "HA_ERR_TEMP_FILE_WRITE_FAILURE"; + exports2[190] = "HA_ERR_INNODB_FORCED_RECOVERY"; + exports2[191] = "HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE"; + exports2[192] = "HA_ERR_FK_DEPTH_EXCEEDED"; + exports2[193] = "HA_MISSING_CREATE_OPTION"; + exports2[194] = "HA_ERR_SE_OUT_OF_MEMORY"; + exports2[195] = "HA_ERR_TABLE_CORRUPT"; + exports2[196] = "HA_ERR_QUERY_INTERRUPTED"; + exports2[197] = "HA_ERR_TABLESPACE_MISSING"; + exports2[198] = "HA_ERR_TABLESPACE_IS_NOT_EMPTY"; + exports2[199] = "HA_ERR_WRONG_FILE_NAME"; + exports2[200] = "HA_ERR_NOT_ALLOWED_COMMAND"; + exports2[201] = "HA_ERR_COMPUTE_FAILED"; + exports2[202] = "HA_ERR_ROW_FORMAT_CHANGED"; + exports2[203] = "HA_ERR_NO_WAIT_LOCK"; + exports2[204] = "HA_ERR_DISK_FULL_NOWAIT"; + exports2[205] = "HA_ERR_NO_SESSION_TEMP"; + exports2[206] = "HA_ERR_WRONG_TABLE_NAME"; + exports2[207] = "HA_ERR_TOO_LONG_PATH"; + exports2[208] = "HA_ERR_SAMPLING_INIT_FAILED"; + exports2[209] = "HA_ERR_FTS_TOO_MANY_NESTED_EXP"; + exports2[1e3] = "ER_HASHCHK"; + exports2[1001] = "ER_NISAMCHK"; + exports2[1002] = "ER_NO"; + exports2[1003] = "ER_YES"; + exports2[1004] = "ER_CANT_CREATE_FILE"; + exports2[1005] = "ER_CANT_CREATE_TABLE"; + exports2[1006] = "ER_CANT_CREATE_DB"; + exports2[1007] = "ER_DB_CREATE_EXISTS"; + exports2[1008] = "ER_DB_DROP_EXISTS"; + exports2[1009] = "ER_DB_DROP_DELETE"; + exports2[1010] = "ER_DB_DROP_RMDIR"; + exports2[1011] = "ER_CANT_DELETE_FILE"; + exports2[1012] = "ER_CANT_FIND_SYSTEM_REC"; + exports2[1013] = "ER_CANT_GET_STAT"; + exports2[1014] = "ER_CANT_GET_WD"; + exports2[1015] = "ER_CANT_LOCK"; + exports2[1016] = "ER_CANT_OPEN_FILE"; + exports2[1017] = "ER_FILE_NOT_FOUND"; + exports2[1018] = "ER_CANT_READ_DIR"; + exports2[1019] = "ER_CANT_SET_WD"; + exports2[1020] = "ER_CHECKREAD"; + exports2[1021] = "ER_DISK_FULL"; + exports2[1022] = "ER_DUP_KEY"; + exports2[1023] = "ER_ERROR_ON_CLOSE"; + exports2[1024] = "ER_ERROR_ON_READ"; + exports2[1025] = "ER_ERROR_ON_RENAME"; + exports2[1026] = "ER_ERROR_ON_WRITE"; + exports2[1027] = "ER_FILE_USED"; + exports2[1028] = "ER_FILSORT_ABORT"; + exports2[1029] = "ER_FORM_NOT_FOUND"; + exports2[1030] = "ER_GET_ERRNO"; + exports2[1031] = "ER_ILLEGAL_HA"; + exports2[1032] = "ER_KEY_NOT_FOUND"; + exports2[1033] = "ER_NOT_FORM_FILE"; + exports2[1034] = "ER_NOT_KEYFILE"; + exports2[1035] = "ER_OLD_KEYFILE"; + exports2[1036] = "ER_OPEN_AS_READONLY"; + exports2[1037] = "ER_OUTOFMEMORY"; + exports2[1038] = "ER_OUT_OF_SORTMEMORY"; + exports2[1039] = "ER_UNEXPECTED_EOF"; + exports2[1040] = "ER_CON_COUNT_ERROR"; + exports2[1041] = "ER_OUT_OF_RESOURCES"; + exports2[1042] = "ER_BAD_HOST_ERROR"; + exports2[1043] = "ER_HANDSHAKE_ERROR"; + exports2[1044] = "ER_DBACCESS_DENIED_ERROR"; + exports2[1045] = "ER_ACCESS_DENIED_ERROR"; + exports2[1046] = "ER_NO_DB_ERROR"; + exports2[1047] = "ER_UNKNOWN_COM_ERROR"; + exports2[1048] = "ER_BAD_NULL_ERROR"; + exports2[1049] = "ER_BAD_DB_ERROR"; + exports2[1050] = "ER_TABLE_EXISTS_ERROR"; + exports2[1051] = "ER_BAD_TABLE_ERROR"; + exports2[1052] = "ER_NON_UNIQ_ERROR"; + exports2[1053] = "ER_SERVER_SHUTDOWN"; + exports2[1054] = "ER_BAD_FIELD_ERROR"; + exports2[1055] = "ER_WRONG_FIELD_WITH_GROUP"; + exports2[1056] = "ER_WRONG_GROUP_FIELD"; + exports2[1057] = "ER_WRONG_SUM_SELECT"; + exports2[1058] = "ER_WRONG_VALUE_COUNT"; + exports2[1059] = "ER_TOO_LONG_IDENT"; + exports2[1060] = "ER_DUP_FIELDNAME"; + exports2[1061] = "ER_DUP_KEYNAME"; + exports2[1062] = "ER_DUP_ENTRY"; + exports2[1063] = "ER_WRONG_FIELD_SPEC"; + exports2[1064] = "ER_PARSE_ERROR"; + exports2[1065] = "ER_EMPTY_QUERY"; + exports2[1066] = "ER_NONUNIQ_TABLE"; + exports2[1067] = "ER_INVALID_DEFAULT"; + exports2[1068] = "ER_MULTIPLE_PRI_KEY"; + exports2[1069] = "ER_TOO_MANY_KEYS"; + exports2[1070] = "ER_TOO_MANY_KEY_PARTS"; + exports2[1071] = "ER_TOO_LONG_KEY"; + exports2[1072] = "ER_KEY_COLUMN_DOES_NOT_EXITS"; + exports2[1073] = "ER_BLOB_USED_AS_KEY"; + exports2[1074] = "ER_TOO_BIG_FIELDLENGTH"; + exports2[1075] = "ER_WRONG_AUTO_KEY"; + exports2[1076] = "ER_READY"; + exports2[1077] = "ER_NORMAL_SHUTDOWN"; + exports2[1078] = "ER_GOT_SIGNAL"; + exports2[1079] = "ER_SHUTDOWN_COMPLETE"; + exports2[1080] = "ER_FORCING_CLOSE"; + exports2[1081] = "ER_IPSOCK_ERROR"; + exports2[1082] = "ER_NO_SUCH_INDEX"; + exports2[1083] = "ER_WRONG_FIELD_TERMINATORS"; + exports2[1084] = "ER_BLOBS_AND_NO_TERMINATED"; + exports2[1085] = "ER_TEXTFILE_NOT_READABLE"; + exports2[1086] = "ER_FILE_EXISTS_ERROR"; + exports2[1087] = "ER_LOAD_INFO"; + exports2[1088] = "ER_ALTER_INFO"; + exports2[1089] = "ER_WRONG_SUB_KEY"; + exports2[1090] = "ER_CANT_REMOVE_ALL_FIELDS"; + exports2[1091] = "ER_CANT_DROP_FIELD_OR_KEY"; + exports2[1092] = "ER_INSERT_INFO"; + exports2[1093] = "ER_UPDATE_TABLE_USED"; + exports2[1094] = "ER_NO_SUCH_THREAD"; + exports2[1095] = "ER_KILL_DENIED_ERROR"; + exports2[1096] = "ER_NO_TABLES_USED"; + exports2[1097] = "ER_TOO_BIG_SET"; + exports2[1098] = "ER_NO_UNIQUE_LOGFILE"; + exports2[1099] = "ER_TABLE_NOT_LOCKED_FOR_WRITE"; + exports2[1100] = "ER_TABLE_NOT_LOCKED"; + exports2[1101] = "ER_BLOB_CANT_HAVE_DEFAULT"; + exports2[1102] = "ER_WRONG_DB_NAME"; + exports2[1103] = "ER_WRONG_TABLE_NAME"; + exports2[1104] = "ER_TOO_BIG_SELECT"; + exports2[1105] = "ER_UNKNOWN_ERROR"; + exports2[1106] = "ER_UNKNOWN_PROCEDURE"; + exports2[1107] = "ER_WRONG_PARAMCOUNT_TO_PROCEDURE"; + exports2[1108] = "ER_WRONG_PARAMETERS_TO_PROCEDURE"; + exports2[1109] = "ER_UNKNOWN_TABLE"; + exports2[1110] = "ER_FIELD_SPECIFIED_TWICE"; + exports2[1111] = "ER_INVALID_GROUP_FUNC_USE"; + exports2[1112] = "ER_UNSUPPORTED_EXTENSION"; + exports2[1113] = "ER_TABLE_MUST_HAVE_COLUMNS"; + exports2[1114] = "ER_RECORD_FILE_FULL"; + exports2[1115] = "ER_UNKNOWN_CHARACTER_SET"; + exports2[1116] = "ER_TOO_MANY_TABLES"; + exports2[1117] = "ER_TOO_MANY_FIELDS"; + exports2[1118] = "ER_TOO_BIG_ROWSIZE"; + exports2[1119] = "ER_STACK_OVERRUN"; + exports2[1120] = "ER_WRONG_OUTER_JOIN"; + exports2[1121] = "ER_NULL_COLUMN_IN_INDEX"; + exports2[1122] = "ER_CANT_FIND_UDF"; + exports2[1123] = "ER_CANT_INITIALIZE_UDF"; + exports2[1124] = "ER_UDF_NO_PATHS"; + exports2[1125] = "ER_UDF_EXISTS"; + exports2[1126] = "ER_CANT_OPEN_LIBRARY"; + exports2[1127] = "ER_CANT_FIND_DL_ENTRY"; + exports2[1128] = "ER_FUNCTION_NOT_DEFINED"; + exports2[1129] = "ER_HOST_IS_BLOCKED"; + exports2[1130] = "ER_HOST_NOT_PRIVILEGED"; + exports2[1131] = "ER_PASSWORD_ANONYMOUS_USER"; + exports2[1132] = "ER_PASSWORD_NOT_ALLOWED"; + exports2[1133] = "ER_PASSWORD_NO_MATCH"; + exports2[1134] = "ER_UPDATE_INFO"; + exports2[1135] = "ER_CANT_CREATE_THREAD"; + exports2[1136] = "ER_WRONG_VALUE_COUNT_ON_ROW"; + exports2[1137] = "ER_CANT_REOPEN_TABLE"; + exports2[1138] = "ER_INVALID_USE_OF_NULL"; + exports2[1139] = "ER_REGEXP_ERROR"; + exports2[1140] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS"; + exports2[1141] = "ER_NONEXISTING_GRANT"; + exports2[1142] = "ER_TABLEACCESS_DENIED_ERROR"; + exports2[1143] = "ER_COLUMNACCESS_DENIED_ERROR"; + exports2[1144] = "ER_ILLEGAL_GRANT_FOR_TABLE"; + exports2[1145] = "ER_GRANT_WRONG_HOST_OR_USER"; + exports2[1146] = "ER_NO_SUCH_TABLE"; + exports2[1147] = "ER_NONEXISTING_TABLE_GRANT"; + exports2[1148] = "ER_NOT_ALLOWED_COMMAND"; + exports2[1149] = "ER_SYNTAX_ERROR"; + exports2[1150] = "ER_UNUSED1"; + exports2[1151] = "ER_UNUSED2"; + exports2[1152] = "ER_ABORTING_CONNECTION"; + exports2[1153] = "ER_NET_PACKET_TOO_LARGE"; + exports2[1154] = "ER_NET_READ_ERROR_FROM_PIPE"; + exports2[1155] = "ER_NET_FCNTL_ERROR"; + exports2[1156] = "ER_NET_PACKETS_OUT_OF_ORDER"; + exports2[1157] = "ER_NET_UNCOMPRESS_ERROR"; + exports2[1158] = "ER_NET_READ_ERROR"; + exports2[1159] = "ER_NET_READ_INTERRUPTED"; + exports2[1160] = "ER_NET_ERROR_ON_WRITE"; + exports2[1161] = "ER_NET_WRITE_INTERRUPTED"; + exports2[1162] = "ER_TOO_LONG_STRING"; + exports2[1163] = "ER_TABLE_CANT_HANDLE_BLOB"; + exports2[1164] = "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT"; + exports2[1165] = "ER_UNUSED3"; + exports2[1166] = "ER_WRONG_COLUMN_NAME"; + exports2[1167] = "ER_WRONG_KEY_COLUMN"; + exports2[1168] = "ER_WRONG_MRG_TABLE"; + exports2[1169] = "ER_DUP_UNIQUE"; + exports2[1170] = "ER_BLOB_KEY_WITHOUT_LENGTH"; + exports2[1171] = "ER_PRIMARY_CANT_HAVE_NULL"; + exports2[1172] = "ER_TOO_MANY_ROWS"; + exports2[1173] = "ER_REQUIRES_PRIMARY_KEY"; + exports2[1174] = "ER_NO_RAID_COMPILED"; + exports2[1175] = "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE"; + exports2[1176] = "ER_KEY_DOES_NOT_EXITS"; + exports2[1177] = "ER_CHECK_NO_SUCH_TABLE"; + exports2[1178] = "ER_CHECK_NOT_IMPLEMENTED"; + exports2[1179] = "ER_CANT_DO_THIS_DURING_AN_TRANSACTION"; + exports2[1180] = "ER_ERROR_DURING_COMMIT"; + exports2[1181] = "ER_ERROR_DURING_ROLLBACK"; + exports2[1182] = "ER_ERROR_DURING_FLUSH_LOGS"; + exports2[1183] = "ER_ERROR_DURING_CHECKPOINT"; + exports2[1184] = "ER_NEW_ABORTING_CONNECTION"; + exports2[1185] = "ER_DUMP_NOT_IMPLEMENTED"; + exports2[1186] = "ER_FLUSH_MASTER_BINLOG_CLOSED"; + exports2[1187] = "ER_INDEX_REBUILD"; + exports2[1188] = "ER_SOURCE"; + exports2[1189] = "ER_SOURCE_NET_READ"; + exports2[1190] = "ER_SOURCE_NET_WRITE"; + exports2[1191] = "ER_FT_MATCHING_KEY_NOT_FOUND"; + exports2[1192] = "ER_LOCK_OR_ACTIVE_TRANSACTION"; + exports2[1193] = "ER_UNKNOWN_SYSTEM_VARIABLE"; + exports2[1194] = "ER_CRASHED_ON_USAGE"; + exports2[1195] = "ER_CRASHED_ON_REPAIR"; + exports2[1196] = "ER_WARNING_NOT_COMPLETE_ROLLBACK"; + exports2[1197] = "ER_TRANS_CACHE_FULL"; + exports2[1198] = "ER_SLAVE_MUST_STOP"; + exports2[1199] = "ER_REPLICA_NOT_RUNNING"; + exports2[1200] = "ER_BAD_REPLICA"; + exports2[1201] = "ER_CONNECTION_METADATA"; + exports2[1202] = "ER_REPLICA_THREAD"; + exports2[1203] = "ER_TOO_MANY_USER_CONNECTIONS"; + exports2[1204] = "ER_SET_CONSTANTS_ONLY"; + exports2[1205] = "ER_LOCK_WAIT_TIMEOUT"; + exports2[1206] = "ER_LOCK_TABLE_FULL"; + exports2[1207] = "ER_READ_ONLY_TRANSACTION"; + exports2[1208] = "ER_DROP_DB_WITH_READ_LOCK"; + exports2[1209] = "ER_CREATE_DB_WITH_READ_LOCK"; + exports2[1210] = "ER_WRONG_ARGUMENTS"; + exports2[1211] = "ER_NO_PERMISSION_TO_CREATE_USER"; + exports2[1212] = "ER_UNION_TABLES_IN_DIFFERENT_DIR"; + exports2[1213] = "ER_LOCK_DEADLOCK"; + exports2[1214] = "ER_TABLE_CANT_HANDLE_FT"; + exports2[1215] = "ER_CANNOT_ADD_FOREIGN"; + exports2[1216] = "ER_NO_REFERENCED_ROW"; + exports2[1217] = "ER_ROW_IS_REFERENCED"; + exports2[1218] = "ER_CONNECT_TO_SOURCE"; + exports2[1219] = "ER_QUERY_ON_MASTER"; + exports2[1220] = "ER_ERROR_WHEN_EXECUTING_COMMAND"; + exports2[1221] = "ER_WRONG_USAGE"; + exports2[1222] = "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT"; + exports2[1223] = "ER_CANT_UPDATE_WITH_READLOCK"; + exports2[1224] = "ER_MIXING_NOT_ALLOWED"; + exports2[1225] = "ER_DUP_ARGUMENT"; + exports2[1226] = "ER_USER_LIMIT_REACHED"; + exports2[1227] = "ER_SPECIFIC_ACCESS_DENIED_ERROR"; + exports2[1228] = "ER_LOCAL_VARIABLE"; + exports2[1229] = "ER_GLOBAL_VARIABLE"; + exports2[1230] = "ER_NO_DEFAULT"; + exports2[1231] = "ER_WRONG_VALUE_FOR_VAR"; + exports2[1232] = "ER_WRONG_TYPE_FOR_VAR"; + exports2[1233] = "ER_VAR_CANT_BE_READ"; + exports2[1234] = "ER_CANT_USE_OPTION_HERE"; + exports2[1235] = "ER_NOT_SUPPORTED_YET"; + exports2[1236] = "ER_SOURCE_FATAL_ERROR_READING_BINLOG"; + exports2[1237] = "ER_REPLICA_IGNORED_TABLE"; + exports2[1238] = "ER_INCORRECT_GLOBAL_LOCAL_VAR"; + exports2[1239] = "ER_WRONG_FK_DEF"; + exports2[1240] = "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF"; + exports2[1241] = "ER_OPERAND_COLUMNS"; + exports2[1242] = "ER_SUBQUERY_NO_1_ROW"; + exports2[1243] = "ER_UNKNOWN_STMT_HANDLER"; + exports2[1244] = "ER_CORRUPT_HELP_DB"; + exports2[1245] = "ER_CYCLIC_REFERENCE"; + exports2[1246] = "ER_AUTO_CONVERT"; + exports2[1247] = "ER_ILLEGAL_REFERENCE"; + exports2[1248] = "ER_DERIVED_MUST_HAVE_ALIAS"; + exports2[1249] = "ER_SELECT_REDUCED"; + exports2[1250] = "ER_TABLENAME_NOT_ALLOWED_HERE"; + exports2[1251] = "ER_NOT_SUPPORTED_AUTH_MODE"; + exports2[1252] = "ER_SPATIAL_CANT_HAVE_NULL"; + exports2[1253] = "ER_COLLATION_CHARSET_MISMATCH"; + exports2[1254] = "ER_SLAVE_WAS_RUNNING"; + exports2[1255] = "ER_SLAVE_WAS_NOT_RUNNING"; + exports2[1256] = "ER_TOO_BIG_FOR_UNCOMPRESS"; + exports2[1257] = "ER_ZLIB_Z_MEM_ERROR"; + exports2[1258] = "ER_ZLIB_Z_BUF_ERROR"; + exports2[1259] = "ER_ZLIB_Z_DATA_ERROR"; + exports2[1260] = "ER_CUT_VALUE_GROUP_CONCAT"; + exports2[1261] = "ER_WARN_TOO_FEW_RECORDS"; + exports2[1262] = "ER_WARN_TOO_MANY_RECORDS"; + exports2[1263] = "ER_WARN_NULL_TO_NOTNULL"; + exports2[1264] = "ER_WARN_DATA_OUT_OF_RANGE"; + exports2[1265] = "WARN_DATA_TRUNCATED"; + exports2[1266] = "ER_WARN_USING_OTHER_HANDLER"; + exports2[1267] = "ER_CANT_AGGREGATE_2COLLATIONS"; + exports2[1268] = "ER_DROP_USER"; + exports2[1269] = "ER_REVOKE_GRANTS"; + exports2[1270] = "ER_CANT_AGGREGATE_3COLLATIONS"; + exports2[1271] = "ER_CANT_AGGREGATE_NCOLLATIONS"; + exports2[1272] = "ER_VARIABLE_IS_NOT_STRUCT"; + exports2[1273] = "ER_UNKNOWN_COLLATION"; + exports2[1274] = "ER_REPLICA_IGNORED_SSL_PARAMS"; + exports2[1275] = "ER_SERVER_IS_IN_SECURE_AUTH_MODE"; + exports2[1276] = "ER_WARN_FIELD_RESOLVED"; + exports2[1277] = "ER_BAD_REPLICA_UNTIL_COND"; + exports2[1278] = "ER_MISSING_SKIP_REPLICA"; + exports2[1279] = "ER_UNTIL_COND_IGNORED"; + exports2[1280] = "ER_WRONG_NAME_FOR_INDEX"; + exports2[1281] = "ER_WRONG_NAME_FOR_CATALOG"; + exports2[1282] = "ER_WARN_QC_RESIZE"; + exports2[1283] = "ER_BAD_FT_COLUMN"; + exports2[1284] = "ER_UNKNOWN_KEY_CACHE"; + exports2[1285] = "ER_WARN_HOSTNAME_WONT_WORK"; + exports2[1286] = "ER_UNKNOWN_STORAGE_ENGINE"; + exports2[1287] = "ER_WARN_DEPRECATED_SYNTAX"; + exports2[1288] = "ER_NON_UPDATABLE_TABLE"; + exports2[1289] = "ER_FEATURE_DISABLED"; + exports2[1290] = "ER_OPTION_PREVENTS_STATEMENT"; + exports2[1291] = "ER_DUPLICATED_VALUE_IN_TYPE"; + exports2[1292] = "ER_TRUNCATED_WRONG_VALUE"; + exports2[1293] = "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS"; + exports2[1294] = "ER_INVALID_ON_UPDATE"; + exports2[1295] = "ER_UNSUPPORTED_PS"; + exports2[1296] = "ER_GET_ERRMSG"; + exports2[1297] = "ER_GET_TEMPORARY_ERRMSG"; + exports2[1298] = "ER_UNKNOWN_TIME_ZONE"; + exports2[1299] = "ER_WARN_INVALID_TIMESTAMP"; + exports2[1300] = "ER_INVALID_CHARACTER_STRING"; + exports2[1301] = "ER_WARN_ALLOWED_PACKET_OVERFLOWED"; + exports2[1302] = "ER_CONFLICTING_DECLARATIONS"; + exports2[1303] = "ER_SP_NO_RECURSIVE_CREATE"; + exports2[1304] = "ER_SP_ALREADY_EXISTS"; + exports2[1305] = "ER_SP_DOES_NOT_EXIST"; + exports2[1306] = "ER_SP_DROP_FAILED"; + exports2[1307] = "ER_SP_STORE_FAILED"; + exports2[1308] = "ER_SP_LILABEL_MISMATCH"; + exports2[1309] = "ER_SP_LABEL_REDEFINE"; + exports2[1310] = "ER_SP_LABEL_MISMATCH"; + exports2[1311] = "ER_SP_UNINIT_VAR"; + exports2[1312] = "ER_SP_BADSELECT"; + exports2[1313] = "ER_SP_BADRETURN"; + exports2[1314] = "ER_SP_BADSTATEMENT"; + exports2[1315] = "ER_UPDATE_LOG_DEPRECATED_IGNORED"; + exports2[1316] = "ER_UPDATE_LOG_DEPRECATED_TRANSLATED"; + exports2[1317] = "ER_QUERY_INTERRUPTED"; + exports2[1318] = "ER_SP_WRONG_NO_OF_ARGS"; + exports2[1319] = "ER_SP_COND_MISMATCH"; + exports2[1320] = "ER_SP_NORETURN"; + exports2[1321] = "ER_SP_NORETURNEND"; + exports2[1322] = "ER_SP_BAD_CURSOR_QUERY"; + exports2[1323] = "ER_SP_BAD_CURSOR_SELECT"; + exports2[1324] = "ER_SP_CURSOR_MISMATCH"; + exports2[1325] = "ER_SP_CURSOR_ALREADY_OPEN"; + exports2[1326] = "ER_SP_CURSOR_NOT_OPEN"; + exports2[1327] = "ER_SP_UNDECLARED_VAR"; + exports2[1328] = "ER_SP_WRONG_NO_OF_FETCH_ARGS"; + exports2[1329] = "ER_SP_FETCH_NO_DATA"; + exports2[1330] = "ER_SP_DUP_PARAM"; + exports2[1331] = "ER_SP_DUP_VAR"; + exports2[1332] = "ER_SP_DUP_COND"; + exports2[1333] = "ER_SP_DUP_CURS"; + exports2[1334] = "ER_SP_CANT_ALTER"; + exports2[1335] = "ER_SP_SUBSELECT_NYI"; + exports2[1336] = "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG"; + exports2[1337] = "ER_SP_VARCOND_AFTER_CURSHNDLR"; + exports2[1338] = "ER_SP_CURSOR_AFTER_HANDLER"; + exports2[1339] = "ER_SP_CASE_NOT_FOUND"; + exports2[1340] = "ER_FPARSER_TOO_BIG_FILE"; + exports2[1341] = "ER_FPARSER_BAD_HEADER"; + exports2[1342] = "ER_FPARSER_EOF_IN_COMMENT"; + exports2[1343] = "ER_FPARSER_ERROR_IN_PARAMETER"; + exports2[1344] = "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER"; + exports2[1345] = "ER_VIEW_NO_EXPLAIN"; + exports2[1346] = "ER_FRM_UNKNOWN_TYPE"; + exports2[1347] = "ER_WRONG_OBJECT"; + exports2[1348] = "ER_NONUPDATEABLE_COLUMN"; + exports2[1349] = "ER_VIEW_SELECT_DERIVED"; + exports2[1350] = "ER_VIEW_SELECT_CLAUSE"; + exports2[1351] = "ER_VIEW_SELECT_VARIABLE"; + exports2[1352] = "ER_VIEW_SELECT_TMPTABLE"; + exports2[1353] = "ER_VIEW_WRONG_LIST"; + exports2[1354] = "ER_WARN_VIEW_MERGE"; + exports2[1355] = "ER_WARN_VIEW_WITHOUT_KEY"; + exports2[1356] = "ER_VIEW_INVALID"; + exports2[1357] = "ER_SP_NO_DROP_SP"; + exports2[1358] = "ER_SP_GOTO_IN_HNDLR"; + exports2[1359] = "ER_TRG_ALREADY_EXISTS"; + exports2[1360] = "ER_TRG_DOES_NOT_EXIST"; + exports2[1361] = "ER_TRG_ON_VIEW_OR_TEMP_TABLE"; + exports2[1362] = "ER_TRG_CANT_CHANGE_ROW"; + exports2[1363] = "ER_TRG_NO_SUCH_ROW_IN_TRG"; + exports2[1364] = "ER_NO_DEFAULT_FOR_FIELD"; + exports2[1365] = "ER_DIVISION_BY_ZERO"; + exports2[1366] = "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD"; + exports2[1367] = "ER_ILLEGAL_VALUE_FOR_TYPE"; + exports2[1368] = "ER_VIEW_NONUPD_CHECK"; + exports2[1369] = "ER_VIEW_CHECK_FAILED"; + exports2[1370] = "ER_PROCACCESS_DENIED_ERROR"; + exports2[1371] = "ER_RELAY_LOG_FAIL"; + exports2[1372] = "ER_PASSWD_LENGTH"; + exports2[1373] = "ER_UNKNOWN_TARGET_BINLOG"; + exports2[1374] = "ER_IO_ERR_LOG_INDEX_READ"; + exports2[1375] = "ER_BINLOG_PURGE_PROHIBITED"; + exports2[1376] = "ER_FSEEK_FAIL"; + exports2[1377] = "ER_BINLOG_PURGE_FATAL_ERR"; + exports2[1378] = "ER_LOG_IN_USE"; + exports2[1379] = "ER_LOG_PURGE_UNKNOWN_ERR"; + exports2[1380] = "ER_RELAY_LOG_INIT"; + exports2[1381] = "ER_NO_BINARY_LOGGING"; + exports2[1382] = "ER_RESERVED_SYNTAX"; + exports2[1383] = "ER_WSAS_FAILED"; + exports2[1384] = "ER_DIFF_GROUPS_PROC"; + exports2[1385] = "ER_NO_GROUP_FOR_PROC"; + exports2[1386] = "ER_ORDER_WITH_PROC"; + exports2[1387] = "ER_LOGGING_PROHIBIT_CHANGING_OF"; + exports2[1388] = "ER_NO_FILE_MAPPING"; + exports2[1389] = "ER_WRONG_MAGIC"; + exports2[1390] = "ER_PS_MANY_PARAM"; + exports2[1391] = "ER_KEY_PART_0"; + exports2[1392] = "ER_VIEW_CHECKSUM"; + exports2[1393] = "ER_VIEW_MULTIUPDATE"; + exports2[1394] = "ER_VIEW_NO_INSERT_FIELD_LIST"; + exports2[1395] = "ER_VIEW_DELETE_MERGE_VIEW"; + exports2[1396] = "ER_CANNOT_USER"; + exports2[1397] = "ER_XAER_NOTA"; + exports2[1398] = "ER_XAER_INVAL"; + exports2[1399] = "ER_XAER_RMFAIL"; + exports2[1400] = "ER_XAER_OUTSIDE"; + exports2[1401] = "ER_XAER_RMERR"; + exports2[1402] = "ER_XA_RBROLLBACK"; + exports2[1403] = "ER_NONEXISTING_PROC_GRANT"; + exports2[1404] = "ER_PROC_AUTO_GRANT_FAIL"; + exports2[1405] = "ER_PROC_AUTO_REVOKE_FAIL"; + exports2[1406] = "ER_DATA_TOO_LONG"; + exports2[1407] = "ER_SP_BAD_SQLSTATE"; + exports2[1408] = "ER_STARTUP"; + exports2[1409] = "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR"; + exports2[1410] = "ER_CANT_CREATE_USER_WITH_GRANT"; + exports2[1411] = "ER_WRONG_VALUE_FOR_TYPE"; + exports2[1412] = "ER_TABLE_DEF_CHANGED"; + exports2[1413] = "ER_SP_DUP_HANDLER"; + exports2[1414] = "ER_SP_NOT_VAR_ARG"; + exports2[1415] = "ER_SP_NO_RETSET"; + exports2[1416] = "ER_CANT_CREATE_GEOMETRY_OBJECT"; + exports2[1417] = "ER_FAILED_ROUTINE_BREAK_BINLOG"; + exports2[1418] = "ER_BINLOG_UNSAFE_ROUTINE"; + exports2[1419] = "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER"; + exports2[1420] = "ER_EXEC_STMT_WITH_OPEN_CURSOR"; + exports2[1421] = "ER_STMT_HAS_NO_OPEN_CURSOR"; + exports2[1422] = "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG"; + exports2[1423] = "ER_NO_DEFAULT_FOR_VIEW_FIELD"; + exports2[1424] = "ER_SP_NO_RECURSION"; + exports2[1425] = "ER_TOO_BIG_SCALE"; + exports2[1426] = "ER_TOO_BIG_PRECISION"; + exports2[1427] = "ER_M_BIGGER_THAN_D"; + exports2[1428] = "ER_WRONG_LOCK_OF_SYSTEM_TABLE"; + exports2[1429] = "ER_CONNECT_TO_FOREIGN_DATA_SOURCE"; + exports2[1430] = "ER_QUERY_ON_FOREIGN_DATA_SOURCE"; + exports2[1431] = "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST"; + exports2[1432] = "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE"; + exports2[1433] = "ER_FOREIGN_DATA_STRING_INVALID"; + exports2[1434] = "ER_CANT_CREATE_FEDERATED_TABLE"; + exports2[1435] = "ER_TRG_IN_WRONG_SCHEMA"; + exports2[1436] = "ER_STACK_OVERRUN_NEED_MORE"; + exports2[1437] = "ER_TOO_LONG_BODY"; + exports2[1438] = "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE"; + exports2[1439] = "ER_TOO_BIG_DISPLAYWIDTH"; + exports2[1440] = "ER_XAER_DUPID"; + exports2[1441] = "ER_DATETIME_FUNCTION_OVERFLOW"; + exports2[1442] = "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG"; + exports2[1443] = "ER_VIEW_PREVENT_UPDATE"; + exports2[1444] = "ER_PS_NO_RECURSION"; + exports2[1445] = "ER_SP_CANT_SET_AUTOCOMMIT"; + exports2[1446] = "ER_MALFORMED_DEFINER"; + exports2[1447] = "ER_VIEW_FRM_NO_USER"; + exports2[1448] = "ER_VIEW_OTHER_USER"; + exports2[1449] = "ER_NO_SUCH_USER"; + exports2[1450] = "ER_FORBID_SCHEMA_CHANGE"; + exports2[1451] = "ER_ROW_IS_REFERENCED_2"; + exports2[1452] = "ER_NO_REFERENCED_ROW_2"; + exports2[1453] = "ER_SP_BAD_VAR_SHADOW"; + exports2[1454] = "ER_TRG_NO_DEFINER"; + exports2[1455] = "ER_OLD_FILE_FORMAT"; + exports2[1456] = "ER_SP_RECURSION_LIMIT"; + exports2[1457] = "ER_SP_PROC_TABLE_CORRUPT"; + exports2[1458] = "ER_SP_WRONG_NAME"; + exports2[1459] = "ER_TABLE_NEEDS_UPGRADE"; + exports2[1460] = "ER_SP_NO_AGGREGATE"; + exports2[1461] = "ER_MAX_PREPARED_STMT_COUNT_REACHED"; + exports2[1462] = "ER_VIEW_RECURSIVE"; + exports2[1463] = "ER_NON_GROUPING_FIELD_USED"; + exports2[1464] = "ER_TABLE_CANT_HANDLE_SPKEYS"; + exports2[1465] = "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA"; + exports2[1466] = "ER_REMOVED_SPACES"; + exports2[1467] = "ER_AUTOINC_READ_FAILED"; + exports2[1468] = "ER_USERNAME"; + exports2[1469] = "ER_HOSTNAME"; + exports2[1470] = "ER_WRONG_STRING_LENGTH"; + exports2[1471] = "ER_NON_INSERTABLE_TABLE"; + exports2[1472] = "ER_ADMIN_WRONG_MRG_TABLE"; + exports2[1473] = "ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT"; + exports2[1474] = "ER_NAME_BECOMES_EMPTY"; + exports2[1475] = "ER_AMBIGUOUS_FIELD_TERM"; + exports2[1476] = "ER_FOREIGN_SERVER_EXISTS"; + exports2[1477] = "ER_FOREIGN_SERVER_DOESNT_EXIST"; + exports2[1478] = "ER_ILLEGAL_HA_CREATE_OPTION"; + exports2[1479] = "ER_PARTITION_REQUIRES_VALUES_ERROR"; + exports2[1480] = "ER_PARTITION_WRONG_VALUES_ERROR"; + exports2[1481] = "ER_PARTITION_MAXVALUE_ERROR"; + exports2[1482] = "ER_PARTITION_SUBPARTITION_ERROR"; + exports2[1483] = "ER_PARTITION_SUBPART_MIX_ERROR"; + exports2[1484] = "ER_PARTITION_WRONG_NO_PART_ERROR"; + exports2[1485] = "ER_PARTITION_WRONG_NO_SUBPART_ERROR"; + exports2[1486] = "ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR"; + exports2[1487] = "ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR"; + exports2[1488] = "ER_FIELD_NOT_FOUND_PART_ERROR"; + exports2[1489] = "ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR"; + exports2[1490] = "ER_INCONSISTENT_PARTITION_INFO_ERROR"; + exports2[1491] = "ER_PARTITION_FUNC_NOT_ALLOWED_ERROR"; + exports2[1492] = "ER_PARTITIONS_MUST_BE_DEFINED_ERROR"; + exports2[1493] = "ER_RANGE_NOT_INCREASING_ERROR"; + exports2[1494] = "ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR"; + exports2[1495] = "ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR"; + exports2[1496] = "ER_PARTITION_ENTRY_ERROR"; + exports2[1497] = "ER_MIX_HANDLER_ERROR"; + exports2[1498] = "ER_PARTITION_NOT_DEFINED_ERROR"; + exports2[1499] = "ER_TOO_MANY_PARTITIONS_ERROR"; + exports2[1500] = "ER_SUBPARTITION_ERROR"; + exports2[1501] = "ER_CANT_CREATE_HANDLER_FILE"; + exports2[1502] = "ER_BLOB_FIELD_IN_PART_FUNC_ERROR"; + exports2[1503] = "ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF"; + exports2[1504] = "ER_NO_PARTS_ERROR"; + exports2[1505] = "ER_PARTITION_MGMT_ON_NONPARTITIONED"; + exports2[1506] = "ER_FOREIGN_KEY_ON_PARTITIONED"; + exports2[1507] = "ER_DROP_PARTITION_NON_EXISTENT"; + exports2[1508] = "ER_DROP_LAST_PARTITION"; + exports2[1509] = "ER_COALESCE_ONLY_ON_HASH_PARTITION"; + exports2[1510] = "ER_REORG_HASH_ONLY_ON_SAME_NO"; + exports2[1511] = "ER_REORG_NO_PARAM_ERROR"; + exports2[1512] = "ER_ONLY_ON_RANGE_LIST_PARTITION"; + exports2[1513] = "ER_ADD_PARTITION_SUBPART_ERROR"; + exports2[1514] = "ER_ADD_PARTITION_NO_NEW_PARTITION"; + exports2[1515] = "ER_COALESCE_PARTITION_NO_PARTITION"; + exports2[1516] = "ER_REORG_PARTITION_NOT_EXIST"; + exports2[1517] = "ER_SAME_NAME_PARTITION"; + exports2[1518] = "ER_NO_BINLOG_ERROR"; + exports2[1519] = "ER_CONSECUTIVE_REORG_PARTITIONS"; + exports2[1520] = "ER_REORG_OUTSIDE_RANGE"; + exports2[1521] = "ER_PARTITION_FUNCTION_FAILURE"; + exports2[1522] = "ER_PART_STATE_ERROR"; + exports2[1523] = "ER_LIMITED_PART_RANGE"; + exports2[1524] = "ER_PLUGIN_IS_NOT_LOADED"; + exports2[1525] = "ER_WRONG_VALUE"; + exports2[1526] = "ER_NO_PARTITION_FOR_GIVEN_VALUE"; + exports2[1527] = "ER_FILEGROUP_OPTION_ONLY_ONCE"; + exports2[1528] = "ER_CREATE_FILEGROUP_FAILED"; + exports2[1529] = "ER_DROP_FILEGROUP_FAILED"; + exports2[1530] = "ER_TABLESPACE_AUTO_EXTEND_ERROR"; + exports2[1531] = "ER_WRONG_SIZE_NUMBER"; + exports2[1532] = "ER_SIZE_OVERFLOW_ERROR"; + exports2[1533] = "ER_ALTER_FILEGROUP_FAILED"; + exports2[1534] = "ER_BINLOG_ROW_LOGGING_FAILED"; + exports2[1535] = "ER_BINLOG_ROW_WRONG_TABLE_DEF"; + exports2[1536] = "ER_BINLOG_ROW_RBR_TO_SBR"; + exports2[1537] = "ER_EVENT_ALREADY_EXISTS"; + exports2[1538] = "ER_EVENT_STORE_FAILED"; + exports2[1539] = "ER_EVENT_DOES_NOT_EXIST"; + exports2[1540] = "ER_EVENT_CANT_ALTER"; + exports2[1541] = "ER_EVENT_DROP_FAILED"; + exports2[1542] = "ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG"; + exports2[1543] = "ER_EVENT_ENDS_BEFORE_STARTS"; + exports2[1544] = "ER_EVENT_EXEC_TIME_IN_THE_PAST"; + exports2[1545] = "ER_EVENT_OPEN_TABLE_FAILED"; + exports2[1546] = "ER_EVENT_NEITHER_M_EXPR_NOR_M_AT"; + exports2[1547] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED"; + exports2[1548] = "ER_CANNOT_LOAD_FROM_TABLE"; + exports2[1549] = "ER_EVENT_CANNOT_DELETE"; + exports2[1550] = "ER_EVENT_COMPILE_ERROR"; + exports2[1551] = "ER_EVENT_SAME_NAME"; + exports2[1552] = "ER_EVENT_DATA_TOO_LONG"; + exports2[1553] = "ER_DROP_INDEX_FK"; + exports2[1554] = "ER_WARN_DEPRECATED_SYNTAX_WITH_VER"; + exports2[1555] = "ER_CANT_WRITE_LOCK_LOG_TABLE"; + exports2[1556] = "ER_CANT_LOCK_LOG_TABLE"; + exports2[1557] = "ER_FOREIGN_DUPLICATE_KEY"; + exports2[1558] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE"; + exports2[1559] = "ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR"; + exports2[1560] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT"; + exports2[1561] = "ER_NDB_CANT_SWITCH_BINLOG_FORMAT"; + exports2[1562] = "ER_PARTITION_NO_TEMPORARY"; + exports2[1563] = "ER_PARTITION_CONST_DOMAIN_ERROR"; + exports2[1564] = "ER_PARTITION_FUNCTION_IS_NOT_ALLOWED"; + exports2[1565] = "ER_DDL_LOG_ERROR"; + exports2[1566] = "ER_NULL_IN_VALUES_LESS_THAN"; + exports2[1567] = "ER_WRONG_PARTITION_NAME"; + exports2[1568] = "ER_CANT_CHANGE_TX_CHARACTERISTICS"; + exports2[1569] = "ER_DUP_ENTRY_AUTOINCREMENT_CASE"; + exports2[1570] = "ER_EVENT_MODIFY_QUEUE_ERROR"; + exports2[1571] = "ER_EVENT_SET_VAR_ERROR"; + exports2[1572] = "ER_PARTITION_MERGE_ERROR"; + exports2[1573] = "ER_CANT_ACTIVATE_LOG"; + exports2[1574] = "ER_RBR_NOT_AVAILABLE"; + exports2[1575] = "ER_BASE64_DECODE_ERROR"; + exports2[1576] = "ER_EVENT_RECURSION_FORBIDDEN"; + exports2[1577] = "ER_EVENTS_DB_ERROR"; + exports2[1578] = "ER_ONLY_INTEGERS_ALLOWED"; + exports2[1579] = "ER_UNSUPORTED_LOG_ENGINE"; + exports2[1580] = "ER_BAD_LOG_STATEMENT"; + exports2[1581] = "ER_CANT_RENAME_LOG_TABLE"; + exports2[1582] = "ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT"; + exports2[1583] = "ER_WRONG_PARAMETERS_TO_NATIVE_FCT"; + exports2[1584] = "ER_WRONG_PARAMETERS_TO_STORED_FCT"; + exports2[1585] = "ER_NATIVE_FCT_NAME_COLLISION"; + exports2[1586] = "ER_DUP_ENTRY_WITH_KEY_NAME"; + exports2[1587] = "ER_BINLOG_PURGE_EMFILE"; + exports2[1588] = "ER_EVENT_CANNOT_CREATE_IN_THE_PAST"; + exports2[1589] = "ER_EVENT_CANNOT_ALTER_IN_THE_PAST"; + exports2[1590] = "ER_SLAVE_INCIDENT"; + exports2[1591] = "ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT"; + exports2[1592] = "ER_BINLOG_UNSAFE_STATEMENT"; + exports2[1593] = "ER_BINLOG_FATAL_ERROR"; + exports2[1594] = "ER_SLAVE_RELAY_LOG_READ_FAILURE"; + exports2[1595] = "ER_SLAVE_RELAY_LOG_WRITE_FAILURE"; + exports2[1596] = "ER_SLAVE_CREATE_EVENT_FAILURE"; + exports2[1597] = "ER_SLAVE_MASTER_COM_FAILURE"; + exports2[1598] = "ER_BINLOG_LOGGING_IMPOSSIBLE"; + exports2[1599] = "ER_VIEW_NO_CREATION_CTX"; + exports2[1600] = "ER_VIEW_INVALID_CREATION_CTX"; + exports2[1601] = "ER_SR_INVALID_CREATION_CTX"; + exports2[1602] = "ER_TRG_CORRUPTED_FILE"; + exports2[1603] = "ER_TRG_NO_CREATION_CTX"; + exports2[1604] = "ER_TRG_INVALID_CREATION_CTX"; + exports2[1605] = "ER_EVENT_INVALID_CREATION_CTX"; + exports2[1606] = "ER_TRG_CANT_OPEN_TABLE"; + exports2[1607] = "ER_CANT_CREATE_SROUTINE"; + exports2[1608] = "ER_NEVER_USED"; + exports2[1609] = "ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT"; + exports2[1610] = "ER_REPLICA_CORRUPT_EVENT"; + exports2[1611] = "ER_LOAD_DATA_INVALID_COLUMN"; + exports2[1612] = "ER_LOG_PURGE_NO_FILE"; + exports2[1613] = "ER_XA_RBTIMEOUT"; + exports2[1614] = "ER_XA_RBDEADLOCK"; + exports2[1615] = "ER_NEED_REPREPARE"; + exports2[1616] = "ER_DELAYED_NOT_SUPPORTED"; + exports2[1617] = "WARN_NO_CONNECTION_METADATA"; + exports2[1618] = "WARN_OPTION_IGNORED"; + exports2[1619] = "ER_PLUGIN_DELETE_BUILTIN"; + exports2[1620] = "WARN_PLUGIN_BUSY"; + exports2[1621] = "ER_VARIABLE_IS_READONLY"; + exports2[1622] = "ER_WARN_ENGINE_TRANSACTION_ROLLBACK"; + exports2[1623] = "ER_SLAVE_HEARTBEAT_FAILURE"; + exports2[1624] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE"; + exports2[1625] = "ER_NDB_REPLICATION_SCHEMA_ERROR"; + exports2[1626] = "ER_CONFLICT_FN_PARSE_ERROR"; + exports2[1627] = "ER_EXCEPTIONS_WRITE_ERROR"; + exports2[1628] = "ER_TOO_LONG_TABLE_COMMENT"; + exports2[1629] = "ER_TOO_LONG_FIELD_COMMENT"; + exports2[1630] = "ER_FUNC_INEXISTENT_NAME_COLLISION"; + exports2[1631] = "ER_DATABASE_NAME"; + exports2[1632] = "ER_TABLE_NAME"; + exports2[1633] = "ER_PARTITION_NAME"; + exports2[1634] = "ER_SUBPARTITION_NAME"; + exports2[1635] = "ER_TEMPORARY_NAME"; + exports2[1636] = "ER_RENAMED_NAME"; + exports2[1637] = "ER_TOO_MANY_CONCURRENT_TRXS"; + exports2[1638] = "WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED"; + exports2[1639] = "ER_DEBUG_SYNC_TIMEOUT"; + exports2[1640] = "ER_DEBUG_SYNC_HIT_LIMIT"; + exports2[1641] = "ER_DUP_SIGNAL_SET"; + exports2[1642] = "ER_SIGNAL_WARN"; + exports2[1643] = "ER_SIGNAL_NOT_FOUND"; + exports2[1644] = "ER_SIGNAL_EXCEPTION"; + exports2[1645] = "ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER"; + exports2[1646] = "ER_SIGNAL_BAD_CONDITION_TYPE"; + exports2[1647] = "WARN_COND_ITEM_TRUNCATED"; + exports2[1648] = "ER_COND_ITEM_TOO_LONG"; + exports2[1649] = "ER_UNKNOWN_LOCALE"; + exports2[1650] = "ER_REPLICA_IGNORE_SERVER_IDS"; + exports2[1651] = "ER_QUERY_CACHE_DISABLED"; + exports2[1652] = "ER_SAME_NAME_PARTITION_FIELD"; + exports2[1653] = "ER_PARTITION_COLUMN_LIST_ERROR"; + exports2[1654] = "ER_WRONG_TYPE_COLUMN_VALUE_ERROR"; + exports2[1655] = "ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR"; + exports2[1656] = "ER_MAXVALUE_IN_VALUES_IN"; + exports2[1657] = "ER_TOO_MANY_VALUES_ERROR"; + exports2[1658] = "ER_ROW_SINGLE_PARTITION_FIELD_ERROR"; + exports2[1659] = "ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD"; + exports2[1660] = "ER_PARTITION_FIELDS_TOO_LONG"; + exports2[1661] = "ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE"; + exports2[1662] = "ER_BINLOG_ROW_MODE_AND_STMT_ENGINE"; + exports2[1663] = "ER_BINLOG_UNSAFE_AND_STMT_ENGINE"; + exports2[1664] = "ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE"; + exports2[1665] = "ER_BINLOG_STMT_MODE_AND_ROW_ENGINE"; + exports2[1666] = "ER_BINLOG_ROW_INJECTION_AND_STMT_MODE"; + exports2[1667] = "ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE"; + exports2[1668] = "ER_BINLOG_UNSAFE_LIMIT"; + exports2[1669] = "ER_UNUSED4"; + exports2[1670] = "ER_BINLOG_UNSAFE_SYSTEM_TABLE"; + exports2[1671] = "ER_BINLOG_UNSAFE_AUTOINC_COLUMNS"; + exports2[1672] = "ER_BINLOG_UNSAFE_UDF"; + exports2[1673] = "ER_BINLOG_UNSAFE_SYSTEM_VARIABLE"; + exports2[1674] = "ER_BINLOG_UNSAFE_SYSTEM_FUNCTION"; + exports2[1675] = "ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS"; + exports2[1676] = "ER_MESSAGE_AND_STATEMENT"; + exports2[1677] = "ER_SLAVE_CONVERSION_FAILED"; + exports2[1678] = "ER_REPLICA_CANT_CREATE_CONVERSION"; + exports2[1679] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT"; + exports2[1680] = "ER_PATH_LENGTH"; + exports2[1681] = "ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT"; + exports2[1682] = "ER_WRONG_NATIVE_TABLE_STRUCTURE"; + exports2[1683] = "ER_WRONG_PERFSCHEMA_USAGE"; + exports2[1684] = "ER_WARN_I_S_SKIPPED_TABLE"; + exports2[1685] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT"; + exports2[1686] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT"; + exports2[1687] = "ER_SPATIAL_MUST_HAVE_GEOM_COL"; + exports2[1688] = "ER_TOO_LONG_INDEX_COMMENT"; + exports2[1689] = "ER_LOCK_ABORTED"; + exports2[1690] = "ER_DATA_OUT_OF_RANGE"; + exports2[1691] = "ER_WRONG_SPVAR_TYPE_IN_LIMIT"; + exports2[1692] = "ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE"; + exports2[1693] = "ER_BINLOG_UNSAFE_MIXED_STATEMENT"; + exports2[1694] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN"; + exports2[1695] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN"; + exports2[1696] = "ER_FAILED_READ_FROM_PAR_FILE"; + exports2[1697] = "ER_VALUES_IS_NOT_INT_TYPE_ERROR"; + exports2[1698] = "ER_ACCESS_DENIED_NO_PASSWORD_ERROR"; + exports2[1699] = "ER_SET_PASSWORD_AUTH_PLUGIN"; + exports2[1700] = "ER_GRANT_PLUGIN_USER_EXISTS"; + exports2[1701] = "ER_TRUNCATE_ILLEGAL_FK"; + exports2[1702] = "ER_PLUGIN_IS_PERMANENT"; + exports2[1703] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN"; + exports2[1704] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX"; + exports2[1705] = "ER_STMT_CACHE_FULL"; + exports2[1706] = "ER_MULTI_UPDATE_KEY_CONFLICT"; + exports2[1707] = "ER_TABLE_NEEDS_REBUILD"; + exports2[1708] = "WARN_OPTION_BELOW_LIMIT"; + exports2[1709] = "ER_INDEX_COLUMN_TOO_LONG"; + exports2[1710] = "ER_ERROR_IN_TRIGGER_BODY"; + exports2[1711] = "ER_ERROR_IN_UNKNOWN_TRIGGER_BODY"; + exports2[1712] = "ER_INDEX_CORRUPT"; + exports2[1713] = "ER_UNDO_RECORD_TOO_BIG"; + exports2[1714] = "ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT"; + exports2[1715] = "ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE"; + exports2[1716] = "ER_BINLOG_UNSAFE_REPLACE_SELECT"; + exports2[1717] = "ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT"; + exports2[1718] = "ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT"; + exports2[1719] = "ER_BINLOG_UNSAFE_UPDATE_IGNORE"; + exports2[1720] = "ER_PLUGIN_NO_UNINSTALL"; + exports2[1721] = "ER_PLUGIN_NO_INSTALL"; + exports2[1722] = "ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT"; + exports2[1723] = "ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC"; + exports2[1724] = "ER_BINLOG_UNSAFE_INSERT_TWO_KEYS"; + exports2[1725] = "ER_TABLE_IN_FK_CHECK"; + exports2[1726] = "ER_UNSUPPORTED_ENGINE"; + exports2[1727] = "ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST"; + exports2[1728] = "ER_CANNOT_LOAD_FROM_TABLE_V2"; + exports2[1729] = "ER_SOURCE_DELAY_VALUE_OUT_OF_RANGE"; + exports2[1730] = "ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT"; + exports2[1731] = "ER_PARTITION_EXCHANGE_DIFFERENT_OPTION"; + exports2[1732] = "ER_PARTITION_EXCHANGE_PART_TABLE"; + exports2[1733] = "ER_PARTITION_EXCHANGE_TEMP_TABLE"; + exports2[1734] = "ER_PARTITION_INSTEAD_OF_SUBPARTITION"; + exports2[1735] = "ER_UNKNOWN_PARTITION"; + exports2[1736] = "ER_TABLES_DIFFERENT_METADATA"; + exports2[1737] = "ER_ROW_DOES_NOT_MATCH_PARTITION"; + exports2[1738] = "ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX"; + exports2[1739] = "ER_WARN_INDEX_NOT_APPLICABLE"; + exports2[1740] = "ER_PARTITION_EXCHANGE_FOREIGN_KEY"; + exports2[1741] = "ER_NO_SUCH_KEY_VALUE"; + exports2[1742] = "ER_RPL_INFO_DATA_TOO_LONG"; + exports2[1743] = "ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE"; + exports2[1744] = "ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE"; + exports2[1745] = "ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX"; + exports2[1746] = "ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT"; + exports2[1747] = "ER_PARTITION_CLAUSE_ON_NONPARTITIONED"; + exports2[1748] = "ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET"; + exports2[1749] = "ER_NO_SUCH_PARTITION"; + exports2[1750] = "ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE"; + exports2[1751] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE"; + exports2[1752] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE"; + exports2[1753] = "ER_MTA_FEATURE_IS_NOT_SUPPORTED"; + exports2[1754] = "ER_MTA_UPDATED_DBS_GREATER_MAX"; + exports2[1755] = "ER_MTA_CANT_PARALLEL"; + exports2[1756] = "ER_MTA_INCONSISTENT_DATA"; + exports2[1757] = "ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING"; + exports2[1758] = "ER_DA_INVALID_CONDITION_NUMBER"; + exports2[1759] = "ER_INSECURE_PLAIN_TEXT"; + exports2[1760] = "ER_INSECURE_CHANGE_SOURCE"; + exports2[1761] = "ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO"; + exports2[1762] = "ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO"; + exports2[1763] = "ER_SQLTHREAD_WITH_SECURE_REPLICA"; + exports2[1764] = "ER_TABLE_HAS_NO_FT"; + exports2[1765] = "ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER"; + exports2[1766] = "ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION"; + exports2[1767] = "ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST"; + exports2[1768] = "ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION"; + exports2[1769] = "ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION"; + exports2[1770] = "ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL"; + exports2[1771] = "ER_SKIPPING_LOGGED_TRANSACTION"; + exports2[1772] = "ER_MALFORMED_GTID_SET_SPECIFICATION"; + exports2[1773] = "ER_MALFORMED_GTID_SET_ENCODING"; + exports2[1774] = "ER_MALFORMED_GTID_SPECIFICATION"; + exports2[1775] = "ER_GNO_EXHAUSTED"; + exports2[1776] = "ER_BAD_REPLICA_AUTO_POSITION"; + exports2[1777] = "ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF"; + exports2[1778] = "ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET"; + exports2[1779] = "ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON"; + exports2[1780] = "ER_GTID_MODE_REQUIRES_BINLOG"; + exports2[1781] = "ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF"; + exports2[1782] = "ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON"; + exports2[1783] = "ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF"; + exports2[1784] = "ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF"; + exports2[1785] = "ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE"; + exports2[1786] = "ER_GTID_UNSAFE_CREATE_SELECT"; + exports2[1787] = "ER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRANSACTION"; + exports2[1788] = "ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME"; + exports2[1789] = "ER_SOURCE_HAS_PURGED_REQUIRED_GTIDS"; + exports2[1790] = "ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID"; + exports2[1791] = "ER_UNKNOWN_EXPLAIN_FORMAT"; + exports2[1792] = "ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION"; + exports2[1793] = "ER_TOO_LONG_TABLE_PARTITION_COMMENT"; + exports2[1794] = "ER_REPLICA_CONFIGURATION"; + exports2[1795] = "ER_INNODB_FT_LIMIT"; + exports2[1796] = "ER_INNODB_NO_FT_TEMP_TABLE"; + exports2[1797] = "ER_INNODB_FT_WRONG_DOCID_COLUMN"; + exports2[1798] = "ER_INNODB_FT_WRONG_DOCID_INDEX"; + exports2[1799] = "ER_INNODB_ONLINE_LOG_TOO_BIG"; + exports2[1800] = "ER_UNKNOWN_ALTER_ALGORITHM"; + exports2[1801] = "ER_UNKNOWN_ALTER_LOCK"; + exports2[1802] = "ER_MTA_CHANGE_SOURCE_CANT_RUN_WITH_GAPS"; + exports2[1803] = "ER_MTA_RECOVERY_FAILURE"; + exports2[1804] = "ER_MTA_RESET_WORKERS"; + exports2[1805] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2"; + exports2[1806] = "ER_REPLICA_SILENT_RETRY_TRANSACTION"; + exports2[1807] = "ER_DISCARD_FK_CHECKS_RUNNING"; + exports2[1808] = "ER_TABLE_SCHEMA_MISMATCH"; + exports2[1809] = "ER_TABLE_IN_SYSTEM_TABLESPACE"; + exports2[1810] = "ER_IO_READ_ERROR"; + exports2[1811] = "ER_IO_WRITE_ERROR"; + exports2[1812] = "ER_TABLESPACE_MISSING"; + exports2[1813] = "ER_TABLESPACE_EXISTS"; + exports2[1814] = "ER_TABLESPACE_DISCARDED"; + exports2[1815] = "ER_INTERNAL_ERROR"; + exports2[1816] = "ER_INNODB_IMPORT_ERROR"; + exports2[1817] = "ER_INNODB_INDEX_CORRUPT"; + exports2[1818] = "ER_INVALID_YEAR_COLUMN_LENGTH"; + exports2[1819] = "ER_NOT_VALID_PASSWORD"; + exports2[1820] = "ER_MUST_CHANGE_PASSWORD"; + exports2[1821] = "ER_FK_NO_INDEX_CHILD"; + exports2[1822] = "ER_FK_NO_INDEX_PARENT"; + exports2[1823] = "ER_FK_FAIL_ADD_SYSTEM"; + exports2[1824] = "ER_FK_CANNOT_OPEN_PARENT"; + exports2[1825] = "ER_FK_INCORRECT_OPTION"; + exports2[1826] = "ER_FK_DUP_NAME"; + exports2[1827] = "ER_PASSWORD_FORMAT"; + exports2[1828] = "ER_FK_COLUMN_CANNOT_DROP"; + exports2[1829] = "ER_FK_COLUMN_CANNOT_DROP_CHILD"; + exports2[1830] = "ER_FK_COLUMN_NOT_NULL"; + exports2[1831] = "ER_DUP_INDEX"; + exports2[1832] = "ER_FK_COLUMN_CANNOT_CHANGE"; + exports2[1833] = "ER_FK_COLUMN_CANNOT_CHANGE_CHILD"; + exports2[1834] = "ER_UNUSED5"; + exports2[1835] = "ER_MALFORMED_PACKET"; + exports2[1836] = "ER_READ_ONLY_MODE"; + exports2[1837] = "ER_GTID_NEXT_TYPE_UNDEFINED_GTID"; + exports2[1838] = "ER_VARIABLE_NOT_SETTABLE_IN_SP"; + exports2[1839] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF"; + exports2[1840] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY"; + exports2[1841] = "ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY"; + exports2[1842] = "ER_GTID_PURGED_WAS_CHANGED"; + exports2[1843] = "ER_GTID_EXECUTED_WAS_CHANGED"; + exports2[1844] = "ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES"; + exports2[1845] = "ER_ALTER_OPERATION_NOT_SUPPORTED"; + exports2[1846] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON"; + exports2[1847] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY"; + exports2[1848] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION"; + exports2[1849] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME"; + exports2[1850] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE"; + exports2[1851] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK"; + exports2[1852] = "ER_UNUSED6"; + exports2[1853] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK"; + exports2[1854] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC"; + exports2[1855] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS"; + exports2[1856] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS"; + exports2[1857] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS"; + exports2[1858] = "ER_SQL_REPLICA_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE"; + exports2[1859] = "ER_DUP_UNKNOWN_IN_INDEX"; + exports2[1860] = "ER_IDENT_CAUSES_TOO_LONG_PATH"; + exports2[1861] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL"; + exports2[1862] = "ER_MUST_CHANGE_PASSWORD_LOGIN"; + exports2[1863] = "ER_ROW_IN_WRONG_PARTITION"; + exports2[1864] = "ER_MTA_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX"; + exports2[1865] = "ER_INNODB_NO_FT_USES_PARSER"; + exports2[1866] = "ER_BINLOG_LOGICAL_CORRUPTION"; + exports2[1867] = "ER_WARN_PURGE_LOG_IN_USE"; + exports2[1868] = "ER_WARN_PURGE_LOG_IS_ACTIVE"; + exports2[1869] = "ER_AUTO_INCREMENT_CONFLICT"; + exports2[1870] = "WARN_ON_BLOCKHOLE_IN_RBR"; + exports2[1871] = "ER_REPLICA_CM_INIT_REPOSITORY"; + exports2[1872] = "ER_REPLICA_AM_INIT_REPOSITORY"; + exports2[1873] = "ER_ACCESS_DENIED_CHANGE_USER_ERROR"; + exports2[1874] = "ER_INNODB_READ_ONLY"; + exports2[1875] = "ER_STOP_REPLICA_SQL_THREAD_TIMEOUT"; + exports2[1876] = "ER_STOP_REPLICA_IO_THREAD_TIMEOUT"; + exports2[1877] = "ER_TABLE_CORRUPT"; + exports2[1878] = "ER_TEMP_FILE_WRITE_FAILURE"; + exports2[1879] = "ER_INNODB_FT_AUX_NOT_HEX_ID"; + exports2[1880] = "ER_OLD_TEMPORALS_UPGRADED"; + exports2[1881] = "ER_INNODB_FORCED_RECOVERY"; + exports2[1882] = "ER_AES_INVALID_IV"; + exports2[1883] = "ER_PLUGIN_CANNOT_BE_UNINSTALLED"; + exports2[1884] = "ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_ASSIGNED_GTID"; + exports2[1885] = "ER_REPLICA_HAS_MORE_GTIDS_THAN_SOURCE"; + exports2[1886] = "ER_MISSING_KEY"; + exports2[1887] = "WARN_NAMED_PIPE_ACCESS_EVERYONE"; + exports2[3e3] = "ER_FILE_CORRUPT"; + exports2[3001] = "ER_ERROR_ON_SOURCE"; + exports2[3002] = "ER_INCONSISTENT_ERROR"; + exports2[3003] = "ER_STORAGE_ENGINE_NOT_LOADED"; + exports2[3004] = "ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER"; + exports2[3005] = "ER_WARN_LEGACY_SYNTAX_CONVERTED"; + exports2[3006] = "ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN"; + exports2[3007] = "ER_CANNOT_DISCARD_TEMPORARY_TABLE"; + exports2[3008] = "ER_FK_DEPTH_EXCEEDED"; + exports2[3009] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2"; + exports2[3010] = "ER_WARN_TRIGGER_DOESNT_HAVE_CREATED"; + exports2[3011] = "ER_REFERENCED_TRG_DOES_NOT_EXIST"; + exports2[3012] = "ER_EXPLAIN_NOT_SUPPORTED"; + exports2[3013] = "ER_INVALID_FIELD_SIZE"; + exports2[3014] = "ER_MISSING_HA_CREATE_OPTION"; + exports2[3015] = "ER_ENGINE_OUT_OF_MEMORY"; + exports2[3016] = "ER_PASSWORD_EXPIRE_ANONYMOUS_USER"; + exports2[3017] = "ER_REPLICA_SQL_THREAD_MUST_STOP"; + exports2[3018] = "ER_NO_FT_MATERIALIZED_SUBQUERY"; + exports2[3019] = "ER_INNODB_UNDO_LOG_FULL"; + exports2[3020] = "ER_INVALID_ARGUMENT_FOR_LOGARITHM"; + exports2[3021] = "ER_REPLICA_CHANNEL_IO_THREAD_MUST_STOP"; + exports2[3022] = "ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO"; + exports2[3023] = "ER_WARN_ONLY_SOURCE_LOG_FILE_NO_POS"; + exports2[3024] = "ER_QUERY_TIMEOUT"; + exports2[3025] = "ER_NON_RO_SELECT_DISABLE_TIMER"; + exports2[3026] = "ER_DUP_LIST_ENTRY"; + exports2[3027] = "ER_SQL_MODE_NO_EFFECT"; + exports2[3028] = "ER_AGGREGATE_ORDER_FOR_UNION"; + exports2[3029] = "ER_AGGREGATE_ORDER_NON_AGG_QUERY"; + exports2[3030] = "ER_REPLICA_WORKER_STOPPED_PREVIOUS_THD_ERROR"; + exports2[3031] = "ER_DONT_SUPPORT_REPLICA_PRESERVE_COMMIT_ORDER"; + exports2[3032] = "ER_SERVER_OFFLINE_MODE"; + exports2[3033] = "ER_GIS_DIFFERENT_SRIDS"; + exports2[3034] = "ER_GIS_UNSUPPORTED_ARGUMENT"; + exports2[3035] = "ER_GIS_UNKNOWN_ERROR"; + exports2[3036] = "ER_GIS_UNKNOWN_EXCEPTION"; + exports2[3037] = "ER_GIS_INVALID_DATA"; + exports2[3038] = "ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION"; + exports2[3039] = "ER_BOOST_GEOMETRY_CENTROID_EXCEPTION"; + exports2[3040] = "ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION"; + exports2[3041] = "ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION"; + exports2[3042] = "ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION"; + exports2[3043] = "ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION"; + exports2[3044] = "ER_STD_BAD_ALLOC_ERROR"; + exports2[3045] = "ER_STD_DOMAIN_ERROR"; + exports2[3046] = "ER_STD_LENGTH_ERROR"; + exports2[3047] = "ER_STD_INVALID_ARGUMENT"; + exports2[3048] = "ER_STD_OUT_OF_RANGE_ERROR"; + exports2[3049] = "ER_STD_OVERFLOW_ERROR"; + exports2[3050] = "ER_STD_RANGE_ERROR"; + exports2[3051] = "ER_STD_UNDERFLOW_ERROR"; + exports2[3052] = "ER_STD_LOGIC_ERROR"; + exports2[3053] = "ER_STD_RUNTIME_ERROR"; + exports2[3054] = "ER_STD_UNKNOWN_EXCEPTION"; + exports2[3055] = "ER_GIS_DATA_WRONG_ENDIANESS"; + exports2[3056] = "ER_CHANGE_SOURCE_PASSWORD_LENGTH"; + exports2[3057] = "ER_USER_LOCK_WRONG_NAME"; + exports2[3058] = "ER_USER_LOCK_DEADLOCK"; + exports2[3059] = "ER_REPLACE_INACCESSIBLE_ROWS"; + exports2[3060] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS"; + exports2[3061] = "ER_ILLEGAL_USER_VAR"; + exports2[3062] = "ER_GTID_MODE_OFF"; + exports2[3063] = "ER_UNSUPPORTED_BY_REPLICATION_THREAD"; + exports2[3064] = "ER_INCORRECT_TYPE"; + exports2[3065] = "ER_FIELD_IN_ORDER_NOT_SELECT"; + exports2[3066] = "ER_AGGREGATE_IN_ORDER_NOT_SELECT"; + exports2[3067] = "ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN"; + exports2[3068] = "ER_NET_OK_PACKET_TOO_LARGE"; + exports2[3069] = "ER_INVALID_JSON_DATA"; + exports2[3070] = "ER_INVALID_GEOJSON_MISSING_MEMBER"; + exports2[3071] = "ER_INVALID_GEOJSON_WRONG_TYPE"; + exports2[3072] = "ER_INVALID_GEOJSON_UNSPECIFIED"; + exports2[3073] = "ER_DIMENSION_UNSUPPORTED"; + exports2[3074] = "ER_REPLICA_CHANNEL_DOES_NOT_EXIST"; + exports2[3075] = "ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT"; + exports2[3076] = "ER_REPLICA_CHANNEL_NAME_INVALID_OR_TOO_LONG"; + exports2[3077] = "ER_REPLICA_NEW_CHANNEL_WRONG_REPOSITORY"; + exports2[3078] = "ER_SLAVE_CHANNEL_DELETE"; + exports2[3079] = "ER_REPLICA_MULTIPLE_CHANNELS_CMD"; + exports2[3080] = "ER_REPLICA_MAX_CHANNELS_EXCEEDED"; + exports2[3081] = "ER_REPLICA_CHANNEL_MUST_STOP"; + exports2[3082] = "ER_REPLICA_CHANNEL_NOT_RUNNING"; + exports2[3083] = "ER_REPLICA_CHANNEL_WAS_RUNNING"; + exports2[3084] = "ER_REPLICA_CHANNEL_WAS_NOT_RUNNING"; + exports2[3085] = "ER_REPLICA_CHANNEL_SQL_THREAD_MUST_STOP"; + exports2[3086] = "ER_REPLICA_CHANNEL_SQL_SKIP_COUNTER"; + exports2[3087] = "ER_WRONG_FIELD_WITH_GROUP_V2"; + exports2[3088] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2"; + exports2[3089] = "ER_WARN_DEPRECATED_SYSVAR_UPDATE"; + exports2[3090] = "ER_WARN_DEPRECATED_SQLMODE"; + exports2[3091] = "ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID"; + exports2[3092] = "ER_GROUP_REPLICATION_CONFIGURATION"; + exports2[3093] = "ER_GROUP_REPLICATION_RUNNING"; + exports2[3094] = "ER_GROUP_REPLICATION_APPLIER_INIT_ERROR"; + exports2[3095] = "ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT"; + exports2[3096] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR"; + exports2[3097] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR"; + exports2[3098] = "ER_BEFORE_DML_VALIDATION_ERROR"; + exports2[3099] = "ER_PREVENTS_VARIABLE_WITHOUT_RBR"; + exports2[3100] = "ER_RUN_HOOK_ERROR"; + exports2[3101] = "ER_TRANSACTION_ROLLBACK_DURING_COMMIT"; + exports2[3102] = "ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED"; + exports2[3103] = "ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN"; + exports2[3104] = "ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN"; + exports2[3105] = "ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN"; + exports2[3106] = "ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN"; + exports2[3107] = "ER_GENERATED_COLUMN_NON_PRIOR"; + exports2[3108] = "ER_DEPENDENT_BY_GENERATED_COLUMN"; + exports2[3109] = "ER_GENERATED_COLUMN_REF_AUTO_INC"; + exports2[3110] = "ER_FEATURE_NOT_AVAILABLE"; + exports2[3111] = "ER_CANT_SET_GTID_MODE"; + exports2[3112] = "ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF"; + exports2[3113] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION"; + exports2[3114] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON"; + exports2[3115] = "ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF"; + exports2[3116] = "ER_CANT_ENFORCE_GTID_CONSISTENCY_WITH_ONGOING_GTID_VIOLATING_TX"; + exports2[3117] = "ER_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TX"; + exports2[3118] = "ER_ACCOUNT_HAS_BEEN_LOCKED"; + exports2[3119] = "ER_WRONG_TABLESPACE_NAME"; + exports2[3120] = "ER_TABLESPACE_IS_NOT_EMPTY"; + exports2[3121] = "ER_WRONG_FILE_NAME"; + exports2[3122] = "ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION"; + exports2[3123] = "ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR"; + exports2[3124] = "ER_WARN_BAD_MAX_EXECUTION_TIME"; + exports2[3125] = "ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME"; + exports2[3126] = "ER_WARN_CONFLICTING_HINT"; + exports2[3127] = "ER_WARN_UNKNOWN_QB_NAME"; + exports2[3128] = "ER_UNRESOLVED_HINT_NAME"; + exports2[3129] = "ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE"; + exports2[3130] = "ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED"; + exports2[3131] = "ER_LOCKING_SERVICE_WRONG_NAME"; + exports2[3132] = "ER_LOCKING_SERVICE_DEADLOCK"; + exports2[3133] = "ER_LOCKING_SERVICE_TIMEOUT"; + exports2[3134] = "ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED"; + exports2[3135] = "ER_SQL_MODE_MERGED"; + exports2[3136] = "ER_VTOKEN_PLUGIN_TOKEN_MISMATCH"; + exports2[3137] = "ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND"; + exports2[3138] = "ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID"; + exports2[3139] = "ER_REPLICA_CHANNEL_OPERATION_NOT_ALLOWED"; + exports2[3140] = "ER_INVALID_JSON_TEXT"; + exports2[3141] = "ER_INVALID_JSON_TEXT_IN_PARAM"; + exports2[3142] = "ER_INVALID_JSON_BINARY_DATA"; + exports2[3143] = "ER_INVALID_JSON_PATH"; + exports2[3144] = "ER_INVALID_JSON_CHARSET"; + exports2[3145] = "ER_INVALID_JSON_CHARSET_IN_FUNCTION"; + exports2[3146] = "ER_INVALID_TYPE_FOR_JSON"; + exports2[3147] = "ER_INVALID_CAST_TO_JSON"; + exports2[3148] = "ER_INVALID_JSON_PATH_CHARSET"; + exports2[3149] = "ER_INVALID_JSON_PATH_WILDCARD"; + exports2[3150] = "ER_JSON_VALUE_TOO_BIG"; + exports2[3151] = "ER_JSON_KEY_TOO_BIG"; + exports2[3152] = "ER_JSON_USED_AS_KEY"; + exports2[3153] = "ER_JSON_VACUOUS_PATH"; + exports2[3154] = "ER_JSON_BAD_ONE_OR_ALL_ARG"; + exports2[3155] = "ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE"; + exports2[3156] = "ER_INVALID_JSON_VALUE_FOR_CAST"; + exports2[3157] = "ER_JSON_DOCUMENT_TOO_DEEP"; + exports2[3158] = "ER_JSON_DOCUMENT_NULL_KEY"; + exports2[3159] = "ER_SECURE_TRANSPORT_REQUIRED"; + exports2[3160] = "ER_NO_SECURE_TRANSPORTS_CONFIGURED"; + exports2[3161] = "ER_DISABLED_STORAGE_ENGINE"; + exports2[3162] = "ER_USER_DOES_NOT_EXIST"; + exports2[3163] = "ER_USER_ALREADY_EXISTS"; + exports2[3164] = "ER_AUDIT_API_ABORT"; + exports2[3165] = "ER_INVALID_JSON_PATH_ARRAY_CELL"; + exports2[3166] = "ER_BUFPOOL_RESIZE_INPROGRESS"; + exports2[3167] = "ER_FEATURE_DISABLED_SEE_DOC"; + exports2[3168] = "ER_SERVER_ISNT_AVAILABLE"; + exports2[3169] = "ER_SESSION_WAS_KILLED"; + exports2[3170] = "ER_CAPACITY_EXCEEDED"; + exports2[3171] = "ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER"; + exports2[3172] = "ER_TABLE_NEEDS_UPG_PART"; + exports2[3173] = "ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID"; + exports2[3174] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL"; + exports2[3175] = "ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT"; + exports2[3176] = "ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE"; + exports2[3177] = "ER_LOCK_REFUSED_BY_ENGINE"; + exports2[3178] = "ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN"; + exports2[3179] = "ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE"; + exports2[3180] = "ER_MASTER_KEY_ROTATION_ERROR_BY_SE"; + exports2[3181] = "ER_MASTER_KEY_ROTATION_BINLOG_FAILED"; + exports2[3182] = "ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE"; + exports2[3183] = "ER_TABLESPACE_CANNOT_ENCRYPT"; + exports2[3184] = "ER_INVALID_ENCRYPTION_OPTION"; + exports2[3185] = "ER_CANNOT_FIND_KEY_IN_KEYRING"; + exports2[3186] = "ER_CAPACITY_EXCEEDED_IN_PARSER"; + exports2[3187] = "ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE"; + exports2[3188] = "ER_KEYRING_UDF_KEYRING_SERVICE_ERROR"; + exports2[3189] = "ER_USER_COLUMN_OLD_LENGTH"; + exports2[3190] = "ER_CANT_RESET_SOURCE"; + exports2[3191] = "ER_GROUP_REPLICATION_MAX_GROUP_SIZE"; + exports2[3192] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED"; + exports2[3193] = "ER_TABLE_REFERENCED"; + exports2[3194] = "ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE"; + exports2[3195] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO"; + exports2[3196] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID"; + exports2[3197] = "ER_XA_RETRY"; + exports2[3198] = "ER_KEYRING_AWS_UDF_AWS_KMS_ERROR"; + exports2[3199] = "ER_BINLOG_UNSAFE_XA"; + exports2[3200] = "ER_UDF_ERROR"; + exports2[3201] = "ER_KEYRING_MIGRATION_FAILURE"; + exports2[3202] = "ER_KEYRING_ACCESS_DENIED_ERROR"; + exports2[3203] = "ER_KEYRING_MIGRATION_STATUS"; + exports2[3204] = "ER_PLUGIN_FAILED_TO_OPEN_TABLES"; + exports2[3205] = "ER_PLUGIN_FAILED_TO_OPEN_TABLE"; + exports2[3206] = "ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED"; + exports2[3207] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET"; + exports2[3208] = "ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY"; + exports2[3209] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED"; + exports2[3210] = "ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED"; + exports2[3211] = "ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE"; + exports2[3212] = "ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED"; + exports2[3213] = "ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS"; + exports2[3214] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE"; + exports2[3215] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT"; + exports2[3216] = "ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED"; + exports2[3217] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE"; + exports2[3218] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE"; + exports2[3219] = "ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR"; + exports2[3220] = "ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY"; + exports2[3221] = "ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY"; + exports2[3222] = "ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS"; + exports2[3223] = "ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC"; + exports2[3224] = "ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER"; + exports2[3225] = "ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER"; + exports2[3226] = "WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP"; + exports2[3227] = "ER_XA_REPLICATION_FILTERS"; + exports2[3228] = "ER_CANT_OPEN_ERROR_LOG"; + exports2[3229] = "ER_GROUPING_ON_TIMESTAMP_IN_DST"; + exports2[3230] = "ER_CANT_START_SERVER_NAMED_PIPE"; + exports2[3231] = "ER_WRITE_SET_EXCEEDS_LIMIT"; + exports2[3232] = "ER_DEPRECATED_TLS_VERSION_SESSION_57"; + exports2[3233] = "ER_WARN_DEPRECATED_TLS_VERSION_57"; + exports2[3234] = "ER_WARN_WRONG_NATIVE_TABLE_STRUCTURE"; + exports2[3235] = "ER_AES_INVALID_KDF_NAME"; + exports2[3236] = "ER_AES_INVALID_KDF_ITERATIONS"; + exports2[3237] = "WARN_AES_KEY_SIZE"; + exports2[3238] = "ER_AES_INVALID_KDF_OPTION_SIZE"; + exports2[3500] = "ER_UNSUPPORT_COMPRESSED_TEMPORARY_TABLE"; + exports2[3501] = "ER_ACL_OPERATION_FAILED"; + exports2[3502] = "ER_UNSUPPORTED_INDEX_ALGORITHM"; + exports2[3503] = "ER_NO_SUCH_DB"; + exports2[3504] = "ER_TOO_BIG_ENUM"; + exports2[3505] = "ER_TOO_LONG_SET_ENUM_VALUE"; + exports2[3506] = "ER_INVALID_DD_OBJECT"; + exports2[3507] = "ER_UPDATING_DD_TABLE"; + exports2[3508] = "ER_INVALID_DD_OBJECT_ID"; + exports2[3509] = "ER_INVALID_DD_OBJECT_NAME"; + exports2[3510] = "ER_TABLESPACE_MISSING_WITH_NAME"; + exports2[3511] = "ER_TOO_LONG_ROUTINE_COMMENT"; + exports2[3512] = "ER_SP_LOAD_FAILED"; + exports2[3513] = "ER_INVALID_BITWISE_OPERANDS_SIZE"; + exports2[3514] = "ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE"; + exports2[3515] = "ER_WARN_UNSUPPORTED_HINT"; + exports2[3516] = "ER_UNEXPECTED_GEOMETRY_TYPE"; + exports2[3517] = "ER_SRS_PARSE_ERROR"; + exports2[3518] = "ER_SRS_PROJ_PARAMETER_MISSING"; + exports2[3519] = "ER_WARN_SRS_NOT_FOUND"; + exports2[3520] = "ER_SRS_NOT_CARTESIAN"; + exports2[3521] = "ER_SRS_NOT_CARTESIAN_UNDEFINED"; + exports2[3522] = "ER_PK_INDEX_CANT_BE_INVISIBLE"; + exports2[3523] = "ER_UNKNOWN_AUTHID"; + exports2[3524] = "ER_FAILED_ROLE_GRANT"; + exports2[3525] = "ER_OPEN_ROLE_TABLES"; + exports2[3526] = "ER_FAILED_DEFAULT_ROLES"; + exports2[3527] = "ER_COMPONENTS_NO_SCHEME"; + exports2[3528] = "ER_COMPONENTS_NO_SCHEME_SERVICE"; + exports2[3529] = "ER_COMPONENTS_CANT_LOAD"; + exports2[3530] = "ER_ROLE_NOT_GRANTED"; + exports2[3531] = "ER_FAILED_REVOKE_ROLE"; + exports2[3532] = "ER_RENAME_ROLE"; + exports2[3533] = "ER_COMPONENTS_CANT_ACQUIRE_SERVICE_IMPLEMENTATION"; + exports2[3534] = "ER_COMPONENTS_CANT_SATISFY_DEPENDENCY"; + exports2[3535] = "ER_COMPONENTS_LOAD_CANT_REGISTER_SERVICE_IMPLEMENTATION"; + exports2[3536] = "ER_COMPONENTS_LOAD_CANT_INITIALIZE"; + exports2[3537] = "ER_COMPONENTS_UNLOAD_NOT_LOADED"; + exports2[3538] = "ER_COMPONENTS_UNLOAD_CANT_DEINITIALIZE"; + exports2[3539] = "ER_COMPONENTS_CANT_RELEASE_SERVICE"; + exports2[3540] = "ER_COMPONENTS_UNLOAD_CANT_UNREGISTER_SERVICE"; + exports2[3541] = "ER_COMPONENTS_CANT_UNLOAD"; + exports2[3542] = "ER_WARN_UNLOAD_THE_NOT_PERSISTED"; + exports2[3543] = "ER_COMPONENT_TABLE_INCORRECT"; + exports2[3544] = "ER_COMPONENT_MANIPULATE_ROW_FAILED"; + exports2[3545] = "ER_COMPONENTS_UNLOAD_DUPLICATE_IN_GROUP"; + exports2[3546] = "ER_CANT_SET_GTID_PURGED_DUE_SETS_CONSTRAINTS"; + exports2[3547] = "ER_CANNOT_LOCK_USER_MANAGEMENT_CACHES"; + exports2[3548] = "ER_SRS_NOT_FOUND"; + exports2[3549] = "ER_VARIABLE_NOT_PERSISTED"; + exports2[3550] = "ER_IS_QUERY_INVALID_CLAUSE"; + exports2[3551] = "ER_UNABLE_TO_STORE_STATISTICS"; + exports2[3552] = "ER_NO_SYSTEM_SCHEMA_ACCESS"; + exports2[3553] = "ER_NO_SYSTEM_TABLESPACE_ACCESS"; + exports2[3554] = "ER_NO_SYSTEM_TABLE_ACCESS"; + exports2[3555] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_DICTIONARY_TABLE"; + exports2[3556] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_SYSTEM_TABLE"; + exports2[3557] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_TABLE"; + exports2[3558] = "ER_INVALID_OPTION_KEY"; + exports2[3559] = "ER_INVALID_OPTION_VALUE"; + exports2[3560] = "ER_INVALID_OPTION_KEY_VALUE_PAIR"; + exports2[3561] = "ER_INVALID_OPTION_START_CHARACTER"; + exports2[3562] = "ER_INVALID_OPTION_END_CHARACTER"; + exports2[3563] = "ER_INVALID_OPTION_CHARACTERS"; + exports2[3564] = "ER_DUPLICATE_OPTION_KEY"; + exports2[3565] = "ER_WARN_SRS_NOT_FOUND_AXIS_ORDER"; + exports2[3566] = "ER_NO_ACCESS_TO_NATIVE_FCT"; + exports2[3567] = "ER_RESET_SOURCE_TO_VALUE_OUT_OF_RANGE"; + exports2[3568] = "ER_UNRESOLVED_TABLE_LOCK"; + exports2[3569] = "ER_DUPLICATE_TABLE_LOCK"; + exports2[3570] = "ER_BINLOG_UNSAFE_SKIP_LOCKED"; + exports2[3571] = "ER_BINLOG_UNSAFE_NOWAIT"; + exports2[3572] = "ER_LOCK_NOWAIT"; + exports2[3573] = "ER_CTE_RECURSIVE_REQUIRES_UNION"; + exports2[3574] = "ER_CTE_RECURSIVE_REQUIRES_NONRECURSIVE_FIRST"; + exports2[3575] = "ER_CTE_RECURSIVE_FORBIDS_AGGREGATION"; + exports2[3576] = "ER_CTE_RECURSIVE_FORBIDDEN_JOIN_ORDER"; + exports2[3577] = "ER_CTE_RECURSIVE_REQUIRES_SINGLE_REFERENCE"; + exports2[3578] = "ER_SWITCH_TMP_ENGINE"; + exports2[3579] = "ER_WINDOW_NO_SUCH_WINDOW"; + exports2[3580] = "ER_WINDOW_CIRCULARITY_IN_WINDOW_GRAPH"; + exports2[3581] = "ER_WINDOW_NO_CHILD_PARTITIONING"; + exports2[3582] = "ER_WINDOW_NO_INHERIT_FRAME"; + exports2[3583] = "ER_WINDOW_NO_REDEFINE_ORDER_BY"; + exports2[3584] = "ER_WINDOW_FRAME_START_ILLEGAL"; + exports2[3585] = "ER_WINDOW_FRAME_END_ILLEGAL"; + exports2[3586] = "ER_WINDOW_FRAME_ILLEGAL"; + exports2[3587] = "ER_WINDOW_RANGE_FRAME_ORDER_TYPE"; + exports2[3588] = "ER_WINDOW_RANGE_FRAME_TEMPORAL_TYPE"; + exports2[3589] = "ER_WINDOW_RANGE_FRAME_NUMERIC_TYPE"; + exports2[3590] = "ER_WINDOW_RANGE_BOUND_NOT_CONSTANT"; + exports2[3591] = "ER_WINDOW_DUPLICATE_NAME"; + exports2[3592] = "ER_WINDOW_ILLEGAL_ORDER_BY"; + exports2[3593] = "ER_WINDOW_INVALID_WINDOW_FUNC_USE"; + exports2[3594] = "ER_WINDOW_INVALID_WINDOW_FUNC_ALIAS_USE"; + exports2[3595] = "ER_WINDOW_NESTED_WINDOW_FUNC_USE_IN_WINDOW_SPEC"; + exports2[3596] = "ER_WINDOW_ROWS_INTERVAL_USE"; + exports2[3597] = "ER_WINDOW_NO_GROUP_ORDER"; + exports2[3598] = "ER_WINDOW_EXPLAIN_JSON"; + exports2[3599] = "ER_WINDOW_FUNCTION_IGNORES_FRAME"; + exports2[3600] = "ER_WL9236_NOW"; + exports2[3601] = "ER_INVALID_NO_OF_ARGS"; + exports2[3602] = "ER_FIELD_IN_GROUPING_NOT_GROUP_BY"; + exports2[3603] = "ER_TOO_LONG_TABLESPACE_COMMENT"; + exports2[3604] = "ER_ENGINE_CANT_DROP_TABLE"; + exports2[3605] = "ER_ENGINE_CANT_DROP_MISSING_TABLE"; + exports2[3606] = "ER_TABLESPACE_DUP_FILENAME"; + exports2[3607] = "ER_DB_DROP_RMDIR2"; + exports2[3608] = "ER_IMP_NO_FILES_MATCHED"; + exports2[3609] = "ER_IMP_SCHEMA_DOES_NOT_EXIST"; + exports2[3610] = "ER_IMP_TABLE_ALREADY_EXISTS"; + exports2[3611] = "ER_IMP_INCOMPATIBLE_MYSQLD_VERSION"; + exports2[3612] = "ER_IMP_INCOMPATIBLE_DD_VERSION"; + exports2[3613] = "ER_IMP_INCOMPATIBLE_SDI_VERSION"; + exports2[3614] = "ER_WARN_INVALID_HINT"; + exports2[3615] = "ER_VAR_DOES_NOT_EXIST"; + exports2[3616] = "ER_LONGITUDE_OUT_OF_RANGE"; + exports2[3617] = "ER_LATITUDE_OUT_OF_RANGE"; + exports2[3618] = "ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS"; + exports2[3619] = "ER_ILLEGAL_PRIVILEGE_LEVEL"; + exports2[3620] = "ER_NO_SYSTEM_VIEW_ACCESS"; + exports2[3621] = "ER_COMPONENT_FILTER_FLABBERGASTED"; + exports2[3622] = "ER_PART_EXPR_TOO_LONG"; + exports2[3623] = "ER_UDF_DROP_DYNAMICALLY_REGISTERED"; + exports2[3624] = "ER_UNABLE_TO_STORE_COLUMN_STATISTICS"; + exports2[3625] = "ER_UNABLE_TO_UPDATE_COLUMN_STATISTICS"; + exports2[3626] = "ER_UNABLE_TO_DROP_COLUMN_STATISTICS"; + exports2[3627] = "ER_UNABLE_TO_BUILD_HISTOGRAM"; + exports2[3628] = "ER_MANDATORY_ROLE"; + exports2[3629] = "ER_MISSING_TABLESPACE_FILE"; + exports2[3630] = "ER_PERSIST_ONLY_ACCESS_DENIED_ERROR"; + exports2[3631] = "ER_CMD_NEED_SUPER"; + exports2[3632] = "ER_PATH_IN_DATADIR"; + exports2[3633] = "ER_CLONE_DDL_IN_PROGRESS"; + exports2[3634] = "ER_CLONE_TOO_MANY_CONCURRENT_CLONES"; + exports2[3635] = "ER_APPLIER_LOG_EVENT_VALIDATION_ERROR"; + exports2[3636] = "ER_CTE_MAX_RECURSION_DEPTH"; + exports2[3637] = "ER_NOT_HINT_UPDATABLE_VARIABLE"; + exports2[3638] = "ER_CREDENTIALS_CONTRADICT_TO_HISTORY"; + exports2[3639] = "ER_WARNING_PASSWORD_HISTORY_CLAUSES_VOID"; + exports2[3640] = "ER_CLIENT_DOES_NOT_SUPPORT"; + exports2[3641] = "ER_I_S_SKIPPED_TABLESPACE"; + exports2[3642] = "ER_TABLESPACE_ENGINE_MISMATCH"; + exports2[3643] = "ER_WRONG_SRID_FOR_COLUMN"; + exports2[3644] = "ER_CANNOT_ALTER_SRID_DUE_TO_INDEX"; + exports2[3645] = "ER_WARN_BINLOG_PARTIAL_UPDATES_DISABLED"; + exports2[3646] = "ER_WARN_BINLOG_V1_ROW_EVENTS_DISABLED"; + exports2[3647] = "ER_WARN_BINLOG_PARTIAL_UPDATES_SUGGESTS_PARTIAL_IMAGES"; + exports2[3648] = "ER_COULD_NOT_APPLY_JSON_DIFF"; + exports2[3649] = "ER_CORRUPTED_JSON_DIFF"; + exports2[3650] = "ER_RESOURCE_GROUP_EXISTS"; + exports2[3651] = "ER_RESOURCE_GROUP_NOT_EXISTS"; + exports2[3652] = "ER_INVALID_VCPU_ID"; + exports2[3653] = "ER_INVALID_VCPU_RANGE"; + exports2[3654] = "ER_INVALID_THREAD_PRIORITY"; + exports2[3655] = "ER_DISALLOWED_OPERATION"; + exports2[3656] = "ER_RESOURCE_GROUP_BUSY"; + exports2[3657] = "ER_RESOURCE_GROUP_DISABLED"; + exports2[3658] = "ER_FEATURE_UNSUPPORTED"; + exports2[3659] = "ER_ATTRIBUTE_IGNORED"; + exports2[3660] = "ER_INVALID_THREAD_ID"; + exports2[3661] = "ER_RESOURCE_GROUP_BIND_FAILED"; + exports2[3662] = "ER_INVALID_USE_OF_FORCE_OPTION"; + exports2[3663] = "ER_GROUP_REPLICATION_COMMAND_FAILURE"; + exports2[3664] = "ER_SDI_OPERATION_FAILED"; + exports2[3665] = "ER_MISSING_JSON_TABLE_VALUE"; + exports2[3666] = "ER_WRONG_JSON_TABLE_VALUE"; + exports2[3667] = "ER_TF_MUST_HAVE_ALIAS"; + exports2[3668] = "ER_TF_FORBIDDEN_JOIN_TYPE"; + exports2[3669] = "ER_JT_VALUE_OUT_OF_RANGE"; + exports2[3670] = "ER_JT_MAX_NESTED_PATH"; + exports2[3671] = "ER_PASSWORD_EXPIRATION_NOT_SUPPORTED_BY_AUTH_METHOD"; + exports2[3672] = "ER_INVALID_GEOJSON_CRS_NOT_TOP_LEVEL"; + exports2[3673] = "ER_BAD_NULL_ERROR_NOT_IGNORED"; + exports2[3674] = "WARN_USELESS_SPATIAL_INDEX"; + exports2[3675] = "ER_DISK_FULL_NOWAIT"; + exports2[3676] = "ER_PARSE_ERROR_IN_DIGEST_FN"; + exports2[3677] = "ER_UNDISCLOSED_PARSE_ERROR_IN_DIGEST_FN"; + exports2[3678] = "ER_SCHEMA_DIR_EXISTS"; + exports2[3679] = "ER_SCHEMA_DIR_MISSING"; + exports2[3680] = "ER_SCHEMA_DIR_CREATE_FAILED"; + exports2[3681] = "ER_SCHEMA_DIR_UNKNOWN"; + exports2[3682] = "ER_ONLY_IMPLEMENTED_FOR_SRID_0_AND_4326"; + exports2[3683] = "ER_BINLOG_EXPIRE_LOG_DAYS_AND_SECS_USED_TOGETHER"; + exports2[3684] = "ER_REGEXP_BUFFER_OVERFLOW"; + exports2[3685] = "ER_REGEXP_ILLEGAL_ARGUMENT"; + exports2[3686] = "ER_REGEXP_INDEX_OUTOFBOUNDS_ERROR"; + exports2[3687] = "ER_REGEXP_INTERNAL_ERROR"; + exports2[3688] = "ER_REGEXP_RULE_SYNTAX"; + exports2[3689] = "ER_REGEXP_BAD_ESCAPE_SEQUENCE"; + exports2[3690] = "ER_REGEXP_UNIMPLEMENTED"; + exports2[3691] = "ER_REGEXP_MISMATCHED_PAREN"; + exports2[3692] = "ER_REGEXP_BAD_INTERVAL"; + exports2[3693] = "ER_REGEXP_MAX_LT_MIN"; + exports2[3694] = "ER_REGEXP_INVALID_BACK_REF"; + exports2[3695] = "ER_REGEXP_LOOK_BEHIND_LIMIT"; + exports2[3696] = "ER_REGEXP_MISSING_CLOSE_BRACKET"; + exports2[3697] = "ER_REGEXP_INVALID_RANGE"; + exports2[3698] = "ER_REGEXP_STACK_OVERFLOW"; + exports2[3699] = "ER_REGEXP_TIME_OUT"; + exports2[3700] = "ER_REGEXP_PATTERN_TOO_BIG"; + exports2[3701] = "ER_CANT_SET_ERROR_LOG_SERVICE"; + exports2[3702] = "ER_EMPTY_PIPELINE_FOR_ERROR_LOG_SERVICE"; + exports2[3703] = "ER_COMPONENT_FILTER_DIAGNOSTICS"; + exports2[3704] = "ER_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS"; + exports2[3705] = "ER_NOT_IMPLEMENTED_FOR_PROJECTED_SRS"; + exports2[3706] = "ER_NONPOSITIVE_RADIUS"; + exports2[3707] = "ER_RESTART_SERVER_FAILED"; + exports2[3708] = "ER_SRS_MISSING_MANDATORY_ATTRIBUTE"; + exports2[3709] = "ER_SRS_MULTIPLE_ATTRIBUTE_DEFINITIONS"; + exports2[3710] = "ER_SRS_NAME_CANT_BE_EMPTY_OR_WHITESPACE"; + exports2[3711] = "ER_SRS_ORGANIZATION_CANT_BE_EMPTY_OR_WHITESPACE"; + exports2[3712] = "ER_SRS_ID_ALREADY_EXISTS"; + exports2[3713] = "ER_WARN_SRS_ID_ALREADY_EXISTS"; + exports2[3714] = "ER_CANT_MODIFY_SRID_0"; + exports2[3715] = "ER_WARN_RESERVED_SRID_RANGE"; + exports2[3716] = "ER_CANT_MODIFY_SRS_USED_BY_COLUMN"; + exports2[3717] = "ER_SRS_INVALID_CHARACTER_IN_ATTRIBUTE"; + exports2[3718] = "ER_SRS_ATTRIBUTE_STRING_TOO_LONG"; + exports2[3719] = "ER_DEPRECATED_UTF8_ALIAS"; + exports2[3720] = "ER_DEPRECATED_NATIONAL"; + exports2[3721] = "ER_INVALID_DEFAULT_UTF8MB4_COLLATION"; + exports2[3722] = "ER_UNABLE_TO_COLLECT_LOG_STATUS"; + exports2[3723] = "ER_RESERVED_TABLESPACE_NAME"; + exports2[3724] = "ER_UNABLE_TO_SET_OPTION"; + exports2[3725] = "ER_REPLICA_POSSIBLY_DIVERGED_AFTER_DDL"; + exports2[3726] = "ER_SRS_NOT_GEOGRAPHIC"; + exports2[3727] = "ER_POLYGON_TOO_LARGE"; + exports2[3728] = "ER_SPATIAL_UNIQUE_INDEX"; + exports2[3729] = "ER_INDEX_TYPE_NOT_SUPPORTED_FOR_SPATIAL_INDEX"; + exports2[3730] = "ER_FK_CANNOT_DROP_PARENT"; + exports2[3731] = "ER_GEOMETRY_PARAM_LONGITUDE_OUT_OF_RANGE"; + exports2[3732] = "ER_GEOMETRY_PARAM_LATITUDE_OUT_OF_RANGE"; + exports2[3733] = "ER_FK_CANNOT_USE_VIRTUAL_COLUMN"; + exports2[3734] = "ER_FK_NO_COLUMN_PARENT"; + exports2[3735] = "ER_CANT_SET_ERROR_SUPPRESSION_LIST"; + exports2[3736] = "ER_SRS_GEOGCS_INVALID_AXES"; + exports2[3737] = "ER_SRS_INVALID_SEMI_MAJOR_AXIS"; + exports2[3738] = "ER_SRS_INVALID_INVERSE_FLATTENING"; + exports2[3739] = "ER_SRS_INVALID_ANGULAR_UNIT"; + exports2[3740] = "ER_SRS_INVALID_PRIME_MERIDIAN"; + exports2[3741] = "ER_TRANSFORM_SOURCE_SRS_NOT_SUPPORTED"; + exports2[3742] = "ER_TRANSFORM_TARGET_SRS_NOT_SUPPORTED"; + exports2[3743] = "ER_TRANSFORM_SOURCE_SRS_MISSING_TOWGS84"; + exports2[3744] = "ER_TRANSFORM_TARGET_SRS_MISSING_TOWGS84"; + exports2[3745] = "ER_TEMP_TABLE_PREVENTS_SWITCH_SESSION_BINLOG_FORMAT"; + exports2[3746] = "ER_TEMP_TABLE_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT"; + exports2[3747] = "ER_RUNNING_APPLIER_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT"; + exports2[3748] = "ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR"; + exports2[3749] = "ER_XA_CANT_CREATE_MDL_BACKUP"; + exports2[3750] = "ER_TABLE_WITHOUT_PK"; + exports2[3751] = "ER_WARN_DATA_TRUNCATED_FUNCTIONAL_INDEX"; + exports2[3752] = "ER_WARN_DATA_OUT_OF_RANGE_FUNCTIONAL_INDEX"; + exports2[3753] = "ER_FUNCTIONAL_INDEX_ON_JSON_OR_GEOMETRY_FUNCTION"; + exports2[3754] = "ER_FUNCTIONAL_INDEX_REF_AUTO_INCREMENT"; + exports2[3755] = "ER_CANNOT_DROP_COLUMN_FUNCTIONAL_INDEX"; + exports2[3756] = "ER_FUNCTIONAL_INDEX_PRIMARY_KEY"; + exports2[3757] = "ER_FUNCTIONAL_INDEX_ON_LOB"; + exports2[3758] = "ER_FUNCTIONAL_INDEX_FUNCTION_IS_NOT_ALLOWED"; + exports2[3759] = "ER_FULLTEXT_FUNCTIONAL_INDEX"; + exports2[3760] = "ER_SPATIAL_FUNCTIONAL_INDEX"; + exports2[3761] = "ER_WRONG_KEY_COLUMN_FUNCTIONAL_INDEX"; + exports2[3762] = "ER_FUNCTIONAL_INDEX_ON_FIELD"; + exports2[3763] = "ER_GENERATED_COLUMN_NAMED_FUNCTION_IS_NOT_ALLOWED"; + exports2[3764] = "ER_GENERATED_COLUMN_ROW_VALUE"; + exports2[3765] = "ER_GENERATED_COLUMN_VARIABLES"; + exports2[3766] = "ER_DEPENDENT_BY_DEFAULT_GENERATED_VALUE"; + exports2[3767] = "ER_DEFAULT_VAL_GENERATED_NON_PRIOR"; + exports2[3768] = "ER_DEFAULT_VAL_GENERATED_REF_AUTO_INC"; + exports2[3769] = "ER_DEFAULT_VAL_GENERATED_FUNCTION_IS_NOT_ALLOWED"; + exports2[3770] = "ER_DEFAULT_VAL_GENERATED_NAMED_FUNCTION_IS_NOT_ALLOWED"; + exports2[3771] = "ER_DEFAULT_VAL_GENERATED_ROW_VALUE"; + exports2[3772] = "ER_DEFAULT_VAL_GENERATED_VARIABLES"; + exports2[3773] = "ER_DEFAULT_AS_VAL_GENERATED"; + exports2[3774] = "ER_UNSUPPORTED_ACTION_ON_DEFAULT_VAL_GENERATED"; + exports2[3775] = "ER_GTID_UNSAFE_ALTER_ADD_COL_WITH_DEFAULT_EXPRESSION"; + exports2[3776] = "ER_FK_CANNOT_CHANGE_ENGINE"; + exports2[3777] = "ER_WARN_DEPRECATED_USER_SET_EXPR"; + exports2[3778] = "ER_WARN_DEPRECATED_UTF8MB3_COLLATION"; + exports2[3779] = "ER_WARN_DEPRECATED_NESTED_COMMENT_SYNTAX"; + exports2[3780] = "ER_FK_INCOMPATIBLE_COLUMNS"; + exports2[3781] = "ER_GR_HOLD_WAIT_TIMEOUT"; + exports2[3782] = "ER_GR_HOLD_KILLED"; + exports2[3783] = "ER_GR_HOLD_MEMBER_STATUS_ERROR"; + exports2[3784] = "ER_RPL_ENCRYPTION_FAILED_TO_FETCH_KEY"; + exports2[3785] = "ER_RPL_ENCRYPTION_KEY_NOT_FOUND"; + exports2[3786] = "ER_RPL_ENCRYPTION_KEYRING_INVALID_KEY"; + exports2[3787] = "ER_RPL_ENCRYPTION_HEADER_ERROR"; + exports2[3788] = "ER_RPL_ENCRYPTION_FAILED_TO_ROTATE_LOGS"; + exports2[3789] = "ER_RPL_ENCRYPTION_KEY_EXISTS_UNEXPECTED"; + exports2[3790] = "ER_RPL_ENCRYPTION_FAILED_TO_GENERATE_KEY"; + exports2[3791] = "ER_RPL_ENCRYPTION_FAILED_TO_STORE_KEY"; + exports2[3792] = "ER_RPL_ENCRYPTION_FAILED_TO_REMOVE_KEY"; + exports2[3793] = "ER_RPL_ENCRYPTION_UNABLE_TO_CHANGE_OPTION"; + exports2[3794] = "ER_RPL_ENCRYPTION_MASTER_KEY_RECOVERY_FAILED"; + exports2[3795] = "ER_SLOW_LOG_MODE_IGNORED_WHEN_NOT_LOGGING_TO_FILE"; + exports2[3796] = "ER_GRP_TRX_CONSISTENCY_NOT_ALLOWED"; + exports2[3797] = "ER_GRP_TRX_CONSISTENCY_BEFORE"; + exports2[3798] = "ER_GRP_TRX_CONSISTENCY_AFTER_ON_TRX_BEGIN"; + exports2[3799] = "ER_GRP_TRX_CONSISTENCY_BEGIN_NOT_ALLOWED"; + exports2[3800] = "ER_FUNCTIONAL_INDEX_ROW_VALUE_IS_NOT_ALLOWED"; + exports2[3801] = "ER_RPL_ENCRYPTION_FAILED_TO_ENCRYPT"; + exports2[3802] = "ER_PAGE_TRACKING_NOT_STARTED"; + exports2[3803] = "ER_PAGE_TRACKING_RANGE_NOT_TRACKED"; + exports2[3804] = "ER_PAGE_TRACKING_CANNOT_PURGE"; + exports2[3805] = "ER_RPL_ENCRYPTION_CANNOT_ROTATE_BINLOG_MASTER_KEY"; + exports2[3806] = "ER_BINLOG_MASTER_KEY_RECOVERY_OUT_OF_COMBINATION"; + exports2[3807] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_OPERATE_KEY"; + exports2[3808] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_ROTATE_LOGS"; + exports2[3809] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG"; + exports2[3810] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_UNUSED_KEYS"; + exports2[3811] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_AUX_KEY"; + exports2[3812] = "ER_NON_BOOLEAN_EXPR_FOR_CHECK_CONSTRAINT"; + exports2[3813] = "ER_COLUMN_CHECK_CONSTRAINT_REFERENCES_OTHER_COLUMN"; + exports2[3814] = "ER_CHECK_CONSTRAINT_NAMED_FUNCTION_IS_NOT_ALLOWED"; + exports2[3815] = "ER_CHECK_CONSTRAINT_FUNCTION_IS_NOT_ALLOWED"; + exports2[3816] = "ER_CHECK_CONSTRAINT_VARIABLES"; + exports2[3817] = "ER_CHECK_CONSTRAINT_ROW_VALUE"; + exports2[3818] = "ER_CHECK_CONSTRAINT_REFERS_AUTO_INCREMENT_COLUMN"; + exports2[3819] = "ER_CHECK_CONSTRAINT_VIOLATED"; + exports2[3820] = "ER_CHECK_CONSTRAINT_REFERS_UNKNOWN_COLUMN"; + exports2[3821] = "ER_CHECK_CONSTRAINT_NOT_FOUND"; + exports2[3822] = "ER_CHECK_CONSTRAINT_DUP_NAME"; + exports2[3823] = "ER_CHECK_CONSTRAINT_CLAUSE_USING_FK_REFER_ACTION_COLUMN"; + exports2[3824] = "WARN_UNENCRYPTED_TABLE_IN_ENCRYPTED_DB"; + exports2[3825] = "ER_INVALID_ENCRYPTION_REQUEST"; + exports2[3826] = "ER_CANNOT_SET_TABLE_ENCRYPTION"; + exports2[3827] = "ER_CANNOT_SET_DATABASE_ENCRYPTION"; + exports2[3828] = "ER_CANNOT_SET_TABLESPACE_ENCRYPTION"; + exports2[3829] = "ER_TABLESPACE_CANNOT_BE_ENCRYPTED"; + exports2[3830] = "ER_TABLESPACE_CANNOT_BE_DECRYPTED"; + exports2[3831] = "ER_TABLESPACE_TYPE_UNKNOWN"; + exports2[3832] = "ER_TARGET_TABLESPACE_UNENCRYPTED"; + exports2[3833] = "ER_CANNOT_USE_ENCRYPTION_CLAUSE"; + exports2[3834] = "ER_INVALID_MULTIPLE_CLAUSES"; + exports2[3835] = "ER_UNSUPPORTED_USE_OF_GRANT_AS"; + exports2[3836] = "ER_UKNOWN_AUTH_ID_OR_ACCESS_DENIED_FOR_GRANT_AS"; + exports2[3837] = "ER_DEPENDENT_BY_FUNCTIONAL_INDEX"; + exports2[3838] = "ER_PLUGIN_NOT_EARLY"; + exports2[3839] = "ER_INNODB_REDO_LOG_ARCHIVE_START_SUBDIR_PATH"; + exports2[3840] = "ER_INNODB_REDO_LOG_ARCHIVE_START_TIMEOUT"; + exports2[3841] = "ER_INNODB_REDO_LOG_ARCHIVE_DIRS_INVALID"; + exports2[3842] = "ER_INNODB_REDO_LOG_ARCHIVE_LABEL_NOT_FOUND"; + exports2[3843] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_EMPTY"; + exports2[3844] = "ER_INNODB_REDO_LOG_ARCHIVE_NO_SUCH_DIR"; + exports2[3845] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_CLASH"; + exports2[3846] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_PERMISSIONS"; + exports2[3847] = "ER_INNODB_REDO_LOG_ARCHIVE_FILE_CREATE"; + exports2[3848] = "ER_INNODB_REDO_LOG_ARCHIVE_ACTIVE"; + exports2[3849] = "ER_INNODB_REDO_LOG_ARCHIVE_INACTIVE"; + exports2[3850] = "ER_INNODB_REDO_LOG_ARCHIVE_FAILED"; + exports2[3851] = "ER_INNODB_REDO_LOG_ARCHIVE_SESSION"; + exports2[3852] = "ER_STD_REGEX_ERROR"; + exports2[3853] = "ER_INVALID_JSON_TYPE"; + exports2[3854] = "ER_CANNOT_CONVERT_STRING"; + exports2[3855] = "ER_DEPENDENT_BY_PARTITION_FUNC"; + exports2[3856] = "ER_WARN_DEPRECATED_FLOAT_AUTO_INCREMENT"; + exports2[3857] = "ER_RPL_CANT_STOP_REPLICA_WHILE_LOCKED_BACKUP"; + exports2[3858] = "ER_WARN_DEPRECATED_FLOAT_DIGITS"; + exports2[3859] = "ER_WARN_DEPRECATED_FLOAT_UNSIGNED"; + exports2[3860] = "ER_WARN_DEPRECATED_INTEGER_DISPLAY_WIDTH"; + exports2[3861] = "ER_WARN_DEPRECATED_ZEROFILL"; + exports2[3862] = "ER_CLONE_DONOR"; + exports2[3863] = "ER_CLONE_PROTOCOL"; + exports2[3864] = "ER_CLONE_DONOR_VERSION"; + exports2[3865] = "ER_CLONE_OS"; + exports2[3866] = "ER_CLONE_PLATFORM"; + exports2[3867] = "ER_CLONE_CHARSET"; + exports2[3868] = "ER_CLONE_CONFIG"; + exports2[3869] = "ER_CLONE_SYS_CONFIG"; + exports2[3870] = "ER_CLONE_PLUGIN_MATCH"; + exports2[3871] = "ER_CLONE_LOOPBACK"; + exports2[3872] = "ER_CLONE_ENCRYPTION"; + exports2[3873] = "ER_CLONE_DISK_SPACE"; + exports2[3874] = "ER_CLONE_IN_PROGRESS"; + exports2[3875] = "ER_CLONE_DISALLOWED"; + exports2[3876] = "ER_CANNOT_GRANT_ROLES_TO_ANONYMOUS_USER"; + exports2[3877] = "ER_SECONDARY_ENGINE_PLUGIN"; + exports2[3878] = "ER_SECOND_PASSWORD_CANNOT_BE_EMPTY"; + exports2[3879] = "ER_DB_ACCESS_DENIED"; + exports2[3880] = "ER_DA_AUTH_ID_WITH_SYSTEM_USER_PRIV_IN_MANDATORY_ROLES"; + exports2[3881] = "ER_DA_RPL_GTID_TABLE_CANNOT_OPEN"; + exports2[3882] = "ER_GEOMETRY_IN_UNKNOWN_LENGTH_UNIT"; + exports2[3883] = "ER_DA_PLUGIN_INSTALL_ERROR"; + exports2[3884] = "ER_NO_SESSION_TEMP"; + exports2[3885] = "ER_DA_UNKNOWN_ERROR_NUMBER"; + exports2[3886] = "ER_COLUMN_CHANGE_SIZE"; + exports2[3887] = "ER_REGEXP_INVALID_CAPTURE_GROUP_NAME"; + exports2[3888] = "ER_DA_SSL_LIBRARY_ERROR"; + exports2[3889] = "ER_SECONDARY_ENGINE"; + exports2[3890] = "ER_SECONDARY_ENGINE_DDL"; + exports2[3891] = "ER_INCORRECT_CURRENT_PASSWORD"; + exports2[3892] = "ER_MISSING_CURRENT_PASSWORD"; + exports2[3893] = "ER_CURRENT_PASSWORD_NOT_REQUIRED"; + exports2[3894] = "ER_PASSWORD_CANNOT_BE_RETAINED_ON_PLUGIN_CHANGE"; + exports2[3895] = "ER_CURRENT_PASSWORD_CANNOT_BE_RETAINED"; + exports2[3896] = "ER_PARTIAL_REVOKES_EXIST"; + exports2[3897] = "ER_CANNOT_GRANT_SYSTEM_PRIV_TO_MANDATORY_ROLE"; + exports2[3898] = "ER_XA_REPLICATION_FILTERS"; + exports2[3899] = "ER_UNSUPPORTED_SQL_MODE"; + exports2[3900] = "ER_REGEXP_INVALID_FLAG"; + exports2[3901] = "ER_PARTIAL_REVOKE_AND_DB_GRANT_BOTH_EXISTS"; + exports2[3902] = "ER_UNIT_NOT_FOUND"; + exports2[3903] = "ER_INVALID_JSON_VALUE_FOR_FUNC_INDEX"; + exports2[3904] = "ER_JSON_VALUE_OUT_OF_RANGE_FOR_FUNC_INDEX"; + exports2[3905] = "ER_EXCEEDED_MV_KEYS_NUM"; + exports2[3906] = "ER_EXCEEDED_MV_KEYS_SPACE"; + exports2[3907] = "ER_FUNCTIONAL_INDEX_DATA_IS_TOO_LONG"; + exports2[3908] = "ER_WRONG_MVI_VALUE"; + exports2[3909] = "ER_WARN_FUNC_INDEX_NOT_APPLICABLE"; + exports2[3910] = "ER_GRP_RPL_UDF_ERROR"; + exports2[3911] = "ER_UPDATE_GTID_PURGED_WITH_GR"; + exports2[3912] = "ER_GROUPING_ON_TIMESTAMP_IN_DST"; + exports2[3913] = "ER_TABLE_NAME_CAUSES_TOO_LONG_PATH"; + exports2[3914] = "ER_AUDIT_LOG_INSUFFICIENT_PRIVILEGE"; + exports2[3915] = "ER_AUDIT_LOG_PASSWORD_HAS_BEEN_COPIED"; + exports2[3916] = "ER_DA_GRP_RPL_STARTED_AUTO_REJOIN"; + exports2[3917] = "ER_SYSVAR_CHANGE_DURING_QUERY"; + exports2[3918] = "ER_GLOBSTAT_CHANGE_DURING_QUERY"; + exports2[3919] = "ER_GRP_RPL_MESSAGE_SERVICE_INIT_FAILURE"; + exports2[3920] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_CLIENT"; + exports2[3921] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_LEVEL_CLIENT"; + exports2[3922] = "ER_WRONG_COMPRESSION_ALGORITHM_CLIENT"; + exports2[3923] = "ER_WRONG_COMPRESSION_LEVEL_CLIENT"; + exports2[3924] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_LIST_CLIENT"; + exports2[3925] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_CANNOT_BE_ANONYMOUS"; + exports2[3926] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_DOES_NOT_EXIST"; + exports2[3927] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_CORRUPT"; + exports2[3928] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_NEEDS_RPL_APPLIER_PRIV"; + exports2[3929] = "ER_WARN_DA_PRIVILEGE_NOT_REGISTERED"; + exports2[3930] = "ER_CLIENT_KEYRING_UDF_KEY_INVALID"; + exports2[3931] = "ER_CLIENT_KEYRING_UDF_KEY_TYPE_INVALID"; + exports2[3932] = "ER_CLIENT_KEYRING_UDF_KEY_TOO_LONG"; + exports2[3933] = "ER_CLIENT_KEYRING_UDF_KEY_TYPE_TOO_LONG"; + exports2[3934] = "ER_JSON_SCHEMA_VALIDATION_ERROR_WITH_DETAILED_REPORT"; + exports2[3935] = "ER_DA_UDF_INVALID_CHARSET_SPECIFIED"; + exports2[3936] = "ER_DA_UDF_INVALID_CHARSET"; + exports2[3937] = "ER_DA_UDF_INVALID_COLLATION"; + exports2[3938] = "ER_DA_UDF_INVALID_EXTENSION_ARGUMENT_TYPE"; + exports2[3939] = "ER_MULTIPLE_CONSTRAINTS_WITH_SAME_NAME"; + exports2[3940] = "ER_CONSTRAINT_NOT_FOUND"; + exports2[3941] = "ER_ALTER_CONSTRAINT_ENFORCEMENT_NOT_SUPPORTED"; + exports2[3942] = "ER_TABLE_VALUE_CONSTRUCTOR_MUST_HAVE_COLUMNS"; + exports2[3943] = "ER_TABLE_VALUE_CONSTRUCTOR_CANNOT_HAVE_DEFAULT"; + exports2[3944] = "ER_CLIENT_QUERY_FAILURE_INVALID_NON_ROW_FORMAT"; + exports2[3945] = "ER_REQUIRE_ROW_FORMAT_INVALID_VALUE"; + exports2[3946] = "ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY"; + exports2[3947] = "ER_FAILED_TO_FETCH_MANDATORY_ROLE_LIST"; + exports2[3948] = "ER_CLIENT_LOCAL_FILES_DISABLED"; + exports2[3949] = "ER_IMP_INCOMPATIBLE_CFG_VERSION"; + exports2[3950] = "ER_DA_OOM"; + exports2[3951] = "ER_DA_UDF_INVALID_ARGUMENT_TO_SET_CHARSET"; + exports2[3952] = "ER_DA_UDF_INVALID_RETURN_TYPE_TO_SET_CHARSET"; + exports2[3953] = "ER_MULTIPLE_INTO_CLAUSES"; + exports2[3954] = "ER_MISPLACED_INTO"; + exports2[3955] = "ER_USER_ACCESS_DENIED_FOR_USER_ACCOUNT_BLOCKED_BY_PASSWORD_LOCK"; + exports2[3956] = "ER_WARN_DEPRECATED_YEAR_UNSIGNED"; + exports2[3957] = "ER_CLONE_NETWORK_PACKET"; + exports2[3958] = "ER_SDI_OPERATION_FAILED_MISSING_RECORD"; + exports2[3959] = "ER_DEPENDENT_BY_CHECK_CONSTRAINT"; + exports2[3960] = "ER_GRP_OPERATION_NOT_ALLOWED_GR_MUST_STOP"; + exports2[3961] = "ER_WARN_DEPRECATED_JSON_TABLE_ON_ERROR_ON_EMPTY"; + exports2[3962] = "ER_WARN_DEPRECATED_INNER_INTO"; + exports2[3963] = "ER_WARN_DEPRECATED_VALUES_FUNCTION_ALWAYS_NULL"; + exports2[3964] = "ER_WARN_DEPRECATED_SQL_CALC_FOUND_ROWS"; + exports2[3965] = "ER_WARN_DEPRECATED_FOUND_ROWS"; + exports2[3966] = "ER_MISSING_JSON_VALUE"; + exports2[3967] = "ER_MULTIPLE_JSON_VALUES"; + exports2[3968] = "ER_HOSTNAME_TOO_LONG"; + exports2[3969] = "ER_WARN_CLIENT_DEPRECATED_PARTITION_PREFIX_KEY"; + exports2[3970] = "ER_GROUP_REPLICATION_USER_EMPTY_MSG"; + exports2[3971] = "ER_GROUP_REPLICATION_USER_MANDATORY_MSG"; + exports2[3972] = "ER_GROUP_REPLICATION_PASSWORD_LENGTH"; + exports2[3973] = "ER_SUBQUERY_TRANSFORM_REJECTED"; + exports2[3974] = "ER_DA_GRP_RPL_RECOVERY_ENDPOINT_FORMAT"; + exports2[3975] = "ER_DA_GRP_RPL_RECOVERY_ENDPOINT_INVALID"; + exports2[3976] = "ER_WRONG_VALUE_FOR_VAR_PLUS_ACTIONABLE_PART"; + exports2[3977] = "ER_STATEMENT_NOT_ALLOWED_AFTER_START_TRANSACTION"; + exports2[3978] = "ER_FOREIGN_KEY_WITH_ATOMIC_CREATE_SELECT"; + exports2[3979] = "ER_NOT_ALLOWED_WITH_START_TRANSACTION"; + exports2[3980] = "ER_INVALID_JSON_ATTRIBUTE"; + exports2[3981] = "ER_ENGINE_ATTRIBUTE_NOT_SUPPORTED"; + exports2[3982] = "ER_INVALID_USER_ATTRIBUTE_JSON"; + exports2[3983] = "ER_INNODB_REDO_DISABLED"; + exports2[3984] = "ER_INNODB_REDO_ARCHIVING_ENABLED"; + exports2[3985] = "ER_MDL_OUT_OF_RESOURCES"; + exports2[3986] = "ER_IMPLICIT_COMPARISON_FOR_JSON"; + exports2[3987] = "ER_FUNCTION_DOES_NOT_SUPPORT_CHARACTER_SET"; + exports2[3988] = "ER_IMPOSSIBLE_STRING_CONVERSION"; + exports2[3989] = "ER_SCHEMA_READ_ONLY"; + exports2[3990] = "ER_RPL_ASYNC_RECONNECT_GTID_MODE_OFF"; + exports2[3991] = "ER_RPL_ASYNC_RECONNECT_AUTO_POSITION_OFF"; + exports2[3992] = "ER_DISABLE_GTID_MODE_REQUIRES_ASYNC_RECONNECT_OFF"; + exports2[3993] = "ER_DISABLE_AUTO_POSITION_REQUIRES_ASYNC_RECONNECT_OFF"; + exports2[3994] = "ER_INVALID_PARAMETER_USE"; + exports2[3995] = "ER_CHARACTER_SET_MISMATCH"; + exports2[3996] = "ER_WARN_VAR_VALUE_CHANGE_NOT_SUPPORTED"; + exports2[3997] = "ER_INVALID_TIME_ZONE_INTERVAL"; + exports2[3998] = "ER_INVALID_CAST"; + exports2[3999] = "ER_HYPERGRAPH_NOT_SUPPORTED_YET"; + exports2[4e3] = "ER_WARN_HYPERGRAPH_EXPERIMENTAL"; + exports2[4001] = "ER_DA_NO_ERROR_LOG_PARSER_CONFIGURED"; + exports2[4002] = "ER_DA_ERROR_LOG_TABLE_DISABLED"; + exports2[4003] = "ER_DA_ERROR_LOG_MULTIPLE_FILTERS"; + exports2[4004] = "ER_DA_CANT_OPEN_ERROR_LOG"; + exports2[4005] = "ER_USER_REFERENCED_AS_DEFINER"; + exports2[4006] = "ER_CANNOT_USER_REFERENCED_AS_DEFINER"; + exports2[4007] = "ER_REGEX_NUMBER_TOO_BIG"; + exports2[4008] = "ER_SPVAR_NONINTEGER_TYPE"; + exports2[4009] = "WARN_UNSUPPORTED_ACL_TABLES_READ"; + exports2[4010] = "ER_BINLOG_UNSAFE_ACL_TABLE_READ_IN_DML_DDL"; + exports2[4011] = "ER_STOP_REPLICA_MONITOR_IO_THREAD_TIMEOUT"; + exports2[4012] = "ER_STARTING_REPLICA_MONITOR_IO_THREAD"; + exports2[4013] = "ER_CANT_USE_ANONYMOUS_TO_GTID_WITH_GTID_MODE_NOT_ON"; + exports2[4014] = "ER_CANT_COMBINE_ANONYMOUS_TO_GTID_AND_AUTOPOSITION"; + exports2[4015] = "ER_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_REQUIRES_GTID_MODE_ON"; + exports2[4016] = "ER_SQL_REPLICA_SKIP_COUNTER_USED_WITH_GTID_MODE_ON"; + exports2[4017] = "ER_USING_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_AS_LOCAL_OR_UUID"; + exports2[4018] = "ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS"; + exports2[4019] = "ER_CANT_SET_SQL_AFTER_OR_BEFORE_GTIDS_WITH_ANONYMOUS_TO_GTID"; + exports2[4020] = "ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_GROUP_NAME"; + exports2[4021] = "ER_CANT_USE_SAME_UUID_AS_GROUP_NAME"; + exports2[4022] = "ER_GRP_RPL_RECOVERY_CHANNEL_STILL_RUNNING"; + exports2[4023] = "ER_INNODB_INVALID_AUTOEXTEND_SIZE_VALUE"; + exports2[4024] = "ER_INNODB_INCOMPATIBLE_WITH_TABLESPACE"; + exports2[4025] = "ER_INNODB_AUTOEXTEND_SIZE_OUT_OF_RANGE"; + exports2[4026] = "ER_CANNOT_USE_AUTOEXTEND_SIZE_CLAUSE"; + exports2[4027] = "ER_ROLE_GRANTED_TO_ITSELF"; + exports2[4028] = "ER_TABLE_MUST_HAVE_A_VISIBLE_COLUMN"; + exports2[4029] = "ER_INNODB_COMPRESSION_FAILURE"; + exports2[4030] = "ER_WARN_ASYNC_CONN_FAILOVER_NETWORK_NAMESPACE"; + exports2[4031] = "ER_CLIENT_INTERACTION_TIMEOUT"; + exports2[4032] = "ER_INVALID_CAST_TO_GEOMETRY"; + exports2[4033] = "ER_INVALID_CAST_POLYGON_RING_DIRECTION"; + exports2[4034] = "ER_GIS_DIFFERENT_SRIDS_AGGREGATION"; + exports2[4035] = "ER_RELOAD_KEYRING_FAILURE"; + exports2[4036] = "ER_SDI_GET_KEYS_INVALID_TABLESPACE"; + exports2[4037] = "ER_CHANGE_RPL_SRC_WRONG_COMPRESSION_ALGORITHM_SIZE"; + exports2[4038] = "ER_WARN_DEPRECATED_TLS_VERSION_FOR_CHANNEL_CLI"; + exports2[4039] = "ER_CANT_USE_SAME_UUID_AS_VIEW_CHANGE_UUID"; + exports2[4040] = "ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_VIEW_CHANGE_UUID"; + exports2[4041] = "ER_GRP_RPL_VIEW_CHANGE_UUID_FAIL_GET_VARIABLE"; + exports2[4042] = "ER_WARN_ADUIT_LOG_MAX_SIZE_AND_PRUNE_SECONDS"; + exports2[4043] = "ER_WARN_ADUIT_LOG_MAX_SIZE_CLOSE_TO_ROTATE_ON_SIZE"; + exports2[4044] = "ER_KERBEROS_CREATE_USER"; + exports2[4045] = "ER_INSTALL_PLUGIN_CONFLICT_CLIENT"; + exports2[4046] = "ER_DA_ERROR_LOG_COMPONENT_FLUSH_FAILED"; + exports2[4047] = "ER_WARN_SQL_AFTER_MTS_GAPS_GAP_NOT_CALCULATED"; + exports2[4048] = "ER_INVALID_ASSIGNMENT_TARGET"; + exports2[4049] = "ER_OPERATION_NOT_ALLOWED_ON_GR_SECONDARY"; + exports2[4050] = "ER_GRP_RPL_FAILOVER_CHANNEL_STATUS_PROPAGATION"; + exports2[4051] = "ER_WARN_AUDIT_LOG_FORMAT_UNIX_TIMESTAMP_ONLY_WHEN_JSON"; + exports2[4052] = "ER_INVALID_MFA_PLUGIN_SPECIFIED"; + exports2[4053] = "ER_IDENTIFIED_BY_UNSUPPORTED"; + exports2[4054] = "ER_INVALID_PLUGIN_FOR_REGISTRATION"; + exports2[4055] = "ER_PLUGIN_REQUIRES_REGISTRATION"; + exports2[4056] = "ER_MFA_METHOD_EXISTS"; + exports2[4057] = "ER_MFA_METHOD_NOT_EXISTS"; + exports2[4058] = "ER_AUTHENTICATION_POLICY_MISMATCH"; + exports2[4059] = "ER_PLUGIN_REGISTRATION_DONE"; + exports2[4060] = "ER_INVALID_USER_FOR_REGISTRATION"; + exports2[4061] = "ER_USER_REGISTRATION_FAILED"; + exports2[4062] = "ER_MFA_METHODS_INVALID_ORDER"; + exports2[4063] = "ER_MFA_METHODS_IDENTICAL"; + exports2[4064] = "ER_INVALID_MFA_OPERATIONS_FOR_PASSWORDLESS_USER"; + exports2[4065] = "ER_CHANGE_REPLICATION_SOURCE_NO_OPTIONS_FOR_GTID_ONLY"; + exports2[4066] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_REQ_ROW_FORMAT_WITH_GTID_ONLY"; + exports2[4067] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POSITION_WITH_GTID_ONLY"; + exports2[4068] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_GTID_ONLY_WITHOUT_POSITIONS"; + exports2[4069] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POS_WITHOUT_POSITIONS"; + exports2[4070] = "ER_CHANGE_REP_SOURCE_GR_CHANNEL_WITH_GTID_MODE_NOT_ON"; + exports2[4071] = "ER_CANT_USE_GTID_ONLY_WITH_GTID_MODE_NOT_ON"; + exports2[4072] = "ER_WARN_C_DISABLE_GTID_ONLY_WITH_SOURCE_AUTO_POS_INVALID_POS"; + exports2[4073] = "ER_DA_SSL_FIPS_MODE_ERROR"; + exports2[4074] = "ER_VALUE_OUT_OF_RANGE"; + exports2[4075] = "ER_FULLTEXT_WITH_ROLLUP"; + exports2[4076] = "ER_REGEXP_MISSING_RESOURCE"; + exports2[4077] = "ER_WARN_REGEXP_USING_DEFAULT"; + exports2[4078] = "ER_REGEXP_MISSING_FILE"; + exports2[4079] = "ER_WARN_DEPRECATED_COLLATION"; + exports2[4080] = "ER_CONCURRENT_PROCEDURE_USAGE"; + exports2[4081] = "ER_DA_GLOBAL_CONN_LIMIT"; + exports2[4082] = "ER_DA_CONN_LIMIT"; + exports2[4083] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE_INSTANT"; + exports2[4084] = "ER_WARN_SF_UDF_NAME_COLLISION"; + exports2[4085] = "ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK"; + exports2[4086] = "ER_TOO_MANY_WINDOWS"; + exports2[4087] = "ER_MYSQLBACKUP_CLIENT_MSG"; + exports2[4088] = "ER_COMMENT_CONTAINS_INVALID_STRING"; + exports2[4089] = "ER_DEFINITION_CONTAINS_INVALID_STRING"; + exports2[4090] = "ER_CANT_EXECUTE_COMMAND_WITH_ASSIGNED_GTID_NEXT"; + exports2[4091] = "ER_XA_TEMP_TABLE"; + exports2[4092] = "ER_INNODB_MAX_ROW_VERSION"; + exports2[4093] = "ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_SIZE"; + exports2[4094] = "ER_OPERATION_NOT_ALLOWED_WHILE_PRIMARY_CHANGE_IS_RUNNING"; + exports2[4095] = "ER_WARN_DEPRECATED_DATETIME_DELIMITER"; + exports2[4096] = "ER_WARN_DEPRECATED_SUPERFLUOUS_DELIMITER"; + exports2[4097] = "ER_CANNOT_PERSIST_SENSITIVE_VARIABLES"; + exports2[4098] = "ER_WARN_CANNOT_SECURELY_PERSIST_SENSITIVE_VARIABLES"; + exports2[4099] = "ER_WARN_TRG_ALREADY_EXISTS"; + exports2[4100] = "ER_IF_NOT_EXISTS_UNSUPPORTED_TRG_EXISTS_ON_DIFFERENT_TABLE"; + exports2[4101] = "ER_IF_NOT_EXISTS_UNSUPPORTED_UDF_NATIVE_FCT_NAME_COLLISION"; + exports2[4102] = "ER_SET_PASSWORD_AUTH_PLUGIN_ERROR"; + exports2[4103] = "ER_REDUCED_DBLWR_FILE_CORRUPTED"; + exports2[4104] = "ER_REDUCED_DBLWR_PAGE_FOUND"; + exports2[4105] = "ER_SRS_INVALID_LATITUDE_OF_ORIGIN"; + exports2[4106] = "ER_SRS_INVALID_LONGITUDE_OF_ORIGIN"; + exports2[4107] = "ER_SRS_UNUSED_PROJ_PARAMETER_PRESENT"; + exports2[4108] = "ER_GIPK_COLUMN_EXISTS"; + exports2[4109] = "ER_GIPK_FAILED_AUTOINC_COLUMN_EXISTS"; + exports2[4110] = "ER_GIPK_COLUMN_ALTER_NOT_ALLOWED"; + exports2[4111] = "ER_DROP_PK_COLUMN_TO_DROP_GIPK"; + exports2[4112] = "ER_CREATE_SELECT_WITH_GIPK_DISALLOWED_IN_SBR"; + exports2[4113] = "ER_DA_EXPIRE_LOGS_DAYS_IGNORED"; + exports2[4114] = "ER_CTE_RECURSIVE_NOT_UNION"; + exports2[4115] = "ER_COMMAND_BACKEND_FAILED_TO_FETCH_SECURITY_CTX"; + exports2[4116] = "ER_COMMAND_SERVICE_BACKEND_FAILED"; + exports2[4117] = "ER_CLIENT_FILE_PRIVILEGE_FOR_REPLICATION_CHECKS"; + exports2[4118] = "ER_GROUP_REPLICATION_FORCE_MEMBERS_COMMAND_FAILURE"; + exports2[4119] = "ER_WARN_DEPRECATED_IDENT"; + exports2[4120] = "ER_INTERSECT_ALL_MAX_DUPLICATES_EXCEEDED"; + exports2[4121] = "ER_TP_QUERY_THRS_PER_GRP_EXCEEDS_TXN_THR_LIMIT"; + exports2[4122] = "ER_BAD_TIMESTAMP_FORMAT"; + exports2[4123] = "ER_SHAPE_PRIDICTION_UDF"; + exports2[4124] = "ER_SRS_INVALID_HEIGHT"; + exports2[4125] = "ER_SRS_INVALID_SCALING"; + exports2[4126] = "ER_SRS_INVALID_ZONE_WIDTH"; + exports2[4127] = "ER_SRS_INVALID_LATITUDE_POLAR_STERE_VAR_A"; + exports2[4128] = "ER_WARN_DEPRECATED_CLIENT_NO_SCHEMA_OPTION"; + exports2[4129] = "ER_TABLE_NOT_EMPTY"; + exports2[4130] = "ER_TABLE_NO_PRIMARY_KEY"; + exports2[4131] = "ER_TABLE_IN_SHARED_TABLESPACE"; + exports2[4132] = "ER_INDEX_OTHER_THAN_PK"; + exports2[4133] = "ER_LOAD_BULK_DATA_UNSORTED"; + exports2[4134] = "ER_BULK_EXECUTOR_ERROR"; + exports2[4135] = "ER_BULK_READER_LIBCURL_INIT_FAILED"; + exports2[4136] = "ER_BULK_READER_LIBCURL_ERROR"; + exports2[4137] = "ER_BULK_READER_SERVER_ERROR"; + exports2[4138] = "ER_BULK_READER_COMMUNICATION_ERROR"; + exports2[4139] = "ER_BULK_LOAD_DATA_FAILED"; + exports2[4140] = "ER_BULK_LOADER_COLUMN_TOO_BIG_FOR_LEFTOVER_BUFFER"; + exports2[4141] = "ER_BULK_LOADER_COMPONENT_ERROR"; + exports2[4142] = "ER_BULK_LOADER_FILE_CONTAINS_LESS_LINES_THAN_IGNORE_CLAUSE"; + exports2[4143] = "ER_BULK_PARSER_MISSING_ENCLOSED_BY"; + exports2[4144] = "ER_BULK_PARSER_ROW_BUFFER_MAX_TOTAL_COLS_EXCEEDED"; + exports2[4145] = "ER_BULK_PARSER_COPY_BUFFER_SIZE_EXCEEDED"; + exports2[4146] = "ER_BULK_PARSER_UNEXPECTED_END_OF_INPUT"; + exports2[4147] = "ER_BULK_PARSER_UNEXPECTED_ROW_TERMINATOR"; + exports2[4148] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_ENDING_ENCLOSED_BY"; + exports2[4149] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_NULL_ESCAPE"; + exports2[4150] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_COLUMN_TERMINATOR"; + exports2[4151] = "ER_BULK_PARSER_INCOMPLETE_ESCAPE_SEQUENCE"; + exports2[4152] = "ER_LOAD_BULK_DATA_FAILED"; + exports2[4153] = "ER_LOAD_BULK_DATA_WRONG_VALUE_FOR_FIELD"; + exports2[4154] = "ER_LOAD_BULK_DATA_WARN_NULL_TO_NOTNULL"; + exports2[4155] = "ER_REQUIRE_TABLE_PRIMARY_KEY_CHECK_GENERATE_WITH_GR"; + exports2[4156] = "ER_CANT_CHANGE_SYS_VAR_IN_READ_ONLY_MODE"; + exports2[4157] = "ER_INNODB_INSTANT_ADD_DROP_NOT_SUPPORTED_MAX_SIZE"; + exports2[4158] = "ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_FIELDS"; + exports2[4159] = "ER_CANT_SET_PERSISTED"; + exports2[4160] = "ER_INSTALL_COMPONENT_SET_NULL_VALUE"; + exports2[4161] = "ER_INSTALL_COMPONENT_SET_UNUSED_VALUE"; + exports2[4162] = "ER_WARN_DEPRECATED_USER_DEFINED_COLLATIONS"; + } +}); + +// node_modules/long/umd/index.js +var require_umd = __commonJS({ + "node_modules/long/umd/index.js"(exports2, module2) { + (function(global2, factory) { + function preferDefault(exports3) { + return exports3.default || exports3; + } + if (typeof define === "function" && define.amd) { + define([], function() { + var exports3 = {}; + factory(exports3); + return preferDefault(exports3); + }); + } else if (typeof exports2 === "object") { + factory(exports2); + if (typeof module2 === "object") module2.exports = preferDefault(exports2); + } else { + (function() { + var exports3 = {}; + factory(exports3); + global2.Long = preferDefault(exports3); + })(); + } + })( + typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports2, + function(_exports) { + "use strict"; + Object.defineProperty(_exports, "__esModule", { + value: true + }); + _exports.default = void 0; + /** + * @license + * Copyright 2009 The Closure Library Authors + * Copyright 2020 Daniel Wirtz / The long.js Authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ + var wasm = null; + try { + wasm = new WebAssembly.Instance( + new WebAssembly.Module( + new Uint8Array([ + // \0asm + 0, + 97, + 115, + 109, + // version 1 + 1, + 0, + 0, + 0, + // section "type" + 1, + 13, + 2, + // 0, () => i32 + 96, + 0, + 1, + 127, + // 1, (i32, i32, i32, i32) => i32 + 96, + 4, + 127, + 127, + 127, + 127, + 1, + 127, + // section "function" + 3, + 7, + 6, + // 0, type 0 + 0, + // 1, type 1 + 1, + // 2, type 1 + 1, + // 3, type 1 + 1, + // 4, type 1 + 1, + // 5, type 1 + 1, + // section "global" + 6, + 6, + 1, + // 0, "high", mutable i32 + 127, + 1, + 65, + 0, + 11, + // section "export" + 7, + 50, + 6, + // 0, "mul" + 3, + 109, + 117, + 108, + 0, + 1, + // 1, "div_s" + 5, + 100, + 105, + 118, + 95, + 115, + 0, + 2, + // 2, "div_u" + 5, + 100, + 105, + 118, + 95, + 117, + 0, + 3, + // 3, "rem_s" + 5, + 114, + 101, + 109, + 95, + 115, + 0, + 4, + // 4, "rem_u" + 5, + 114, + 101, + 109, + 95, + 117, + 0, + 5, + // 5, "get_high" + 8, + 103, + 101, + 116, + 95, + 104, + 105, + 103, + 104, + 0, + 0, + // section "code" + 10, + 191, + 1, + 6, + // 0, "get_high" + 4, + 0, + 35, + 0, + 11, + // 1, "mul" + 36, + 1, + 1, + 126, + 32, + 0, + 173, + 32, + 1, + 173, + 66, + 32, + 134, + 132, + 32, + 2, + 173, + 32, + 3, + 173, + 66, + 32, + 134, + 132, + 126, + 34, + 4, + 66, + 32, + 135, + 167, + 36, + 0, + 32, + 4, + 167, + 11, + // 2, "div_s" + 36, + 1, + 1, + 126, + 32, + 0, + 173, + 32, + 1, + 173, + 66, + 32, + 134, + 132, + 32, + 2, + 173, + 32, + 3, + 173, + 66, + 32, + 134, + 132, + 127, + 34, + 4, + 66, + 32, + 135, + 167, + 36, + 0, + 32, + 4, + 167, + 11, + // 3, "div_u" + 36, + 1, + 1, + 126, + 32, + 0, + 173, + 32, + 1, + 173, + 66, + 32, + 134, + 132, + 32, + 2, + 173, + 32, + 3, + 173, + 66, + 32, + 134, + 132, + 128, + 34, + 4, + 66, + 32, + 135, + 167, + 36, + 0, + 32, + 4, + 167, + 11, + // 4, "rem_s" + 36, + 1, + 1, + 126, + 32, + 0, + 173, + 32, + 1, + 173, + 66, + 32, + 134, + 132, + 32, + 2, + 173, + 32, + 3, + 173, + 66, + 32, + 134, + 132, + 129, + 34, + 4, + 66, + 32, + 135, + 167, + 36, + 0, + 32, + 4, + 167, + 11, + // 5, "rem_u" + 36, + 1, + 1, + 126, + 32, + 0, + 173, + 32, + 1, + 173, + 66, + 32, + 134, + 132, + 32, + 2, + 173, + 32, + 3, + 173, + 66, + 32, + 134, + 132, + 130, + 34, + 4, + 66, + 32, + 135, + 167, + 36, + 0, + 32, + 4, + 167, + 11 + ]) + ), + {} + ).exports; + } catch { + } + function Long(low, high, unsigned) { + this.low = low | 0; + this.high = high | 0; + this.unsigned = !!unsigned; + } + Long.prototype.__isLong__; + Object.defineProperty(Long.prototype, "__isLong__", { + value: true + }); + function isLong(obj) { + return (obj && obj["__isLong__"]) === true; + } + function ctz32(value) { + var c = Math.clz32(value & -value); + return value ? 31 - c : c; + } + Long.isLong = isLong; + var INT_CACHE = {}; + var UINT_CACHE = {}; + function fromInt(value, unsigned) { + var obj, cachedObj, cache; + if (unsigned) { + value >>>= 0; + if (cache = 0 <= value && value < 256) { + cachedObj = UINT_CACHE[value]; + if (cachedObj) return cachedObj; + } + obj = fromBits(value, 0, true); + if (cache) UINT_CACHE[value] = obj; + return obj; + } else { + value |= 0; + if (cache = -128 <= value && value < 128) { + cachedObj = INT_CACHE[value]; + if (cachedObj) return cachedObj; + } + obj = fromBits(value, value < 0 ? -1 : 0, false); + if (cache) INT_CACHE[value] = obj; + return obj; + } + } + Long.fromInt = fromInt; + function fromNumber(value, unsigned) { + if (isNaN(value)) return unsigned ? UZERO : ZERO; + if (unsigned) { + if (value < 0) return UZERO; + if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE; + } else { + if (value <= -TWO_PWR_63_DBL) return MIN_VALUE; + if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE; + } + if (value < 0) return fromNumber(-value, unsigned).neg(); + return fromBits( + value % TWO_PWR_32_DBL | 0, + value / TWO_PWR_32_DBL | 0, + unsigned + ); + } + Long.fromNumber = fromNumber; + function fromBits(lowBits, highBits, unsigned) { + return new Long(lowBits, highBits, unsigned); + } + Long.fromBits = fromBits; + var pow_dbl = Math.pow; + function fromString(str, unsigned, radix) { + if (str.length === 0) throw Error("empty string"); + if (typeof unsigned === "number") { + radix = unsigned; + unsigned = false; + } else { + unsigned = !!unsigned; + } + if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity") + return unsigned ? UZERO : ZERO; + radix = radix || 10; + if (radix < 2 || 36 < radix) throw RangeError("radix"); + var p; + if ((p = str.indexOf("-")) > 0) throw Error("interior hyphen"); + else if (p === 0) { + return fromString(str.substring(1), unsigned, radix).neg(); + } + var radixToPower = fromNumber(pow_dbl(radix, 8)); + var result = ZERO; + for (var i = 0; i < str.length; i += 8) { + var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + var power = fromNumber(pow_dbl(radix, size)); + result = result.mul(power).add(fromNumber(value)); + } else { + result = result.mul(radixToPower); + result = result.add(fromNumber(value)); + } + } + result.unsigned = unsigned; + return result; + } + Long.fromString = fromString; + function fromValue(val, unsigned) { + if (typeof val === "number") return fromNumber(val, unsigned); + if (typeof val === "string") return fromString(val, unsigned); + return fromBits( + val.low, + val.high, + typeof unsigned === "boolean" ? unsigned : val.unsigned + ); + } + Long.fromValue = fromValue; + var TWO_PWR_16_DBL = 1 << 16; + var TWO_PWR_24_DBL = 1 << 24; + var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; + var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; + var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; + var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL); + var ZERO = fromInt(0); + Long.ZERO = ZERO; + var UZERO = fromInt(0, true); + Long.UZERO = UZERO; + var ONE = fromInt(1); + Long.ONE = ONE; + var UONE = fromInt(1, true); + Long.UONE = UONE; + var NEG_ONE = fromInt(-1); + Long.NEG_ONE = NEG_ONE; + var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false); + Long.MAX_VALUE = MAX_VALUE; + var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true); + Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE; + var MIN_VALUE = fromBits(0, 2147483648 | 0, false); + Long.MIN_VALUE = MIN_VALUE; + var LongPrototype = Long.prototype; + LongPrototype.toInt = function toInt() { + return this.unsigned ? this.low >>> 0 : this.low; + }; + LongPrototype.toNumber = function toNumber() { + if (this.unsigned) + return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0); + return this.high * TWO_PWR_32_DBL + (this.low >>> 0); + }; + LongPrototype.toString = function toString(radix) { + radix = radix || 10; + if (radix < 2 || 36 < radix) throw RangeError("radix"); + if (this.isZero()) return "0"; + if (this.isNegative()) { + if (this.eq(MIN_VALUE)) { + var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this); + return div.toString(radix) + rem1.toInt().toString(radix); + } else return "-" + this.neg().toString(radix); + } + var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this; + var result = ""; + while (true) { + var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix); + rem = remDiv; + if (rem.isZero()) return digits + result; + else { + while (digits.length < 6) digits = "0" + digits; + result = "" + digits + result; + } + } + }; + LongPrototype.getHighBits = function getHighBits() { + return this.high; + }; + LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() { + return this.high >>> 0; + }; + LongPrototype.getLowBits = function getLowBits() { + return this.low; + }; + LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() { + return this.low >>> 0; + }; + LongPrototype.getNumBitsAbs = function getNumBitsAbs() { + if (this.isNegative()) + return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); + var val = this.high != 0 ? this.high : this.low; + for (var bit = 31; bit > 0; bit--) if ((val & 1 << bit) != 0) break; + return this.high != 0 ? bit + 33 : bit + 1; + }; + LongPrototype.isSafeInteger = function isSafeInteger() { + var top11Bits = this.high >> 21; + if (!top11Bits) return true; + if (this.unsigned) return false; + return top11Bits === -1 && !(this.low === 0 && this.high === -2097152); + }; + LongPrototype.isZero = function isZero() { + return this.high === 0 && this.low === 0; + }; + LongPrototype.eqz = LongPrototype.isZero; + LongPrototype.isNegative = function isNegative() { + return !this.unsigned && this.high < 0; + }; + LongPrototype.isPositive = function isPositive() { + return this.unsigned || this.high >= 0; + }; + LongPrototype.isOdd = function isOdd() { + return (this.low & 1) === 1; + }; + LongPrototype.isEven = function isEven() { + return (this.low & 1) === 0; + }; + LongPrototype.equals = function equals(other) { + if (!isLong(other)) other = fromValue(other); + if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1) + return false; + return this.high === other.high && this.low === other.low; + }; + LongPrototype.eq = LongPrototype.equals; + LongPrototype.notEquals = function notEquals(other) { + return !this.eq( + /* validates */ + other + ); + }; + LongPrototype.neq = LongPrototype.notEquals; + LongPrototype.ne = LongPrototype.notEquals; + LongPrototype.lessThan = function lessThan(other) { + return this.comp( + /* validates */ + other + ) < 0; + }; + LongPrototype.lt = LongPrototype.lessThan; + LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) { + return this.comp( + /* validates */ + other + ) <= 0; + }; + LongPrototype.lte = LongPrototype.lessThanOrEqual; + LongPrototype.le = LongPrototype.lessThanOrEqual; + LongPrototype.greaterThan = function greaterThan(other) { + return this.comp( + /* validates */ + other + ) > 0; + }; + LongPrototype.gt = LongPrototype.greaterThan; + LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) { + return this.comp( + /* validates */ + other + ) >= 0; + }; + LongPrototype.gte = LongPrototype.greaterThanOrEqual; + LongPrototype.ge = LongPrototype.greaterThanOrEqual; + LongPrototype.compare = function compare(other) { + if (!isLong(other)) other = fromValue(other); + if (this.eq(other)) return 0; + var thisNeg = this.isNegative(), otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) return -1; + if (!thisNeg && otherNeg) return 1; + if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1; + return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1; + }; + LongPrototype.comp = LongPrototype.compare; + LongPrototype.negate = function negate() { + if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE; + return this.not().add(ONE); + }; + LongPrototype.neg = LongPrototype.negate; + LongPrototype.add = function add(addend) { + if (!isLong(addend)) addend = fromValue(addend); + var a48 = this.high >>> 16; + var a32 = this.high & 65535; + var a16 = this.low >>> 16; + var a00 = this.low & 65535; + var b48 = addend.high >>> 16; + var b32 = addend.high & 65535; + var b16 = addend.low >>> 16; + var b00 = addend.low & 65535; + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 + b48; + c48 &= 65535; + return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); + }; + LongPrototype.subtract = function subtract(subtrahend) { + if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend); + return this.add(subtrahend.neg()); + }; + LongPrototype.sub = LongPrototype.subtract; + LongPrototype.multiply = function multiply(multiplier) { + if (this.isZero()) return this; + if (!isLong(multiplier)) multiplier = fromValue(multiplier); + if (wasm) { + var low = wasm["mul"]( + this.low, + this.high, + multiplier.low, + multiplier.high + ); + return fromBits(low, wasm["get_high"](), this.unsigned); + } + if (multiplier.isZero()) return this.unsigned ? UZERO : ZERO; + if (this.eq(MIN_VALUE)) return multiplier.isOdd() ? MIN_VALUE : ZERO; + if (multiplier.eq(MIN_VALUE)) return this.isOdd() ? MIN_VALUE : ZERO; + if (this.isNegative()) { + if (multiplier.isNegative()) return this.neg().mul(multiplier.neg()); + else return this.neg().mul(multiplier).neg(); + } else if (multiplier.isNegative()) + return this.mul(multiplier.neg()).neg(); + if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24)) + return fromNumber( + this.toNumber() * multiplier.toNumber(), + this.unsigned + ); + var a48 = this.high >>> 16; + var a32 = this.high & 65535; + var a16 = this.low >>> 16; + var a00 = this.low & 65535; + var b48 = multiplier.high >>> 16; + var b32 = multiplier.high & 65535; + var b16 = multiplier.low >>> 16; + var b00 = multiplier.low & 65535; + var c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 65535; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 65535; + return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); + }; + LongPrototype.mul = LongPrototype.multiply; + LongPrototype.divide = function divide(divisor) { + if (!isLong(divisor)) divisor = fromValue(divisor); + if (divisor.isZero()) throw Error("division by zero"); + if (wasm) { + if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) { + return this; + } + var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])( + this.low, + this.high, + divisor.low, + divisor.high + ); + return fromBits(low, wasm["get_high"](), this.unsigned); + } + if (this.isZero()) return this.unsigned ? UZERO : ZERO; + var approx, rem, res; + if (!this.unsigned) { + if (this.eq(MIN_VALUE)) { + if (divisor.eq(ONE) || divisor.eq(NEG_ONE)) + return MIN_VALUE; + else if (divisor.eq(MIN_VALUE)) return ONE; + else { + var halfThis = this.shr(1); + approx = halfThis.div(divisor).shl(1); + if (approx.eq(ZERO)) { + return divisor.isNegative() ? ONE : NEG_ONE; + } else { + rem = this.sub(divisor.mul(approx)); + res = approx.add(rem.div(divisor)); + return res; + } + } + } else if (divisor.eq(MIN_VALUE)) return this.unsigned ? UZERO : ZERO; + if (this.isNegative()) { + if (divisor.isNegative()) return this.neg().div(divisor.neg()); + return this.neg().div(divisor).neg(); + } else if (divisor.isNegative()) return this.div(divisor.neg()).neg(); + res = ZERO; + } else { + if (!divisor.unsigned) divisor = divisor.toUnsigned(); + if (divisor.gt(this)) return UZERO; + if (divisor.gt(this.shru(1))) + return UONE; + res = UZERO; + } + rem = this; + while (rem.gte(divisor)) { + approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); + var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor); + while (approxRem.isNegative() || approxRem.gt(rem)) { + approx -= delta; + approxRes = fromNumber(approx, this.unsigned); + approxRem = approxRes.mul(divisor); + } + if (approxRes.isZero()) approxRes = ONE; + res = res.add(approxRes); + rem = rem.sub(approxRem); + } + return res; + }; + LongPrototype.div = LongPrototype.divide; + LongPrototype.modulo = function modulo(divisor) { + if (!isLong(divisor)) divisor = fromValue(divisor); + if (wasm) { + var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])( + this.low, + this.high, + divisor.low, + divisor.high + ); + return fromBits(low, wasm["get_high"](), this.unsigned); + } + return this.sub(this.div(divisor).mul(divisor)); + }; + LongPrototype.mod = LongPrototype.modulo; + LongPrototype.rem = LongPrototype.modulo; + LongPrototype.not = function not() { + return fromBits(~this.low, ~this.high, this.unsigned); + }; + LongPrototype.countLeadingZeros = function countLeadingZeros() { + return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32; + }; + LongPrototype.clz = LongPrototype.countLeadingZeros; + LongPrototype.countTrailingZeros = function countTrailingZeros() { + return this.low ? ctz32(this.low) : ctz32(this.high) + 32; + }; + LongPrototype.ctz = LongPrototype.countTrailingZeros; + LongPrototype.and = function and(other) { + if (!isLong(other)) other = fromValue(other); + return fromBits( + this.low & other.low, + this.high & other.high, + this.unsigned + ); + }; + LongPrototype.or = function or(other) { + if (!isLong(other)) other = fromValue(other); + return fromBits( + this.low | other.low, + this.high | other.high, + this.unsigned + ); + }; + LongPrototype.xor = function xor(other) { + if (!isLong(other)) other = fromValue(other); + return fromBits( + this.low ^ other.low, + this.high ^ other.high, + this.unsigned + ); + }; + LongPrototype.shiftLeft = function shiftLeft(numBits) { + if (isLong(numBits)) numBits = numBits.toInt(); + if ((numBits &= 63) === 0) return this; + else if (numBits < 32) + return fromBits( + this.low << numBits, + this.high << numBits | this.low >>> 32 - numBits, + this.unsigned + ); + else return fromBits(0, this.low << numBits - 32, this.unsigned); + }; + LongPrototype.shl = LongPrototype.shiftLeft; + LongPrototype.shiftRight = function shiftRight(numBits) { + if (isLong(numBits)) numBits = numBits.toInt(); + if ((numBits &= 63) === 0) return this; + else if (numBits < 32) + return fromBits( + this.low >>> numBits | this.high << 32 - numBits, + this.high >> numBits, + this.unsigned + ); + else + return fromBits( + this.high >> numBits - 32, + this.high >= 0 ? 0 : -1, + this.unsigned + ); + }; + LongPrototype.shr = LongPrototype.shiftRight; + LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) { + if (isLong(numBits)) numBits = numBits.toInt(); + if ((numBits &= 63) === 0) return this; + if (numBits < 32) + return fromBits( + this.low >>> numBits | this.high << 32 - numBits, + this.high >>> numBits, + this.unsigned + ); + if (numBits === 32) return fromBits(this.high, 0, this.unsigned); + return fromBits(this.high >>> numBits - 32, 0, this.unsigned); + }; + LongPrototype.shru = LongPrototype.shiftRightUnsigned; + LongPrototype.shr_u = LongPrototype.shiftRightUnsigned; + LongPrototype.rotateLeft = function rotateLeft(numBits) { + var b; + if (isLong(numBits)) numBits = numBits.toInt(); + if ((numBits &= 63) === 0) return this; + if (numBits === 32) return fromBits(this.high, this.low, this.unsigned); + if (numBits < 32) { + b = 32 - numBits; + return fromBits( + this.low << numBits | this.high >>> b, + this.high << numBits | this.low >>> b, + this.unsigned + ); + } + numBits -= 32; + b = 32 - numBits; + return fromBits( + this.high << numBits | this.low >>> b, + this.low << numBits | this.high >>> b, + this.unsigned + ); + }; + LongPrototype.rotl = LongPrototype.rotateLeft; + LongPrototype.rotateRight = function rotateRight(numBits) { + var b; + if (isLong(numBits)) numBits = numBits.toInt(); + if ((numBits &= 63) === 0) return this; + if (numBits === 32) return fromBits(this.high, this.low, this.unsigned); + if (numBits < 32) { + b = 32 - numBits; + return fromBits( + this.high << b | this.low >>> numBits, + this.low << b | this.high >>> numBits, + this.unsigned + ); + } + numBits -= 32; + b = 32 - numBits; + return fromBits( + this.low << b | this.high >>> numBits, + this.high << b | this.low >>> numBits, + this.unsigned + ); + }; + LongPrototype.rotr = LongPrototype.rotateRight; + LongPrototype.toSigned = function toSigned() { + if (!this.unsigned) return this; + return fromBits(this.low, this.high, false); + }; + LongPrototype.toUnsigned = function toUnsigned() { + if (this.unsigned) return this; + return fromBits(this.low, this.high, true); + }; + LongPrototype.toBytes = function toBytes(le) { + return le ? this.toBytesLE() : this.toBytesBE(); + }; + LongPrototype.toBytesLE = function toBytesLE() { + var hi = this.high, lo = this.low; + return [ + lo & 255, + lo >>> 8 & 255, + lo >>> 16 & 255, + lo >>> 24, + hi & 255, + hi >>> 8 & 255, + hi >>> 16 & 255, + hi >>> 24 + ]; + }; + LongPrototype.toBytesBE = function toBytesBE() { + var hi = this.high, lo = this.low; + return [ + hi >>> 24, + hi >>> 16 & 255, + hi >>> 8 & 255, + hi & 255, + lo >>> 24, + lo >>> 16 & 255, + lo >>> 8 & 255, + lo & 255 + ]; + }; + Long.fromBytes = function fromBytes(bytes, unsigned, le) { + return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned); + }; + Long.fromBytesLE = function fromBytesLE(bytes, unsigned) { + return new Long( + bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, + bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, + unsigned + ); + }; + Long.fromBytesBE = function fromBytesBE(bytes, unsigned) { + return new Long( + bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], + bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], + unsigned + ); + }; + if (typeof BigInt === "function") { + Long.fromBigInt = function fromBigInt(value, unsigned) { + var lowBits = Number(BigInt.asIntN(32, value)); + var highBits = Number(BigInt.asIntN(32, value >> BigInt(32))); + return fromBits(lowBits, highBits, unsigned); + }; + Long.fromValue = function fromValueWithBigInt(value, unsigned) { + if (typeof value === "bigint") return Long.fromBigInt(value, unsigned); + return fromValue(value, unsigned); + }; + LongPrototype.toBigInt = function toBigInt() { + var lowBigInt = BigInt(this.low >>> 0); + var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high); + return highBigInt << BigInt(32) | lowBigInt; + }; + } + var _default = _exports.default = Long; + } + ); + } +}); + +// node_modules/safer-buffer/safer.js +var require_safer = __commonJS({ + "node_modules/safer-buffer/safer.js"(exports2, module2) { + "use strict"; + var buffer = require("buffer"); + var Buffer2 = buffer.Buffer; + var safer = {}; + var key; + for (key in buffer) { + if (!buffer.hasOwnProperty(key)) continue; + if (key === "SlowBuffer" || key === "Buffer") continue; + safer[key] = buffer[key]; + } + var Safer = safer.Buffer = {}; + for (key in Buffer2) { + if (!Buffer2.hasOwnProperty(key)) continue; + if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue; + Safer[key] = Buffer2[key]; + } + safer.Buffer.prototype = Buffer2.prototype; + if (!Safer.from || Safer.from === Uint8Array.from) { + Safer.from = function(value, encodingOrOffset, length) { + if (typeof value === "number") { + throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value); + } + if (value && typeof value.length === "undefined") { + throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value); + } + return Buffer2(value, encodingOrOffset, length); + }; + } + if (!Safer.alloc) { + Safer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size); + } + if (size < 0 || size >= 2 * (1 << 30)) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + var buf = Buffer2(size); + if (!fill || fill.length === 0) { + buf.fill(0); + } else if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + return buf; + }; + } + if (!safer.kStringMaxLength) { + try { + safer.kStringMaxLength = process.binding("buffer").kStringMaxLength; + } catch (e) { + } + } + if (!safer.constants) { + safer.constants = { + MAX_LENGTH: safer.kMaxLength + }; + if (safer.kStringMaxLength) { + safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength; + } + } + module2.exports = safer; + } +}); + +// node_modules/iconv-lite/lib/bom-handling.js +var require_bom_handling = __commonJS({ + "node_modules/iconv-lite/lib/bom-handling.js"(exports2) { + "use strict"; + var BOMChar = "\uFEFF"; + exports2.PrependBOM = PrependBOMWrapper; + function PrependBOMWrapper(encoder, options) { + this.encoder = encoder; + this.addBOM = true; + } + PrependBOMWrapper.prototype.write = function(str) { + if (this.addBOM) { + str = BOMChar + str; + this.addBOM = false; + } + return this.encoder.write(str); + }; + PrependBOMWrapper.prototype.end = function() { + return this.encoder.end(); + }; + exports2.StripBOM = StripBOMWrapper; + function StripBOMWrapper(decoder, options) { + this.decoder = decoder; + this.pass = false; + this.options = options || {}; + } + StripBOMWrapper.prototype.write = function(buf) { + var res = this.decoder.write(buf); + if (this.pass || !res) { + return res; + } + if (res[0] === BOMChar) { + res = res.slice(1); + if (typeof this.options.stripBOM === "function") { + this.options.stripBOM(); + } + } + this.pass = true; + return res; + }; + StripBOMWrapper.prototype.end = function() { + return this.decoder.end(); + }; + } +}); + +// node_modules/iconv-lite/lib/helpers/merge-exports.js +var require_merge_exports = __commonJS({ + "node_modules/iconv-lite/lib/helpers/merge-exports.js"(exports2, module2) { + "use strict"; + var hasOwn = typeof Object.hasOwn === "undefined" ? Function.call.bind(Object.prototype.hasOwnProperty) : Object.hasOwn; + function mergeModules(target, module3) { + for (var key in module3) { + if (hasOwn(module3, key)) { + target[key] = module3[key]; + } + } + } + module2.exports = mergeModules; + } +}); + +// node_modules/iconv-lite/encodings/internal.js +var require_internal = __commonJS({ + "node_modules/iconv-lite/encodings/internal.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + module2.exports = { + // Encodings + utf8: { type: "_internal", bomAware: true }, + cesu8: { type: "_internal", bomAware: true }, + unicode11utf8: "utf8", + ucs2: { type: "_internal", bomAware: true }, + utf16le: "ucs2", + binary: { type: "_internal" }, + base64: { type: "_internal" }, + hex: { type: "_internal" }, + // Codec. + _internal: InternalCodec + }; + function InternalCodec(codecOptions, iconv) { + this.enc = codecOptions.encodingName; + this.bomAware = codecOptions.bomAware; + if (this.enc === "base64") { + this.encoder = InternalEncoderBase64; + } else if (this.enc === "utf8") { + this.encoder = InternalEncoderUtf8; + } else if (this.enc === "cesu8") { + this.enc = "utf8"; + this.encoder = InternalEncoderCesu8; + if (Buffer2.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") { + this.decoder = InternalDecoderCesu8; + this.defaultCharUnicode = iconv.defaultCharUnicode; + } + } + } + InternalCodec.prototype.encoder = InternalEncoder; + InternalCodec.prototype.decoder = InternalDecoder; + var StringDecoder = require("string_decoder").StringDecoder; + function InternalDecoder(options, codec) { + this.decoder = new StringDecoder(codec.enc); + } + InternalDecoder.prototype.write = function(buf) { + if (!Buffer2.isBuffer(buf)) { + buf = Buffer2.from(buf); + } + return this.decoder.write(buf); + }; + InternalDecoder.prototype.end = function() { + return this.decoder.end(); + }; + function InternalEncoder(options, codec) { + this.enc = codec.enc; + } + InternalEncoder.prototype.write = function(str) { + return Buffer2.from(str, this.enc); + }; + InternalEncoder.prototype.end = function() { + }; + function InternalEncoderBase64(options, codec) { + this.prevStr = ""; + } + InternalEncoderBase64.prototype.write = function(str) { + str = this.prevStr + str; + var completeQuads = str.length - str.length % 4; + this.prevStr = str.slice(completeQuads); + str = str.slice(0, completeQuads); + return Buffer2.from(str, "base64"); + }; + InternalEncoderBase64.prototype.end = function() { + return Buffer2.from(this.prevStr, "base64"); + }; + function InternalEncoderCesu8(options, codec) { + } + InternalEncoderCesu8.prototype.write = function(str) { + var buf = Buffer2.alloc(str.length * 3); + var bufIdx = 0; + for (var i = 0; i < str.length; i++) { + var charCode = str.charCodeAt(i); + if (charCode < 128) { + buf[bufIdx++] = charCode; + } else if (charCode < 2048) { + buf[bufIdx++] = 192 + (charCode >>> 6); + buf[bufIdx++] = 128 + (charCode & 63); + } else { + buf[bufIdx++] = 224 + (charCode >>> 12); + buf[bufIdx++] = 128 + (charCode >>> 6 & 63); + buf[bufIdx++] = 128 + (charCode & 63); + } + } + return buf.slice(0, bufIdx); + }; + InternalEncoderCesu8.prototype.end = function() { + }; + function InternalDecoderCesu8(options, codec) { + this.acc = 0; + this.contBytes = 0; + this.accBytes = 0; + this.defaultCharUnicode = codec.defaultCharUnicode; + } + InternalDecoderCesu8.prototype.write = function(buf) { + var acc = this.acc; + var contBytes = this.contBytes; + var accBytes = this.accBytes; + var res = ""; + for (var i = 0; i < buf.length; i++) { + var curByte = buf[i]; + if ((curByte & 192) !== 128) { + if (contBytes > 0) { + res += this.defaultCharUnicode; + contBytes = 0; + } + if (curByte < 128) { + res += String.fromCharCode(curByte); + } else if (curByte < 224) { + acc = curByte & 31; + contBytes = 1; + accBytes = 1; + } else if (curByte < 240) { + acc = curByte & 15; + contBytes = 2; + accBytes = 1; + } else { + res += this.defaultCharUnicode; + } + } else { + if (contBytes > 0) { + acc = acc << 6 | curByte & 63; + contBytes--; + accBytes++; + if (contBytes === 0) { + if (accBytes === 2 && acc < 128 && acc > 0) { + res += this.defaultCharUnicode; + } else if (accBytes === 3 && acc < 2048) { + res += this.defaultCharUnicode; + } else { + res += String.fromCharCode(acc); + } + } + } else { + res += this.defaultCharUnicode; + } + } + } + this.acc = acc; + this.contBytes = contBytes; + this.accBytes = accBytes; + return res; + }; + InternalDecoderCesu8.prototype.end = function() { + var res = 0; + if (this.contBytes > 0) { + res += this.defaultCharUnicode; + } + return res; + }; + function InternalEncoderUtf8(options, codec) { + this.highSurrogate = ""; + } + InternalEncoderUtf8.prototype.write = function(str) { + if (this.highSurrogate) { + str = this.highSurrogate + str; + this.highSurrogate = ""; + } + if (str.length > 0) { + var charCode = str.charCodeAt(str.length - 1); + if (charCode >= 55296 && charCode < 56320) { + this.highSurrogate = str[str.length - 1]; + str = str.slice(0, str.length - 1); + } + } + return Buffer2.from(str, this.enc); + }; + InternalEncoderUtf8.prototype.end = function() { + if (this.highSurrogate) { + var str = this.highSurrogate; + this.highSurrogate = ""; + return Buffer2.from(str, this.enc); + } + }; + } +}); + +// node_modules/iconv-lite/encodings/utf32.js +var require_utf32 = __commonJS({ + "node_modules/iconv-lite/encodings/utf32.js"(exports2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + exports2._utf32 = Utf32Codec; + function Utf32Codec(codecOptions, iconv) { + this.iconv = iconv; + this.bomAware = true; + this.isLE = codecOptions.isLE; + } + exports2.utf32le = { type: "_utf32", isLE: true }; + exports2.utf32be = { type: "_utf32", isLE: false }; + exports2.ucs4le = "utf32le"; + exports2.ucs4be = "utf32be"; + Utf32Codec.prototype.encoder = Utf32Encoder; + Utf32Codec.prototype.decoder = Utf32Decoder; + function Utf32Encoder(options, codec) { + this.isLE = codec.isLE; + this.highSurrogate = 0; + } + Utf32Encoder.prototype.write = function(str) { + var src = Buffer2.from(str, "ucs2"); + var dst = Buffer2.alloc(src.length * 2 + 4); + var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE; + var offset = 0; + for (var i = 0; i < src.length; i += 2) { + var code = src.readUInt16LE(i); + var isHighSurrogate = code >= 55296 && code < 56320; + var isLowSurrogate = code >= 56320 && code < 57344; + if (this.highSurrogate) { + if (isHighSurrogate || !isLowSurrogate) { + write32.call(dst, this.highSurrogate, offset); + offset += 4; + } else { + var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536; + write32.call(dst, codepoint, offset); + offset += 4; + this.highSurrogate = 0; + continue; + } + } + if (isHighSurrogate) { + this.highSurrogate = code; + } else { + write32.call(dst, code, offset); + offset += 4; + this.highSurrogate = 0; + } + } + if (offset < dst.length) { + dst = dst.slice(0, offset); + } + return dst; + }; + Utf32Encoder.prototype.end = function() { + if (!this.highSurrogate) { + return; + } + var buf = Buffer2.alloc(4); + if (this.isLE) { + buf.writeUInt32LE(this.highSurrogate, 0); + } else { + buf.writeUInt32BE(this.highSurrogate, 0); + } + this.highSurrogate = 0; + return buf; + }; + function Utf32Decoder(options, codec) { + this.isLE = codec.isLE; + this.badChar = codec.iconv.defaultCharUnicode.charCodeAt(0); + this.overflow = []; + } + Utf32Decoder.prototype.write = function(src) { + if (src.length === 0) { + return ""; + } + var i = 0; + var codepoint = 0; + var dst = Buffer2.alloc(src.length + 4); + var offset = 0; + var isLE = this.isLE; + var overflow = this.overflow; + var badChar = this.badChar; + if (overflow.length > 0) { + for (; i < src.length && overflow.length < 4; i++) { + overflow.push(src[i]); + } + if (overflow.length === 4) { + if (isLE) { + codepoint = overflow[0] | overflow[1] << 8 | overflow[2] << 16 | overflow[3] << 24; + } else { + codepoint = overflow[3] | overflow[2] << 8 | overflow[1] << 16 | overflow[0] << 24; + } + overflow.length = 0; + offset = _writeCodepoint(dst, offset, codepoint, badChar); + } + } + for (; i < src.length - 3; i += 4) { + if (isLE) { + codepoint = src[i] | src[i + 1] << 8 | src[i + 2] << 16 | src[i + 3] << 24; + } else { + codepoint = src[i + 3] | src[i + 2] << 8 | src[i + 1] << 16 | src[i] << 24; + } + offset = _writeCodepoint(dst, offset, codepoint, badChar); + } + for (; i < src.length; i++) { + overflow.push(src[i]); + } + return dst.slice(0, offset).toString("ucs2"); + }; + function _writeCodepoint(dst, offset, codepoint, badChar) { + if (codepoint < 0 || codepoint > 1114111) { + codepoint = badChar; + } + if (codepoint >= 65536) { + codepoint -= 65536; + var high = 55296 | codepoint >> 10; + dst[offset++] = high & 255; + dst[offset++] = high >> 8; + var codepoint = 56320 | codepoint & 1023; + } + dst[offset++] = codepoint & 255; + dst[offset++] = codepoint >> 8; + return offset; + } + Utf32Decoder.prototype.end = function() { + if (this.overflow.length === 0) { + return; + } + this.overflow.length = 0; + return String.fromCharCode(this.badChar); + }; + exports2.utf32 = Utf32AutoCodec; + exports2.ucs4 = "utf32"; + function Utf32AutoCodec(options, iconv) { + this.iconv = iconv; + } + Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder; + Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder; + function Utf32AutoEncoder(options, codec) { + options = options || {}; + if (options.addBOM === void 0) { + options.addBOM = true; + } + this.encoder = codec.iconv.getEncoder(options.defaultEncoding || "utf-32le", options); + } + Utf32AutoEncoder.prototype.write = function(str) { + return this.encoder.write(str); + }; + Utf32AutoEncoder.prototype.end = function() { + return this.encoder.end(); + }; + function Utf32AutoDecoder(options, codec) { + this.decoder = null; + this.initialBufs = []; + this.initialBufsLen = 0; + this.options = options || {}; + this.iconv = codec.iconv; + } + Utf32AutoDecoder.prototype.write = function(buf) { + if (!this.decoder) { + this.initialBufs.push(buf); + this.initialBufsLen += buf.length; + if (this.initialBufsLen < 32) { + return ""; + } + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + var resStr = ""; + for (var i = 0; i < this.initialBufs.length; i++) { + resStr += this.decoder.write(this.initialBufs[i]); + } + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + return this.decoder.write(buf); + }; + Utf32AutoDecoder.prototype.end = function() { + if (!this.decoder) { + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + var resStr = ""; + for (var i = 0; i < this.initialBufs.length; i++) { + resStr += this.decoder.write(this.initialBufs[i]); + } + var trail = this.decoder.end(); + if (trail) { + resStr += trail; + } + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + return this.decoder.end(); + }; + function detectEncoding(bufs, defaultEncoding) { + var b = []; + var charsProcessed = 0; + var invalidLE = 0; + var invalidBE = 0; + var bmpCharsLE = 0; + var bmpCharsBE = 0; + outerLoop: + for (var i = 0; i < bufs.length; i++) { + var buf = bufs[i]; + for (var j = 0; j < buf.length; j++) { + b.push(buf[j]); + if (b.length === 4) { + if (charsProcessed === 0) { + if (b[0] === 255 && b[1] === 254 && b[2] === 0 && b[3] === 0) { + return "utf-32le"; + } + if (b[0] === 0 && b[1] === 0 && b[2] === 254 && b[3] === 255) { + return "utf-32be"; + } + } + if (b[0] !== 0 || b[1] > 16) invalidBE++; + if (b[3] !== 0 || b[2] > 16) invalidLE++; + if (b[0] === 0 && b[1] === 0 && (b[2] !== 0 || b[3] !== 0)) bmpCharsBE++; + if ((b[0] !== 0 || b[1] !== 0) && b[2] === 0 && b[3] === 0) bmpCharsLE++; + b.length = 0; + charsProcessed++; + if (charsProcessed >= 100) { + break outerLoop; + } + } + } + } + if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return "utf-32be"; + if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return "utf-32le"; + return defaultEncoding || "utf-32le"; + } + } +}); + +// node_modules/iconv-lite/encodings/utf16.js +var require_utf16 = __commonJS({ + "node_modules/iconv-lite/encodings/utf16.js"(exports2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + exports2.utf16be = Utf16BECodec; + function Utf16BECodec() { + } + Utf16BECodec.prototype.encoder = Utf16BEEncoder; + Utf16BECodec.prototype.decoder = Utf16BEDecoder; + Utf16BECodec.prototype.bomAware = true; + function Utf16BEEncoder() { + } + Utf16BEEncoder.prototype.write = function(str) { + var buf = Buffer2.from(str, "ucs2"); + for (var i = 0; i < buf.length; i += 2) { + var tmp = buf[i]; + buf[i] = buf[i + 1]; + buf[i + 1] = tmp; + } + return buf; + }; + Utf16BEEncoder.prototype.end = function() { + }; + function Utf16BEDecoder() { + this.overflowByte = -1; + } + Utf16BEDecoder.prototype.write = function(buf) { + if (buf.length == 0) { + return ""; + } + var buf2 = Buffer2.alloc(buf.length + 1); + var i = 0; + var j = 0; + if (this.overflowByte !== -1) { + buf2[0] = buf[0]; + buf2[1] = this.overflowByte; + i = 1; + j = 2; + } + for (; i < buf.length - 1; i += 2, j += 2) { + buf2[j] = buf[i + 1]; + buf2[j + 1] = buf[i]; + } + this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1; + return buf2.slice(0, j).toString("ucs2"); + }; + Utf16BEDecoder.prototype.end = function() { + this.overflowByte = -1; + }; + exports2.utf16 = Utf16Codec; + function Utf16Codec(codecOptions, iconv) { + this.iconv = iconv; + } + Utf16Codec.prototype.encoder = Utf16Encoder; + Utf16Codec.prototype.decoder = Utf16Decoder; + function Utf16Encoder(options, codec) { + options = options || {}; + if (options.addBOM === void 0) { + options.addBOM = true; + } + this.encoder = codec.iconv.getEncoder("utf-16le", options); + } + Utf16Encoder.prototype.write = function(str) { + return this.encoder.write(str); + }; + Utf16Encoder.prototype.end = function() { + return this.encoder.end(); + }; + function Utf16Decoder(options, codec) { + this.decoder = null; + this.initialBufs = []; + this.initialBufsLen = 0; + this.options = options || {}; + this.iconv = codec.iconv; + } + Utf16Decoder.prototype.write = function(buf) { + if (!this.decoder) { + this.initialBufs.push(buf); + this.initialBufsLen += buf.length; + if (this.initialBufsLen < 16) { + return ""; + } + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + var resStr = ""; + for (var i = 0; i < this.initialBufs.length; i++) { + resStr += this.decoder.write(this.initialBufs[i]); + } + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + return this.decoder.write(buf); + }; + Utf16Decoder.prototype.end = function() { + if (!this.decoder) { + var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding); + this.decoder = this.iconv.getDecoder(encoding, this.options); + var resStr = ""; + for (var i = 0; i < this.initialBufs.length; i++) { + resStr += this.decoder.write(this.initialBufs[i]); + } + var trail = this.decoder.end(); + if (trail) { + resStr += trail; + } + this.initialBufs.length = this.initialBufsLen = 0; + return resStr; + } + return this.decoder.end(); + }; + function detectEncoding(bufs, defaultEncoding) { + var b = []; + var charsProcessed = 0; + var asciiCharsLE = 0; + var asciiCharsBE = 0; + outerLoop: + for (var i = 0; i < bufs.length; i++) { + var buf = bufs[i]; + for (var j = 0; j < buf.length; j++) { + b.push(buf[j]); + if (b.length === 2) { + if (charsProcessed === 0) { + if (b[0] === 255 && b[1] === 254) return "utf-16le"; + if (b[0] === 254 && b[1] === 255) return "utf-16be"; + } + if (b[0] === 0 && b[1] !== 0) asciiCharsBE++; + if (b[0] !== 0 && b[1] === 0) asciiCharsLE++; + b.length = 0; + charsProcessed++; + if (charsProcessed >= 100) { + break outerLoop; + } + } + } + } + if (asciiCharsBE > asciiCharsLE) return "utf-16be"; + if (asciiCharsBE < asciiCharsLE) return "utf-16le"; + return defaultEncoding || "utf-16le"; + } + } +}); + +// node_modules/iconv-lite/encodings/utf7.js +var require_utf7 = __commonJS({ + "node_modules/iconv-lite/encodings/utf7.js"(exports2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + exports2.utf7 = Utf7Codec; + exports2.unicode11utf7 = "utf7"; + function Utf7Codec(codecOptions, iconv) { + this.iconv = iconv; + } + Utf7Codec.prototype.encoder = Utf7Encoder; + Utf7Codec.prototype.decoder = Utf7Decoder; + Utf7Codec.prototype.bomAware = true; + var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g; + function Utf7Encoder(options, codec) { + this.iconv = codec.iconv; + } + Utf7Encoder.prototype.write = function(str) { + return Buffer2.from(str.replace(nonDirectChars, function(chunk) { + return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-"; + }.bind(this))); + }; + Utf7Encoder.prototype.end = function() { + }; + function Utf7Decoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = ""; + } + var base64Regex = /[A-Za-z0-9\/+]/; + var base64Chars = []; + for (i = 0; i < 256; i++) { + base64Chars[i] = base64Regex.test(String.fromCharCode(i)); + } + var i; + var plusChar = "+".charCodeAt(0); + var minusChar = "-".charCodeAt(0); + var andChar = "&".charCodeAt(0); + Utf7Decoder.prototype.write = function(buf) { + var res = ""; + var lastI = 0; + var inBase64 = this.inBase64; + var base64Accum = this.base64Accum; + for (var i2 = 0; i2 < buf.length; i2++) { + if (!inBase64) { + if (buf[i2] == plusChar) { + res += this.iconv.decode(buf.slice(lastI, i2), "ascii"); + lastI = i2 + 1; + inBase64 = true; + } + } else { + if (!base64Chars[buf[i2]]) { + if (i2 == lastI && buf[i2] == minusChar) { + res += "+"; + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii"); + res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be"); + } + if (buf[i2] != minusChar) { + i2--; + } + lastI = i2 + 1; + inBase64 = false; + base64Accum = ""; + } + } + } + if (!inBase64) { + res += this.iconv.decode(buf.slice(lastI), "ascii"); + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii"); + var canBeDecoded = b64str.length - b64str.length % 8; + base64Accum = b64str.slice(canBeDecoded); + b64str = b64str.slice(0, canBeDecoded); + res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be"); + } + this.inBase64 = inBase64; + this.base64Accum = base64Accum; + return res; + }; + Utf7Decoder.prototype.end = function() { + var res = ""; + if (this.inBase64 && this.base64Accum.length > 0) { + res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be"); + } + this.inBase64 = false; + this.base64Accum = ""; + return res; + }; + exports2.utf7imap = Utf7IMAPCodec; + function Utf7IMAPCodec(codecOptions, iconv) { + this.iconv = iconv; + } + Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder; + Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder; + Utf7IMAPCodec.prototype.bomAware = true; + function Utf7IMAPEncoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = Buffer2.alloc(6); + this.base64AccumIdx = 0; + } + Utf7IMAPEncoder.prototype.write = function(str) { + var inBase64 = this.inBase64; + var base64Accum = this.base64Accum; + var base64AccumIdx = this.base64AccumIdx; + var buf = Buffer2.alloc(str.length * 5 + 10); + var bufIdx = 0; + for (var i2 = 0; i2 < str.length; i2++) { + var uChar = str.charCodeAt(i2); + if (uChar >= 32 && uChar <= 126) { + if (inBase64) { + if (base64AccumIdx > 0) { + bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx); + base64AccumIdx = 0; + } + buf[bufIdx++] = minusChar; + inBase64 = false; + } + if (!inBase64) { + buf[bufIdx++] = uChar; + if (uChar === andChar) { + buf[bufIdx++] = minusChar; + } + } + } else { + if (!inBase64) { + buf[bufIdx++] = andChar; + inBase64 = true; + } + if (inBase64) { + base64Accum[base64AccumIdx++] = uChar >> 8; + base64Accum[base64AccumIdx++] = uChar & 255; + if (base64AccumIdx == base64Accum.length) { + bufIdx += buf.write(base64Accum.toString("base64").replace(/\//g, ","), bufIdx); + base64AccumIdx = 0; + } + } + } + } + this.inBase64 = inBase64; + this.base64AccumIdx = base64AccumIdx; + return buf.slice(0, bufIdx); + }; + Utf7IMAPEncoder.prototype.end = function() { + var buf = Buffer2.alloc(10); + var bufIdx = 0; + if (this.inBase64) { + if (this.base64AccumIdx > 0) { + bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx); + this.base64AccumIdx = 0; + } + buf[bufIdx++] = minusChar; + this.inBase64 = false; + } + return buf.slice(0, bufIdx); + }; + function Utf7IMAPDecoder(options, codec) { + this.iconv = codec.iconv; + this.inBase64 = false; + this.base64Accum = ""; + } + var base64IMAPChars = base64Chars.slice(); + base64IMAPChars[",".charCodeAt(0)] = true; + Utf7IMAPDecoder.prototype.write = function(buf) { + var res = ""; + var lastI = 0; + var inBase64 = this.inBase64; + var base64Accum = this.base64Accum; + for (var i2 = 0; i2 < buf.length; i2++) { + if (!inBase64) { + if (buf[i2] == andChar) { + res += this.iconv.decode(buf.slice(lastI, i2), "ascii"); + lastI = i2 + 1; + inBase64 = true; + } + } else { + if (!base64IMAPChars[buf[i2]]) { + if (i2 == lastI && buf[i2] == minusChar) { + res += "&"; + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), "ascii").replace(/,/g, "/"); + res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be"); + } + if (buf[i2] != minusChar) { + i2--; + } + lastI = i2 + 1; + inBase64 = false; + base64Accum = ""; + } + } + } + if (!inBase64) { + res += this.iconv.decode(buf.slice(lastI), "ascii"); + } else { + var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii").replace(/,/g, "/"); + var canBeDecoded = b64str.length - b64str.length % 8; + base64Accum = b64str.slice(canBeDecoded); + b64str = b64str.slice(0, canBeDecoded); + res += this.iconv.decode(Buffer2.from(b64str, "base64"), "utf16-be"); + } + this.inBase64 = inBase64; + this.base64Accum = base64Accum; + return res; + }; + Utf7IMAPDecoder.prototype.end = function() { + var res = ""; + if (this.inBase64 && this.base64Accum.length > 0) { + res = this.iconv.decode(Buffer2.from(this.base64Accum, "base64"), "utf16-be"); + } + this.inBase64 = false; + this.base64Accum = ""; + return res; + }; + } +}); + +// node_modules/iconv-lite/encodings/sbcs-codec.js +var require_sbcs_codec = __commonJS({ + "node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + exports2._sbcs = SBCSCodec; + function SBCSCodec(codecOptions, iconv) { + if (!codecOptions) { + throw new Error("SBCS codec is called without the data."); + } + if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256) { + throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)"); + } + if (codecOptions.chars.length === 128) { + var asciiString = ""; + for (var i = 0; i < 128; i++) { + asciiString += String.fromCharCode(i); + } + codecOptions.chars = asciiString + codecOptions.chars; + } + this.decodeBuf = Buffer2.from(codecOptions.chars, "ucs2"); + var encodeBuf = Buffer2.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0)); + for (var i = 0; i < codecOptions.chars.length; i++) { + encodeBuf[codecOptions.chars.charCodeAt(i)] = i; + } + this.encodeBuf = encodeBuf; + } + SBCSCodec.prototype.encoder = SBCSEncoder; + SBCSCodec.prototype.decoder = SBCSDecoder; + function SBCSEncoder(options, codec) { + this.encodeBuf = codec.encodeBuf; + } + SBCSEncoder.prototype.write = function(str) { + var buf = Buffer2.alloc(str.length); + for (var i = 0; i < str.length; i++) { + buf[i] = this.encodeBuf[str.charCodeAt(i)]; + } + return buf; + }; + SBCSEncoder.prototype.end = function() { + }; + function SBCSDecoder(options, codec) { + this.decodeBuf = codec.decodeBuf; + } + SBCSDecoder.prototype.write = function(buf) { + var decodeBuf = this.decodeBuf; + var newBuf = Buffer2.alloc(buf.length * 2); + var idx1 = 0; + var idx2 = 0; + for (var i = 0; i < buf.length; i++) { + idx1 = buf[i] * 2; + idx2 = i * 2; + newBuf[idx2] = decodeBuf[idx1]; + newBuf[idx2 + 1] = decodeBuf[idx1 + 1]; + } + return newBuf.toString("ucs2"); + }; + SBCSDecoder.prototype.end = function() { + }; + } +}); + +// node_modules/iconv-lite/encodings/sbcs-data.js +var require_sbcs_data = __commonJS({ + "node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module2) { + "use strict"; + module2.exports = { + // Not supported by iconv, not sure why. + 10029: "maccenteuro", + maccenteuro: { + type: "_sbcs", + chars: "\xC4\u0100\u0101\xC9\u0104\xD6\xDC\xE1\u0105\u010C\xE4\u010D\u0106\u0107\xE9\u0179\u017A\u010E\xED\u010F\u0112\u0113\u0116\xF3\u0117\xF4\xF6\xF5\xFA\u011A\u011B\xFC\u2020\xB0\u0118\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\u0119\xA8\u2260\u0123\u012E\u012F\u012A\u2264\u2265\u012B\u0136\u2202\u2211\u0142\u013B\u013C\u013D\u013E\u0139\u013A\u0145\u0146\u0143\xAC\u221A\u0144\u0147\u2206\xAB\xBB\u2026\xA0\u0148\u0150\xD5\u0151\u014C\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\u014D\u0154\u0155\u0158\u2039\u203A\u0159\u0156\u0157\u0160\u201A\u201E\u0161\u015A\u015B\xC1\u0164\u0165\xCD\u017D\u017E\u016A\xD3\xD4\u016B\u016E\xDA\u016F\u0170\u0171\u0172\u0173\xDD\xFD\u0137\u017B\u0141\u017C\u0122\u02C7" + }, + 808: "cp808", + ibm808: "cp808", + cp808: { + type: "_sbcs", + chars: "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\u20AC\u25A0\xA0" + }, + mik: { + type: "_sbcs", + chars: "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2514\u2534\u252C\u251C\u2500\u253C\u2563\u2551\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2510\u2591\u2592\u2593\u2502\u2524\u2116\xA7\u2557\u255D\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + cp720: { + type: "_sbcs", + chars: "\x80\x81\xE9\xE2\x84\xE0\x86\xE7\xEA\xEB\xE8\xEF\xEE\x8D\x8E\x8F\x90\u0651\u0652\xF4\xA4\u0640\xFB\xF9\u0621\u0622\u0623\u0624\xA3\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0636\u0637\u0638\u0639\u063A\u0641\xB5\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u2261\u064B\u064C\u064D\u064E\u064F\u0650\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + // Aliases of generated encodings. + ascii8bit: "ascii", + usascii: "ascii", + ansix34: "ascii", + ansix341968: "ascii", + ansix341986: "ascii", + csascii: "ascii", + cp367: "ascii", + ibm367: "ascii", + isoir6: "ascii", + iso646us: "ascii", + iso646irv: "ascii", + us: "ascii", + latin1: "iso88591", + latin2: "iso88592", + latin3: "iso88593", + latin4: "iso88594", + latin5: "iso88599", + latin6: "iso885910", + latin7: "iso885913", + latin8: "iso885914", + latin9: "iso885915", + latin10: "iso885916", + csisolatin1: "iso88591", + csisolatin2: "iso88592", + csisolatin3: "iso88593", + csisolatin4: "iso88594", + csisolatincyrillic: "iso88595", + csisolatinarabic: "iso88596", + csisolatingreek: "iso88597", + csisolatinhebrew: "iso88598", + csisolatin5: "iso88599", + csisolatin6: "iso885910", + l1: "iso88591", + l2: "iso88592", + l3: "iso88593", + l4: "iso88594", + l5: "iso88599", + l6: "iso885910", + l7: "iso885913", + l8: "iso885914", + l9: "iso885915", + l10: "iso885916", + isoir14: "iso646jp", + isoir57: "iso646cn", + isoir100: "iso88591", + isoir101: "iso88592", + isoir109: "iso88593", + isoir110: "iso88594", + isoir144: "iso88595", + isoir127: "iso88596", + isoir126: "iso88597", + isoir138: "iso88598", + isoir148: "iso88599", + isoir157: "iso885910", + isoir166: "tis620", + isoir179: "iso885913", + isoir199: "iso885914", + isoir203: "iso885915", + isoir226: "iso885916", + cp819: "iso88591", + ibm819: "iso88591", + cyrillic: "iso88595", + arabic: "iso88596", + arabic8: "iso88596", + ecma114: "iso88596", + asmo708: "iso88596", + greek: "iso88597", + greek8: "iso88597", + ecma118: "iso88597", + elot928: "iso88597", + hebrew: "iso88598", + hebrew8: "iso88598", + iso88598i: "iso88598", + iso88598e: "iso88598", + turkish: "iso88599", + turkish8: "iso88599", + thai: "iso885911", + thai8: "iso885911", + celtic: "iso885914", + celtic8: "iso885914", + isoceltic: "iso885914", + tis6200: "tis620", + tis62025291: "tis620", + tis62025330: "tis620", + 1e4: "macroman", + 10006: "macgreek", + 10007: "maccyrillic", + 10079: "maciceland", + 10081: "macturkish", + cspc8codepage437: "cp437", + cspc775baltic: "cp775", + cspc850multilingual: "cp850", + cspcp852: "cp852", + cspc862latinhebrew: "cp862", + cpgr: "cp869", + msee: "cp1250", + mscyrl: "cp1251", + msansi: "cp1252", + msgreek: "cp1253", + msturk: "cp1254", + mshebr: "cp1255", + msarab: "cp1256", + winbaltrim: "cp1257", + cp20866: "koi8r", + 20866: "koi8r", + ibm878: "koi8r", + cskoi8r: "koi8r", + cp21866: "koi8u", + 21866: "koi8u", + ibm1168: "koi8u", + strk10482002: "rk1048", + tcvn5712: "tcvn", + tcvn57121: "tcvn", + gb198880: "iso646cn", + cn: "iso646cn", + csiso14jisc6220ro: "iso646jp", + jisc62201969ro: "iso646jp", + jp: "iso646jp", + cshproman8: "hproman8", + r8: "hproman8", + roman8: "hproman8", + xroman8: "hproman8", + ibm1051: "hproman8", + mac: "macintosh", + csmacintosh: "macintosh" + }; + } +}); + +// node_modules/iconv-lite/encodings/sbcs-data-generated.js +var require_sbcs_data_generated = __commonJS({ + "node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module2) { + "use strict"; + module2.exports = { + "437": "cp437", + "737": "cp737", + "775": "cp775", + "850": "cp850", + "852": "cp852", + "855": "cp855", + "856": "cp856", + "857": "cp857", + "858": "cp858", + "860": "cp860", + "861": "cp861", + "862": "cp862", + "863": "cp863", + "864": "cp864", + "865": "cp865", + "866": "cp866", + "869": "cp869", + "874": "windows874", + "922": "cp922", + "1046": "cp1046", + "1124": "cp1124", + "1125": "cp1125", + "1129": "cp1129", + "1133": "cp1133", + "1161": "cp1161", + "1162": "cp1162", + "1163": "cp1163", + "1250": "windows1250", + "1251": "windows1251", + "1252": "windows1252", + "1253": "windows1253", + "1254": "windows1254", + "1255": "windows1255", + "1256": "windows1256", + "1257": "windows1257", + "1258": "windows1258", + "28591": "iso88591", + "28592": "iso88592", + "28593": "iso88593", + "28594": "iso88594", + "28595": "iso88595", + "28596": "iso88596", + "28597": "iso88597", + "28598": "iso88598", + "28599": "iso88599", + "28600": "iso885910", + "28601": "iso885911", + "28603": "iso885913", + "28604": "iso885914", + "28605": "iso885915", + "28606": "iso885916", + "windows874": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\uFFFD\uFFFD\uFFFD\u2026\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "win874": "windows874", + "cp874": "windows874", + "windows1250": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\u0160\u2039\u015A\u0164\u017D\u0179\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0161\u203A\u015B\u0165\u017E\u017A\xA0\u02C7\u02D8\u0141\xA4\u0104\xA6\xA7\xA8\xA9\u015E\xAB\xAC\xAD\xAE\u017B\xB0\xB1\u02DB\u0142\xB4\xB5\xB6\xB7\xB8\u0105\u015F\xBB\u013D\u02DD\u013E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9" + }, + "win1250": "windows1250", + "cp1250": "windows1250", + "windows1251": { + "type": "_sbcs", + "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u040C\u040B\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u045C\u045B\u045F\xA0\u040E\u045E\u0408\xA4\u0490\xA6\xA7\u0401\xA9\u0404\xAB\xAC\xAD\xAE\u0407\xB0\xB1\u0406\u0456\u0491\xB5\xB6\xB7\u0451\u2116\u0454\xBB\u0458\u0405\u0455\u0457\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F" + }, + "win1251": "windows1251", + "cp1251": "windows1251", + "windows1252": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF" + }, + "win1252": "windows1252", + "cp1252": "windows1252", + "windows1253": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0385\u0386\xA3\xA4\xA5\xA6\xA7\xA8\xA9\uFFFD\xAB\xAC\xAD\xAE\u2015\xB0\xB1\xB2\xB3\u0384\xB5\xB6\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD" + }, + "win1253": "windows1253", + "cp1253": "windows1253", + "windows1254": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF" + }, + "win1254": "windows1254", + "cp1254": "windows1254", + "windows1255": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\xA1\xA2\xA3\u20AA\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\xBF\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD\u05BE\u05BF\u05C0\u05C1\u05C2\u05C3\u05F0\u05F1\u05F2\u05F3\u05F4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD" + }, + "win1255": "windows1255", + "cp1255": "windows1255", + "windows1256": { + "type": "_sbcs", + "chars": "\u20AC\u067E\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0679\u2039\u0152\u0686\u0698\u0688\u06AF\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u06A9\u2122\u0691\u203A\u0153\u200C\u200D\u06BA\xA0\u060C\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\u06BE\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\u061B\xBB\xBC\xBD\xBE\u061F\u06C1\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\xD7\u0637\u0638\u0639\u063A\u0640\u0641\u0642\u0643\xE0\u0644\xE2\u0645\u0646\u0647\u0648\xE7\xE8\xE9\xEA\xEB\u0649\u064A\xEE\xEF\u064B\u064C\u064D\u064E\xF4\u064F\u0650\xF7\u0651\xF9\u0652\xFB\xFC\u200E\u200F\u06D2" + }, + "win1256": "windows1256", + "cp1256": "windows1256", + "windows1257": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\xA8\u02C7\xB8\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\xAF\u02DB\uFFFD\xA0\uFFFD\xA2\xA3\xA4\uFFFD\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u02D9" + }, + "win1257": "windows1257", + "cp1257": "windows1257", + "windows1258": { + "type": "_sbcs", + "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF" + }, + "win1258": "windows1258", + "cp1258": "windows1258", + "iso88591": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF" + }, + "cp28591": "iso88591", + "iso88592": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u02D8\u0141\xA4\u013D\u015A\xA7\xA8\u0160\u015E\u0164\u0179\xAD\u017D\u017B\xB0\u0105\u02DB\u0142\xB4\u013E\u015B\u02C7\xB8\u0161\u015F\u0165\u017A\u02DD\u017E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9" + }, + "cp28592": "iso88592", + "iso88593": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0126\u02D8\xA3\xA4\uFFFD\u0124\xA7\xA8\u0130\u015E\u011E\u0134\xAD\uFFFD\u017B\xB0\u0127\xB2\xB3\xB4\xB5\u0125\xB7\xB8\u0131\u015F\u011F\u0135\xBD\uFFFD\u017C\xC0\xC1\xC2\uFFFD\xC4\u010A\u0108\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\uFFFD\xD1\xD2\xD3\xD4\u0120\xD6\xD7\u011C\xD9\xDA\xDB\xDC\u016C\u015C\xDF\xE0\xE1\xE2\uFFFD\xE4\u010B\u0109\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\uFFFD\xF1\xF2\xF3\xF4\u0121\xF6\xF7\u011D\xF9\xFA\xFB\xFC\u016D\u015D\u02D9" + }, + "cp28593": "iso88593", + "iso88594": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0138\u0156\xA4\u0128\u013B\xA7\xA8\u0160\u0112\u0122\u0166\xAD\u017D\xAF\xB0\u0105\u02DB\u0157\xB4\u0129\u013C\u02C7\xB8\u0161\u0113\u0123\u0167\u014A\u017E\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\u012A\u0110\u0145\u014C\u0136\xD4\xD5\xD6\xD7\xD8\u0172\xDA\xDB\xDC\u0168\u016A\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\u012B\u0111\u0146\u014D\u0137\xF4\xF5\xF6\xF7\xF8\u0173\xFA\xFB\xFC\u0169\u016B\u02D9" + }, + "cp28594": "iso88594", + "iso88595": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0453\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F" + }, + "cp28595": "iso88595", + "iso88596": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\uFFFD\uFFFD\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u060C\xAD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u061B\uFFFD\uFFFD\uFFFD\u061F\uFFFD\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "cp28596": "iso88596", + "iso88597": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u2018\u2019\xA3\u20AC\u20AF\xA6\xA7\xA8\xA9\u037A\xAB\xAC\xAD\uFFFD\u2015\xB0\xB1\xB2\xB3\u0384\u0385\u0386\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD" + }, + "cp28597": "iso88597", + "iso88598": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2017\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD" + }, + "cp28598": "iso88598", + "iso88599": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF" + }, + "cp28599": "iso88599", + "iso885910": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0112\u0122\u012A\u0128\u0136\xA7\u013B\u0110\u0160\u0166\u017D\xAD\u016A\u014A\xB0\u0105\u0113\u0123\u012B\u0129\u0137\xB7\u013C\u0111\u0161\u0167\u017E\u2015\u016B\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\xCF\xD0\u0145\u014C\xD3\xD4\xD5\xD6\u0168\xD8\u0172\xDA\xDB\xDC\xDD\xDE\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\xEF\xF0\u0146\u014D\xF3\xF4\xF5\xF6\u0169\xF8\u0173\xFA\xFB\xFC\xFD\xFE\u0138" + }, + "cp28600": "iso885910", + "iso885911": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "cp28601": "iso885911", + "iso885913": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u201D\xA2\xA3\xA4\u201E\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\u201C\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u2019" + }, + "cp28603": "iso885913", + "iso885914": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u1E02\u1E03\xA3\u010A\u010B\u1E0A\xA7\u1E80\xA9\u1E82\u1E0B\u1EF2\xAD\xAE\u0178\u1E1E\u1E1F\u0120\u0121\u1E40\u1E41\xB6\u1E56\u1E81\u1E57\u1E83\u1E60\u1EF3\u1E84\u1E85\u1E61\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0174\xD1\xD2\xD3\xD4\xD5\xD6\u1E6A\xD8\xD9\xDA\xDB\xDC\xDD\u0176\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0175\xF1\xF2\xF3\xF4\xF5\xF6\u1E6B\xF8\xF9\xFA\xFB\xFC\xFD\u0177\xFF" + }, + "cp28604": "iso885914", + "iso885915": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\u0160\xA7\u0161\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u017D\xB5\xB6\xB7\u017E\xB9\xBA\xBB\u0152\u0153\u0178\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF" + }, + "cp28605": "iso885915", + "iso885916": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0105\u0141\u20AC\u201E\u0160\xA7\u0161\xA9\u0218\xAB\u0179\xAD\u017A\u017B\xB0\xB1\u010C\u0142\u017D\u201D\xB6\xB7\u017E\u010D\u0219\xBB\u0152\u0153\u0178\u017C\xC0\xC1\xC2\u0102\xC4\u0106\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0110\u0143\xD2\xD3\xD4\u0150\xD6\u015A\u0170\xD9\xDA\xDB\xDC\u0118\u021A\xDF\xE0\xE1\xE2\u0103\xE4\u0107\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0111\u0144\xF2\xF3\xF4\u0151\xF6\u015B\u0171\xF9\xFA\xFB\xFC\u0119\u021B\xFF" + }, + "cp28606": "iso885916", + "cp437": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm437": "cp437", + "csibm437": "cp437", + "cp737": { + "type": "_sbcs", + "chars": "\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u03C5\u03C6\u03C7\u03C8\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03C9\u03AC\u03AD\u03AE\u03CA\u03AF\u03CC\u03CD\u03CB\u03CE\u0386\u0388\u0389\u038A\u038C\u038E\u038F\xB1\u2265\u2264\u03AA\u03AB\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm737": "cp737", + "csibm737": "cp737", + "cp775": { + "type": "_sbcs", + "chars": "\u0106\xFC\xE9\u0101\xE4\u0123\xE5\u0107\u0142\u0113\u0156\u0157\u012B\u0179\xC4\xC5\xC9\xE6\xC6\u014D\xF6\u0122\xA2\u015A\u015B\xD6\xDC\xF8\xA3\xD8\xD7\xA4\u0100\u012A\xF3\u017B\u017C\u017A\u201D\xA6\xA9\xAE\xAC\xBD\xBC\u0141\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0104\u010C\u0118\u0116\u2563\u2551\u2557\u255D\u012E\u0160\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0172\u016A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u017D\u0105\u010D\u0119\u0117\u012F\u0161\u0173\u016B\u017E\u2518\u250C\u2588\u2584\u258C\u2590\u2580\xD3\xDF\u014C\u0143\xF5\xD5\xB5\u0144\u0136\u0137\u013B\u013C\u0146\u0112\u0145\u2019\xAD\xB1\u201C\xBE\xB6\xA7\xF7\u201E\xB0\u2219\xB7\xB9\xB3\xB2\u25A0\xA0" + }, + "ibm775": "cp775", + "csibm775": "cp775", + "cp850": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u0131\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0" + }, + "ibm850": "cp850", + "csibm850": "cp850", + "cp852": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\u016F\u0107\xE7\u0142\xEB\u0150\u0151\xEE\u0179\xC4\u0106\xC9\u0139\u013A\xF4\xF6\u013D\u013E\u015A\u015B\xD6\xDC\u0164\u0165\u0141\xD7\u010D\xE1\xED\xF3\xFA\u0104\u0105\u017D\u017E\u0118\u0119\xAC\u017A\u010C\u015F\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\u011A\u015E\u2563\u2551\u2557\u255D\u017B\u017C\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0102\u0103\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u0111\u0110\u010E\xCB\u010F\u0147\xCD\xCE\u011B\u2518\u250C\u2588\u2584\u0162\u016E\u2580\xD3\xDF\xD4\u0143\u0144\u0148\u0160\u0161\u0154\xDA\u0155\u0170\xFD\xDD\u0163\xB4\xAD\u02DD\u02DB\u02C7\u02D8\xA7\xF7\xB8\xB0\xA8\u02D9\u0171\u0158\u0159\u25A0\xA0" + }, + "ibm852": "cp852", + "csibm852": "cp852", + "cp855": { + "type": "_sbcs", + "chars": "\u0452\u0402\u0453\u0403\u0451\u0401\u0454\u0404\u0455\u0405\u0456\u0406\u0457\u0407\u0458\u0408\u0459\u0409\u045A\u040A\u045B\u040B\u045C\u040C\u045E\u040E\u045F\u040F\u044E\u042E\u044A\u042A\u0430\u0410\u0431\u0411\u0446\u0426\u0434\u0414\u0435\u0415\u0444\u0424\u0433\u0413\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0445\u0425\u0438\u0418\u2563\u2551\u2557\u255D\u0439\u0419\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u043A\u041A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u043B\u041B\u043C\u041C\u043D\u041D\u043E\u041E\u043F\u2518\u250C\u2588\u2584\u041F\u044F\u2580\u042F\u0440\u0420\u0441\u0421\u0442\u0422\u0443\u0423\u0436\u0416\u0432\u0412\u044C\u042C\u2116\xAD\u044B\u042B\u0437\u0417\u0448\u0428\u044D\u042D\u0449\u0429\u0447\u0427\xA7\u25A0\xA0" + }, + "ibm855": "cp855", + "csibm855": "cp855", + "cp856": { + "type": "_sbcs", + "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\xA3\uFFFD\xD7\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAE\xAC\xBD\xBC\uFFFD\xAB\xBB\u2591\u2592\u2593\u2502\u2524\uFFFD\uFFFD\uFFFD\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\uFFFD\uFFFD\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2518\u250C\u2588\u2584\xA6\uFFFD\u2580\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xB5\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0" + }, + "ibm856": "cp856", + "csibm856": "cp856", + "cp857": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\u0131\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\u0130\xD6\xDC\xF8\xA3\xD8\u015E\u015F\xE1\xED\xF3\xFA\xF1\xD1\u011E\u011F\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xBA\xAA\xCA\xCB\xC8\uFFFD\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\uFFFD\xD7\xDA\xDB\xD9\xEC\xFF\xAF\xB4\xAD\xB1\uFFFD\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0" + }, + "ibm857": "cp857", + "csibm857": "cp857", + "cp858": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u20AC\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0" + }, + "ibm858": "cp858", + "csibm858": "cp858", + "cp860": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE3\xE0\xC1\xE7\xEA\xCA\xE8\xCD\xD4\xEC\xC3\xC2\xC9\xC0\xC8\xF4\xF5\xF2\xDA\xF9\xCC\xD5\xDC\xA2\xA3\xD9\u20A7\xD3\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xD2\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm860": "cp860", + "csibm860": "cp860", + "cp861": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xD0\xF0\xDE\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xFE\xFB\xDD\xFD\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xC1\xCD\xD3\xDA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm861": "cp861", + "csibm861": "cp861", + "cp862": { + "type": "_sbcs", + "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm862": "cp862", + "csibm862": "cp862", + "cp863": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xC2\xE0\xB6\xE7\xEA\xEB\xE8\xEF\xEE\u2017\xC0\xA7\xC9\xC8\xCA\xF4\xCB\xCF\xFB\xF9\xA4\xD4\xDC\xA2\xA3\xD9\xDB\u0192\xA6\xB4\xF3\xFA\xA8\xB8\xB3\xAF\xCE\u2310\xAC\xBD\xBC\xBE\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm863": "cp863", + "csibm863": "cp863", + "cp864": { + "type": "_sbcs", + "chars": "\0\x07\b \n\v\f\r\x1B !\"#$\u066A&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xB0\xB7\u2219\u221A\u2592\u2500\u2502\u253C\u2524\u252C\u251C\u2534\u2510\u250C\u2514\u2518\u03B2\u221E\u03C6\xB1\xBD\xBC\u2248\xAB\xBB\uFEF7\uFEF8\uFFFD\uFFFD\uFEFB\uFEFC\uFFFD\xA0\xAD\uFE82\xA3\xA4\uFE84\uFFFD\uFFFD\uFE8E\uFE8F\uFE95\uFE99\u060C\uFE9D\uFEA1\uFEA5\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFED1\u061B\uFEB1\uFEB5\uFEB9\u061F\xA2\uFE80\uFE81\uFE83\uFE85\uFECA\uFE8B\uFE8D\uFE91\uFE93\uFE97\uFE9B\uFE9F\uFEA3\uFEA7\uFEA9\uFEAB\uFEAD\uFEAF\uFEB3\uFEB7\uFEBB\uFEBF\uFEC1\uFEC5\uFECB\uFECF\xA6\xAC\xF7\xD7\uFEC9\u0640\uFED3\uFED7\uFEDB\uFEDF\uFEE3\uFEE7\uFEEB\uFEED\uFEEF\uFEF3\uFEBD\uFECC\uFECE\uFECD\uFEE1\uFE7D\u0651\uFEE5\uFEE9\uFEEC\uFEF0\uFEF2\uFED0\uFED5\uFEF5\uFEF6\uFEDD\uFED9\uFEF1\u25A0\uFFFD" + }, + "ibm864": "cp864", + "csibm864": "cp864", + "cp865": { + "type": "_sbcs", + "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xA4\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0" + }, + "ibm865": "cp865", + "csibm865": "cp865", + "cp866": { + "type": "_sbcs", + "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\xA4\u25A0\xA0" + }, + "ibm866": "cp866", + "csibm866": "cp866", + "cp869": { + "type": "_sbcs", + "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0386\uFFFD\xB7\xAC\xA6\u2018\u2019\u0388\u2015\u0389\u038A\u03AA\u038C\uFFFD\uFFFD\u038E\u03AB\xA9\u038F\xB2\xB3\u03AC\xA3\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03CD\u0391\u0392\u0393\u0394\u0395\u0396\u0397\xBD\u0398\u0399\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u039A\u039B\u039C\u039D\u2563\u2551\u2557\u255D\u039E\u039F\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u03A0\u03A1\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u2518\u250C\u2588\u2584\u03B4\u03B5\u2580\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u0384\xAD\xB1\u03C5\u03C6\u03C7\xA7\u03C8\u0385\xB0\xA8\u03C9\u03CB\u03B0\u03CE\u25A0\xA0" + }, + "ibm869": "cp869", + "csibm869": "cp869", + "cp922": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\u203E\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0160\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\u017D\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0161\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\u017E\xFF" + }, + "ibm922": "cp922", + "csibm922": "cp922", + "cp1046": { + "type": "_sbcs", + "chars": "\uFE88\xD7\xF7\uF8F6\uF8F5\uF8F4\uF8F7\uFE71\x88\u25A0\u2502\u2500\u2510\u250C\u2514\u2518\uFE79\uFE7B\uFE7D\uFE7F\uFE77\uFE8A\uFEF0\uFEF3\uFEF2\uFECE\uFECF\uFED0\uFEF6\uFEF8\uFEFA\uFEFC\xA0\uF8FA\uF8F9\uF8F8\xA4\uF8FB\uFE8B\uFE91\uFE97\uFE9B\uFE9F\uFEA3\u060C\xAD\uFEA7\uFEB3\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFEB7\u061B\uFEBB\uFEBF\uFECA\u061F\uFECB\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\uFEC7\u0639\u063A\uFECC\uFE82\uFE84\uFE8E\uFED3\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFED7\uFEDB\uFEDF\uF8FC\uFEF5\uFEF7\uFEF9\uFEFB\uFEE3\uFEE7\uFEEC\uFEE9\uFFFD" + }, + "ibm1046": "cp1046", + "csibm1046": "cp1046", + "cp1124": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0490\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0491\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F" + }, + "ibm1124": "cp1124", + "csibm1124": "cp1124", + "cp1125": { + "type": "_sbcs", + "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0490\u0491\u0404\u0454\u0406\u0456\u0407\u0457\xB7\u221A\u2116\xA4\u25A0\xA0" + }, + "ibm1125": "cp1125", + "csibm1125": "cp1125", + "cp1129": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF" + }, + "ibm1129": "cp1129", + "csibm1129": "cp1129", + "cp1133": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E81\u0E82\u0E84\u0E87\u0E88\u0EAA\u0E8A\u0E8D\u0E94\u0E95\u0E96\u0E97\u0E99\u0E9A\u0E9B\u0E9C\u0E9D\u0E9E\u0E9F\u0EA1\u0EA2\u0EA3\u0EA5\u0EA7\u0EAB\u0EAD\u0EAE\uFFFD\uFFFD\uFFFD\u0EAF\u0EB0\u0EB2\u0EB3\u0EB4\u0EB5\u0EB6\u0EB7\u0EB8\u0EB9\u0EBC\u0EB1\u0EBB\u0EBD\uFFFD\uFFFD\uFFFD\u0EC0\u0EC1\u0EC2\u0EC3\u0EC4\u0EC8\u0EC9\u0ECA\u0ECB\u0ECC\u0ECD\u0EC6\uFFFD\u0EDC\u0EDD\u20AD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0ED0\u0ED1\u0ED2\u0ED3\u0ED4\u0ED5\u0ED6\u0ED7\u0ED8\u0ED9\uFFFD\uFFFD\xA2\xAC\xA6\uFFFD" + }, + "ibm1133": "cp1133", + "csibm1133": "cp1133", + "cp1161": { + "type": "_sbcs", + "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E48\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\u0E49\u0E4A\u0E4B\u20AC\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\xA2\xAC\xA6\xA0" + }, + "ibm1161": "cp1161", + "csibm1161": "cp1161", + "cp1162": { + "type": "_sbcs", + "chars": "\u20AC\x81\x82\x83\x84\u2026\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "ibm1162": "cp1162", + "csibm1162": "cp1162", + "cp1163": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF" + }, + "ibm1163": "cp1163", + "csibm1163": "cp1163", + "maccroatian": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\u0160\u2122\xB4\xA8\u2260\u017D\xD8\u221E\xB1\u2264\u2265\u2206\xB5\u2202\u2211\u220F\u0161\u222B\xAA\xBA\u2126\u017E\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u0106\xAB\u010C\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\uFFFD\xA9\u2044\xA4\u2039\u203A\xC6\xBB\u2013\xB7\u201A\u201E\u2030\xC2\u0107\xC1\u010D\xC8\xCD\xCE\xCF\xCC\xD3\xD4\u0111\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u03C0\xCB\u02DA\xB8\xCA\xE6\u02C7" + }, + "maccyrillic": { + "type": "_sbcs", + "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\xA2\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u2202\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4" + }, + "macgreek": { + "type": "_sbcs", + "chars": "\xC4\xB9\xB2\xC9\xB3\xD6\xDC\u0385\xE0\xE2\xE4\u0384\xA8\xE7\xE9\xE8\xEA\xEB\xA3\u2122\xEE\xEF\u2022\xBD\u2030\xF4\xF6\xA6\xAD\xF9\xFB\xFC\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xDF\xAE\xA9\u03A3\u03AA\xA7\u2260\xB0\u0387\u0391\xB1\u2264\u2265\xA5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xAC\u039F\u03A1\u2248\u03A4\xAB\xBB\u2026\xA0\u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xF7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\uFFFD" + }, + "maciceland": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\xDD\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\xD0\xF0\xDE\xFE\xFD\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7" + }, + "macroman": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7" + }, + "macromania": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\u0102\u015E\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\u0103\u015F\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\u0162\u0163\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7" + }, + "macthai": { + "type": "_sbcs", + "chars": "\xAB\xBB\u2026\uF88C\uF88F\uF892\uF895\uF898\uF88B\uF88E\uF891\uF894\uF897\u201C\u201D\uF899\uFFFD\u2022\uF884\uF889\uF885\uF886\uF887\uF888\uF88A\uF88D\uF890\uF893\uF896\u2018\u2019\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFEFF\u200B\u2013\u2014\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u2122\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\xAE\xA9\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "macturkish": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\uFFFD\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7" + }, + "macukraine": { + "type": "_sbcs", + "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\u0490\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u0491\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4" + }, + "koi8r": { + "type": "_sbcs", + "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u2553\u2554\u2555\u2556\u2557\u2558\u2559\u255A\u255B\u255C\u255D\u255E\u255F\u2560\u2561\u0401\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569\u256A\u256B\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A" + }, + "koi8u": { + "type": "_sbcs", + "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u255D\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A" + }, + "koi8ru": { + "type": "_sbcs", + "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u045E\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u040E\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A" + }, + "koi8t": { + "type": "_sbcs", + "chars": "\u049B\u0493\u201A\u0492\u201E\u2026\u2020\u2021\uFFFD\u2030\u04B3\u2039\u04B2\u04B7\u04B6\uFFFD\u049A\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u04EF\u04EE\u0451\xA4\u04E3\xA6\xA7\uFFFD\uFFFD\uFFFD\xAB\xAC\xAD\xAE\uFFFD\xB0\xB1\xB2\u0401\uFFFD\u04E2\xB6\xB7\uFFFD\u2116\uFFFD\xBB\uFFFD\uFFFD\uFFFD\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A" + }, + "armscii8": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\u0587\u0589)(\xBB\xAB\u2014.\u055D,-\u058A\u2026\u055C\u055B\u055E\u0531\u0561\u0532\u0562\u0533\u0563\u0534\u0564\u0535\u0565\u0536\u0566\u0537\u0567\u0538\u0568\u0539\u0569\u053A\u056A\u053B\u056B\u053C\u056C\u053D\u056D\u053E\u056E\u053F\u056F\u0540\u0570\u0541\u0571\u0542\u0572\u0543\u0573\u0544\u0574\u0545\u0575\u0546\u0576\u0547\u0577\u0548\u0578\u0549\u0579\u054A\u057A\u054B\u057B\u054C\u057C\u054D\u057D\u054E\u057E\u054F\u057F\u0550\u0580\u0551\u0581\u0552\u0582\u0553\u0583\u0554\u0584\u0555\u0585\u0556\u0586\u055A\uFFFD" + }, + "rk1048": { + "type": "_sbcs", + "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u049A\u04BA\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u049B\u04BB\u045F\xA0\u04B0\u04B1\u04D8\xA4\u04E8\xA6\xA7\u0401\xA9\u0492\xAB\xAC\xAD\xAE\u04AE\xB0\xB1\u0406\u0456\u04E9\xB5\xB6\xB7\u0451\u2116\u0493\xBB\u04D9\u04A2\u04A3\u04AF\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F" + }, + "tcvn": { + "type": "_sbcs", + "chars": "\0\xDA\u1EE4\u1EEA\u1EEC\u1EEE\x07\b \n\v\f\r\u1EE8\u1EF0\u1EF2\u1EF6\u1EF8\xDD\u1EF4\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xC0\u1EA2\xC3\xC1\u1EA0\u1EB6\u1EAC\xC8\u1EBA\u1EBC\xC9\u1EB8\u1EC6\xCC\u1EC8\u0128\xCD\u1ECA\xD2\u1ECE\xD5\xD3\u1ECC\u1ED8\u1EDC\u1EDE\u1EE0\u1EDA\u1EE2\xD9\u1EE6\u0168\xA0\u0102\xC2\xCA\xD4\u01A0\u01AF\u0110\u0103\xE2\xEA\xF4\u01A1\u01B0\u0111\u1EB0\u0300\u0309\u0303\u0301\u0323\xE0\u1EA3\xE3\xE1\u1EA1\u1EB2\u1EB1\u1EB3\u1EB5\u1EAF\u1EB4\u1EAE\u1EA6\u1EA8\u1EAA\u1EA4\u1EC0\u1EB7\u1EA7\u1EA9\u1EAB\u1EA5\u1EAD\xE8\u1EC2\u1EBB\u1EBD\xE9\u1EB9\u1EC1\u1EC3\u1EC5\u1EBF\u1EC7\xEC\u1EC9\u1EC4\u1EBE\u1ED2\u0129\xED\u1ECB\xF2\u1ED4\u1ECF\xF5\xF3\u1ECD\u1ED3\u1ED5\u1ED7\u1ED1\u1ED9\u1EDD\u1EDF\u1EE1\u1EDB\u1EE3\xF9\u1ED6\u1EE7\u0169\xFA\u1EE5\u1EEB\u1EED\u1EEF\u1EE9\u1EF1\u1EF3\u1EF7\u1EF9\xFD\u1EF5\u1ED0" + }, + "georgianacademy": { + "type": "_sbcs", + "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10EF\u10F0\u10F1\u10F2\u10F3\u10F4\u10F5\u10F6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF" + }, + "georgianps": { + "type": "_sbcs", + "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10F1\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10F2\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10F3\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10F4\u10EF\u10F0\u10F5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF" + }, + "pt154": { + "type": "_sbcs", + "chars": "\u0496\u0492\u04EE\u0493\u201E\u2026\u04B6\u04AE\u04B2\u04AF\u04A0\u04E2\u04A2\u049A\u04BA\u04B8\u0497\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u04B3\u04B7\u04A1\u04E3\u04A3\u049B\u04BB\u04B9\xA0\u040E\u045E\u0408\u04E8\u0498\u04B0\xA7\u0401\xA9\u04D8\xAB\xAC\u04EF\xAE\u049C\xB0\u04B1\u0406\u0456\u0499\u04E9\xB6\xB7\u0451\u2116\u04D9\xBB\u0458\u04AA\u04AB\u049D\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F" + }, + "viscii": { + "type": "_sbcs", + "chars": "\0\u1EB2\u1EB4\u1EAA\x07\b \n\v\f\r\u1EF6\u1EF8\x1B\u1EF4 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\u1EA0\u1EAE\u1EB0\u1EB6\u1EA4\u1EA6\u1EA8\u1EAC\u1EBC\u1EB8\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EE2\u1EDA\u1EDC\u1EDE\u1ECA\u1ECE\u1ECC\u1EC8\u1EE6\u0168\u1EE4\u1EF2\xD5\u1EAF\u1EB1\u1EB7\u1EA5\u1EA7\u1EA9\u1EAD\u1EBD\u1EB9\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1ED1\u1ED3\u1ED5\u1ED7\u1EE0\u01A0\u1ED9\u1EDD\u1EDF\u1ECB\u1EF0\u1EE8\u1EEA\u1EEC\u01A1\u1EDB\u01AF\xC0\xC1\xC2\xC3\u1EA2\u0102\u1EB3\u1EB5\xC8\xC9\xCA\u1EBA\xCC\xCD\u0128\u1EF3\u0110\u1EE9\xD2\xD3\xD4\u1EA1\u1EF7\u1EEB\u1EED\xD9\xDA\u1EF9\u1EF5\xDD\u1EE1\u01B0\xE0\xE1\xE2\xE3\u1EA3\u0103\u1EEF\u1EAB\xE8\xE9\xEA\u1EBB\xEC\xED\u0129\u1EC9\u0111\u1EF1\xF2\xF3\xF4\xF5\u1ECF\u1ECD\u1EE5\xF9\xFA\u0169\u1EE7\xFD\u1EE3\u1EEE" + }, + "iso646cn": { + "type": "_sbcs", + "chars": "\0\x07\b \n\v\f\r\x1B !\"#\xA5%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "iso646jp": { + "type": "_sbcs", + "chars": "\0\x07\b \n\v\f\r\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\xA5]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "hproman8": { + "type": "_sbcs", + "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xC0\xC2\xC8\xCA\xCB\xCE\xCF\xB4\u02CB\u02C6\xA8\u02DC\xD9\xDB\u20A4\xAF\xDD\xFD\xB0\xC7\xE7\xD1\xF1\xA1\xBF\xA4\xA3\xA5\xA7\u0192\xA2\xE2\xEA\xF4\xFB\xE1\xE9\xF3\xFA\xE0\xE8\xF2\xF9\xE4\xEB\xF6\xFC\xC5\xEE\xD8\xC6\xE5\xED\xF8\xE6\xC4\xEC\xD6\xDC\xC9\xEF\xDF\xD4\xC1\xC3\xE3\xD0\xF0\xCD\xCC\xD3\xD2\xD5\xF5\u0160\u0161\xDA\u0178\xFF\xDE\xFE\xB7\xB5\xB6\xBE\u2014\xBC\xBD\xAA\xBA\xAB\u25A0\xBB\xB1\uFFFD" + }, + "macintosh": { + "type": "_sbcs", + "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7" + }, + "ascii": { + "type": "_sbcs", + "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD" + }, + "tis620": { + "type": "_sbcs", + "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD" + } + }; + } +}); + +// node_modules/iconv-lite/encodings/dbcs-codec.js +var require_dbcs_codec = __commonJS({ + "node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + exports2._dbcs = DBCSCodec; + var UNASSIGNED = -1; + var GB18030_CODE = -2; + var SEQ_START = -10; + var NODE_START = -1e3; + var UNASSIGNED_NODE = new Array(256); + var DEF_CHAR = -1; + for (i = 0; i < 256; i++) { + UNASSIGNED_NODE[i] = UNASSIGNED; + } + var i; + function DBCSCodec(codecOptions, iconv) { + this.encodingName = codecOptions.encodingName; + if (!codecOptions) { + throw new Error("DBCS codec is called without the data."); + } + if (!codecOptions.table) { + throw new Error("Encoding '" + this.encodingName + "' has no data."); + } + var mappingTable = codecOptions.table(); + this.decodeTables = []; + this.decodeTables[0] = UNASSIGNED_NODE.slice(0); + this.decodeTableSeq = []; + for (var i2 = 0; i2 < mappingTable.length; i2++) { + this._addDecodeChunk(mappingTable[i2]); + } + if (typeof codecOptions.gb18030 === "function") { + this.gb18030 = codecOptions.gb18030(); + var commonThirdByteNodeIdx = this.decodeTables.length; + this.decodeTables.push(UNASSIGNED_NODE.slice(0)); + var commonFourthByteNodeIdx = this.decodeTables.length; + this.decodeTables.push(UNASSIGNED_NODE.slice(0)); + var firstByteNode = this.decodeTables[0]; + for (var i2 = 129; i2 <= 254; i2++) { + var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i2]]; + for (var j = 48; j <= 57; j++) { + if (secondByteNode[j] === UNASSIGNED) { + secondByteNode[j] = NODE_START - commonThirdByteNodeIdx; + } else if (secondByteNode[j] > NODE_START) { + throw new Error("gb18030 decode tables conflict at byte 2"); + } + var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]]; + for (var k = 129; k <= 254; k++) { + if (thirdByteNode[k] === UNASSIGNED) { + thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx; + } else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) { + continue; + } else if (thirdByteNode[k] > NODE_START) { + throw new Error("gb18030 decode tables conflict at byte 3"); + } + var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]]; + for (var l = 48; l <= 57; l++) { + if (fourthByteNode[l] === UNASSIGNED) { + fourthByteNode[l] = GB18030_CODE; + } + } + } + } + } + } + this.defaultCharUnicode = iconv.defaultCharUnicode; + this.encodeTable = []; + this.encodeTableSeq = []; + var skipEncodeChars = {}; + if (codecOptions.encodeSkipVals) { + for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) { + var val = codecOptions.encodeSkipVals[i2]; + if (typeof val === "number") { + skipEncodeChars[val] = true; + } else { + for (var j = val.from; j <= val.to; j++) { + skipEncodeChars[j] = true; + } + } + } + } + this._fillEncodeTable(0, 0, skipEncodeChars); + if (codecOptions.encodeAdd) { + for (var uChar in codecOptions.encodeAdd) { + if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) { + this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]); + } + } + } + this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)]; + if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"]; + if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0); + } + DBCSCodec.prototype.encoder = DBCSEncoder; + DBCSCodec.prototype.decoder = DBCSDecoder; + DBCSCodec.prototype._getDecodeTrieNode = function(addr) { + var bytes = []; + for (; addr > 0; addr >>>= 8) { + bytes.push(addr & 255); + } + if (bytes.length == 0) { + bytes.push(0); + } + var node = this.decodeTables[0]; + for (var i2 = bytes.length - 1; i2 > 0; i2--) { + var val = node[bytes[i2]]; + if (val == UNASSIGNED) { + node[bytes[i2]] = NODE_START - this.decodeTables.length; + this.decodeTables.push(node = UNASSIGNED_NODE.slice(0)); + } else if (val <= NODE_START) { + node = this.decodeTables[NODE_START - val]; + } else { + throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16)); + } + } + return node; + }; + DBCSCodec.prototype._addDecodeChunk = function(chunk) { + var curAddr = parseInt(chunk[0], 16); + var writeTable = this._getDecodeTrieNode(curAddr); + curAddr = curAddr & 255; + for (var k = 1; k < chunk.length; k++) { + var part = chunk[k]; + if (typeof part === "string") { + for (var l = 0; l < part.length; ) { + var code = part.charCodeAt(l++); + if (code >= 55296 && code < 56320) { + var codeTrail = part.charCodeAt(l++); + if (codeTrail >= 56320 && codeTrail < 57344) { + writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320); + } else { + throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]); + } + } else if (code > 4080 && code <= 4095) { + var len = 4095 - code + 2; + var seq = []; + for (var m = 0; m < len; m++) { + seq.push(part.charCodeAt(l++)); + } + writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length; + this.decodeTableSeq.push(seq); + } else { + writeTable[curAddr++] = code; + } + } + } else if (typeof part === "number") { + var charCode = writeTable[curAddr - 1] + 1; + for (var l = 0; l < part; l++) { + writeTable[curAddr++] = charCode++; + } + } else { + throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]); + } + } + if (curAddr > 255) { + throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr); + } + }; + DBCSCodec.prototype._getEncodeBucket = function(uCode) { + var high = uCode >> 8; + if (this.encodeTable[high] === void 0) { + this.encodeTable[high] = UNASSIGNED_NODE.slice(0); + } + return this.encodeTable[high]; + }; + DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) { + var bucket = this._getEncodeBucket(uCode); + var low = uCode & 255; + if (bucket[low] <= SEQ_START) { + this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode; + } else if (bucket[low] == UNASSIGNED) { + bucket[low] = dbcsCode; + } + }; + DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) { + var uCode = seq[0]; + var bucket = this._getEncodeBucket(uCode); + var low = uCode & 255; + var node; + if (bucket[low] <= SEQ_START) { + node = this.encodeTableSeq[SEQ_START - bucket[low]]; + } else { + node = {}; + if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low]; + bucket[low] = SEQ_START - this.encodeTableSeq.length; + this.encodeTableSeq.push(node); + } + for (var j = 1; j < seq.length - 1; j++) { + var oldVal = node[uCode]; + if (typeof oldVal === "object") { + node = oldVal; + } else { + node = node[uCode] = {}; + if (oldVal !== void 0) { + node[DEF_CHAR] = oldVal; + } + } + } + uCode = seq[seq.length - 1]; + node[uCode] = dbcsCode; + }; + DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) { + var node = this.decodeTables[nodeIdx]; + var hasValues = false; + var subNodeEmpty = {}; + for (var i2 = 0; i2 < 256; i2++) { + var uCode = node[i2]; + var mbCode = prefix + i2; + if (skipEncodeChars[mbCode]) { + continue; + } + if (uCode >= 0) { + this._setEncodeChar(uCode, mbCode); + hasValues = true; + } else if (uCode <= NODE_START) { + var subNodeIdx = NODE_START - uCode; + if (!subNodeEmpty[subNodeIdx]) { + var newPrefix = mbCode << 8 >>> 0; + if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars)) { + hasValues = true; + } else { + subNodeEmpty[subNodeIdx] = true; + } + } + } else if (uCode <= SEQ_START) { + this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode); + hasValues = true; + } + } + return hasValues; + }; + function DBCSEncoder(options, codec) { + this.leadSurrogate = -1; + this.seqObj = void 0; + this.encodeTable = codec.encodeTable; + this.encodeTableSeq = codec.encodeTableSeq; + this.defaultCharSingleByte = codec.defCharSB; + this.gb18030 = codec.gb18030; + } + DBCSEncoder.prototype.write = function(str) { + var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3)); + var leadSurrogate = this.leadSurrogate; + var seqObj = this.seqObj; + var nextChar = -1; + var i2 = 0; + var j = 0; + while (true) { + if (nextChar === -1) { + if (i2 == str.length) break; + var uCode = str.charCodeAt(i2++); + } else { + var uCode = nextChar; + nextChar = -1; + } + if (uCode >= 55296 && uCode < 57344) { + if (uCode < 56320) { + if (leadSurrogate === -1) { + leadSurrogate = uCode; + continue; + } else { + leadSurrogate = uCode; + uCode = UNASSIGNED; + } + } else { + if (leadSurrogate !== -1) { + uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320); + leadSurrogate = -1; + } else { + uCode = UNASSIGNED; + } + } + } else if (leadSurrogate !== -1) { + nextChar = uCode; + uCode = UNASSIGNED; + leadSurrogate = -1; + } + var dbcsCode = UNASSIGNED; + if (seqObj !== void 0 && uCode != UNASSIGNED) { + var resCode = seqObj[uCode]; + if (typeof resCode === "object") { + seqObj = resCode; + continue; + } else if (typeof resCode === "number") { + dbcsCode = resCode; + } else if (resCode == void 0) { + resCode = seqObj[DEF_CHAR]; + if (resCode !== void 0) { + dbcsCode = resCode; + nextChar = uCode; + } else { + } + } + seqObj = void 0; + } else if (uCode >= 0) { + var subtable = this.encodeTable[uCode >> 8]; + if (subtable !== void 0) { + dbcsCode = subtable[uCode & 255]; + } + if (dbcsCode <= SEQ_START) { + seqObj = this.encodeTableSeq[SEQ_START - dbcsCode]; + continue; + } + if (dbcsCode == UNASSIGNED && this.gb18030) { + var idx = findIdx(this.gb18030.uChars, uCode); + if (idx != -1) { + var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]); + newBuf[j++] = 129 + Math.floor(dbcsCode / 12600); + dbcsCode = dbcsCode % 12600; + newBuf[j++] = 48 + Math.floor(dbcsCode / 1260); + dbcsCode = dbcsCode % 1260; + newBuf[j++] = 129 + Math.floor(dbcsCode / 10); + dbcsCode = dbcsCode % 10; + newBuf[j++] = 48 + dbcsCode; + continue; + } + } + } + if (dbcsCode === UNASSIGNED) { + dbcsCode = this.defaultCharSingleByte; + } + if (dbcsCode < 256) { + newBuf[j++] = dbcsCode; + } else if (dbcsCode < 65536) { + newBuf[j++] = dbcsCode >> 8; + newBuf[j++] = dbcsCode & 255; + } else if (dbcsCode < 16777216) { + newBuf[j++] = dbcsCode >> 16; + newBuf[j++] = dbcsCode >> 8 & 255; + newBuf[j++] = dbcsCode & 255; + } else { + newBuf[j++] = dbcsCode >>> 24; + newBuf[j++] = dbcsCode >>> 16 & 255; + newBuf[j++] = dbcsCode >>> 8 & 255; + newBuf[j++] = dbcsCode & 255; + } + } + this.seqObj = seqObj; + this.leadSurrogate = leadSurrogate; + return newBuf.slice(0, j); + }; + DBCSEncoder.prototype.end = function() { + if (this.leadSurrogate === -1 && this.seqObj === void 0) { + return; + } + var newBuf = Buffer2.alloc(10); + var j = 0; + if (this.seqObj) { + var dbcsCode = this.seqObj[DEF_CHAR]; + if (dbcsCode !== void 0) { + if (dbcsCode < 256) { + newBuf[j++] = dbcsCode; + } else { + newBuf[j++] = dbcsCode >> 8; + newBuf[j++] = dbcsCode & 255; + } + } else { + } + this.seqObj = void 0; + } + if (this.leadSurrogate !== -1) { + newBuf[j++] = this.defaultCharSingleByte; + this.leadSurrogate = -1; + } + return newBuf.slice(0, j); + }; + DBCSEncoder.prototype.findIdx = findIdx; + function DBCSDecoder(options, codec) { + this.nodeIdx = 0; + this.prevBytes = []; + this.decodeTables = codec.decodeTables; + this.decodeTableSeq = codec.decodeTableSeq; + this.defaultCharUnicode = codec.defaultCharUnicode; + this.gb18030 = codec.gb18030; + } + DBCSDecoder.prototype.write = function(buf) { + var newBuf = Buffer2.alloc(buf.length * 2); + var nodeIdx = this.nodeIdx; + var prevBytes = this.prevBytes; + var prevOffset = this.prevBytes.length; + var seqStart = -this.prevBytes.length; + var uCode; + for (var i2 = 0, j = 0; i2 < buf.length; i2++) { + var curByte = i2 >= 0 ? buf[i2] : prevBytes[i2 + prevOffset]; + var uCode = this.decodeTables[nodeIdx][curByte]; + if (uCode >= 0) { + } else if (uCode === UNASSIGNED) { + uCode = this.defaultCharUnicode.charCodeAt(0); + i2 = seqStart; + } else if (uCode === GB18030_CODE) { + if (i2 >= 3) { + var ptr = (buf[i2 - 3] - 129) * 12600 + (buf[i2 - 2] - 48) * 1260 + (buf[i2 - 1] - 129) * 10 + (curByte - 48); + } else { + var ptr = (prevBytes[i2 - 3 + prevOffset] - 129) * 12600 + ((i2 - 2 >= 0 ? buf[i2 - 2] : prevBytes[i2 - 2 + prevOffset]) - 48) * 1260 + ((i2 - 1 >= 0 ? buf[i2 - 1] : prevBytes[i2 - 1 + prevOffset]) - 129) * 10 + (curByte - 48); + } + var idx = findIdx(this.gb18030.gbChars, ptr); + uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx]; + } else if (uCode <= NODE_START) { + nodeIdx = NODE_START - uCode; + continue; + } else if (uCode <= SEQ_START) { + var seq = this.decodeTableSeq[SEQ_START - uCode]; + for (var k = 0; k < seq.length - 1; k++) { + uCode = seq[k]; + newBuf[j++] = uCode & 255; + newBuf[j++] = uCode >> 8; + } + uCode = seq[seq.length - 1]; + } else { + throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte); + } + if (uCode >= 65536) { + uCode -= 65536; + var uCodeLead = 55296 | uCode >> 10; + newBuf[j++] = uCodeLead & 255; + newBuf[j++] = uCodeLead >> 8; + uCode = 56320 | uCode & 1023; + } + newBuf[j++] = uCode & 255; + newBuf[j++] = uCode >> 8; + nodeIdx = 0; + seqStart = i2 + 1; + } + this.nodeIdx = nodeIdx; + this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf)); + return newBuf.slice(0, j).toString("ucs2"); + }; + DBCSDecoder.prototype.end = function() { + var ret = ""; + while (this.prevBytes.length > 0) { + ret += this.defaultCharUnicode; + var bytesArr = this.prevBytes.slice(1); + this.prevBytes = []; + this.nodeIdx = 0; + if (bytesArr.length > 0) { + ret += this.write(bytesArr); + } + } + this.prevBytes = []; + this.nodeIdx = 0; + return ret; + }; + function findIdx(table, val) { + if (table[0] > val) { + return -1; + } + var l = 0; + var r = table.length; + while (l < r - 1) { + var mid = l + (r - l + 1 >> 1); + if (table[mid] <= val) { + l = mid; + } else { + r = mid; + } + } + return l; + } + } +}); + +// node_modules/iconv-lite/encodings/tables/shiftjis.json +var require_shiftjis = __commonJS({ + "node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module2) { + module2.exports = [ + ["0", "\0", 128], + ["a1", "\uFF61", 62], + ["8140", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7"], + ["8180", "\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"], + ["81b8", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"], + ["81c8", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"], + ["81da", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"], + ["81f0", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"], + ["81fc", "\u25EF"], + ["824f", "\uFF10", 9], + ["8260", "\uFF21", 25], + ["8281", "\uFF41", 25], + ["829f", "\u3041", 82], + ["8340", "\u30A1", 62], + ["8380", "\u30E0", 22], + ["839f", "\u0391", 16, "\u03A3", 6], + ["83bf", "\u03B1", 16, "\u03C3", 6], + ["8440", "\u0410", 5, "\u0401\u0416", 25], + ["8470", "\u0430", 5, "\u0451\u0436", 7], + ["8480", "\u043E", 17], + ["849f", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"], + ["8740", "\u2460", 19, "\u2160", 9], + ["875f", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"], + ["877e", "\u337B"], + ["8780", "\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"], + ["889f", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"], + ["8940", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186"], + ["8980", "\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"], + ["8a40", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B"], + ["8a80", "\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"], + ["8b40", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551"], + ["8b80", "\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"], + ["8c40", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8"], + ["8c80", "\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"], + ["8d40", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D"], + ["8d80", "\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"], + ["8e40", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62"], + ["8e80", "\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"], + ["8f40", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3"], + ["8f80", "\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"], + ["9040", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8"], + ["9080", "\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"], + ["9140", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB"], + ["9180", "\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"], + ["9240", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4"], + ["9280", "\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"], + ["9340", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC"], + ["9380", "\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"], + ["9440", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885"], + ["9480", "\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"], + ["9540", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577"], + ["9580", "\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"], + ["9640", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6"], + ["9680", "\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"], + ["9740", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32"], + ["9780", "\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"], + ["9840", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"], + ["989f", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"], + ["9940", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED"], + ["9980", "\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"], + ["9a40", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638"], + ["9a80", "\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"], + ["9b40", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80"], + ["9b80", "\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"], + ["9c40", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060"], + ["9c80", "\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"], + ["9d40", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B"], + ["9d80", "\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"], + ["9e40", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E"], + ["9e80", "\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"], + ["9f40", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF"], + ["9f80", "\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"], + ["e040", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD"], + ["e080", "\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"], + ["e140", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF"], + ["e180", "\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"], + ["e240", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0"], + ["e280", "\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"], + ["e340", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37"], + ["e380", "\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"], + ["e440", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264"], + ["e480", "\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"], + ["e540", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC"], + ["e580", "\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"], + ["e640", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7"], + ["e680", "\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"], + ["e740", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C"], + ["e780", "\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"], + ["e840", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599"], + ["e880", "\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"], + ["e940", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43"], + ["e980", "\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"], + ["ea40", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF"], + ["ea80", "\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0\u582F\u69C7\u9059\u7464\u51DC\u7199"], + ["ed40", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F"], + ["ed80", "\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"], + ["ee40", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559"], + ["ee80", "\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"], + ["eeef", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"], + ["f040", "\uE000", 62], + ["f080", "\uE03F", 124], + ["f140", "\uE0BC", 62], + ["f180", "\uE0FB", 124], + ["f240", "\uE178", 62], + ["f280", "\uE1B7", 124], + ["f340", "\uE234", 62], + ["f380", "\uE273", 124], + ["f440", "\uE2F0", 62], + ["f480", "\uE32F", 124], + ["f540", "\uE3AC", 62], + ["f580", "\uE3EB", 124], + ["f640", "\uE468", 62], + ["f680", "\uE4A7", 124], + ["f740", "\uE524", 62], + ["f780", "\uE563", 124], + ["f840", "\uE5E0", 62], + ["f880", "\uE61F", 124], + ["f940", "\uE69C"], + ["fa40", "\u2170", 9, "\u2160", 9, "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u2235\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A"], + ["fa80", "\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F"], + ["fb40", "\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19"], + ["fb80", "\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9"], + ["fc40", "\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/eucjp.json +var require_eucjp = __commonJS({ + "node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module2) { + module2.exports = [ + ["0", "\0", 127], + ["8ea1", "\uFF61", 62], + ["a1a1", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7"], + ["a2a1", "\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"], + ["a2ba", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"], + ["a2ca", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"], + ["a2dc", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"], + ["a2f2", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"], + ["a2fe", "\u25EF"], + ["a3b0", "\uFF10", 9], + ["a3c1", "\uFF21", 25], + ["a3e1", "\uFF41", 25], + ["a4a1", "\u3041", 82], + ["a5a1", "\u30A1", 85], + ["a6a1", "\u0391", 16, "\u03A3", 6], + ["a6c1", "\u03B1", 16, "\u03C3", 6], + ["a7a1", "\u0410", 5, "\u0401\u0416", 25], + ["a7d1", "\u0430", 5, "\u0451\u0436", 25], + ["a8a1", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"], + ["ada1", "\u2460", 19, "\u2160", 9], + ["adc0", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"], + ["addf", "\u337B\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"], + ["b0a1", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"], + ["b1a1", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC"], + ["b2a1", "\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"], + ["b3a1", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431"], + ["b4a1", "\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"], + ["b5a1", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC"], + ["b6a1", "\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"], + ["b7a1", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372"], + ["b8a1", "\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"], + ["b9a1", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC"], + ["baa1", "\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"], + ["bba1", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642"], + ["bca1", "\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"], + ["bda1", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F"], + ["bea1", "\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"], + ["bfa1", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE"], + ["c0a1", "\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"], + ["c1a1", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E"], + ["c2a1", "\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"], + ["c3a1", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5"], + ["c4a1", "\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"], + ["c5a1", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230"], + ["c6a1", "\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"], + ["c7a1", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6"], + ["c8a1", "\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"], + ["c9a1", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D"], + ["caa1", "\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"], + ["cba1", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80"], + ["cca1", "\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"], + ["cda1", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483"], + ["cea1", "\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"], + ["cfa1", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"], + ["d0a1", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"], + ["d1a1", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8"], + ["d2a1", "\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"], + ["d3a1", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709"], + ["d4a1", "\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"], + ["d5a1", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53"], + ["d6a1", "\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"], + ["d7a1", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A"], + ["d8a1", "\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"], + ["d9a1", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC"], + ["daa1", "\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"], + ["dba1", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD"], + ["dca1", "\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"], + ["dda1", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE"], + ["dea1", "\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"], + ["dfa1", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC"], + ["e0a1", "\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"], + ["e1a1", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670"], + ["e2a1", "\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"], + ["e3a1", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50"], + ["e4a1", "\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"], + ["e5a1", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A"], + ["e6a1", "\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"], + ["e7a1", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9"], + ["e8a1", "\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"], + ["e9a1", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759"], + ["eaa1", "\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"], + ["eba1", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B"], + ["eca1", "\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"], + ["eda1", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8"], + ["eea1", "\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"], + ["efa1", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E"], + ["f0a1", "\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"], + ["f1a1", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7"], + ["f2a1", "\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"], + ["f3a1", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0"], + ["f4a1", "\u582F\u69C7\u9059\u7464\u51DC\u7199"], + ["f9a1", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7"], + ["faa1", "\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"], + ["fba1", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA"], + ["fca1", "\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"], + ["fcf1", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"], + ["8fa2af", "\u02D8\u02C7\xB8\u02D9\u02DD\xAF\u02DB\u02DA\uFF5E\u0384\u0385"], + ["8fa2c2", "\xA1\xA6\xBF"], + ["8fa2eb", "\xBA\xAA\xA9\xAE\u2122\xA4\u2116"], + ["8fa6e1", "\u0386\u0388\u0389\u038A\u03AA"], + ["8fa6e7", "\u038C"], + ["8fa6e9", "\u038E\u03AB"], + ["8fa6ec", "\u038F"], + ["8fa6f1", "\u03AC\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03C2\u03CD\u03CB\u03B0\u03CE"], + ["8fa7c2", "\u0402", 10, "\u040E\u040F"], + ["8fa7f2", "\u0452", 10, "\u045E\u045F"], + ["8fa9a1", "\xC6\u0110"], + ["8fa9a4", "\u0126"], + ["8fa9a6", "\u0132"], + ["8fa9a8", "\u0141\u013F"], + ["8fa9ab", "\u014A\xD8\u0152"], + ["8fa9af", "\u0166\xDE"], + ["8fa9c1", "\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0142\u0140\u0149\u014B\xF8\u0153\xDF\u0167\xFE"], + ["8faaa1", "\xC1\xC0\xC4\xC2\u0102\u01CD\u0100\u0104\xC5\xC3\u0106\u0108\u010C\xC7\u010A\u010E\xC9\xC8\xCB\xCA\u011A\u0116\u0112\u0118"], + ["8faaba", "\u011C\u011E\u0122\u0120\u0124\xCD\xCC\xCF\xCE\u01CF\u0130\u012A\u012E\u0128\u0134\u0136\u0139\u013D\u013B\u0143\u0147\u0145\xD1\xD3\xD2\xD6\xD4\u01D1\u0150\u014C\xD5\u0154\u0158\u0156\u015A\u015C\u0160\u015E\u0164\u0162\xDA\xD9\xDC\xDB\u016C\u01D3\u0170\u016A\u0172\u016E\u0168\u01D7\u01DB\u01D9\u01D5\u0174\xDD\u0178\u0176\u0179\u017D\u017B"], + ["8faba1", "\xE1\xE0\xE4\xE2\u0103\u01CE\u0101\u0105\xE5\xE3\u0107\u0109\u010D\xE7\u010B\u010F\xE9\xE8\xEB\xEA\u011B\u0117\u0113\u0119\u01F5\u011D\u011F"], + ["8fabbd", "\u0121\u0125\xED\xEC\xEF\xEE\u01D0"], + ["8fabc5", "\u012B\u012F\u0129\u0135\u0137\u013A\u013E\u013C\u0144\u0148\u0146\xF1\xF3\xF2\xF6\xF4\u01D2\u0151\u014D\xF5\u0155\u0159\u0157\u015B\u015D\u0161\u015F\u0165\u0163\xFA\xF9\xFC\xFB\u016D\u01D4\u0171\u016B\u0173\u016F\u0169\u01D8\u01DC\u01DA\u01D6\u0175\xFD\xFF\u0177\u017A\u017E\u017C"], + ["8fb0a1", "\u4E02\u4E04\u4E05\u4E0C\u4E12\u4E1F\u4E23\u4E24\u4E28\u4E2B\u4E2E\u4E2F\u4E30\u4E35\u4E40\u4E41\u4E44\u4E47\u4E51\u4E5A\u4E5C\u4E63\u4E68\u4E69\u4E74\u4E75\u4E79\u4E7F\u4E8D\u4E96\u4E97\u4E9D\u4EAF\u4EB9\u4EC3\u4ED0\u4EDA\u4EDB\u4EE0\u4EE1\u4EE2\u4EE8\u4EEF\u4EF1\u4EF3\u4EF5\u4EFD\u4EFE\u4EFF\u4F00\u4F02\u4F03\u4F08\u4F0B\u4F0C\u4F12\u4F15\u4F16\u4F17\u4F19\u4F2E\u4F31\u4F60\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E\u4F40\u4F42\u4F48\u4F49\u4F4B\u4F4C\u4F52\u4F54\u4F56\u4F58\u4F5F\u4F63\u4F6A\u4F6C\u4F6E\u4F71\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F7E\u4F81\u4F82\u4F84"], + ["8fb1a1", "\u4F85\u4F89\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F94\u4F97\u4F99\u4F9A\u4F9E\u4F9F\u4FB2\u4FB7\u4FB9\u4FBB\u4FBC\u4FBD\u4FBE\u4FC0\u4FC1\u4FC5\u4FC6\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FCF\u4FD2\u4FDC\u4FE0\u4FE2\u4FF0\u4FF2\u4FFC\u4FFD\u4FFF\u5000\u5001\u5004\u5007\u500A\u500C\u500E\u5010\u5013\u5017\u5018\u501B\u501C\u501D\u501E\u5022\u5027\u502E\u5030\u5032\u5033\u5035\u5040\u5041\u5042\u5045\u5046\u504A\u504C\u504E\u5051\u5052\u5053\u5057\u5059\u505F\u5060\u5062\u5063\u5066\u5067\u506A\u506D\u5070\u5071\u503B\u5081\u5083\u5084\u5086\u508A\u508E\u508F\u5090"], + ["8fb2a1", "\u5092\u5093\u5094\u5096\u509B\u509C\u509E", 4, "\u50AA\u50AF\u50B0\u50B9\u50BA\u50BD\u50C0\u50C3\u50C4\u50C7\u50CC\u50CE\u50D0\u50D3\u50D4\u50D8\u50DC\u50DD\u50DF\u50E2\u50E4\u50E6\u50E8\u50E9\u50EF\u50F1\u50F6\u50FA\u50FE\u5103\u5106\u5107\u5108\u510B\u510C\u510D\u510E\u50F2\u5110\u5117\u5119\u511B\u511C\u511D\u511E\u5123\u5127\u5128\u512C\u512D\u512F\u5131\u5133\u5134\u5135\u5138\u5139\u5142\u514A\u514F\u5153\u5155\u5157\u5158\u515F\u5164\u5166\u517E\u5183\u5184\u518B\u518E\u5198\u519D\u51A1\u51A3\u51AD\u51B8\u51BA\u51BC\u51BE\u51BF\u51C2"], + ["8fb3a1", "\u51C8\u51CF\u51D1\u51D2\u51D3\u51D5\u51D8\u51DE\u51E2\u51E5\u51EE\u51F2\u51F3\u51F4\u51F7\u5201\u5202\u5205\u5212\u5213\u5215\u5216\u5218\u5222\u5228\u5231\u5232\u5235\u523C\u5245\u5249\u5255\u5257\u5258\u525A\u525C\u525F\u5260\u5261\u5266\u526E\u5277\u5278\u5279\u5280\u5282\u5285\u528A\u528C\u5293\u5295\u5296\u5297\u5298\u529A\u529C\u52A4\u52A5\u52A6\u52A7\u52AF\u52B0\u52B6\u52B7\u52B8\u52BA\u52BB\u52BD\u52C0\u52C4\u52C6\u52C8\u52CC\u52CF\u52D1\u52D4\u52D6\u52DB\u52DC\u52E1\u52E5\u52E8\u52E9\u52EA\u52EC\u52F0\u52F1\u52F4\u52F6\u52F7\u5300\u5303\u530A\u530B"], + ["8fb4a1", "\u530C\u5311\u5313\u5318\u531B\u531C\u531E\u531F\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u5330\u5332\u5335\u533C\u533D\u533E\u5342\u534C\u534B\u5359\u535B\u5361\u5363\u5365\u536C\u536D\u5372\u5379\u537E\u5383\u5387\u5388\u538E\u5393\u5394\u5399\u539D\u53A1\u53A4\u53AA\u53AB\u53AF\u53B2\u53B4\u53B5\u53B7\u53B8\u53BA\u53BD\u53C0\u53C5\u53CF\u53D2\u53D3\u53D5\u53DA\u53DD\u53DE\u53E0\u53E6\u53E7\u53F5\u5402\u5413\u541A\u5421\u5427\u5428\u542A\u542F\u5431\u5434\u5435\u5443\u5444\u5447\u544D\u544F\u545E\u5462\u5464\u5466\u5467\u5469\u546B\u546D\u546E\u5474\u547F"], + ["8fb5a1", "\u5481\u5483\u5485\u5488\u5489\u548D\u5491\u5495\u5496\u549C\u549F\u54A1\u54A6\u54A7\u54A9\u54AA\u54AD\u54AE\u54B1\u54B7\u54B9\u54BA\u54BB\u54BF\u54C6\u54CA\u54CD\u54CE\u54E0\u54EA\u54EC\u54EF\u54F6\u54FC\u54FE\u54FF\u5500\u5501\u5505\u5508\u5509\u550C\u550D\u550E\u5515\u552A\u552B\u5532\u5535\u5536\u553B\u553C\u553D\u5541\u5547\u5549\u554A\u554D\u5550\u5551\u5558\u555A\u555B\u555E\u5560\u5561\u5564\u5566\u557F\u5581\u5582\u5586\u5588\u558E\u558F\u5591\u5592\u5593\u5594\u5597\u55A3\u55A4\u55AD\u55B2\u55BF\u55C1\u55C3\u55C6\u55C9\u55CB\u55CC\u55CE\u55D1\u55D2"], + ["8fb6a1", "\u55D3\u55D7\u55D8\u55DB\u55DE\u55E2\u55E9\u55F6\u55FF\u5605\u5608\u560A\u560D", 5, "\u5619\u562C\u5630\u5633\u5635\u5637\u5639\u563B\u563C\u563D\u563F\u5640\u5641\u5643\u5644\u5646\u5649\u564B\u564D\u564F\u5654\u565E\u5660\u5661\u5662\u5663\u5666\u5669\u566D\u566F\u5671\u5672\u5675\u5684\u5685\u5688\u568B\u568C\u5695\u5699\u569A\u569D\u569E\u569F\u56A6\u56A7\u56A8\u56A9\u56AB\u56AC\u56AD\u56B1\u56B3\u56B7\u56BE\u56C5\u56C9\u56CA\u56CB\u56CF\u56D0\u56CC\u56CD\u56D9\u56DC\u56DD\u56DF\u56E1\u56E4", 4, "\u56F1\u56EB\u56ED"], + ["8fb7a1", "\u56F6\u56F7\u5701\u5702\u5707\u570A\u570C\u5711\u5715\u571A\u571B\u571D\u5720\u5722\u5723\u5724\u5725\u5729\u572A\u572C\u572E\u572F\u5733\u5734\u573D\u573E\u573F\u5745\u5746\u574C\u574D\u5752\u5762\u5765\u5767\u5768\u576B\u576D", 4, "\u5773\u5774\u5775\u5777\u5779\u577A\u577B\u577C\u577E\u5781\u5783\u578C\u5794\u5797\u5799\u579A\u579C\u579D\u579E\u579F\u57A1\u5795\u57A7\u57A8\u57A9\u57AC\u57B8\u57BD\u57C7\u57C8\u57CC\u57CF\u57D5\u57DD\u57DE\u57E4\u57E6\u57E7\u57E9\u57ED\u57F0\u57F5\u57F6\u57F8\u57FD\u57FE\u57FF\u5803\u5804\u5808\u5809\u57E1"], + ["8fb8a1", "\u580C\u580D\u581B\u581E\u581F\u5820\u5826\u5827\u582D\u5832\u5839\u583F\u5849\u584C\u584D\u584F\u5850\u5855\u585F\u5861\u5864\u5867\u5868\u5878\u587C\u587F\u5880\u5881\u5887\u5888\u5889\u588A\u588C\u588D\u588F\u5890\u5894\u5896\u589D\u58A0\u58A1\u58A2\u58A6\u58A9\u58B1\u58B2\u58C4\u58BC\u58C2\u58C8\u58CD\u58CE\u58D0\u58D2\u58D4\u58D6\u58DA\u58DD\u58E1\u58E2\u58E9\u58F3\u5905\u5906\u590B\u590C\u5912\u5913\u5914\u8641\u591D\u5921\u5923\u5924\u5928\u592F\u5930\u5933\u5935\u5936\u593F\u5943\u5946\u5952\u5953\u5959\u595B\u595D\u595E\u595F\u5961\u5963\u596B\u596D"], + ["8fb9a1", "\u596F\u5972\u5975\u5976\u5979\u597B\u597C\u598B\u598C\u598E\u5992\u5995\u5997\u599F\u59A4\u59A7\u59AD\u59AE\u59AF\u59B0\u59B3\u59B7\u59BA\u59BC\u59C1\u59C3\u59C4\u59C8\u59CA\u59CD\u59D2\u59DD\u59DE\u59DF\u59E3\u59E4\u59E7\u59EE\u59EF\u59F1\u59F2\u59F4\u59F7\u5A00\u5A04\u5A0C\u5A0D\u5A0E\u5A12\u5A13\u5A1E\u5A23\u5A24\u5A27\u5A28\u5A2A\u5A2D\u5A30\u5A44\u5A45\u5A47\u5A48\u5A4C\u5A50\u5A55\u5A5E\u5A63\u5A65\u5A67\u5A6D\u5A77\u5A7A\u5A7B\u5A7E\u5A8B\u5A90\u5A93\u5A96\u5A99\u5A9C\u5A9E\u5A9F\u5AA0\u5AA2\u5AA7\u5AAC\u5AB1\u5AB2\u5AB3\u5AB5\u5AB8\u5ABA\u5ABB\u5ABF"], + ["8fbaa1", "\u5AC4\u5AC6\u5AC8\u5ACF\u5ADA\u5ADC\u5AE0\u5AE5\u5AEA\u5AEE\u5AF5\u5AF6\u5AFD\u5B00\u5B01\u5B08\u5B17\u5B34\u5B19\u5B1B\u5B1D\u5B21\u5B25\u5B2D\u5B38\u5B41\u5B4B\u5B4C\u5B52\u5B56\u5B5E\u5B68\u5B6E\u5B6F\u5B7C\u5B7D\u5B7E\u5B7F\u5B81\u5B84\u5B86\u5B8A\u5B8E\u5B90\u5B91\u5B93\u5B94\u5B96\u5BA8\u5BA9\u5BAC\u5BAD\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBC\u5BC0\u5BC1\u5BCD\u5BCF\u5BD6", 4, "\u5BE0\u5BEF\u5BF1\u5BF4\u5BFD\u5C0C\u5C17\u5C1E\u5C1F\u5C23\u5C26\u5C29\u5C2B\u5C2C\u5C2E\u5C30\u5C32\u5C35\u5C36\u5C59\u5C5A\u5C5C\u5C62\u5C63\u5C67\u5C68\u5C69"], + ["8fbba1", "\u5C6D\u5C70\u5C74\u5C75\u5C7A\u5C7B\u5C7C\u5C7D\u5C87\u5C88\u5C8A\u5C8F\u5C92\u5C9D\u5C9F\u5CA0\u5CA2\u5CA3\u5CA6\u5CAA\u5CB2\u5CB4\u5CB5\u5CBA\u5CC9\u5CCB\u5CD2\u5CDD\u5CD7\u5CEE\u5CF1\u5CF2\u5CF4\u5D01\u5D06\u5D0D\u5D12\u5D2B\u5D23\u5D24\u5D26\u5D27\u5D31\u5D34\u5D39\u5D3D\u5D3F\u5D42\u5D43\u5D46\u5D48\u5D55\u5D51\u5D59\u5D4A\u5D5F\u5D60\u5D61\u5D62\u5D64\u5D6A\u5D6D\u5D70\u5D79\u5D7A\u5D7E\u5D7F\u5D81\u5D83\u5D88\u5D8A\u5D92\u5D93\u5D94\u5D95\u5D99\u5D9B\u5D9F\u5DA0\u5DA7\u5DAB\u5DB0\u5DB4\u5DB8\u5DB9\u5DC3\u5DC7\u5DCB\u5DD0\u5DCE\u5DD8\u5DD9\u5DE0\u5DE4"], + ["8fbca1", "\u5DE9\u5DF8\u5DF9\u5E00\u5E07\u5E0D\u5E12\u5E14\u5E15\u5E18\u5E1F\u5E20\u5E2E\u5E28\u5E32\u5E35\u5E3E\u5E4B\u5E50\u5E49\u5E51\u5E56\u5E58\u5E5B\u5E5C\u5E5E\u5E68\u5E6A", 4, "\u5E70\u5E80\u5E8B\u5E8E\u5EA2\u5EA4\u5EA5\u5EA8\u5EAA\u5EAC\u5EB1\u5EB3\u5EBD\u5EBE\u5EBF\u5EC6\u5ECC\u5ECB\u5ECE\u5ED1\u5ED2\u5ED4\u5ED5\u5EDC\u5EDE\u5EE5\u5EEB\u5F02\u5F06\u5F07\u5F08\u5F0E\u5F19\u5F1C\u5F1D\u5F21\u5F22\u5F23\u5F24\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F34\u5F36\u5F3B\u5F3D\u5F3F\u5F40\u5F44\u5F45\u5F47\u5F4D\u5F50\u5F54\u5F58\u5F5B\u5F60\u5F63\u5F64\u5F67"], + ["8fbda1", "\u5F6F\u5F72\u5F74\u5F75\u5F78\u5F7A\u5F7D\u5F7E\u5F89\u5F8D\u5F8F\u5F96\u5F9C\u5F9D\u5FA2\u5FA7\u5FAB\u5FA4\u5FAC\u5FAF\u5FB0\u5FB1\u5FB8\u5FC4\u5FC7\u5FC8\u5FC9\u5FCB\u5FD0", 4, "\u5FDE\u5FE1\u5FE2\u5FE8\u5FE9\u5FEA\u5FEC\u5FED\u5FEE\u5FEF\u5FF2\u5FF3\u5FF6\u5FFA\u5FFC\u6007\u600A\u600D\u6013\u6014\u6017\u6018\u601A\u601F\u6024\u602D\u6033\u6035\u6040\u6047\u6048\u6049\u604C\u6051\u6054\u6056\u6057\u605D\u6061\u6067\u6071\u607E\u607F\u6082\u6086\u6088\u608A\u608E\u6091\u6093\u6095\u6098\u609D\u609E\u60A2\u60A4\u60A5\u60A8\u60B0\u60B1\u60B7"], + ["8fbea1", "\u60BB\u60BE\u60C2\u60C4\u60C8\u60C9\u60CA\u60CB\u60CE\u60CF\u60D4\u60D5\u60D9\u60DB\u60DD\u60DE\u60E2\u60E5\u60F2\u60F5\u60F8\u60FC\u60FD\u6102\u6107\u610A\u610C\u6110", 4, "\u6116\u6117\u6119\u611C\u611E\u6122\u612A\u612B\u6130\u6131\u6135\u6136\u6137\u6139\u6141\u6145\u6146\u6149\u615E\u6160\u616C\u6172\u6178\u617B\u617C\u617F\u6180\u6181\u6183\u6184\u618B\u618D\u6192\u6193\u6197\u6198\u619C\u619D\u619F\u61A0\u61A5\u61A8\u61AA\u61AD\u61B8\u61B9\u61BC\u61C0\u61C1\u61C2\u61CE\u61CF\u61D5\u61DC\u61DD\u61DE\u61DF\u61E1\u61E2\u61E7\u61E9\u61E5"], + ["8fbfa1", "\u61EC\u61ED\u61EF\u6201\u6203\u6204\u6207\u6213\u6215\u621C\u6220\u6222\u6223\u6227\u6229\u622B\u6239\u623D\u6242\u6243\u6244\u6246\u624C\u6250\u6251\u6252\u6254\u6256\u625A\u625C\u6264\u626D\u626F\u6273\u627A\u627D\u628D\u628E\u628F\u6290\u62A6\u62A8\u62B3\u62B6\u62B7\u62BA\u62BE\u62BF\u62C4\u62CE\u62D5\u62D6\u62DA\u62EA\u62F2\u62F4\u62FC\u62FD\u6303\u6304\u630A\u630B\u630D\u6310\u6313\u6316\u6318\u6329\u632A\u632D\u6335\u6336\u6339\u633C\u6341\u6342\u6343\u6344\u6346\u634A\u634B\u634E\u6352\u6353\u6354\u6358\u635B\u6365\u6366\u636C\u636D\u6371\u6374\u6375"], + ["8fc0a1", "\u6378\u637C\u637D\u637F\u6382\u6384\u6387\u638A\u6390\u6394\u6395\u6399\u639A\u639E\u63A4\u63A6\u63AD\u63AE\u63AF\u63BD\u63C1\u63C5\u63C8\u63CE\u63D1\u63D3\u63D4\u63D5\u63DC\u63E0\u63E5\u63EA\u63EC\u63F2\u63F3\u63F5\u63F8\u63F9\u6409\u640A\u6410\u6412\u6414\u6418\u641E\u6420\u6422\u6424\u6425\u6429\u642A\u642F\u6430\u6435\u643D\u643F\u644B\u644F\u6451\u6452\u6453\u6454\u645A\u645B\u645C\u645D\u645F\u6460\u6461\u6463\u646D\u6473\u6474\u647B\u647D\u6485\u6487\u648F\u6490\u6491\u6498\u6499\u649B\u649D\u649F\u64A1\u64A3\u64A6\u64A8\u64AC\u64B3\u64BD\u64BE\u64BF"], + ["8fc1a1", "\u64C4\u64C9\u64CA\u64CB\u64CC\u64CE\u64D0\u64D1\u64D5\u64D7\u64E4\u64E5\u64E9\u64EA\u64ED\u64F0\u64F5\u64F7\u64FB\u64FF\u6501\u6504\u6508\u6509\u650A\u650F\u6513\u6514\u6516\u6519\u651B\u651E\u651F\u6522\u6526\u6529\u652E\u6531\u653A\u653C\u653D\u6543\u6547\u6549\u6550\u6552\u6554\u655F\u6560\u6567\u656B\u657A\u657D\u6581\u6585\u658A\u6592\u6595\u6598\u659D\u65A0\u65A3\u65A6\u65AE\u65B2\u65B3\u65B4\u65BF\u65C2\u65C8\u65C9\u65CE\u65D0\u65D4\u65D6\u65D8\u65DF\u65F0\u65F2\u65F4\u65F5\u65F9\u65FE\u65FF\u6600\u6604\u6608\u6609\u660D\u6611\u6612\u6615\u6616\u661D"], + ["8fc2a1", "\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6631\u6633\u6639\u6637\u6640\u6645\u6646\u664A\u664C\u6651\u664E\u6657\u6658\u6659\u665B\u665C\u6660\u6661\u66FB\u666A\u666B\u666C\u667E\u6673\u6675\u667F\u6677\u6678\u6679\u667B\u6680\u667C\u668B\u668C\u668D\u6690\u6692\u6699\u669A\u669B\u669C\u669F\u66A0\u66A4\u66AD\u66B1\u66B2\u66B5\u66BB\u66BF\u66C0\u66C2\u66C3\u66C8\u66CC\u66CE\u66CF\u66D4\u66DB\u66DF\u66E8\u66EB\u66EC\u66EE\u66FA\u6705\u6707\u670E\u6713\u6719\u671C\u6720\u6722\u6733\u673E\u6745\u6747\u6748\u674C\u6754\u6755\u675D"], + ["8fc3a1", "\u6766\u676C\u676E\u6774\u6776\u677B\u6781\u6784\u678E\u678F\u6791\u6793\u6796\u6798\u6799\u679B\u67B0\u67B1\u67B2\u67B5\u67BB\u67BC\u67BD\u67F9\u67C0\u67C2\u67C3\u67C5\u67C8\u67C9\u67D2\u67D7\u67D9\u67DC\u67E1\u67E6\u67F0\u67F2\u67F6\u67F7\u6852\u6814\u6819\u681D\u681F\u6828\u6827\u682C\u682D\u682F\u6830\u6831\u6833\u683B\u683F\u6844\u6845\u684A\u684C\u6855\u6857\u6858\u685B\u686B\u686E", 4, "\u6875\u6879\u687A\u687B\u687C\u6882\u6884\u6886\u6888\u6896\u6898\u689A\u689C\u68A1\u68A3\u68A5\u68A9\u68AA\u68AE\u68B2\u68BB\u68C5\u68C8\u68CC\u68CF"], + ["8fc4a1", "\u68D0\u68D1\u68D3\u68D6\u68D9\u68DC\u68DD\u68E5\u68E8\u68EA\u68EB\u68EC\u68ED\u68F0\u68F1\u68F5\u68F6\u68FB\u68FC\u68FD\u6906\u6909\u690A\u6910\u6911\u6913\u6916\u6917\u6931\u6933\u6935\u6938\u693B\u6942\u6945\u6949\u694E\u6957\u695B\u6963\u6964\u6965\u6966\u6968\u6969\u696C\u6970\u6971\u6972\u697A\u697B\u697F\u6980\u698D\u6992\u6996\u6998\u69A1\u69A5\u69A6\u69A8\u69AB\u69AD\u69AF\u69B7\u69B8\u69BA\u69BC\u69C5\u69C8\u69D1\u69D6\u69D7\u69E2\u69E5\u69EE\u69EF\u69F1\u69F3\u69F5\u69FE\u6A00\u6A01\u6A03\u6A0F\u6A11\u6A15\u6A1A\u6A1D\u6A20\u6A24\u6A28\u6A30\u6A32"], + ["8fc5a1", "\u6A34\u6A37\u6A3B\u6A3E\u6A3F\u6A45\u6A46\u6A49\u6A4A\u6A4E\u6A50\u6A51\u6A52\u6A55\u6A56\u6A5B\u6A64\u6A67\u6A6A\u6A71\u6A73\u6A7E\u6A81\u6A83\u6A86\u6A87\u6A89\u6A8B\u6A91\u6A9B\u6A9D\u6A9E\u6A9F\u6AA5\u6AAB\u6AAF\u6AB0\u6AB1\u6AB4\u6ABD\u6ABE\u6ABF\u6AC6\u6AC9\u6AC8\u6ACC\u6AD0\u6AD4\u6AD5\u6AD6\u6ADC\u6ADD\u6AE4\u6AE7\u6AEC\u6AF0\u6AF1\u6AF2\u6AFC\u6AFD\u6B02\u6B03\u6B06\u6B07\u6B09\u6B0F\u6B10\u6B11\u6B17\u6B1B\u6B1E\u6B24\u6B28\u6B2B\u6B2C\u6B2F\u6B35\u6B36\u6B3B\u6B3F\u6B46\u6B4A\u6B4D\u6B52\u6B56\u6B58\u6B5D\u6B60\u6B67\u6B6B\u6B6E\u6B70\u6B75\u6B7D"], + ["8fc6a1", "\u6B7E\u6B82\u6B85\u6B97\u6B9B\u6B9F\u6BA0\u6BA2\u6BA3\u6BA8\u6BA9\u6BAC\u6BAD\u6BAE\u6BB0\u6BB8\u6BB9\u6BBD\u6BBE\u6BC3\u6BC4\u6BC9\u6BCC\u6BD6\u6BDA\u6BE1\u6BE3\u6BE6\u6BE7\u6BEE\u6BF1\u6BF7\u6BF9\u6BFF\u6C02\u6C04\u6C05\u6C09\u6C0D\u6C0E\u6C10\u6C12\u6C19\u6C1F\u6C26\u6C27\u6C28\u6C2C\u6C2E\u6C33\u6C35\u6C36\u6C3A\u6C3B\u6C3F\u6C4A\u6C4B\u6C4D\u6C4F\u6C52\u6C54\u6C59\u6C5B\u6C5C\u6C6B\u6C6D\u6C6F\u6C74\u6C76\u6C78\u6C79\u6C7B\u6C85\u6C86\u6C87\u6C89\u6C94\u6C95\u6C97\u6C98\u6C9C\u6C9F\u6CB0\u6CB2\u6CB4\u6CC2\u6CC6\u6CCD\u6CCF\u6CD0\u6CD1\u6CD2\u6CD4\u6CD6"], + ["8fc7a1", "\u6CDA\u6CDC\u6CE0\u6CE7\u6CE9\u6CEB\u6CEC\u6CEE\u6CF2\u6CF4\u6D04\u6D07\u6D0A\u6D0E\u6D0F\u6D11\u6D13\u6D1A\u6D26\u6D27\u6D28\u6C67\u6D2E\u6D2F\u6D31\u6D39\u6D3C\u6D3F\u6D57\u6D5E\u6D5F\u6D61\u6D65\u6D67\u6D6F\u6D70\u6D7C\u6D82\u6D87\u6D91\u6D92\u6D94\u6D96\u6D97\u6D98\u6DAA\u6DAC\u6DB4\u6DB7\u6DB9\u6DBD\u6DBF\u6DC4\u6DC8\u6DCA\u6DCE\u6DCF\u6DD6\u6DDB\u6DDD\u6DDF\u6DE0\u6DE2\u6DE5\u6DE9\u6DEF\u6DF0\u6DF4\u6DF6\u6DFC\u6E00\u6E04\u6E1E\u6E22\u6E27\u6E32\u6E36\u6E39\u6E3B\u6E3C\u6E44\u6E45\u6E48\u6E49\u6E4B\u6E4F\u6E51\u6E52\u6E53\u6E54\u6E57\u6E5C\u6E5D\u6E5E"], + ["8fc8a1", "\u6E62\u6E63\u6E68\u6E73\u6E7B\u6E7D\u6E8D\u6E93\u6E99\u6EA0\u6EA7\u6EAD\u6EAE\u6EB1\u6EB3\u6EBB\u6EBF\u6EC0\u6EC1\u6EC3\u6EC7\u6EC8\u6ECA\u6ECD\u6ECE\u6ECF\u6EEB\u6EED\u6EEE\u6EF9\u6EFB\u6EFD\u6F04\u6F08\u6F0A\u6F0C\u6F0D\u6F16\u6F18\u6F1A\u6F1B\u6F26\u6F29\u6F2A\u6F2F\u6F30\u6F33\u6F36\u6F3B\u6F3C\u6F2D\u6F4F\u6F51\u6F52\u6F53\u6F57\u6F59\u6F5A\u6F5D\u6F5E\u6F61\u6F62\u6F68\u6F6C\u6F7D\u6F7E\u6F83\u6F87\u6F88\u6F8B\u6F8C\u6F8D\u6F90\u6F92\u6F93\u6F94\u6F96\u6F9A\u6F9F\u6FA0\u6FA5\u6FA6\u6FA7\u6FA8\u6FAE\u6FAF\u6FB0\u6FB5\u6FB6\u6FBC\u6FC5\u6FC7\u6FC8\u6FCA"], + ["8fc9a1", "\u6FDA\u6FDE\u6FE8\u6FE9\u6FF0\u6FF5\u6FF9\u6FFC\u6FFD\u7000\u7005\u7006\u7007\u700D\u7017\u7020\u7023\u702F\u7034\u7037\u7039\u703C\u7043\u7044\u7048\u7049\u704A\u704B\u7054\u7055\u705D\u705E\u704E\u7064\u7065\u706C\u706E\u7075\u7076\u707E\u7081\u7085\u7086\u7094", 4, "\u709B\u70A4\u70AB\u70B0\u70B1\u70B4\u70B7\u70CA\u70D1\u70D3\u70D4\u70D5\u70D6\u70D8\u70DC\u70E4\u70FA\u7103", 4, "\u710B\u710C\u710F\u711E\u7120\u712B\u712D\u712F\u7130\u7131\u7138\u7141\u7145\u7146\u7147\u714A\u714B\u7150\u7152\u7157\u715A\u715C\u715E\u7160"], + ["8fcaa1", "\u7168\u7179\u7180\u7185\u7187\u718C\u7192\u719A\u719B\u71A0\u71A2\u71AF\u71B0\u71B2\u71B3\u71BA\u71BF\u71C0\u71C1\u71C4\u71CB\u71CC\u71D3\u71D6\u71D9\u71DA\u71DC\u71F8\u71FE\u7200\u7207\u7208\u7209\u7213\u7217\u721A\u721D\u721F\u7224\u722B\u722F\u7234\u7238\u7239\u7241\u7242\u7243\u7245\u724E\u724F\u7250\u7253\u7255\u7256\u725A\u725C\u725E\u7260\u7263\u7268\u726B\u726E\u726F\u7271\u7277\u7278\u727B\u727C\u727F\u7284\u7289\u728D\u728E\u7293\u729B\u72A8\u72AD\u72AE\u72B1\u72B4\u72BE\u72C1\u72C7\u72C9\u72CC\u72D5\u72D6\u72D8\u72DF\u72E5\u72F3\u72F4\u72FA\u72FB"], + ["8fcba1", "\u72FE\u7302\u7304\u7305\u7307\u730B\u730D\u7312\u7313\u7318\u7319\u731E\u7322\u7324\u7327\u7328\u732C\u7331\u7332\u7335\u733A\u733B\u733D\u7343\u734D\u7350\u7352\u7356\u7358\u735D\u735E\u735F\u7360\u7366\u7367\u7369\u736B\u736C\u736E\u736F\u7371\u7377\u7379\u737C\u7380\u7381\u7383\u7385\u7386\u738E\u7390\u7393\u7395\u7397\u7398\u739C\u739E\u739F\u73A0\u73A2\u73A5\u73A6\u73AA\u73AB\u73AD\u73B5\u73B7\u73B9\u73BC\u73BD\u73BF\u73C5\u73C6\u73C9\u73CB\u73CC\u73CF\u73D2\u73D3\u73D6\u73D9\u73DD\u73E1\u73E3\u73E6\u73E7\u73E9\u73F4\u73F5\u73F7\u73F9\u73FA\u73FB\u73FD"], + ["8fcca1", "\u73FF\u7400\u7401\u7404\u7407\u740A\u7411\u741A\u741B\u7424\u7426\u7428", 9, "\u7439\u7440\u7443\u7444\u7446\u7447\u744B\u744D\u7451\u7452\u7457\u745D\u7462\u7466\u7467\u7468\u746B\u746D\u746E\u7471\u7472\u7480\u7481\u7485\u7486\u7487\u7489\u748F\u7490\u7491\u7492\u7498\u7499\u749A\u749C\u749F\u74A0\u74A1\u74A3\u74A6\u74A8\u74A9\u74AA\u74AB\u74AE\u74AF\u74B1\u74B2\u74B5\u74B9\u74BB\u74BF\u74C8\u74C9\u74CC\u74D0\u74D3\u74D8\u74DA\u74DB\u74DE\u74DF\u74E4\u74E8\u74EA\u74EB\u74EF\u74F4\u74FA\u74FB\u74FC\u74FF\u7506"], + ["8fcda1", "\u7512\u7516\u7517\u7520\u7521\u7524\u7527\u7529\u752A\u752F\u7536\u7539\u753D\u753E\u753F\u7540\u7543\u7547\u7548\u754E\u7550\u7552\u7557\u755E\u755F\u7561\u756F\u7571\u7579", 5, "\u7581\u7585\u7590\u7592\u7593\u7595\u7599\u759C\u75A2\u75A4\u75B4\u75BA\u75BF\u75C0\u75C1\u75C4\u75C6\u75CC\u75CE\u75CF\u75D7\u75DC\u75DF\u75E0\u75E1\u75E4\u75E7\u75EC\u75EE\u75EF\u75F1\u75F9\u7600\u7602\u7603\u7604\u7607\u7608\u760A\u760C\u760F\u7612\u7613\u7615\u7616\u7619\u761B\u761C\u761D\u761E\u7623\u7625\u7626\u7629\u762D\u7632\u7633\u7635\u7638\u7639"], + ["8fcea1", "\u763A\u763C\u764A\u7640\u7641\u7643\u7644\u7645\u7649\u764B\u7655\u7659\u765F\u7664\u7665\u766D\u766E\u766F\u7671\u7674\u7681\u7685\u768C\u768D\u7695\u769B\u769C\u769D\u769F\u76A0\u76A2", 6, "\u76AA\u76AD\u76BD\u76C1\u76C5\u76C9\u76CB\u76CC\u76CE\u76D4\u76D9\u76E0\u76E6\u76E8\u76EC\u76F0\u76F1\u76F6\u76F9\u76FC\u7700\u7706\u770A\u770E\u7712\u7714\u7715\u7717\u7719\u771A\u771C\u7722\u7728\u772D\u772E\u772F\u7734\u7735\u7736\u7739\u773D\u773E\u7742\u7745\u7746\u774A\u774D\u774E\u774F\u7752\u7756\u7757\u775C\u775E\u775F\u7760\u7762"], + ["8fcfa1", "\u7764\u7767\u776A\u776C\u7770\u7772\u7773\u7774\u777A\u777D\u7780\u7784\u778C\u778D\u7794\u7795\u7796\u779A\u779F\u77A2\u77A7\u77AA\u77AE\u77AF\u77B1\u77B5\u77BE\u77C3\u77C9\u77D1\u77D2\u77D5\u77D9\u77DE\u77DF\u77E0\u77E4\u77E6\u77EA\u77EC\u77F0\u77F1\u77F4\u77F8\u77FB\u7805\u7806\u7809\u780D\u780E\u7811\u781D\u7821\u7822\u7823\u782D\u782E\u7830\u7835\u7837\u7843\u7844\u7847\u7848\u784C\u784E\u7852\u785C\u785E\u7860\u7861\u7863\u7864\u7868\u786A\u786E\u787A\u787E\u788A\u788F\u7894\u7898\u78A1\u789D\u789E\u789F\u78A4\u78A8\u78AC\u78AD\u78B0\u78B1\u78B2\u78B3"], + ["8fd0a1", "\u78BB\u78BD\u78BF\u78C7\u78C8\u78C9\u78CC\u78CE\u78D2\u78D3\u78D5\u78D6\u78E4\u78DB\u78DF\u78E0\u78E1\u78E6\u78EA\u78F2\u78F3\u7900\u78F6\u78F7\u78FA\u78FB\u78FF\u7906\u790C\u7910\u791A\u791C\u791E\u791F\u7920\u7925\u7927\u7929\u792D\u7931\u7934\u7935\u793B\u793D\u793F\u7944\u7945\u7946\u794A\u794B\u794F\u7951\u7954\u7958\u795B\u795C\u7967\u7969\u796B\u7972\u7979\u797B\u797C\u797E\u798B\u798C\u7991\u7993\u7994\u7995\u7996\u7998\u799B\u799C\u79A1\u79A8\u79A9\u79AB\u79AF\u79B1\u79B4\u79B8\u79BB\u79C2\u79C4\u79C7\u79C8\u79CA\u79CF\u79D4\u79D6\u79DA\u79DD\u79DE"], + ["8fd1a1", "\u79E0\u79E2\u79E5\u79EA\u79EB\u79ED\u79F1\u79F8\u79FC\u7A02\u7A03\u7A07\u7A09\u7A0A\u7A0C\u7A11\u7A15\u7A1B\u7A1E\u7A21\u7A27\u7A2B\u7A2D\u7A2F\u7A30\u7A34\u7A35\u7A38\u7A39\u7A3A\u7A44\u7A45\u7A47\u7A48\u7A4C\u7A55\u7A56\u7A59\u7A5C\u7A5D\u7A5F\u7A60\u7A65\u7A67\u7A6A\u7A6D\u7A75\u7A78\u7A7E\u7A80\u7A82\u7A85\u7A86\u7A8A\u7A8B\u7A90\u7A91\u7A94\u7A9E\u7AA0\u7AA3\u7AAC\u7AB3\u7AB5\u7AB9\u7ABB\u7ABC\u7AC6\u7AC9\u7ACC\u7ACE\u7AD1\u7ADB\u7AE8\u7AE9\u7AEB\u7AEC\u7AF1\u7AF4\u7AFB\u7AFD\u7AFE\u7B07\u7B14\u7B1F\u7B23\u7B27\u7B29\u7B2A\u7B2B\u7B2D\u7B2E\u7B2F\u7B30"], + ["8fd2a1", "\u7B31\u7B34\u7B3D\u7B3F\u7B40\u7B41\u7B47\u7B4E\u7B55\u7B60\u7B64\u7B66\u7B69\u7B6A\u7B6D\u7B6F\u7B72\u7B73\u7B77\u7B84\u7B89\u7B8E\u7B90\u7B91\u7B96\u7B9B\u7B9E\u7BA0\u7BA5\u7BAC\u7BAF\u7BB0\u7BB2\u7BB5\u7BB6\u7BBA\u7BBB\u7BBC\u7BBD\u7BC2\u7BC5\u7BC8\u7BCA\u7BD4\u7BD6\u7BD7\u7BD9\u7BDA\u7BDB\u7BE8\u7BEA\u7BF2\u7BF4\u7BF5\u7BF8\u7BF9\u7BFA\u7BFC\u7BFE\u7C01\u7C02\u7C03\u7C04\u7C06\u7C09\u7C0B\u7C0C\u7C0E\u7C0F\u7C19\u7C1B\u7C20\u7C25\u7C26\u7C28\u7C2C\u7C31\u7C33\u7C34\u7C36\u7C39\u7C3A\u7C46\u7C4A\u7C55\u7C51\u7C52\u7C53\u7C59", 5], + ["8fd3a1", "\u7C61\u7C63\u7C67\u7C69\u7C6D\u7C6E\u7C70\u7C72\u7C79\u7C7C\u7C7D\u7C86\u7C87\u7C8F\u7C94\u7C9E\u7CA0\u7CA6\u7CB0\u7CB6\u7CB7\u7CBA\u7CBB\u7CBC\u7CBF\u7CC4\u7CC7\u7CC8\u7CC9\u7CCD\u7CCF\u7CD3\u7CD4\u7CD5\u7CD7\u7CD9\u7CDA\u7CDD\u7CE6\u7CE9\u7CEB\u7CF5\u7D03\u7D07\u7D08\u7D09\u7D0F\u7D11\u7D12\u7D13\u7D16\u7D1D\u7D1E\u7D23\u7D26\u7D2A\u7D2D\u7D31\u7D3C\u7D3D\u7D3E\u7D40\u7D41\u7D47\u7D48\u7D4D\u7D51\u7D53\u7D57\u7D59\u7D5A\u7D5C\u7D5D\u7D65\u7D67\u7D6A\u7D70\u7D78\u7D7A\u7D7B\u7D7F\u7D81\u7D82\u7D83\u7D85\u7D86\u7D88\u7D8B\u7D8C\u7D8D\u7D91\u7D96\u7D97\u7D9D"], + ["8fd4a1", "\u7D9E\u7DA6\u7DA7\u7DAA\u7DB3\u7DB6\u7DB7\u7DB9\u7DC2", 4, "\u7DCC\u7DCD\u7DCE\u7DD7\u7DD9\u7E00\u7DE2\u7DE5\u7DE6\u7DEA\u7DEB\u7DED\u7DF1\u7DF5\u7DF6\u7DF9\u7DFA\u7E08\u7E10\u7E11\u7E15\u7E17\u7E1C\u7E1D\u7E20\u7E27\u7E28\u7E2C\u7E2D\u7E2F\u7E33\u7E36\u7E3F\u7E44\u7E45\u7E47\u7E4E\u7E50\u7E52\u7E58\u7E5F\u7E61\u7E62\u7E65\u7E6B\u7E6E\u7E6F\u7E73\u7E78\u7E7E\u7E81\u7E86\u7E87\u7E8A\u7E8D\u7E91\u7E95\u7E98\u7E9A\u7E9D\u7E9E\u7F3C\u7F3B\u7F3D\u7F3E\u7F3F\u7F43\u7F44\u7F47\u7F4F\u7F52\u7F53\u7F5B\u7F5C\u7F5D\u7F61\u7F63\u7F64\u7F65\u7F66\u7F6D"], + ["8fd5a1", "\u7F71\u7F7D\u7F7E\u7F7F\u7F80\u7F8B\u7F8D\u7F8F\u7F90\u7F91\u7F96\u7F97\u7F9C\u7FA1\u7FA2\u7FA6\u7FAA\u7FAD\u7FB4\u7FBC\u7FBF\u7FC0\u7FC3\u7FC8\u7FCE\u7FCF\u7FDB\u7FDF\u7FE3\u7FE5\u7FE8\u7FEC\u7FEE\u7FEF\u7FF2\u7FFA\u7FFD\u7FFE\u7FFF\u8007\u8008\u800A\u800D\u800E\u800F\u8011\u8013\u8014\u8016\u801D\u801E\u801F\u8020\u8024\u8026\u802C\u802E\u8030\u8034\u8035\u8037\u8039\u803A\u803C\u803E\u8040\u8044\u8060\u8064\u8066\u806D\u8071\u8075\u8081\u8088\u808E\u809C\u809E\u80A6\u80A7\u80AB\u80B8\u80B9\u80C8\u80CD\u80CF\u80D2\u80D4\u80D5\u80D7\u80D8\u80E0\u80ED\u80EE"], + ["8fd6a1", "\u80F0\u80F2\u80F3\u80F6\u80F9\u80FA\u80FE\u8103\u810B\u8116\u8117\u8118\u811C\u811E\u8120\u8124\u8127\u812C\u8130\u8135\u813A\u813C\u8145\u8147\u814A\u814C\u8152\u8157\u8160\u8161\u8167\u8168\u8169\u816D\u816F\u8177\u8181\u8190\u8184\u8185\u8186\u818B\u818E\u8196\u8198\u819B\u819E\u81A2\u81AE\u81B2\u81B4\u81BB\u81CB\u81C3\u81C5\u81CA\u81CE\u81CF\u81D5\u81D7\u81DB\u81DD\u81DE\u81E1\u81E4\u81EB\u81EC\u81F0\u81F1\u81F2\u81F5\u81F6\u81F8\u81F9\u81FD\u81FF\u8200\u8203\u820F\u8213\u8214\u8219\u821A\u821D\u8221\u8222\u8228\u8232\u8234\u823A\u8243\u8244\u8245\u8246"], + ["8fd7a1", "\u824B\u824E\u824F\u8251\u8256\u825C\u8260\u8263\u8267\u826D\u8274\u827B\u827D\u827F\u8280\u8281\u8283\u8284\u8287\u8289\u828A\u828E\u8291\u8294\u8296\u8298\u829A\u829B\u82A0\u82A1\u82A3\u82A4\u82A7\u82A8\u82A9\u82AA\u82AE\u82B0\u82B2\u82B4\u82B7\u82BA\u82BC\u82BE\u82BF\u82C6\u82D0\u82D5\u82DA\u82E0\u82E2\u82E4\u82E8\u82EA\u82ED\u82EF\u82F6\u82F7\u82FD\u82FE\u8300\u8301\u8307\u8308\u830A\u830B\u8354\u831B\u831D\u831E\u831F\u8321\u8322\u832C\u832D\u832E\u8330\u8333\u8337\u833A\u833C\u833D\u8342\u8343\u8344\u8347\u834D\u834E\u8351\u8355\u8356\u8357\u8370\u8378"], + ["8fd8a1", "\u837D\u837F\u8380\u8382\u8384\u8386\u838D\u8392\u8394\u8395\u8398\u8399\u839B\u839C\u839D\u83A6\u83A7\u83A9\u83AC\u83BE\u83BF\u83C0\u83C7\u83C9\u83CF\u83D0\u83D1\u83D4\u83DD\u8353\u83E8\u83EA\u83F6\u83F8\u83F9\u83FC\u8401\u8406\u840A\u840F\u8411\u8415\u8419\u83AD\u842F\u8439\u8445\u8447\u8448\u844A\u844D\u844F\u8451\u8452\u8456\u8458\u8459\u845A\u845C\u8460\u8464\u8465\u8467\u846A\u8470\u8473\u8474\u8476\u8478\u847C\u847D\u8481\u8485\u8492\u8493\u8495\u849E\u84A6\u84A8\u84A9\u84AA\u84AF\u84B1\u84B4\u84BA\u84BD\u84BE\u84C0\u84C2\u84C7\u84C8\u84CC\u84CF\u84D3"], + ["8fd9a1", "\u84DC\u84E7\u84EA\u84EF\u84F0\u84F1\u84F2\u84F7\u8532\u84FA\u84FB\u84FD\u8502\u8503\u8507\u850C\u850E\u8510\u851C\u851E\u8522\u8523\u8524\u8525\u8527\u852A\u852B\u852F\u8533\u8534\u8536\u853F\u8546\u854F", 4, "\u8556\u8559\u855C", 6, "\u8564\u856B\u856F\u8579\u857A\u857B\u857D\u857F\u8581\u8585\u8586\u8589\u858B\u858C\u858F\u8593\u8598\u859D\u859F\u85A0\u85A2\u85A5\u85A7\u85B4\u85B6\u85B7\u85B8\u85BC\u85BD\u85BE\u85BF\u85C2\u85C7\u85CA\u85CB\u85CE\u85AD\u85D8\u85DA\u85DF\u85E0\u85E6\u85E8\u85ED\u85F3\u85F6\u85FC"], + ["8fdaa1", "\u85FF\u8600\u8604\u8605\u860D\u860E\u8610\u8611\u8612\u8618\u8619\u861B\u861E\u8621\u8627\u8629\u8636\u8638\u863A\u863C\u863D\u8640\u8642\u8646\u8652\u8653\u8656\u8657\u8658\u8659\u865D\u8660", 4, "\u8669\u866C\u866F\u8675\u8676\u8677\u867A\u868D\u8691\u8696\u8698\u869A\u869C\u86A1\u86A6\u86A7\u86A8\u86AD\u86B1\u86B3\u86B4\u86B5\u86B7\u86B8\u86B9\u86BF\u86C0\u86C1\u86C3\u86C5\u86D1\u86D2\u86D5\u86D7\u86DA\u86DC\u86E0\u86E3\u86E5\u86E7\u8688\u86FA\u86FC\u86FD\u8704\u8705\u8707\u870B\u870E\u870F\u8710\u8713\u8714\u8719\u871E\u871F\u8721\u8723"], + ["8fdba1", "\u8728\u872E\u872F\u8731\u8732\u8739\u873A\u873C\u873D\u873E\u8740\u8743\u8745\u874D\u8758\u875D\u8761\u8764\u8765\u876F\u8771\u8772\u877B\u8783", 6, "\u878B\u878C\u8790\u8793\u8795\u8797\u8798\u8799\u879E\u87A0\u87A3\u87A7\u87AC\u87AD\u87AE\u87B1\u87B5\u87BE\u87BF\u87C1\u87C8\u87C9\u87CA\u87CE\u87D5\u87D6\u87D9\u87DA\u87DC\u87DF\u87E2\u87E3\u87E4\u87EA\u87EB\u87ED\u87F1\u87F3\u87F8\u87FA\u87FF\u8801\u8803\u8806\u8809\u880A\u880B\u8810\u8819\u8812\u8813\u8814\u8818\u881A\u881B\u881C\u881E\u881F\u8828\u882D\u882E\u8830\u8832\u8835"], + ["8fdca1", "\u883A\u883C\u8841\u8843\u8845\u8848\u8849\u884A\u884B\u884E\u8851\u8855\u8856\u8858\u885A\u885C\u885F\u8860\u8864\u8869\u8871\u8879\u887B\u8880\u8898\u889A\u889B\u889C\u889F\u88A0\u88A8\u88AA\u88BA\u88BD\u88BE\u88C0\u88CA", 4, "\u88D1\u88D2\u88D3\u88DB\u88DE\u88E7\u88EF\u88F0\u88F1\u88F5\u88F7\u8901\u8906\u890D\u890E\u890F\u8915\u8916\u8918\u8919\u891A\u891C\u8920\u8926\u8927\u8928\u8930\u8931\u8932\u8935\u8939\u893A\u893E\u8940\u8942\u8945\u8946\u8949\u894F\u8952\u8957\u895A\u895B\u895C\u8961\u8962\u8963\u896B\u896E\u8970\u8973\u8975\u897A"], + ["8fdda1", "\u897B\u897C\u897D\u8989\u898D\u8990\u8994\u8995\u899B\u899C\u899F\u89A0\u89A5\u89B0\u89B4\u89B5\u89B6\u89B7\u89BC\u89D4", 4, "\u89E5\u89E9\u89EB\u89ED\u89F1\u89F3\u89F6\u89F9\u89FD\u89FF\u8A04\u8A05\u8A07\u8A0F\u8A11\u8A12\u8A14\u8A15\u8A1E\u8A20\u8A22\u8A24\u8A26\u8A2B\u8A2C\u8A2F\u8A35\u8A37\u8A3D\u8A3E\u8A40\u8A43\u8A45\u8A47\u8A49\u8A4D\u8A4E\u8A53\u8A56\u8A57\u8A58\u8A5C\u8A5D\u8A61\u8A65\u8A67\u8A75\u8A76\u8A77\u8A79\u8A7A\u8A7B\u8A7E\u8A7F\u8A80\u8A83\u8A86\u8A8B\u8A8F\u8A90\u8A92\u8A96\u8A97\u8A99\u8A9F\u8AA7\u8AA9\u8AAE\u8AAF\u8AB3"], + ["8fdea1", "\u8AB6\u8AB7\u8ABB\u8ABE\u8AC3\u8AC6\u8AC8\u8AC9\u8ACA\u8AD1\u8AD3\u8AD4\u8AD5\u8AD7\u8ADD\u8ADF\u8AEC\u8AF0\u8AF4\u8AF5\u8AF6\u8AFC\u8AFF\u8B05\u8B06\u8B0B\u8B11\u8B1C\u8B1E\u8B1F\u8B0A\u8B2D\u8B30\u8B37\u8B3C\u8B42", 4, "\u8B48\u8B52\u8B53\u8B54\u8B59\u8B4D\u8B5E\u8B63\u8B6D\u8B76\u8B78\u8B79\u8B7C\u8B7E\u8B81\u8B84\u8B85\u8B8B\u8B8D\u8B8F\u8B94\u8B95\u8B9C\u8B9E\u8B9F\u8C38\u8C39\u8C3D\u8C3E\u8C45\u8C47\u8C49\u8C4B\u8C4F\u8C51\u8C53\u8C54\u8C57\u8C58\u8C5B\u8C5D\u8C59\u8C63\u8C64\u8C66\u8C68\u8C69\u8C6D\u8C73\u8C75\u8C76\u8C7B\u8C7E\u8C86"], + ["8fdfa1", "\u8C87\u8C8B\u8C90\u8C92\u8C93\u8C99\u8C9B\u8C9C\u8CA4\u8CB9\u8CBA\u8CC5\u8CC6\u8CC9\u8CCB\u8CCF\u8CD6\u8CD5\u8CD9\u8CDD\u8CE1\u8CE8\u8CEC\u8CEF\u8CF0\u8CF2\u8CF5\u8CF7\u8CF8\u8CFE\u8CFF\u8D01\u8D03\u8D09\u8D12\u8D17\u8D1B\u8D65\u8D69\u8D6C\u8D6E\u8D7F\u8D82\u8D84\u8D88\u8D8D\u8D90\u8D91\u8D95\u8D9E\u8D9F\u8DA0\u8DA6\u8DAB\u8DAC\u8DAF\u8DB2\u8DB5\u8DB7\u8DB9\u8DBB\u8DC0\u8DC5\u8DC6\u8DC7\u8DC8\u8DCA\u8DCE\u8DD1\u8DD4\u8DD5\u8DD7\u8DD9\u8DE4\u8DE5\u8DE7\u8DEC\u8DF0\u8DBC\u8DF1\u8DF2\u8DF4\u8DFD\u8E01\u8E04\u8E05\u8E06\u8E0B\u8E11\u8E14\u8E16\u8E20\u8E21\u8E22"], + ["8fe0a1", "\u8E23\u8E26\u8E27\u8E31\u8E33\u8E36\u8E37\u8E38\u8E39\u8E3D\u8E40\u8E41\u8E4B\u8E4D\u8E4E\u8E4F\u8E54\u8E5B\u8E5C\u8E5D\u8E5E\u8E61\u8E62\u8E69\u8E6C\u8E6D\u8E6F\u8E70\u8E71\u8E79\u8E7A\u8E7B\u8E82\u8E83\u8E89\u8E90\u8E92\u8E95\u8E9A\u8E9B\u8E9D\u8E9E\u8EA2\u8EA7\u8EA9\u8EAD\u8EAE\u8EB3\u8EB5\u8EBA\u8EBB\u8EC0\u8EC1\u8EC3\u8EC4\u8EC7\u8ECF\u8ED1\u8ED4\u8EDC\u8EE8\u8EEE\u8EF0\u8EF1\u8EF7\u8EF9\u8EFA\u8EED\u8F00\u8F02\u8F07\u8F08\u8F0F\u8F10\u8F16\u8F17\u8F18\u8F1E\u8F20\u8F21\u8F23\u8F25\u8F27\u8F28\u8F2C\u8F2D\u8F2E\u8F34\u8F35\u8F36\u8F37\u8F3A\u8F40\u8F41"], + ["8fe1a1", "\u8F43\u8F47\u8F4F\u8F51", 4, "\u8F58\u8F5D\u8F5E\u8F65\u8F9D\u8FA0\u8FA1\u8FA4\u8FA5\u8FA6\u8FB5\u8FB6\u8FB8\u8FBE\u8FC0\u8FC1\u8FC6\u8FCA\u8FCB\u8FCD\u8FD0\u8FD2\u8FD3\u8FD5\u8FE0\u8FE3\u8FE4\u8FE8\u8FEE\u8FF1\u8FF5\u8FF6\u8FFB\u8FFE\u9002\u9004\u9008\u900C\u9018\u901B\u9028\u9029\u902F\u902A\u902C\u902D\u9033\u9034\u9037\u903F\u9043\u9044\u904C\u905B\u905D\u9062\u9066\u9067\u906C\u9070\u9074\u9079\u9085\u9088\u908B\u908C\u908E\u9090\u9095\u9097\u9098\u9099\u909B\u90A0\u90A1\u90A2\u90A5\u90B0\u90B2\u90B3\u90B4\u90B6\u90BD\u90CC\u90BE\u90C3"], + ["8fe2a1", "\u90C4\u90C5\u90C7\u90C8\u90D5\u90D7\u90D8\u90D9\u90DC\u90DD\u90DF\u90E5\u90D2\u90F6\u90EB\u90EF\u90F0\u90F4\u90FE\u90FF\u9100\u9104\u9105\u9106\u9108\u910D\u9110\u9114\u9116\u9117\u9118\u911A\u911C\u911E\u9120\u9125\u9122\u9123\u9127\u9129\u912E\u912F\u9131\u9134\u9136\u9137\u9139\u913A\u913C\u913D\u9143\u9147\u9148\u914F\u9153\u9157\u9159\u915A\u915B\u9161\u9164\u9167\u916D\u9174\u9179\u917A\u917B\u9181\u9183\u9185\u9186\u918A\u918E\u9191\u9193\u9194\u9195\u9198\u919E\u91A1\u91A6\u91A8\u91AC\u91AD\u91AE\u91B0\u91B1\u91B2\u91B3\u91B6\u91BB\u91BC\u91BD\u91BF"], + ["8fe3a1", "\u91C2\u91C3\u91C5\u91D3\u91D4\u91D7\u91D9\u91DA\u91DE\u91E4\u91E5\u91E9\u91EA\u91EC", 5, "\u91F7\u91F9\u91FB\u91FD\u9200\u9201\u9204\u9205\u9206\u9207\u9209\u920A\u920C\u9210\u9212\u9213\u9216\u9218\u921C\u921D\u9223\u9224\u9225\u9226\u9228\u922E\u922F\u9230\u9233\u9235\u9236\u9238\u9239\u923A\u923C\u923E\u9240\u9242\u9243\u9246\u9247\u924A\u924D\u924E\u924F\u9251\u9258\u9259\u925C\u925D\u9260\u9261\u9265\u9267\u9268\u9269\u926E\u926F\u9270\u9275", 4, "\u927B\u927C\u927D\u927F\u9288\u9289\u928A\u928D\u928E\u9292\u9297"], + ["8fe4a1", "\u9299\u929F\u92A0\u92A4\u92A5\u92A7\u92A8\u92AB\u92AF\u92B2\u92B6\u92B8\u92BA\u92BB\u92BC\u92BD\u92BF", 4, "\u92C5\u92C6\u92C7\u92C8\u92CB\u92CC\u92CD\u92CE\u92D0\u92D3\u92D5\u92D7\u92D8\u92D9\u92DC\u92DD\u92DF\u92E0\u92E1\u92E3\u92E5\u92E7\u92E8\u92EC\u92EE\u92F0\u92F9\u92FB\u92FF\u9300\u9302\u9308\u930D\u9311\u9314\u9315\u931C\u931D\u931E\u931F\u9321\u9324\u9325\u9327\u9329\u932A\u9333\u9334\u9336\u9337\u9347\u9348\u9349\u9350\u9351\u9352\u9355\u9357\u9358\u935A\u935E\u9364\u9365\u9367\u9369\u936A\u936D\u936F\u9370\u9371\u9373\u9374\u9376"], + ["8fe5a1", "\u937A\u937D\u937F\u9380\u9381\u9382\u9388\u938A\u938B\u938D\u938F\u9392\u9395\u9398\u939B\u939E\u93A1\u93A3\u93A4\u93A6\u93A8\u93AB\u93B4\u93B5\u93B6\u93BA\u93A9\u93C1\u93C4\u93C5\u93C6\u93C7\u93C9", 4, "\u93D3\u93D9\u93DC\u93DE\u93DF\u93E2\u93E6\u93E7\u93F9\u93F7\u93F8\u93FA\u93FB\u93FD\u9401\u9402\u9404\u9408\u9409\u940D\u940E\u940F\u9415\u9416\u9417\u941F\u942E\u942F\u9431\u9432\u9433\u9434\u943B\u943F\u943D\u9443\u9445\u9448\u944A\u944C\u9455\u9459\u945C\u945F\u9461\u9463\u9468\u946B\u946D\u946E\u946F\u9471\u9472\u9484\u9483\u9578\u9579"], + ["8fe6a1", "\u957E\u9584\u9588\u958C\u958D\u958E\u959D\u959E\u959F\u95A1\u95A6\u95A9\u95AB\u95AC\u95B4\u95B6\u95BA\u95BD\u95BF\u95C6\u95C8\u95C9\u95CB\u95D0\u95D1\u95D2\u95D3\u95D9\u95DA\u95DD\u95DE\u95DF\u95E0\u95E4\u95E6\u961D\u961E\u9622\u9624\u9625\u9626\u962C\u9631\u9633\u9637\u9638\u9639\u963A\u963C\u963D\u9641\u9652\u9654\u9656\u9657\u9658\u9661\u966E\u9674\u967B\u967C\u967E\u967F\u9681\u9682\u9683\u9684\u9689\u9691\u9696\u969A\u969D\u969F\u96A4\u96A5\u96A6\u96A9\u96AE\u96AF\u96B3\u96BA\u96CA\u96D2\u5DB2\u96D8\u96DA\u96DD\u96DE\u96DF\u96E9\u96EF\u96F1\u96FA\u9702"], + ["8fe7a1", "\u9703\u9705\u9709\u971A\u971B\u971D\u9721\u9722\u9723\u9728\u9731\u9733\u9741\u9743\u974A\u974E\u974F\u9755\u9757\u9758\u975A\u975B\u9763\u9767\u976A\u976E\u9773\u9776\u9777\u9778\u977B\u977D\u977F\u9780\u9789\u9795\u9796\u9797\u9799\u979A\u979E\u979F\u97A2\u97AC\u97AE\u97B1\u97B2\u97B5\u97B6\u97B8\u97B9\u97BA\u97BC\u97BE\u97BF\u97C1\u97C4\u97C5\u97C7\u97C9\u97CA\u97CC\u97CD\u97CE\u97D0\u97D1\u97D4\u97D7\u97D8\u97D9\u97DD\u97DE\u97E0\u97DB\u97E1\u97E4\u97EF\u97F1\u97F4\u97F7\u97F8\u97FA\u9807\u980A\u9819\u980D\u980E\u9814\u9816\u981C\u981E\u9820\u9823\u9826"], + ["8fe8a1", "\u982B\u982E\u982F\u9830\u9832\u9833\u9835\u9825\u983E\u9844\u9847\u984A\u9851\u9852\u9853\u9856\u9857\u9859\u985A\u9862\u9863\u9865\u9866\u986A\u986C\u98AB\u98AD\u98AE\u98B0\u98B4\u98B7\u98B8\u98BA\u98BB\u98BF\u98C2\u98C5\u98C8\u98CC\u98E1\u98E3\u98E5\u98E6\u98E7\u98EA\u98F3\u98F6\u9902\u9907\u9908\u9911\u9915\u9916\u9917\u991A\u991B\u991C\u991F\u9922\u9926\u9927\u992B\u9931", 4, "\u9939\u993A\u993B\u993C\u9940\u9941\u9946\u9947\u9948\u994D\u994E\u9954\u9958\u9959\u995B\u995C\u995E\u995F\u9960\u999B\u999D\u999F\u99A6\u99B0\u99B1\u99B2\u99B5"], + ["8fe9a1", "\u99B9\u99BA\u99BD\u99BF\u99C3\u99C9\u99D3\u99D4\u99D9\u99DA\u99DC\u99DE\u99E7\u99EA\u99EB\u99EC\u99F0\u99F4\u99F5\u99F9\u99FD\u99FE\u9A02\u9A03\u9A04\u9A0B\u9A0C\u9A10\u9A11\u9A16\u9A1E\u9A20\u9A22\u9A23\u9A24\u9A27\u9A2D\u9A2E\u9A33\u9A35\u9A36\u9A38\u9A47\u9A41\u9A44\u9A4A\u9A4B\u9A4C\u9A4E\u9A51\u9A54\u9A56\u9A5D\u9AAA\u9AAC\u9AAE\u9AAF\u9AB2\u9AB4\u9AB5\u9AB6\u9AB9\u9ABB\u9ABE\u9ABF\u9AC1\u9AC3\u9AC6\u9AC8\u9ACE\u9AD0\u9AD2\u9AD5\u9AD6\u9AD7\u9ADB\u9ADC\u9AE0\u9AE4\u9AE5\u9AE7\u9AE9\u9AEC\u9AF2\u9AF3\u9AF5\u9AF9\u9AFA\u9AFD\u9AFF", 4], + ["8feaa1", "\u9B04\u9B05\u9B08\u9B09\u9B0B\u9B0C\u9B0D\u9B0E\u9B10\u9B12\u9B16\u9B19\u9B1B\u9B1C\u9B20\u9B26\u9B2B\u9B2D\u9B33\u9B34\u9B35\u9B37\u9B39\u9B3A\u9B3D\u9B48\u9B4B\u9B4C\u9B55\u9B56\u9B57\u9B5B\u9B5E\u9B61\u9B63\u9B65\u9B66\u9B68\u9B6A", 4, "\u9B73\u9B75\u9B77\u9B78\u9B79\u9B7F\u9B80\u9B84\u9B85\u9B86\u9B87\u9B89\u9B8A\u9B8B\u9B8D\u9B8F\u9B90\u9B94\u9B9A\u9B9D\u9B9E\u9BA6\u9BA7\u9BA9\u9BAC\u9BB0\u9BB1\u9BB2\u9BB7\u9BB8\u9BBB\u9BBC\u9BBE\u9BBF\u9BC1\u9BC7\u9BC8\u9BCE\u9BD0\u9BD7\u9BD8\u9BDD\u9BDF\u9BE5\u9BE7\u9BEA\u9BEB\u9BEF\u9BF3\u9BF7\u9BF8"], + ["8feba1", "\u9BF9\u9BFA\u9BFD\u9BFF\u9C00\u9C02\u9C0B\u9C0F\u9C11\u9C16\u9C18\u9C19\u9C1A\u9C1C\u9C1E\u9C22\u9C23\u9C26", 4, "\u9C31\u9C35\u9C36\u9C37\u9C3D\u9C41\u9C43\u9C44\u9C45\u9C49\u9C4A\u9C4E\u9C4F\u9C50\u9C53\u9C54\u9C56\u9C58\u9C5B\u9C5D\u9C5E\u9C5F\u9C63\u9C69\u9C6A\u9C5C\u9C6B\u9C68\u9C6E\u9C70\u9C72\u9C75\u9C77\u9C7B\u9CE6\u9CF2\u9CF7\u9CF9\u9D0B\u9D02\u9D11\u9D17\u9D18\u9D1C\u9D1D\u9D1E\u9D2F\u9D30\u9D32\u9D33\u9D34\u9D3A\u9D3C\u9D45\u9D3D\u9D42\u9D43\u9D47\u9D4A\u9D53\u9D54\u9D5F\u9D63\u9D62\u9D65\u9D69\u9D6A\u9D6B\u9D70\u9D76\u9D77\u9D7B"], + ["8feca1", "\u9D7C\u9D7E\u9D83\u9D84\u9D86\u9D8A\u9D8D\u9D8E\u9D92\u9D93\u9D95\u9D96\u9D97\u9D98\u9DA1\u9DAA\u9DAC\u9DAE\u9DB1\u9DB5\u9DB9\u9DBC\u9DBF\u9DC3\u9DC7\u9DC9\u9DCA\u9DD4\u9DD5\u9DD6\u9DD7\u9DDA\u9DDE\u9DDF\u9DE0\u9DE5\u9DE7\u9DE9\u9DEB\u9DEE\u9DF0\u9DF3\u9DF4\u9DFE\u9E0A\u9E02\u9E07\u9E0E\u9E10\u9E11\u9E12\u9E15\u9E16\u9E19\u9E1C\u9E1D\u9E7A\u9E7B\u9E7C\u9E80\u9E82\u9E83\u9E84\u9E85\u9E87\u9E8E\u9E8F\u9E96\u9E98\u9E9B\u9E9E\u9EA4\u9EA8\u9EAC\u9EAE\u9EAF\u9EB0\u9EB3\u9EB4\u9EB5\u9EC6\u9EC8\u9ECB\u9ED5\u9EDF\u9EE4\u9EE7\u9EEC\u9EED\u9EEE\u9EF0\u9EF1\u9EF2\u9EF5"], + ["8feda1", "\u9EF8\u9EFF\u9F02\u9F03\u9F09\u9F0F\u9F10\u9F11\u9F12\u9F14\u9F16\u9F17\u9F19\u9F1A\u9F1B\u9F1F\u9F22\u9F26\u9F2A\u9F2B\u9F2F\u9F31\u9F32\u9F34\u9F37\u9F39\u9F3A\u9F3C\u9F3D\u9F3F\u9F41\u9F43", 4, "\u9F53\u9F55\u9F56\u9F57\u9F58\u9F5A\u9F5D\u9F5E\u9F68\u9F69\u9F6D", 4, "\u9F73\u9F75\u9F7A\u9F7D\u9F8F\u9F90\u9F91\u9F92\u9F94\u9F96\u9F97\u9F9E\u9FA1\u9FA2\u9FA3\u9FA5"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/cp936.json +var require_cp936 = __commonJS({ + "node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module2) { + module2.exports = [ + ["0", "\0", 127, "\u20AC"], + ["8140", "\u4E02\u4E04\u4E05\u4E06\u4E0F\u4E12\u4E17\u4E1F\u4E20\u4E21\u4E23\u4E26\u4E29\u4E2E\u4E2F\u4E31\u4E33\u4E35\u4E37\u4E3C\u4E40\u4E41\u4E42\u4E44\u4E46\u4E4A\u4E51\u4E55\u4E57\u4E5A\u4E5B\u4E62\u4E63\u4E64\u4E65\u4E67\u4E68\u4E6A", 5, "\u4E72\u4E74", 9, "\u4E7F", 6, "\u4E87\u4E8A"], + ["8180", "\u4E90\u4E96\u4E97\u4E99\u4E9C\u4E9D\u4E9E\u4EA3\u4EAA\u4EAF\u4EB0\u4EB1\u4EB4\u4EB6\u4EB7\u4EB8\u4EB9\u4EBC\u4EBD\u4EBE\u4EC8\u4ECC\u4ECF\u4ED0\u4ED2\u4EDA\u4EDB\u4EDC\u4EE0\u4EE2\u4EE6\u4EE7\u4EE9\u4EED\u4EEE\u4EEF\u4EF1\u4EF4\u4EF8\u4EF9\u4EFA\u4EFC\u4EFE\u4F00\u4F02", 6, "\u4F0B\u4F0C\u4F12", 4, "\u4F1C\u4F1D\u4F21\u4F23\u4F28\u4F29\u4F2C\u4F2D\u4F2E\u4F31\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E", 4, "\u4F44\u4F45\u4F47", 5, "\u4F52\u4F54\u4F56\u4F61\u4F62\u4F66\u4F68\u4F6A\u4F6B\u4F6D\u4F6E\u4F71\u4F72\u4F75\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F80\u4F81\u4F82\u4F85\u4F86\u4F87\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F95\u4F96\u4F98\u4F99\u4F9A\u4F9C\u4F9E\u4F9F\u4FA1\u4FA2"], + ["8240", "\u4FA4\u4FAB\u4FAD\u4FB0", 4, "\u4FB6", 8, "\u4FC0\u4FC1\u4FC2\u4FC6\u4FC7\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FD2", 4, "\u4FD9\u4FDB\u4FE0\u4FE2\u4FE4\u4FE5\u4FE7\u4FEB\u4FEC\u4FF0\u4FF2\u4FF4\u4FF5\u4FF6\u4FF7\u4FF9\u4FFB\u4FFC\u4FFD\u4FFF", 11], + ["8280", "\u500B\u500E\u5010\u5011\u5013\u5015\u5016\u5017\u501B\u501D\u501E\u5020\u5022\u5023\u5024\u5027\u502B\u502F", 10, "\u503B\u503D\u503F\u5040\u5041\u5042\u5044\u5045\u5046\u5049\u504A\u504B\u504D\u5050", 4, "\u5056\u5057\u5058\u5059\u505B\u505D", 7, "\u5066", 5, "\u506D", 8, "\u5078\u5079\u507A\u507C\u507D\u5081\u5082\u5083\u5084\u5086\u5087\u5089\u508A\u508B\u508C\u508E", 20, "\u50A4\u50A6\u50AA\u50AB\u50AD", 4, "\u50B3", 6, "\u50BC"], + ["8340", "\u50BD", 17, "\u50D0", 5, "\u50D7\u50D8\u50D9\u50DB", 10, "\u50E8\u50E9\u50EA\u50EB\u50EF\u50F0\u50F1\u50F2\u50F4\u50F6", 4, "\u50FC", 9, "\u5108"], + ["8380", "\u5109\u510A\u510C", 5, "\u5113", 13, "\u5122", 28, "\u5142\u5147\u514A\u514C\u514E\u514F\u5150\u5152\u5153\u5157\u5158\u5159\u515B\u515D", 4, "\u5163\u5164\u5166\u5167\u5169\u516A\u516F\u5172\u517A\u517E\u517F\u5183\u5184\u5186\u5187\u518A\u518B\u518E\u518F\u5190\u5191\u5193\u5194\u5198\u519A\u519D\u519E\u519F\u51A1\u51A3\u51A6", 4, "\u51AD\u51AE\u51B4\u51B8\u51B9\u51BA\u51BE\u51BF\u51C1\u51C2\u51C3\u51C5\u51C8\u51CA\u51CD\u51CE\u51D0\u51D2", 5], + ["8440", "\u51D8\u51D9\u51DA\u51DC\u51DE\u51DF\u51E2\u51E3\u51E5", 5, "\u51EC\u51EE\u51F1\u51F2\u51F4\u51F7\u51FE\u5204\u5205\u5209\u520B\u520C\u520F\u5210\u5213\u5214\u5215\u521C\u521E\u521F\u5221\u5222\u5223\u5225\u5226\u5227\u522A\u522C\u522F\u5231\u5232\u5234\u5235\u523C\u523E\u5244", 5, "\u524B\u524E\u524F\u5252\u5253\u5255\u5257\u5258"], + ["8480", "\u5259\u525A\u525B\u525D\u525F\u5260\u5262\u5263\u5264\u5266\u5268\u526B\u526C\u526D\u526E\u5270\u5271\u5273", 9, "\u527E\u5280\u5283", 4, "\u5289", 6, "\u5291\u5292\u5294", 6, "\u529C\u52A4\u52A5\u52A6\u52A7\u52AE\u52AF\u52B0\u52B4", 9, "\u52C0\u52C1\u52C2\u52C4\u52C5\u52C6\u52C8\u52CA\u52CC\u52CD\u52CE\u52CF\u52D1\u52D3\u52D4\u52D5\u52D7\u52D9", 5, "\u52E0\u52E1\u52E2\u52E3\u52E5", 10, "\u52F1", 7, "\u52FB\u52FC\u52FD\u5301\u5302\u5303\u5304\u5307\u5309\u530A\u530B\u530C\u530E"], + ["8540", "\u5311\u5312\u5313\u5314\u5318\u531B\u531C\u531E\u531F\u5322\u5324\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u532F", 9, "\u533C\u533D\u5340\u5342\u5344\u5346\u534B\u534C\u534D\u5350\u5354\u5358\u5359\u535B\u535D\u5365\u5368\u536A\u536C\u536D\u5372\u5376\u5379\u537B\u537C\u537D\u537E\u5380\u5381\u5383\u5387\u5388\u538A\u538E\u538F"], + ["8580", "\u5390", 4, "\u5396\u5397\u5399\u539B\u539C\u539E\u53A0\u53A1\u53A4\u53A7\u53AA\u53AB\u53AC\u53AD\u53AF", 6, "\u53B7\u53B8\u53B9\u53BA\u53BC\u53BD\u53BE\u53C0\u53C3", 4, "\u53CE\u53CF\u53D0\u53D2\u53D3\u53D5\u53DA\u53DC\u53DD\u53DE\u53E1\u53E2\u53E7\u53F4\u53FA\u53FE\u53FF\u5400\u5402\u5405\u5407\u540B\u5414\u5418\u5419\u541A\u541C\u5422\u5424\u5425\u542A\u5430\u5433\u5436\u5437\u543A\u543D\u543F\u5441\u5442\u5444\u5445\u5447\u5449\u544C\u544D\u544E\u544F\u5451\u545A\u545D", 4, "\u5463\u5465\u5467\u5469", 7, "\u5474\u5479\u547A\u547E\u547F\u5481\u5483\u5485\u5487\u5488\u5489\u548A\u548D\u5491\u5493\u5497\u5498\u549C\u549E\u549F\u54A0\u54A1"], + ["8640", "\u54A2\u54A5\u54AE\u54B0\u54B2\u54B5\u54B6\u54B7\u54B9\u54BA\u54BC\u54BE\u54C3\u54C5\u54CA\u54CB\u54D6\u54D8\u54DB\u54E0", 4, "\u54EB\u54EC\u54EF\u54F0\u54F1\u54F4", 5, "\u54FB\u54FE\u5500\u5502\u5503\u5504\u5505\u5508\u550A", 4, "\u5512\u5513\u5515", 5, "\u551C\u551D\u551E\u551F\u5521\u5525\u5526"], + ["8680", "\u5528\u5529\u552B\u552D\u5532\u5534\u5535\u5536\u5538\u5539\u553A\u553B\u553D\u5540\u5542\u5545\u5547\u5548\u554B", 4, "\u5551\u5552\u5553\u5554\u5557", 4, "\u555D\u555E\u555F\u5560\u5562\u5563\u5568\u5569\u556B\u556F", 5, "\u5579\u557A\u557D\u557F\u5585\u5586\u558C\u558D\u558E\u5590\u5592\u5593\u5595\u5596\u5597\u559A\u559B\u559E\u55A0", 6, "\u55A8", 8, "\u55B2\u55B4\u55B6\u55B8\u55BA\u55BC\u55BF", 4, "\u55C6\u55C7\u55C8\u55CA\u55CB\u55CE\u55CF\u55D0\u55D5\u55D7", 4, "\u55DE\u55E0\u55E2\u55E7\u55E9\u55ED\u55EE\u55F0\u55F1\u55F4\u55F6\u55F8", 4, "\u55FF\u5602\u5603\u5604\u5605"], + ["8740", "\u5606\u5607\u560A\u560B\u560D\u5610", 7, "\u5619\u561A\u561C\u561D\u5620\u5621\u5622\u5625\u5626\u5628\u5629\u562A\u562B\u562E\u562F\u5630\u5633\u5635\u5637\u5638\u563A\u563C\u563D\u563E\u5640", 11, "\u564F", 4, "\u5655\u5656\u565A\u565B\u565D", 4], + ["8780", "\u5663\u5665\u5666\u5667\u566D\u566E\u566F\u5670\u5672\u5673\u5674\u5675\u5677\u5678\u5679\u567A\u567D", 7, "\u5687", 6, "\u5690\u5691\u5692\u5694", 14, "\u56A4", 10, "\u56B0", 6, "\u56B8\u56B9\u56BA\u56BB\u56BD", 12, "\u56CB", 8, "\u56D5\u56D6\u56D8\u56D9\u56DC\u56E3\u56E5", 5, "\u56EC\u56EE\u56EF\u56F2\u56F3\u56F6\u56F7\u56F8\u56FB\u56FC\u5700\u5701\u5702\u5705\u5707\u570B", 6], + ["8840", "\u5712", 9, "\u571D\u571E\u5720\u5721\u5722\u5724\u5725\u5726\u5727\u572B\u5731\u5732\u5734", 4, "\u573C\u573D\u573F\u5741\u5743\u5744\u5745\u5746\u5748\u5749\u574B\u5752", 4, "\u5758\u5759\u5762\u5763\u5765\u5767\u576C\u576E\u5770\u5771\u5772\u5774\u5775\u5778\u5779\u577A\u577D\u577E\u577F\u5780"], + ["8880", "\u5781\u5787\u5788\u5789\u578A\u578D", 4, "\u5794", 6, "\u579C\u579D\u579E\u579F\u57A5\u57A8\u57AA\u57AC\u57AF\u57B0\u57B1\u57B3\u57B5\u57B6\u57B7\u57B9", 8, "\u57C4", 6, "\u57CC\u57CD\u57D0\u57D1\u57D3\u57D6\u57D7\u57DB\u57DC\u57DE\u57E1\u57E2\u57E3\u57E5", 7, "\u57EE\u57F0\u57F1\u57F2\u57F3\u57F5\u57F6\u57F7\u57FB\u57FC\u57FE\u57FF\u5801\u5803\u5804\u5805\u5808\u5809\u580A\u580C\u580E\u580F\u5810\u5812\u5813\u5814\u5816\u5817\u5818\u581A\u581B\u581C\u581D\u581F\u5822\u5823\u5825", 4, "\u582B", 4, "\u5831\u5832\u5833\u5834\u5836", 7], + ["8940", "\u583E", 5, "\u5845", 6, "\u584E\u584F\u5850\u5852\u5853\u5855\u5856\u5857\u5859", 4, "\u585F", 5, "\u5866", 4, "\u586D", 16, "\u587F\u5882\u5884\u5886\u5887\u5888\u588A\u588B\u588C"], + ["8980", "\u588D", 4, "\u5894", 4, "\u589B\u589C\u589D\u58A0", 7, "\u58AA", 17, "\u58BD\u58BE\u58BF\u58C0\u58C2\u58C3\u58C4\u58C6", 10, "\u58D2\u58D3\u58D4\u58D6", 13, "\u58E5", 5, "\u58ED\u58EF\u58F1\u58F2\u58F4\u58F5\u58F7\u58F8\u58FA", 7, "\u5903\u5905\u5906\u5908", 4, "\u590E\u5910\u5911\u5912\u5913\u5917\u5918\u591B\u591D\u591E\u5920\u5921\u5922\u5923\u5926\u5928\u592C\u5930\u5932\u5933\u5935\u5936\u593B"], + ["8a40", "\u593D\u593E\u593F\u5940\u5943\u5945\u5946\u594A\u594C\u594D\u5950\u5952\u5953\u5959\u595B", 4, "\u5961\u5963\u5964\u5966", 12, "\u5975\u5977\u597A\u597B\u597C\u597E\u597F\u5980\u5985\u5989\u598B\u598C\u598E\u598F\u5990\u5991\u5994\u5995\u5998\u599A\u599B\u599C\u599D\u599F\u59A0\u59A1\u59A2\u59A6"], + ["8a80", "\u59A7\u59AC\u59AD\u59B0\u59B1\u59B3", 5, "\u59BA\u59BC\u59BD\u59BF", 6, "\u59C7\u59C8\u59C9\u59CC\u59CD\u59CE\u59CF\u59D5\u59D6\u59D9\u59DB\u59DE", 4, "\u59E4\u59E6\u59E7\u59E9\u59EA\u59EB\u59ED", 11, "\u59FA\u59FC\u59FD\u59FE\u5A00\u5A02\u5A0A\u5A0B\u5A0D\u5A0E\u5A0F\u5A10\u5A12\u5A14\u5A15\u5A16\u5A17\u5A19\u5A1A\u5A1B\u5A1D\u5A1E\u5A21\u5A22\u5A24\u5A26\u5A27\u5A28\u5A2A", 6, "\u5A33\u5A35\u5A37", 4, "\u5A3D\u5A3E\u5A3F\u5A41", 4, "\u5A47\u5A48\u5A4B", 9, "\u5A56\u5A57\u5A58\u5A59\u5A5B", 5], + ["8b40", "\u5A61\u5A63\u5A64\u5A65\u5A66\u5A68\u5A69\u5A6B", 8, "\u5A78\u5A79\u5A7B\u5A7C\u5A7D\u5A7E\u5A80", 17, "\u5A93", 6, "\u5A9C", 13, "\u5AAB\u5AAC"], + ["8b80", "\u5AAD", 4, "\u5AB4\u5AB6\u5AB7\u5AB9", 4, "\u5ABF\u5AC0\u5AC3", 5, "\u5ACA\u5ACB\u5ACD", 4, "\u5AD3\u5AD5\u5AD7\u5AD9\u5ADA\u5ADB\u5ADD\u5ADE\u5ADF\u5AE2\u5AE4\u5AE5\u5AE7\u5AE8\u5AEA\u5AEC", 4, "\u5AF2", 22, "\u5B0A", 11, "\u5B18", 25, "\u5B33\u5B35\u5B36\u5B38", 7, "\u5B41", 6], + ["8c40", "\u5B48", 7, "\u5B52\u5B56\u5B5E\u5B60\u5B61\u5B67\u5B68\u5B6B\u5B6D\u5B6E\u5B6F\u5B72\u5B74\u5B76\u5B77\u5B78\u5B79\u5B7B\u5B7C\u5B7E\u5B7F\u5B82\u5B86\u5B8A\u5B8D\u5B8E\u5B90\u5B91\u5B92\u5B94\u5B96\u5B9F\u5BA7\u5BA8\u5BA9\u5BAC\u5BAD\u5BAE\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBB\u5BBC\u5BC0\u5BC1\u5BC3\u5BC8\u5BC9\u5BCA\u5BCB\u5BCD\u5BCE\u5BCF"], + ["8c80", "\u5BD1\u5BD4", 8, "\u5BE0\u5BE2\u5BE3\u5BE6\u5BE7\u5BE9", 4, "\u5BEF\u5BF1", 6, "\u5BFD\u5BFE\u5C00\u5C02\u5C03\u5C05\u5C07\u5C08\u5C0B\u5C0C\u5C0D\u5C0E\u5C10\u5C12\u5C13\u5C17\u5C19\u5C1B\u5C1E\u5C1F\u5C20\u5C21\u5C23\u5C26\u5C28\u5C29\u5C2A\u5C2B\u5C2D\u5C2E\u5C2F\u5C30\u5C32\u5C33\u5C35\u5C36\u5C37\u5C43\u5C44\u5C46\u5C47\u5C4C\u5C4D\u5C52\u5C53\u5C54\u5C56\u5C57\u5C58\u5C5A\u5C5B\u5C5C\u5C5D\u5C5F\u5C62\u5C64\u5C67", 6, "\u5C70\u5C72", 6, "\u5C7B\u5C7C\u5C7D\u5C7E\u5C80\u5C83", 4, "\u5C89\u5C8A\u5C8B\u5C8E\u5C8F\u5C92\u5C93\u5C95\u5C9D", 4, "\u5CA4", 4], + ["8d40", "\u5CAA\u5CAE\u5CAF\u5CB0\u5CB2\u5CB4\u5CB6\u5CB9\u5CBA\u5CBB\u5CBC\u5CBE\u5CC0\u5CC2\u5CC3\u5CC5", 5, "\u5CCC", 5, "\u5CD3", 5, "\u5CDA", 6, "\u5CE2\u5CE3\u5CE7\u5CE9\u5CEB\u5CEC\u5CEE\u5CEF\u5CF1", 9, "\u5CFC", 4], + ["8d80", "\u5D01\u5D04\u5D05\u5D08", 5, "\u5D0F", 4, "\u5D15\u5D17\u5D18\u5D19\u5D1A\u5D1C\u5D1D\u5D1F", 4, "\u5D25\u5D28\u5D2A\u5D2B\u5D2C\u5D2F", 4, "\u5D35", 7, "\u5D3F", 7, "\u5D48\u5D49\u5D4D", 10, "\u5D59\u5D5A\u5D5C\u5D5E", 10, "\u5D6A\u5D6D\u5D6E\u5D70\u5D71\u5D72\u5D73\u5D75", 12, "\u5D83", 21, "\u5D9A\u5D9B\u5D9C\u5D9E\u5D9F\u5DA0"], + ["8e40", "\u5DA1", 21, "\u5DB8", 12, "\u5DC6", 6, "\u5DCE", 12, "\u5DDC\u5DDF\u5DE0\u5DE3\u5DE4\u5DEA\u5DEC\u5DED"], + ["8e80", "\u5DF0\u5DF5\u5DF6\u5DF8", 4, "\u5DFF\u5E00\u5E04\u5E07\u5E09\u5E0A\u5E0B\u5E0D\u5E0E\u5E12\u5E13\u5E17\u5E1E", 7, "\u5E28", 4, "\u5E2F\u5E30\u5E32", 4, "\u5E39\u5E3A\u5E3E\u5E3F\u5E40\u5E41\u5E43\u5E46", 5, "\u5E4D", 6, "\u5E56", 4, "\u5E5C\u5E5D\u5E5F\u5E60\u5E63", 14, "\u5E75\u5E77\u5E79\u5E7E\u5E81\u5E82\u5E83\u5E85\u5E88\u5E89\u5E8C\u5E8D\u5E8E\u5E92\u5E98\u5E9B\u5E9D\u5EA1\u5EA2\u5EA3\u5EA4\u5EA8", 4, "\u5EAE", 4, "\u5EB4\u5EBA\u5EBB\u5EBC\u5EBD\u5EBF", 6], + ["8f40", "\u5EC6\u5EC7\u5EC8\u5ECB", 5, "\u5ED4\u5ED5\u5ED7\u5ED8\u5ED9\u5EDA\u5EDC", 11, "\u5EE9\u5EEB", 8, "\u5EF5\u5EF8\u5EF9\u5EFB\u5EFC\u5EFD\u5F05\u5F06\u5F07\u5F09\u5F0C\u5F0D\u5F0E\u5F10\u5F12\u5F14\u5F16\u5F19\u5F1A\u5F1C\u5F1D\u5F1E\u5F21\u5F22\u5F23\u5F24"], + ["8f80", "\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F32", 6, "\u5F3B\u5F3D\u5F3E\u5F3F\u5F41", 14, "\u5F51\u5F54\u5F59\u5F5A\u5F5B\u5F5C\u5F5E\u5F5F\u5F60\u5F63\u5F65\u5F67\u5F68\u5F6B\u5F6E\u5F6F\u5F72\u5F74\u5F75\u5F76\u5F78\u5F7A\u5F7D\u5F7E\u5F7F\u5F83\u5F86\u5F8D\u5F8E\u5F8F\u5F91\u5F93\u5F94\u5F96\u5F9A\u5F9B\u5F9D\u5F9E\u5F9F\u5FA0\u5FA2", 5, "\u5FA9\u5FAB\u5FAC\u5FAF", 5, "\u5FB6\u5FB8\u5FB9\u5FBA\u5FBB\u5FBE", 4, "\u5FC7\u5FC8\u5FCA\u5FCB\u5FCE\u5FD3\u5FD4\u5FD5\u5FDA\u5FDB\u5FDC\u5FDE\u5FDF\u5FE2\u5FE3\u5FE5\u5FE6\u5FE8\u5FE9\u5FEC\u5FEF\u5FF0\u5FF2\u5FF3\u5FF4\u5FF6\u5FF7\u5FF9\u5FFA\u5FFC\u6007"], + ["9040", "\u6008\u6009\u600B\u600C\u6010\u6011\u6013\u6017\u6018\u601A\u601E\u601F\u6022\u6023\u6024\u602C\u602D\u602E\u6030", 4, "\u6036", 4, "\u603D\u603E\u6040\u6044", 6, "\u604C\u604E\u604F\u6051\u6053\u6054\u6056\u6057\u6058\u605B\u605C\u605E\u605F\u6060\u6061\u6065\u6066\u606E\u6071\u6072\u6074\u6075\u6077\u607E\u6080"], + ["9080", "\u6081\u6082\u6085\u6086\u6087\u6088\u608A\u608B\u608E\u608F\u6090\u6091\u6093\u6095\u6097\u6098\u6099\u609C\u609E\u60A1\u60A2\u60A4\u60A5\u60A7\u60A9\u60AA\u60AE\u60B0\u60B3\u60B5\u60B6\u60B7\u60B9\u60BA\u60BD", 7, "\u60C7\u60C8\u60C9\u60CC", 4, "\u60D2\u60D3\u60D4\u60D6\u60D7\u60D9\u60DB\u60DE\u60E1", 4, "\u60EA\u60F1\u60F2\u60F5\u60F7\u60F8\u60FB", 4, "\u6102\u6103\u6104\u6105\u6107\u610A\u610B\u610C\u6110", 4, "\u6116\u6117\u6118\u6119\u611B\u611C\u611D\u611E\u6121\u6122\u6125\u6128\u6129\u612A\u612C", 18, "\u6140", 6], + ["9140", "\u6147\u6149\u614B\u614D\u614F\u6150\u6152\u6153\u6154\u6156", 6, "\u615E\u615F\u6160\u6161\u6163\u6164\u6165\u6166\u6169", 6, "\u6171\u6172\u6173\u6174\u6176\u6178", 18, "\u618C\u618D\u618F", 4, "\u6195"], + ["9180", "\u6196", 6, "\u619E", 8, "\u61AA\u61AB\u61AD", 9, "\u61B8", 5, "\u61BF\u61C0\u61C1\u61C3", 4, "\u61C9\u61CC", 4, "\u61D3\u61D5", 16, "\u61E7", 13, "\u61F6", 8, "\u6200", 5, "\u6207\u6209\u6213\u6214\u6219\u621C\u621D\u621E\u6220\u6223\u6226\u6227\u6228\u6229\u622B\u622D\u622F\u6230\u6231\u6232\u6235\u6236\u6238", 4, "\u6242\u6244\u6245\u6246\u624A"], + ["9240", "\u624F\u6250\u6255\u6256\u6257\u6259\u625A\u625C", 6, "\u6264\u6265\u6268\u6271\u6272\u6274\u6275\u6277\u6278\u627A\u627B\u627D\u6281\u6282\u6283\u6285\u6286\u6287\u6288\u628B", 5, "\u6294\u6299\u629C\u629D\u629E\u62A3\u62A6\u62A7\u62A9\u62AA\u62AD\u62AE\u62AF\u62B0\u62B2\u62B3\u62B4\u62B6\u62B7\u62B8\u62BA\u62BE\u62C0\u62C1"], + ["9280", "\u62C3\u62CB\u62CF\u62D1\u62D5\u62DD\u62DE\u62E0\u62E1\u62E4\u62EA\u62EB\u62F0\u62F2\u62F5\u62F8\u62F9\u62FA\u62FB\u6300\u6303\u6304\u6305\u6306\u630A\u630B\u630C\u630D\u630F\u6310\u6312\u6313\u6314\u6315\u6317\u6318\u6319\u631C\u6326\u6327\u6329\u632C\u632D\u632E\u6330\u6331\u6333", 5, "\u633B\u633C\u633E\u633F\u6340\u6341\u6344\u6347\u6348\u634A\u6351\u6352\u6353\u6354\u6356", 7, "\u6360\u6364\u6365\u6366\u6368\u636A\u636B\u636C\u636F\u6370\u6372\u6373\u6374\u6375\u6378\u6379\u637C\u637D\u637E\u637F\u6381\u6383\u6384\u6385\u6386\u638B\u638D\u6391\u6393\u6394\u6395\u6397\u6399", 6, "\u63A1\u63A4\u63A6\u63AB\u63AF\u63B1\u63B2\u63B5\u63B6\u63B9\u63BB\u63BD\u63BF\u63C0"], + ["9340", "\u63C1\u63C2\u63C3\u63C5\u63C7\u63C8\u63CA\u63CB\u63CC\u63D1\u63D3\u63D4\u63D5\u63D7", 6, "\u63DF\u63E2\u63E4", 4, "\u63EB\u63EC\u63EE\u63EF\u63F0\u63F1\u63F3\u63F5\u63F7\u63F9\u63FA\u63FB\u63FC\u63FE\u6403\u6404\u6406", 4, "\u640D\u640E\u6411\u6412\u6415", 5, "\u641D\u641F\u6422\u6423\u6424"], + ["9380", "\u6425\u6427\u6428\u6429\u642B\u642E", 5, "\u6435", 4, "\u643B\u643C\u643E\u6440\u6442\u6443\u6449\u644B", 6, "\u6453\u6455\u6456\u6457\u6459", 4, "\u645F", 7, "\u6468\u646A\u646B\u646C\u646E", 9, "\u647B", 6, "\u6483\u6486\u6488", 8, "\u6493\u6494\u6497\u6498\u649A\u649B\u649C\u649D\u649F", 4, "\u64A5\u64A6\u64A7\u64A8\u64AA\u64AB\u64AF\u64B1\u64B2\u64B3\u64B4\u64B6\u64B9\u64BB\u64BD\u64BE\u64BF\u64C1\u64C3\u64C4\u64C6", 6, "\u64CF\u64D1\u64D3\u64D4\u64D5\u64D6\u64D9\u64DA"], + ["9440", "\u64DB\u64DC\u64DD\u64DF\u64E0\u64E1\u64E3\u64E5\u64E7", 24, "\u6501", 7, "\u650A", 7, "\u6513", 4, "\u6519", 8], + ["9480", "\u6522\u6523\u6524\u6526", 4, "\u652C\u652D\u6530\u6531\u6532\u6533\u6537\u653A\u653C\u653D\u6540", 4, "\u6546\u6547\u654A\u654B\u654D\u654E\u6550\u6552\u6553\u6554\u6557\u6558\u655A\u655C\u655F\u6560\u6561\u6564\u6565\u6567\u6568\u6569\u656A\u656D\u656E\u656F\u6571\u6573\u6575\u6576\u6578", 14, "\u6588\u6589\u658A\u658D\u658E\u658F\u6592\u6594\u6595\u6596\u6598\u659A\u659D\u659E\u65A0\u65A2\u65A3\u65A6\u65A8\u65AA\u65AC\u65AE\u65B1", 7, "\u65BA\u65BB\u65BE\u65BF\u65C0\u65C2\u65C7\u65C8\u65C9\u65CA\u65CD\u65D0\u65D1\u65D3\u65D4\u65D5\u65D8", 7, "\u65E1\u65E3\u65E4\u65EA\u65EB"], + ["9540", "\u65F2\u65F3\u65F4\u65F5\u65F8\u65F9\u65FB", 4, "\u6601\u6604\u6605\u6607\u6608\u6609\u660B\u660D\u6610\u6611\u6612\u6616\u6617\u6618\u661A\u661B\u661C\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6632\u6633\u6637", 4, "\u663D\u663F\u6640\u6642\u6644", 6, "\u664D\u664E\u6650\u6651\u6658"], + ["9580", "\u6659\u665B\u665C\u665D\u665E\u6660\u6662\u6663\u6665\u6667\u6669", 4, "\u6671\u6672\u6673\u6675\u6678\u6679\u667B\u667C\u667D\u667F\u6680\u6681\u6683\u6685\u6686\u6688\u6689\u668A\u668B\u668D\u668E\u668F\u6690\u6692\u6693\u6694\u6695\u6698", 4, "\u669E", 8, "\u66A9", 4, "\u66AF", 4, "\u66B5\u66B6\u66B7\u66B8\u66BA\u66BB\u66BC\u66BD\u66BF", 25, "\u66DA\u66DE", 7, "\u66E7\u66E8\u66EA", 5, "\u66F1\u66F5\u66F6\u66F8\u66FA\u66FB\u66FD\u6701\u6702\u6703"], + ["9640", "\u6704\u6705\u6706\u6707\u670C\u670E\u670F\u6711\u6712\u6713\u6716\u6718\u6719\u671A\u671C\u671E\u6720", 5, "\u6727\u6729\u672E\u6730\u6732\u6733\u6736\u6737\u6738\u6739\u673B\u673C\u673E\u673F\u6741\u6744\u6745\u6747\u674A\u674B\u674D\u6752\u6754\u6755\u6757", 4, "\u675D\u6762\u6763\u6764\u6766\u6767\u676B\u676C\u676E\u6771\u6774\u6776"], + ["9680", "\u6778\u6779\u677A\u677B\u677D\u6780\u6782\u6783\u6785\u6786\u6788\u678A\u678C\u678D\u678E\u678F\u6791\u6792\u6793\u6794\u6796\u6799\u679B\u679F\u67A0\u67A1\u67A4\u67A6\u67A9\u67AC\u67AE\u67B1\u67B2\u67B4\u67B9", 7, "\u67C2\u67C5", 9, "\u67D5\u67D6\u67D7\u67DB\u67DF\u67E1\u67E3\u67E4\u67E6\u67E7\u67E8\u67EA\u67EB\u67ED\u67EE\u67F2\u67F5", 7, "\u67FE\u6801\u6802\u6803\u6804\u6806\u680D\u6810\u6812\u6814\u6815\u6818", 4, "\u681E\u681F\u6820\u6822", 6, "\u682B", 6, "\u6834\u6835\u6836\u683A\u683B\u683F\u6847\u684B\u684D\u684F\u6852\u6856", 5], + ["9740", "\u685C\u685D\u685E\u685F\u686A\u686C", 7, "\u6875\u6878", 8, "\u6882\u6884\u6887", 7, "\u6890\u6891\u6892\u6894\u6895\u6896\u6898", 9, "\u68A3\u68A4\u68A5\u68A9\u68AA\u68AB\u68AC\u68AE\u68B1\u68B2\u68B4\u68B6\u68B7\u68B8"], + ["9780", "\u68B9", 6, "\u68C1\u68C3", 5, "\u68CA\u68CC\u68CE\u68CF\u68D0\u68D1\u68D3\u68D4\u68D6\u68D7\u68D9\u68DB", 4, "\u68E1\u68E2\u68E4", 9, "\u68EF\u68F2\u68F3\u68F4\u68F6\u68F7\u68F8\u68FB\u68FD\u68FE\u68FF\u6900\u6902\u6903\u6904\u6906", 4, "\u690C\u690F\u6911\u6913", 11, "\u6921\u6922\u6923\u6925", 7, "\u692E\u692F\u6931\u6932\u6933\u6935\u6936\u6937\u6938\u693A\u693B\u693C\u693E\u6940\u6941\u6943", 16, "\u6955\u6956\u6958\u6959\u695B\u695C\u695F"], + ["9840", "\u6961\u6962\u6964\u6965\u6967\u6968\u6969\u696A\u696C\u696D\u696F\u6970\u6972", 4, "\u697A\u697B\u697D\u697E\u697F\u6981\u6983\u6985\u698A\u698B\u698C\u698E", 5, "\u6996\u6997\u6999\u699A\u699D", 9, "\u69A9\u69AA\u69AC\u69AE\u69AF\u69B0\u69B2\u69B3\u69B5\u69B6\u69B8\u69B9\u69BA\u69BC\u69BD"], + ["9880", "\u69BE\u69BF\u69C0\u69C2", 7, "\u69CB\u69CD\u69CF\u69D1\u69D2\u69D3\u69D5", 5, "\u69DC\u69DD\u69DE\u69E1", 11, "\u69EE\u69EF\u69F0\u69F1\u69F3", 9, "\u69FE\u6A00", 9, "\u6A0B", 11, "\u6A19", 5, "\u6A20\u6A22", 5, "\u6A29\u6A2B\u6A2C\u6A2D\u6A2E\u6A30\u6A32\u6A33\u6A34\u6A36", 6, "\u6A3F", 4, "\u6A45\u6A46\u6A48", 7, "\u6A51", 6, "\u6A5A"], + ["9940", "\u6A5C", 4, "\u6A62\u6A63\u6A64\u6A66", 10, "\u6A72", 6, "\u6A7A\u6A7B\u6A7D\u6A7E\u6A7F\u6A81\u6A82\u6A83\u6A85", 8, "\u6A8F\u6A92", 4, "\u6A98", 7, "\u6AA1", 5], + ["9980", "\u6AA7\u6AA8\u6AAA\u6AAD", 114, "\u6B25\u6B26\u6B28", 6], + ["9a40", "\u6B2F\u6B30\u6B31\u6B33\u6B34\u6B35\u6B36\u6B38\u6B3B\u6B3C\u6B3D\u6B3F\u6B40\u6B41\u6B42\u6B44\u6B45\u6B48\u6B4A\u6B4B\u6B4D", 11, "\u6B5A", 7, "\u6B68\u6B69\u6B6B", 13, "\u6B7A\u6B7D\u6B7E\u6B7F\u6B80\u6B85\u6B88"], + ["9a80", "\u6B8C\u6B8E\u6B8F\u6B90\u6B91\u6B94\u6B95\u6B97\u6B98\u6B99\u6B9C", 4, "\u6BA2", 7, "\u6BAB", 7, "\u6BB6\u6BB8", 6, "\u6BC0\u6BC3\u6BC4\u6BC6", 4, "\u6BCC\u6BCE\u6BD0\u6BD1\u6BD8\u6BDA\u6BDC", 4, "\u6BE2", 7, "\u6BEC\u6BED\u6BEE\u6BF0\u6BF1\u6BF2\u6BF4\u6BF6\u6BF7\u6BF8\u6BFA\u6BFB\u6BFC\u6BFE", 6, "\u6C08", 4, "\u6C0E\u6C12\u6C17\u6C1C\u6C1D\u6C1E\u6C20\u6C23\u6C25\u6C2B\u6C2C\u6C2D\u6C31\u6C33\u6C36\u6C37\u6C39\u6C3A\u6C3B\u6C3C\u6C3E\u6C3F\u6C43\u6C44\u6C45\u6C48\u6C4B", 4, "\u6C51\u6C52\u6C53\u6C56\u6C58"], + ["9b40", "\u6C59\u6C5A\u6C62\u6C63\u6C65\u6C66\u6C67\u6C6B", 4, "\u6C71\u6C73\u6C75\u6C77\u6C78\u6C7A\u6C7B\u6C7C\u6C7F\u6C80\u6C84\u6C87\u6C8A\u6C8B\u6C8D\u6C8E\u6C91\u6C92\u6C95\u6C96\u6C97\u6C98\u6C9A\u6C9C\u6C9D\u6C9E\u6CA0\u6CA2\u6CA8\u6CAC\u6CAF\u6CB0\u6CB4\u6CB5\u6CB6\u6CB7\u6CBA\u6CC0\u6CC1\u6CC2\u6CC3\u6CC6\u6CC7\u6CC8\u6CCB\u6CCD\u6CCE\u6CCF\u6CD1\u6CD2\u6CD8"], + ["9b80", "\u6CD9\u6CDA\u6CDC\u6CDD\u6CDF\u6CE4\u6CE6\u6CE7\u6CE9\u6CEC\u6CED\u6CF2\u6CF4\u6CF9\u6CFF\u6D00\u6D02\u6D03\u6D05\u6D06\u6D08\u6D09\u6D0A\u6D0D\u6D0F\u6D10\u6D11\u6D13\u6D14\u6D15\u6D16\u6D18\u6D1C\u6D1D\u6D1F", 5, "\u6D26\u6D28\u6D29\u6D2C\u6D2D\u6D2F\u6D30\u6D34\u6D36\u6D37\u6D38\u6D3A\u6D3F\u6D40\u6D42\u6D44\u6D49\u6D4C\u6D50\u6D55\u6D56\u6D57\u6D58\u6D5B\u6D5D\u6D5F\u6D61\u6D62\u6D64\u6D65\u6D67\u6D68\u6D6B\u6D6C\u6D6D\u6D70\u6D71\u6D72\u6D73\u6D75\u6D76\u6D79\u6D7A\u6D7B\u6D7D", 4, "\u6D83\u6D84\u6D86\u6D87\u6D8A\u6D8B\u6D8D\u6D8F\u6D90\u6D92\u6D96", 4, "\u6D9C\u6DA2\u6DA5\u6DAC\u6DAD\u6DB0\u6DB1\u6DB3\u6DB4\u6DB6\u6DB7\u6DB9", 5, "\u6DC1\u6DC2\u6DC3\u6DC8\u6DC9\u6DCA"], + ["9c40", "\u6DCD\u6DCE\u6DCF\u6DD0\u6DD2\u6DD3\u6DD4\u6DD5\u6DD7\u6DDA\u6DDB\u6DDC\u6DDF\u6DE2\u6DE3\u6DE5\u6DE7\u6DE8\u6DE9\u6DEA\u6DED\u6DEF\u6DF0\u6DF2\u6DF4\u6DF5\u6DF6\u6DF8\u6DFA\u6DFD", 7, "\u6E06\u6E07\u6E08\u6E09\u6E0B\u6E0F\u6E12\u6E13\u6E15\u6E18\u6E19\u6E1B\u6E1C\u6E1E\u6E1F\u6E22\u6E26\u6E27\u6E28\u6E2A\u6E2C\u6E2E\u6E30\u6E31\u6E33\u6E35"], + ["9c80", "\u6E36\u6E37\u6E39\u6E3B", 7, "\u6E45", 7, "\u6E4F\u6E50\u6E51\u6E52\u6E55\u6E57\u6E59\u6E5A\u6E5C\u6E5D\u6E5E\u6E60", 10, "\u6E6C\u6E6D\u6E6F", 14, "\u6E80\u6E81\u6E82\u6E84\u6E87\u6E88\u6E8A", 4, "\u6E91", 6, "\u6E99\u6E9A\u6E9B\u6E9D\u6E9E\u6EA0\u6EA1\u6EA3\u6EA4\u6EA6\u6EA8\u6EA9\u6EAB\u6EAC\u6EAD\u6EAE\u6EB0\u6EB3\u6EB5\u6EB8\u6EB9\u6EBC\u6EBE\u6EBF\u6EC0\u6EC3\u6EC4\u6EC5\u6EC6\u6EC8\u6EC9\u6ECA\u6ECC\u6ECD\u6ECE\u6ED0\u6ED2\u6ED6\u6ED8\u6ED9\u6EDB\u6EDC\u6EDD\u6EE3\u6EE7\u6EEA", 5], + ["9d40", "\u6EF0\u6EF1\u6EF2\u6EF3\u6EF5\u6EF6\u6EF7\u6EF8\u6EFA", 7, "\u6F03\u6F04\u6F05\u6F07\u6F08\u6F0A", 4, "\u6F10\u6F11\u6F12\u6F16", 9, "\u6F21\u6F22\u6F23\u6F25\u6F26\u6F27\u6F28\u6F2C\u6F2E\u6F30\u6F32\u6F34\u6F35\u6F37", 6, "\u6F3F\u6F40\u6F41\u6F42"], + ["9d80", "\u6F43\u6F44\u6F45\u6F48\u6F49\u6F4A\u6F4C\u6F4E", 9, "\u6F59\u6F5A\u6F5B\u6F5D\u6F5F\u6F60\u6F61\u6F63\u6F64\u6F65\u6F67", 5, "\u6F6F\u6F70\u6F71\u6F73\u6F75\u6F76\u6F77\u6F79\u6F7B\u6F7D", 6, "\u6F85\u6F86\u6F87\u6F8A\u6F8B\u6F8F", 12, "\u6F9D\u6F9E\u6F9F\u6FA0\u6FA2", 4, "\u6FA8", 10, "\u6FB4\u6FB5\u6FB7\u6FB8\u6FBA", 5, "\u6FC1\u6FC3", 5, "\u6FCA", 6, "\u6FD3", 10, "\u6FDF\u6FE2\u6FE3\u6FE4\u6FE5"], + ["9e40", "\u6FE6", 7, "\u6FF0", 32, "\u7012", 7, "\u701C", 6, "\u7024", 6], + ["9e80", "\u702B", 9, "\u7036\u7037\u7038\u703A", 17, "\u704D\u704E\u7050", 13, "\u705F", 11, "\u706E\u7071\u7072\u7073\u7074\u7077\u7079\u707A\u707B\u707D\u7081\u7082\u7083\u7084\u7086\u7087\u7088\u708B\u708C\u708D\u708F\u7090\u7091\u7093\u7097\u7098\u709A\u709B\u709E", 12, "\u70B0\u70B2\u70B4\u70B5\u70B6\u70BA\u70BE\u70BF\u70C4\u70C5\u70C6\u70C7\u70C9\u70CB", 12, "\u70DA"], + ["9f40", "\u70DC\u70DD\u70DE\u70E0\u70E1\u70E2\u70E3\u70E5\u70EA\u70EE\u70F0", 6, "\u70F8\u70FA\u70FB\u70FC\u70FE", 10, "\u710B", 4, "\u7111\u7112\u7114\u7117\u711B", 10, "\u7127", 7, "\u7132\u7133\u7134"], + ["9f80", "\u7135\u7137", 13, "\u7146\u7147\u7148\u7149\u714B\u714D\u714F", 12, "\u715D\u715F", 4, "\u7165\u7169", 4, "\u716F\u7170\u7171\u7174\u7175\u7176\u7177\u7179\u717B\u717C\u717E", 5, "\u7185", 4, "\u718B\u718C\u718D\u718E\u7190\u7191\u7192\u7193\u7195\u7196\u7197\u719A", 4, "\u71A1", 6, "\u71A9\u71AA\u71AB\u71AD", 5, "\u71B4\u71B6\u71B7\u71B8\u71BA", 8, "\u71C4", 9, "\u71CF", 4], + ["a040", "\u71D6", 9, "\u71E1\u71E2\u71E3\u71E4\u71E6\u71E8", 5, "\u71EF", 9, "\u71FA", 11, "\u7207", 19], + ["a080", "\u721B\u721C\u721E", 9, "\u7229\u722B\u722D\u722E\u722F\u7232\u7233\u7234\u723A\u723C\u723E\u7240", 6, "\u7249\u724A\u724B\u724E\u724F\u7250\u7251\u7253\u7254\u7255\u7257\u7258\u725A\u725C\u725E\u7260\u7263\u7264\u7265\u7268\u726A\u726B\u726C\u726D\u7270\u7271\u7273\u7274\u7276\u7277\u7278\u727B\u727C\u727D\u7282\u7283\u7285", 4, "\u728C\u728E\u7290\u7291\u7293", 11, "\u72A0", 11, "\u72AE\u72B1\u72B2\u72B3\u72B5\u72BA", 6, "\u72C5\u72C6\u72C7\u72C9\u72CA\u72CB\u72CC\u72CF\u72D1\u72D3\u72D4\u72D5\u72D6\u72D8\u72DA\u72DB"], + ["a1a1", "\u3000\u3001\u3002\xB7\u02C9\u02C7\xA8\u3003\u3005\u2014\uFF5E\u2016\u2026\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 7, "\u3016\u3017\u3010\u3011\xB1\xD7\xF7\u2236\u2227\u2228\u2211\u220F\u222A\u2229\u2208\u2237\u221A\u22A5\u2225\u2220\u2312\u2299\u222B\u222E\u2261\u224C\u2248\u223D\u221D\u2260\u226E\u226F\u2264\u2265\u221E\u2235\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFF04\xA4\uFFE0\uFFE1\u2030\xA7\u2116\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u203B\u2192\u2190\u2191\u2193\u3013"], + ["a2a1", "\u2170", 9], + ["a2b1", "\u2488", 19, "\u2474", 19, "\u2460", 9], + ["a2e5", "\u3220", 9], + ["a2f1", "\u2160", 11], + ["a3a1", "\uFF01\uFF02\uFF03\uFFE5\uFF05", 88, "\uFFE3"], + ["a4a1", "\u3041", 82], + ["a5a1", "\u30A1", 85], + ["a6a1", "\u0391", 16, "\u03A3", 6], + ["a6c1", "\u03B1", 16, "\u03C3", 6], + ["a6e0", "\uFE35\uFE36\uFE39\uFE3A\uFE3F\uFE40\uFE3D\uFE3E\uFE41\uFE42\uFE43\uFE44"], + ["a6ee", "\uFE3B\uFE3C\uFE37\uFE38\uFE31"], + ["a6f4", "\uFE33\uFE34"], + ["a7a1", "\u0410", 5, "\u0401\u0416", 25], + ["a7d1", "\u0430", 5, "\u0451\u0436", 25], + ["a840", "\u02CA\u02CB\u02D9\u2013\u2015\u2025\u2035\u2105\u2109\u2196\u2197\u2198\u2199\u2215\u221F\u2223\u2252\u2266\u2267\u22BF\u2550", 35, "\u2581", 6], + ["a880", "\u2588", 7, "\u2593\u2594\u2595\u25BC\u25BD\u25E2\u25E3\u25E4\u25E5\u2609\u2295\u3012\u301D\u301E"], + ["a8a1", "\u0101\xE1\u01CE\xE0\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA\u01DC\xFC\xEA\u0251"], + ["a8bd", "\u0144\u0148"], + ["a8c0", "\u0261"], + ["a8c5", "\u3105", 36], + ["a940", "\u3021", 8, "\u32A3\u338E\u338F\u339C\u339D\u339E\u33A1\u33C4\u33CE\u33D1\u33D2\u33D5\uFE30\uFFE2\uFFE4"], + ["a959", "\u2121\u3231"], + ["a95c", "\u2010"], + ["a960", "\u30FC\u309B\u309C\u30FD\u30FE\u3006\u309D\u309E\uFE49", 9, "\uFE54\uFE55\uFE56\uFE57\uFE59", 8], + ["a980", "\uFE62", 4, "\uFE68\uFE69\uFE6A\uFE6B"], + ["a996", "\u3007"], + ["a9a4", "\u2500", 75], + ["aa40", "\u72DC\u72DD\u72DF\u72E2", 5, "\u72EA\u72EB\u72F5\u72F6\u72F9\u72FD\u72FE\u72FF\u7300\u7302\u7304", 5, "\u730B\u730C\u730D\u730F\u7310\u7311\u7312\u7314\u7318\u7319\u731A\u731F\u7320\u7323\u7324\u7326\u7327\u7328\u732D\u732F\u7330\u7332\u7333\u7335\u7336\u733A\u733B\u733C\u733D\u7340", 8], + ["aa80", "\u7349\u734A\u734B\u734C\u734E\u734F\u7351\u7353\u7354\u7355\u7356\u7358", 7, "\u7361", 10, "\u736E\u7370\u7371"], + ["ab40", "\u7372", 11, "\u737F", 4, "\u7385\u7386\u7388\u738A\u738C\u738D\u738F\u7390\u7392\u7393\u7394\u7395\u7397\u7398\u7399\u739A\u739C\u739D\u739E\u73A0\u73A1\u73A3", 5, "\u73AA\u73AC\u73AD\u73B1\u73B4\u73B5\u73B6\u73B8\u73B9\u73BC\u73BD\u73BE\u73BF\u73C1\u73C3", 4], + ["ab80", "\u73CB\u73CC\u73CE\u73D2", 6, "\u73DA\u73DB\u73DC\u73DD\u73DF\u73E1\u73E2\u73E3\u73E4\u73E6\u73E8\u73EA\u73EB\u73EC\u73EE\u73EF\u73F0\u73F1\u73F3", 4], + ["ac40", "\u73F8", 10, "\u7404\u7407\u7408\u740B\u740C\u740D\u740E\u7411", 8, "\u741C", 5, "\u7423\u7424\u7427\u7429\u742B\u742D\u742F\u7431\u7432\u7437", 4, "\u743D\u743E\u743F\u7440\u7442", 11], + ["ac80", "\u744E", 6, "\u7456\u7458\u745D\u7460", 12, "\u746E\u746F\u7471", 4, "\u7478\u7479\u747A"], + ["ad40", "\u747B\u747C\u747D\u747F\u7482\u7484\u7485\u7486\u7488\u7489\u748A\u748C\u748D\u748F\u7491", 10, "\u749D\u749F", 7, "\u74AA", 15, "\u74BB", 12], + ["ad80", "\u74C8", 9, "\u74D3", 8, "\u74DD\u74DF\u74E1\u74E5\u74E7", 6, "\u74F0\u74F1\u74F2"], + ["ae40", "\u74F3\u74F5\u74F8", 6, "\u7500\u7501\u7502\u7503\u7505", 7, "\u750E\u7510\u7512\u7514\u7515\u7516\u7517\u751B\u751D\u751E\u7520", 4, "\u7526\u7527\u752A\u752E\u7534\u7536\u7539\u753C\u753D\u753F\u7541\u7542\u7543\u7544\u7546\u7547\u7549\u754A\u754D\u7550\u7551\u7552\u7553\u7555\u7556\u7557\u7558"], + ["ae80", "\u755D", 7, "\u7567\u7568\u7569\u756B", 6, "\u7573\u7575\u7576\u7577\u757A", 4, "\u7580\u7581\u7582\u7584\u7585\u7587"], + ["af40", "\u7588\u7589\u758A\u758C\u758D\u758E\u7590\u7593\u7595\u7598\u759B\u759C\u759E\u75A2\u75A6", 4, "\u75AD\u75B6\u75B7\u75BA\u75BB\u75BF\u75C0\u75C1\u75C6\u75CB\u75CC\u75CE\u75CF\u75D0\u75D1\u75D3\u75D7\u75D9\u75DA\u75DC\u75DD\u75DF\u75E0\u75E1\u75E5\u75E9\u75EC\u75ED\u75EE\u75EF\u75F2\u75F3\u75F5\u75F6\u75F7\u75F8\u75FA\u75FB\u75FD\u75FE\u7602\u7604\u7606\u7607"], + ["af80", "\u7608\u7609\u760B\u760D\u760E\u760F\u7611\u7612\u7613\u7614\u7616\u761A\u761C\u761D\u761E\u7621\u7623\u7627\u7628\u762C\u762E\u762F\u7631\u7632\u7636\u7637\u7639\u763A\u763B\u763D\u7641\u7642\u7644"], + ["b040", "\u7645", 6, "\u764E", 5, "\u7655\u7657", 4, "\u765D\u765F\u7660\u7661\u7662\u7664", 6, "\u766C\u766D\u766E\u7670", 7, "\u7679\u767A\u767C\u767F\u7680\u7681\u7683\u7685\u7689\u768A\u768C\u768D\u768F\u7690\u7692\u7694\u7695\u7697\u7698\u769A\u769B"], + ["b080", "\u769C", 7, "\u76A5", 8, "\u76AF\u76B0\u76B3\u76B5", 9, "\u76C0\u76C1\u76C3\u554A\u963F\u57C3\u6328\u54CE\u5509\u54C0\u7691\u764C\u853C\u77EE\u827E\u788D\u7231\u9698\u978D\u6C28\u5B89\u4FFA\u6309\u6697\u5CB8\u80FA\u6848\u80AE\u6602\u76CE\u51F9\u6556\u71AC\u7FF1\u8884\u50B2\u5965\u61CA\u6FB3\u82AD\u634C\u6252\u53ED\u5427\u7B06\u516B\u75A4\u5DF4\u62D4\u8DCB\u9776\u628A\u8019\u575D\u9738\u7F62\u7238\u767D\u67CF\u767E\u6446\u4F70\u8D25\u62DC\u7A17\u6591\u73ED\u642C\u6273\u822C\u9881\u677F\u7248\u626E\u62CC\u4F34\u74E3\u534A\u529E\u7ECA\u90A6\u5E2E\u6886\u699C\u8180\u7ED1\u68D2\u78C5\u868C\u9551\u508D\u8C24\u82DE\u80DE\u5305\u8912\u5265"], + ["b140", "\u76C4\u76C7\u76C9\u76CB\u76CC\u76D3\u76D5\u76D9\u76DA\u76DC\u76DD\u76DE\u76E0", 4, "\u76E6", 7, "\u76F0\u76F3\u76F5\u76F6\u76F7\u76FA\u76FB\u76FD\u76FF\u7700\u7702\u7703\u7705\u7706\u770A\u770C\u770E", 10, "\u771B\u771C\u771D\u771E\u7721\u7723\u7724\u7725\u7727\u772A\u772B"], + ["b180", "\u772C\u772E\u7730", 4, "\u7739\u773B\u773D\u773E\u773F\u7742\u7744\u7745\u7746\u7748", 7, "\u7752", 7, "\u775C\u8584\u96F9\u4FDD\u5821\u9971\u5B9D\u62B1\u62A5\u66B4\u8C79\u9C8D\u7206\u676F\u7891\u60B2\u5351\u5317\u8F88\u80CC\u8D1D\u94A1\u500D\u72C8\u5907\u60EB\u7119\u88AB\u5954\u82EF\u672C\u7B28\u5D29\u7EF7\u752D\u6CF5\u8E66\u8FF8\u903C\u9F3B\u6BD4\u9119\u7B14\u5F7C\u78A7\u84D6\u853D\u6BD5\u6BD9\u6BD6\u5E01\u5E87\u75F9\u95ED\u655D\u5F0A\u5FC5\u8F9F\u58C1\u81C2\u907F\u965B\u97AD\u8FB9\u7F16\u8D2C\u6241\u4FBF\u53D8\u535E\u8FA8\u8FA9\u8FAB\u904D\u6807\u5F6A\u8198\u8868\u9CD6\u618B\u522B\u762A\u5F6C\u658C\u6FD2\u6EE8\u5BBE\u6448\u5175\u51B0\u67C4\u4E19\u79C9\u997C\u70B3"], + ["b240", "\u775D\u775E\u775F\u7760\u7764\u7767\u7769\u776A\u776D", 11, "\u777A\u777B\u777C\u7781\u7782\u7783\u7786", 5, "\u778F\u7790\u7793", 11, "\u77A1\u77A3\u77A4\u77A6\u77A8\u77AB\u77AD\u77AE\u77AF\u77B1\u77B2\u77B4\u77B6", 4], + ["b280", "\u77BC\u77BE\u77C0", 12, "\u77CE", 8, "\u77D8\u77D9\u77DA\u77DD", 4, "\u77E4\u75C5\u5E76\u73BB\u83E0\u64AD\u62E8\u94B5\u6CE2\u535A\u52C3\u640F\u94C2\u7B94\u4F2F\u5E1B\u8236\u8116\u818A\u6E24\u6CCA\u9A73\u6355\u535C\u54FA\u8865\u57E0\u4E0D\u5E03\u6B65\u7C3F\u90E8\u6016\u64E6\u731C\u88C1\u6750\u624D\u8D22\u776C\u8E29\u91C7\u5F69\u83DC\u8521\u9910\u53C2\u8695\u6B8B\u60ED\u60E8\u707F\u82CD\u8231\u4ED3\u6CA7\u85CF\u64CD\u7CD9\u69FD\u66F9\u8349\u5395\u7B56\u4FA7\u518C\u6D4B\u5C42\u8E6D\u63D2\u53C9\u832C\u8336\u67E5\u78B4\u643D\u5BDF\u5C94\u5DEE\u8BE7\u62C6\u67F4\u8C7A\u6400\u63BA\u8749\u998B\u8C17\u7F20\u94F2\u4EA7\u9610\u98A4\u660C\u7316"], + ["b340", "\u77E6\u77E8\u77EA\u77EF\u77F0\u77F1\u77F2\u77F4\u77F5\u77F7\u77F9\u77FA\u77FB\u77FC\u7803", 5, "\u780A\u780B\u780E\u780F\u7810\u7813\u7815\u7819\u781B\u781E\u7820\u7821\u7822\u7824\u7828\u782A\u782B\u782E\u782F\u7831\u7832\u7833\u7835\u7836\u783D\u783F\u7841\u7842\u7843\u7844\u7846\u7848\u7849\u784A\u784B\u784D\u784F\u7851\u7853\u7854\u7858\u7859\u785A"], + ["b380", "\u785B\u785C\u785E", 11, "\u786F", 7, "\u7878\u7879\u787A\u787B\u787D", 6, "\u573A\u5C1D\u5E38\u957F\u507F\u80A0\u5382\u655E\u7545\u5531\u5021\u8D85\u6284\u949E\u671D\u5632\u6F6E\u5DE2\u5435\u7092\u8F66\u626F\u64A4\u63A3\u5F7B\u6F88\u90F4\u81E3\u8FB0\u5C18\u6668\u5FF1\u6C89\u9648\u8D81\u886C\u6491\u79F0\u57CE\u6A59\u6210\u5448\u4E58\u7A0B\u60E9\u6F84\u8BDA\u627F\u901E\u9A8B\u79E4\u5403\u75F4\u6301\u5319\u6C60\u8FDF\u5F1B\u9A70\u803B\u9F7F\u4F88\u5C3A\u8D64\u7FC5\u65A5\u70BD\u5145\u51B2\u866B\u5D07\u5BA0\u62BD\u916C\u7574\u8E0C\u7A20\u6101\u7B79\u4EC7\u7EF8\u7785\u4E11\u81ED\u521D\u51FA\u6A71\u53A8\u8E87\u9504\u96CF\u6EC1\u9664\u695A"], + ["b440", "\u7884\u7885\u7886\u7888\u788A\u788B\u788F\u7890\u7892\u7894\u7895\u7896\u7899\u789D\u789E\u78A0\u78A2\u78A4\u78A6\u78A8", 7, "\u78B5\u78B6\u78B7\u78B8\u78BA\u78BB\u78BC\u78BD\u78BF\u78C0\u78C2\u78C3\u78C4\u78C6\u78C7\u78C8\u78CC\u78CD\u78CE\u78CF\u78D1\u78D2\u78D3\u78D6\u78D7\u78D8\u78DA", 9], + ["b480", "\u78E4\u78E5\u78E6\u78E7\u78E9\u78EA\u78EB\u78ED", 4, "\u78F3\u78F5\u78F6\u78F8\u78F9\u78FB", 5, "\u7902\u7903\u7904\u7906", 6, "\u7840\u50A8\u77D7\u6410\u89E6\u5904\u63E3\u5DDD\u7A7F\u693D\u4F20\u8239\u5598\u4E32\u75AE\u7A97\u5E62\u5E8A\u95EF\u521B\u5439\u708A\u6376\u9524\u5782\u6625\u693F\u9187\u5507\u6DF3\u7EAF\u8822\u6233\u7EF0\u75B5\u8328\u78C1\u96CC\u8F9E\u6148\u74F7\u8BCD\u6B64\u523A\u8D50\u6B21\u806A\u8471\u56F1\u5306\u4ECE\u4E1B\u51D1\u7C97\u918B\u7C07\u4FC3\u8E7F\u7BE1\u7A9C\u6467\u5D14\u50AC\u8106\u7601\u7CB9\u6DEC\u7FE0\u6751\u5B58\u5BF8\u78CB\u64AE\u6413\u63AA\u632B\u9519\u642D\u8FBE\u7B54\u7629\u6253\u5927\u5446\u6B79\u50A3\u6234\u5E26\u6B86\u4EE3\u8D37\u888B\u5F85\u902E"], + ["b540", "\u790D", 5, "\u7914", 9, "\u791F", 4, "\u7925", 14, "\u7935", 4, "\u793D\u793F\u7942\u7943\u7944\u7945\u7947\u794A", 8, "\u7954\u7955\u7958\u7959\u7961\u7963"], + ["b580", "\u7964\u7966\u7969\u796A\u796B\u796C\u796E\u7970", 6, "\u7979\u797B", 4, "\u7982\u7983\u7986\u7987\u7988\u7989\u798B\u798C\u798D\u798E\u7990\u7991\u7992\u6020\u803D\u62C5\u4E39\u5355\u90F8\u63B8\u80C6\u65E6\u6C2E\u4F46\u60EE\u6DE1\u8BDE\u5F39\u86CB\u5F53\u6321\u515A\u8361\u6863\u5200\u6363\u8E48\u5012\u5C9B\u7977\u5BFC\u5230\u7A3B\u60BC\u9053\u76D7\u5FB7\u5F97\u7684\u8E6C\u706F\u767B\u7B49\u77AA\u51F3\u9093\u5824\u4F4E\u6EF4\u8FEA\u654C\u7B1B\u72C4\u6DA4\u7FDF\u5AE1\u62B5\u5E95\u5730\u8482\u7B2C\u5E1D\u5F1F\u9012\u7F14\u98A0\u6382\u6EC7\u7898\u70B9\u5178\u975B\u57AB\u7535\u4F43\u7538\u5E97\u60E6\u5960\u6DC0\u6BBF\u7889\u53FC\u96D5\u51CB\u5201\u6389\u540A\u9493\u8C03\u8DCC\u7239\u789F\u8776\u8FED\u8C0D\u53E0"], + ["b640", "\u7993", 6, "\u799B", 11, "\u79A8", 10, "\u79B4", 4, "\u79BC\u79BF\u79C2\u79C4\u79C5\u79C7\u79C8\u79CA\u79CC\u79CE\u79CF\u79D0\u79D3\u79D4\u79D6\u79D7\u79D9", 5, "\u79E0\u79E1\u79E2\u79E5\u79E8\u79EA"], + ["b680", "\u79EC\u79EE\u79F1", 6, "\u79F9\u79FA\u79FC\u79FE\u79FF\u7A01\u7A04\u7A05\u7A07\u7A08\u7A09\u7A0A\u7A0C\u7A0F", 4, "\u7A15\u7A16\u7A18\u7A19\u7A1B\u7A1C\u4E01\u76EF\u53EE\u9489\u9876\u9F0E\u952D\u5B9A\u8BA2\u4E22\u4E1C\u51AC\u8463\u61C2\u52A8\u680B\u4F97\u606B\u51BB\u6D1E\u515C\u6296\u6597\u9661\u8C46\u9017\u75D8\u90FD\u7763\u6BD2\u728A\u72EC\u8BFB\u5835\u7779\u8D4C\u675C\u9540\u809A\u5EA6\u6E21\u5992\u7AEF\u77ED\u953B\u6BB5\u65AD\u7F0E\u5806\u5151\u961F\u5BF9\u58A9\u5428\u8E72\u6566\u987F\u56E4\u949D\u76FE\u9041\u6387\u54C6\u591A\u593A\u579B\u8EB2\u6735\u8DFA\u8235\u5241\u60F0\u5815\u86FE\u5CE8\u9E45\u4FC4\u989D\u8BB9\u5A25\u6076\u5384\u627C\u904F\u9102\u997F\u6069\u800C\u513F\u8033\u5C14\u9975\u6D31\u4E8C"], + ["b740", "\u7A1D\u7A1F\u7A21\u7A22\u7A24", 14, "\u7A34\u7A35\u7A36\u7A38\u7A3A\u7A3E\u7A40", 5, "\u7A47", 9, "\u7A52", 4, "\u7A58", 16], + ["b780", "\u7A69", 6, "\u7A71\u7A72\u7A73\u7A75\u7A7B\u7A7C\u7A7D\u7A7E\u7A82\u7A85\u7A87\u7A89\u7A8A\u7A8B\u7A8C\u7A8E\u7A8F\u7A90\u7A93\u7A94\u7A99\u7A9A\u7A9B\u7A9E\u7AA1\u7AA2\u8D30\u53D1\u7F5A\u7B4F\u4F10\u4E4F\u9600\u6CD5\u73D0\u85E9\u5E06\u756A\u7FFB\u6A0A\u77FE\u9492\u7E41\u51E1\u70E6\u53CD\u8FD4\u8303\u8D29\u72AF\u996D\u6CDB\u574A\u82B3\u65B9\u80AA\u623F\u9632\u59A8\u4EFF\u8BBF\u7EBA\u653E\u83F2\u975E\u5561\u98DE\u80A5\u532A\u8BFD\u5420\u80BA\u5E9F\u6CB8\u8D39\u82AC\u915A\u5429\u6C1B\u5206\u7EB7\u575F\u711A\u6C7E\u7C89\u594B\u4EFD\u5FFF\u6124\u7CAA\u4E30\u5C01\u67AB\u8702\u5CF0\u950B\u98CE\u75AF\u70FD\u9022\u51AF\u7F1D\u8BBD\u5949\u51E4\u4F5B\u5426\u592B\u6577\u80A4\u5B75\u6276\u62C2\u8F90\u5E45\u6C1F\u7B26\u4F0F\u4FD8\u670D"], + ["b840", "\u7AA3\u7AA4\u7AA7\u7AA9\u7AAA\u7AAB\u7AAE", 4, "\u7AB4", 10, "\u7AC0", 10, "\u7ACC", 9, "\u7AD7\u7AD8\u7ADA\u7ADB\u7ADC\u7ADD\u7AE1\u7AE2\u7AE4\u7AE7", 5, "\u7AEE\u7AF0\u7AF1\u7AF2\u7AF3"], + ["b880", "\u7AF4", 4, "\u7AFB\u7AFC\u7AFE\u7B00\u7B01\u7B02\u7B05\u7B07\u7B09\u7B0C\u7B0D\u7B0E\u7B10\u7B12\u7B13\u7B16\u7B17\u7B18\u7B1A\u7B1C\u7B1D\u7B1F\u7B21\u7B22\u7B23\u7B27\u7B29\u7B2D\u6D6E\u6DAA\u798F\u88B1\u5F17\u752B\u629A\u8F85\u4FEF\u91DC\u65A7\u812F\u8151\u5E9C\u8150\u8D74\u526F\u8986\u8D4B\u590D\u5085\u4ED8\u961C\u7236\u8179\u8D1F\u5BCC\u8BA3\u9644\u5987\u7F1A\u5490\u5676\u560E\u8BE5\u6539\u6982\u9499\u76D6\u6E89\u5E72\u7518\u6746\u67D1\u7AFF\u809D\u8D76\u611F\u79C6\u6562\u8D63\u5188\u521A\u94A2\u7F38\u809B\u7EB2\u5C97\u6E2F\u6760\u7BD9\u768B\u9AD8\u818F\u7F94\u7CD5\u641E\u9550\u7A3F\u544A\u54E5\u6B4C\u6401\u6208\u9E3D\u80F3\u7599\u5272\u9769\u845B\u683C\u86E4\u9601\u9694\u94EC\u4E2A\u5404\u7ED9\u6839\u8DDF\u8015\u66F4\u5E9A\u7FB9"], + ["b940", "\u7B2F\u7B30\u7B32\u7B34\u7B35\u7B36\u7B37\u7B39\u7B3B\u7B3D\u7B3F", 5, "\u7B46\u7B48\u7B4A\u7B4D\u7B4E\u7B53\u7B55\u7B57\u7B59\u7B5C\u7B5E\u7B5F\u7B61\u7B63", 10, "\u7B6F\u7B70\u7B73\u7B74\u7B76\u7B78\u7B7A\u7B7C\u7B7D\u7B7F\u7B81\u7B82\u7B83\u7B84\u7B86", 6, "\u7B8E\u7B8F"], + ["b980", "\u7B91\u7B92\u7B93\u7B96\u7B98\u7B99\u7B9A\u7B9B\u7B9E\u7B9F\u7BA0\u7BA3\u7BA4\u7BA5\u7BAE\u7BAF\u7BB0\u7BB2\u7BB3\u7BB5\u7BB6\u7BB7\u7BB9", 7, "\u7BC2\u7BC3\u7BC4\u57C2\u803F\u6897\u5DE5\u653B\u529F\u606D\u9F9A\u4F9B\u8EAC\u516C\u5BAB\u5F13\u5DE9\u6C5E\u62F1\u8D21\u5171\u94A9\u52FE\u6C9F\u82DF\u72D7\u57A2\u6784\u8D2D\u591F\u8F9C\u83C7\u5495\u7B8D\u4F30\u6CBD\u5B64\u59D1\u9F13\u53E4\u86CA\u9AA8\u8C37\u80A1\u6545\u987E\u56FA\u96C7\u522E\u74DC\u5250\u5BE1\u6302\u8902\u4E56\u62D0\u602A\u68FA\u5173\u5B98\u51A0\u89C2\u7BA1\u9986\u7F50\u60EF\u704C\u8D2F\u5149\u5E7F\u901B\u7470\u89C4\u572D\u7845\u5F52\u9F9F\u95FA\u8F68\u9B3C\u8BE1\u7678\u6842\u67DC\u8DEA\u8D35\u523D\u8F8A\u6EDA\u68CD\u9505\u90ED\u56FD\u679C\u88F9\u8FC7\u54C8"], + ["ba40", "\u7BC5\u7BC8\u7BC9\u7BCA\u7BCB\u7BCD\u7BCE\u7BCF\u7BD0\u7BD2\u7BD4", 4, "\u7BDB\u7BDC\u7BDE\u7BDF\u7BE0\u7BE2\u7BE3\u7BE4\u7BE7\u7BE8\u7BE9\u7BEB\u7BEC\u7BED\u7BEF\u7BF0\u7BF2", 4, "\u7BF8\u7BF9\u7BFA\u7BFB\u7BFD\u7BFF", 7, "\u7C08\u7C09\u7C0A\u7C0D\u7C0E\u7C10", 5, "\u7C17\u7C18\u7C19"], + ["ba80", "\u7C1A", 4, "\u7C20", 5, "\u7C28\u7C29\u7C2B", 12, "\u7C39", 5, "\u7C42\u9AB8\u5B69\u6D77\u6C26\u4EA5\u5BB3\u9A87\u9163\u61A8\u90AF\u97E9\u542B\u6DB5\u5BD2\u51FD\u558A\u7F55\u7FF0\u64BC\u634D\u65F1\u61BE\u608D\u710A\u6C57\u6C49\u592F\u676D\u822A\u58D5\u568E\u8C6A\u6BEB\u90DD\u597D\u8017\u53F7\u6D69\u5475\u559D\u8377\u83CF\u6838\u79BE\u548C\u4F55\u5408\u76D2\u8C89\u9602\u6CB3\u6DB8\u8D6B\u8910\u9E64\u8D3A\u563F\u9ED1\u75D5\u5F88\u72E0\u6068\u54FC\u4EA8\u6A2A\u8861\u6052\u8F70\u54C4\u70D8\u8679\u9E3F\u6D2A\u5B8F\u5F18\u7EA2\u5589\u4FAF\u7334\u543C\u539A\u5019\u540E\u547C\u4E4E\u5FFD\u745A\u58F6\u846B\u80E1\u8774\u72D0\u7CCA\u6E56"], + ["bb40", "\u7C43", 9, "\u7C4E", 36, "\u7C75", 5, "\u7C7E", 9], + ["bb80", "\u7C88\u7C8A", 6, "\u7C93\u7C94\u7C96\u7C99\u7C9A\u7C9B\u7CA0\u7CA1\u7CA3\u7CA6\u7CA7\u7CA8\u7CA9\u7CAB\u7CAC\u7CAD\u7CAF\u7CB0\u7CB4", 4, "\u7CBA\u7CBB\u5F27\u864E\u552C\u62A4\u4E92\u6CAA\u6237\u82B1\u54D7\u534E\u733E\u6ED1\u753B\u5212\u5316\u8BDD\u69D0\u5F8A\u6000\u6DEE\u574F\u6B22\u73AF\u6853\u8FD8\u7F13\u6362\u60A3\u5524\u75EA\u8C62\u7115\u6DA3\u5BA6\u5E7B\u8352\u614C\u9EC4\u78FA\u8757\u7C27\u7687\u51F0\u60F6\u714C\u6643\u5E4C\u604D\u8C0E\u7070\u6325\u8F89\u5FBD\u6062\u86D4\u56DE\u6BC1\u6094\u6167\u5349\u60E0\u6666\u8D3F\u79FD\u4F1A\u70E9\u6C47\u8BB3\u8BF2\u7ED8\u8364\u660F\u5A5A\u9B42\u6D51\u6DF7\u8C41\u6D3B\u4F19\u706B\u83B7\u6216\u60D1\u970D\u8D27\u7978\u51FB\u573E\u57FA\u673A\u7578\u7A3D\u79EF\u7B95"], + ["bc40", "\u7CBF\u7CC0\u7CC2\u7CC3\u7CC4\u7CC6\u7CC9\u7CCB\u7CCE", 6, "\u7CD8\u7CDA\u7CDB\u7CDD\u7CDE\u7CE1", 6, "\u7CE9", 5, "\u7CF0", 7, "\u7CF9\u7CFA\u7CFC", 13, "\u7D0B", 5], + ["bc80", "\u7D11", 14, "\u7D21\u7D23\u7D24\u7D25\u7D26\u7D28\u7D29\u7D2A\u7D2C\u7D2D\u7D2E\u7D30", 6, "\u808C\u9965\u8FF9\u6FC0\u8BA5\u9E21\u59EC\u7EE9\u7F09\u5409\u6781\u68D8\u8F91\u7C4D\u96C6\u53CA\u6025\u75BE\u6C72\u5373\u5AC9\u7EA7\u6324\u51E0\u810A\u5DF1\u84DF\u6280\u5180\u5B63\u4F0E\u796D\u5242\u60B8\u6D4E\u5BC4\u5BC2\u8BA1\u8BB0\u65E2\u5FCC\u9645\u5993\u7EE7\u7EAA\u5609\u67B7\u5939\u4F73\u5BB6\u52A0\u835A\u988A\u8D3E\u7532\u94BE\u5047\u7A3C\u4EF7\u67B6\u9A7E\u5AC1\u6B7C\u76D1\u575A\u5C16\u7B3A\u95F4\u714E\u517C\u80A9\u8270\u5978\u7F04\u8327\u68C0\u67EC\u78B1\u7877\u62E3\u6361\u7B80\u4FED\u526A\u51CF\u8350\u69DB\u9274\u8DF5\u8D31\u89C1\u952E\u7BAD\u4EF6"], + ["bd40", "\u7D37", 54, "\u7D6F", 7], + ["bd80", "\u7D78", 32, "\u5065\u8230\u5251\u996F\u6E10\u6E85\u6DA7\u5EFA\u50F5\u59DC\u5C06\u6D46\u6C5F\u7586\u848B\u6868\u5956\u8BB2\u5320\u9171\u964D\u8549\u6912\u7901\u7126\u80F6\u4EA4\u90CA\u6D47\u9A84\u5A07\u56BC\u6405\u94F0\u77EB\u4FA5\u811A\u72E1\u89D2\u997A\u7F34\u7EDE\u527F\u6559\u9175\u8F7F\u8F83\u53EB\u7A96\u63ED\u63A5\u7686\u79F8\u8857\u9636\u622A\u52AB\u8282\u6854\u6770\u6377\u776B\u7AED\u6D01\u7ED3\u89E3\u59D0\u6212\u85C9\u82A5\u754C\u501F\u4ECB\u75A5\u8BEB\u5C4A\u5DFE\u7B4B\u65A4\u91D1\u4ECA\u6D25\u895F\u7D27\u9526\u4EC5\u8C28\u8FDB\u9773\u664B\u7981\u8FD1\u70EC\u6D78"], + ["be40", "\u7D99", 12, "\u7DA7", 6, "\u7DAF", 42], + ["be80", "\u7DDA", 32, "\u5C3D\u52B2\u8346\u5162\u830E\u775B\u6676\u9CB8\u4EAC\u60CA\u7CBE\u7CB3\u7ECF\u4E95\u8B66\u666F\u9888\u9759\u5883\u656C\u955C\u5F84\u75C9\u9756\u7ADF\u7ADE\u51C0\u70AF\u7A98\u63EA\u7A76\u7EA0\u7396\u97ED\u4E45\u7078\u4E5D\u9152\u53A9\u6551\u65E7\u81FC\u8205\u548E\u5C31\u759A\u97A0\u62D8\u72D9\u75BD\u5C45\u9A79\u83CA\u5C40\u5480\u77E9\u4E3E\u6CAE\u805A\u62D2\u636E\u5DE8\u5177\u8DDD\u8E1E\u952F\u4FF1\u53E5\u60E7\u70AC\u5267\u6350\u9E43\u5A1F\u5026\u7737\u5377\u7EE2\u6485\u652B\u6289\u6398\u5014\u7235\u89C9\u51B3\u8BC0\u7EDD\u5747\u83CC\u94A7\u519B\u541B\u5CFB"], + ["bf40", "\u7DFB", 62], + ["bf80", "\u7E3A\u7E3C", 4, "\u7E42", 4, "\u7E48", 21, "\u4FCA\u7AE3\u6D5A\u90E1\u9A8F\u5580\u5496\u5361\u54AF\u5F00\u63E9\u6977\u51EF\u6168\u520A\u582A\u52D8\u574E\u780D\u770B\u5EB7\u6177\u7CE0\u625B\u6297\u4EA2\u7095\u8003\u62F7\u70E4\u9760\u5777\u82DB\u67EF\u68F5\u78D5\u9897\u79D1\u58F3\u54B3\u53EF\u6E34\u514B\u523B\u5BA2\u8BFE\u80AF\u5543\u57A6\u6073\u5751\u542D\u7A7A\u6050\u5B54\u63A7\u62A0\u53E3\u6263\u5BC7\u67AF\u54ED\u7A9F\u82E6\u9177\u5E93\u88E4\u5938\u57AE\u630E\u8DE8\u80EF\u5757\u7B77\u4FA9\u5FEB\u5BBD\u6B3E\u5321\u7B50\u72C2\u6846\u77FF\u7736\u65F7\u51B5\u4E8F\u76D4\u5CBF\u7AA5\u8475\u594E\u9B41\u5080"], + ["c040", "\u7E5E", 35, "\u7E83", 23, "\u7E9C\u7E9D\u7E9E"], + ["c080", "\u7EAE\u7EB4\u7EBB\u7EBC\u7ED6\u7EE4\u7EEC\u7EF9\u7F0A\u7F10\u7F1E\u7F37\u7F39\u7F3B", 6, "\u7F43\u7F46", 9, "\u7F52\u7F53\u9988\u6127\u6E83\u5764\u6606\u6346\u56F0\u62EC\u6269\u5ED3\u9614\u5783\u62C9\u5587\u8721\u814A\u8FA3\u5566\u83B1\u6765\u8D56\u84DD\u5A6A\u680F\u62E6\u7BEE\u9611\u5170\u6F9C\u8C30\u63FD\u89C8\u61D2\u7F06\u70C2\u6EE5\u7405\u6994\u72FC\u5ECA\u90CE\u6717\u6D6A\u635E\u52B3\u7262\u8001\u4F6C\u59E5\u916A\u70D9\u6D9D\u52D2\u4E50\u96F7\u956D\u857E\u78CA\u7D2F\u5121\u5792\u64C2\u808B\u7C7B\u6CEA\u68F1\u695E\u51B7\u5398\u68A8\u7281\u9ECE\u7BF1\u72F8\u79BB\u6F13\u7406\u674E\u91CC\u9CA4\u793C\u8389\u8354\u540F\u6817\u4E3D\u5389\u52B1\u783E\u5386\u5229\u5088\u4F8B\u4FD0"], + ["c140", "\u7F56\u7F59\u7F5B\u7F5C\u7F5D\u7F5E\u7F60\u7F63", 4, "\u7F6B\u7F6C\u7F6D\u7F6F\u7F70\u7F73\u7F75\u7F76\u7F77\u7F78\u7F7A\u7F7B\u7F7C\u7F7D\u7F7F\u7F80\u7F82", 7, "\u7F8B\u7F8D\u7F8F", 4, "\u7F95", 4, "\u7F9B\u7F9C\u7FA0\u7FA2\u7FA3\u7FA5\u7FA6\u7FA8", 6, "\u7FB1"], + ["c180", "\u7FB3", 4, "\u7FBA\u7FBB\u7FBE\u7FC0\u7FC2\u7FC3\u7FC4\u7FC6\u7FC7\u7FC8\u7FC9\u7FCB\u7FCD\u7FCF", 4, "\u7FD6\u7FD7\u7FD9", 5, "\u7FE2\u7FE3\u75E2\u7ACB\u7C92\u6CA5\u96B6\u529B\u7483\u54E9\u4FE9\u8054\u83B2\u8FDE\u9570\u5EC9\u601C\u6D9F\u5E18\u655B\u8138\u94FE\u604B\u70BC\u7EC3\u7CAE\u51C9\u6881\u7CB1\u826F\u4E24\u8F86\u91CF\u667E\u4EAE\u8C05\u64A9\u804A\u50DA\u7597\u71CE\u5BE5\u8FBD\u6F66\u4E86\u6482\u9563\u5ED6\u6599\u5217\u88C2\u70C8\u52A3\u730E\u7433\u6797\u78F7\u9716\u4E34\u90BB\u9CDE\u6DCB\u51DB\u8D41\u541D\u62CE\u73B2\u83F1\u96F6\u9F84\u94C3\u4F36\u7F9A\u51CC\u7075\u9675\u5CAD\u9886\u53E6\u4EE4\u6E9C\u7409\u69B4\u786B\u998F\u7559\u5218\u7624\u6D41\u67F3\u516D\u9F99\u804B\u5499\u7B3C\u7ABF"], + ["c240", "\u7FE4\u7FE7\u7FE8\u7FEA\u7FEB\u7FEC\u7FED\u7FEF\u7FF2\u7FF4", 6, "\u7FFD\u7FFE\u7FFF\u8002\u8007\u8008\u8009\u800A\u800E\u800F\u8011\u8013\u801A\u801B\u801D\u801E\u801F\u8021\u8023\u8024\u802B", 5, "\u8032\u8034\u8039\u803A\u803C\u803E\u8040\u8041\u8044\u8045\u8047\u8048\u8049\u804E\u804F\u8050\u8051\u8053\u8055\u8056\u8057"], + ["c280", "\u8059\u805B", 13, "\u806B", 5, "\u8072", 11, "\u9686\u5784\u62E2\u9647\u697C\u5A04\u6402\u7BD3\u6F0F\u964B\u82A6\u5362\u9885\u5E90\u7089\u63B3\u5364\u864F\u9C81\u9E93\u788C\u9732\u8DEF\u8D42\u9E7F\u6F5E\u7984\u5F55\u9646\u622E\u9A74\u5415\u94DD\u4FA3\u65C5\u5C65\u5C61\u7F15\u8651\u6C2F\u5F8B\u7387\u6EE4\u7EFF\u5CE6\u631B\u5B6A\u6EE6\u5375\u4E71\u63A0\u7565\u62A1\u8F6E\u4F26\u4ED1\u6CA6\u7EB6\u8BBA\u841D\u87BA\u7F57\u903B\u9523\u7BA9\u9AA1\u88F8\u843D\u6D1B\u9A86\u7EDC\u5988\u9EBB\u739B\u7801\u8682\u9A6C\u9A82\u561B\u5417\u57CB\u4E70\u9EA6\u5356\u8FC8\u8109\u7792\u9992\u86EE\u6EE1\u8513\u66FC\u6162\u6F2B"], + ["c340", "\u807E\u8081\u8082\u8085\u8088\u808A\u808D", 5, "\u8094\u8095\u8097\u8099\u809E\u80A3\u80A6\u80A7\u80A8\u80AC\u80B0\u80B3\u80B5\u80B6\u80B8\u80B9\u80BB\u80C5\u80C7", 4, "\u80CF", 6, "\u80D8\u80DF\u80E0\u80E2\u80E3\u80E6\u80EE\u80F5\u80F7\u80F9\u80FB\u80FE\u80FF\u8100\u8101\u8103\u8104\u8105\u8107\u8108\u810B"], + ["c380", "\u810C\u8115\u8117\u8119\u811B\u811C\u811D\u811F", 12, "\u812D\u812E\u8130\u8133\u8134\u8135\u8137\u8139", 4, "\u813F\u8C29\u8292\u832B\u76F2\u6C13\u5FD9\u83BD\u732B\u8305\u951A\u6BDB\u77DB\u94C6\u536F\u8302\u5192\u5E3D\u8C8C\u8D38\u4E48\u73AB\u679A\u6885\u9176\u9709\u7164\u6CA1\u7709\u5A92\u9541\u6BCF\u7F8E\u6627\u5BD0\u59B9\u5A9A\u95E8\u95F7\u4EEC\u840C\u8499\u6AAC\u76DF\u9530\u731B\u68A6\u5B5F\u772F\u919A\u9761\u7CDC\u8FF7\u8C1C\u5F25\u7C73\u79D8\u89C5\u6CCC\u871C\u5BC6\u5E42\u68C9\u7720\u7EF5\u5195\u514D\u52C9\u5A29\u7F05\u9762\u82D7\u63CF\u7784\u85D0\u79D2\u6E3A\u5E99\u5999\u8511\u706D\u6C11\u62BF\u76BF\u654F\u60AF\u95FD\u660E\u879F\u9E23\u94ED\u540D\u547D\u8C2C\u6478"], + ["c440", "\u8140", 5, "\u8147\u8149\u814D\u814E\u814F\u8152\u8156\u8157\u8158\u815B", 4, "\u8161\u8162\u8163\u8164\u8166\u8168\u816A\u816B\u816C\u816F\u8172\u8173\u8175\u8176\u8177\u8178\u8181\u8183", 4, "\u8189\u818B\u818C\u818D\u818E\u8190\u8192", 5, "\u8199\u819A\u819E", 4, "\u81A4\u81A5"], + ["c480", "\u81A7\u81A9\u81AB", 7, "\u81B4", 5, "\u81BC\u81BD\u81BE\u81BF\u81C4\u81C5\u81C7\u81C8\u81C9\u81CB\u81CD", 6, "\u6479\u8611\u6A21\u819C\u78E8\u6469\u9B54\u62B9\u672B\u83AB\u58A8\u9ED8\u6CAB\u6F20\u5BDE\u964C\u8C0B\u725F\u67D0\u62C7\u7261\u4EA9\u59C6\u6BCD\u5893\u66AE\u5E55\u52DF\u6155\u6728\u76EE\u7766\u7267\u7A46\u62FF\u54EA\u5450\u94A0\u90A3\u5A1C\u7EB3\u6C16\u4E43\u5976\u8010\u5948\u5357\u7537\u96BE\u56CA\u6320\u8111\u607C\u95F9\u6DD6\u5462\u9981\u5185\u5AE9\u80FD\u59AE\u9713\u502A\u6CE5\u5C3C\u62DF\u4F60\u533F\u817B\u9006\u6EBA\u852B\u62C8\u5E74\u78BE\u64B5\u637B\u5FF5\u5A18\u917F\u9E1F\u5C3F\u634F\u8042\u5B7D\u556E\u954A\u954D\u6D85\u60A8\u67E0\u72DE\u51DD\u5B81"], + ["c540", "\u81D4", 14, "\u81E4\u81E5\u81E6\u81E8\u81E9\u81EB\u81EE", 4, "\u81F5", 5, "\u81FD\u81FF\u8203\u8207", 4, "\u820E\u820F\u8211\u8213\u8215", 5, "\u821D\u8220\u8224\u8225\u8226\u8227\u8229\u822E\u8232\u823A\u823C\u823D\u823F"], + ["c580", "\u8240\u8241\u8242\u8243\u8245\u8246\u8248\u824A\u824C\u824D\u824E\u8250", 7, "\u8259\u825B\u825C\u825D\u825E\u8260", 7, "\u8269\u62E7\u6CDE\u725B\u626D\u94AE\u7EBD\u8113\u6D53\u519C\u5F04\u5974\u52AA\u6012\u5973\u6696\u8650\u759F\u632A\u61E6\u7CEF\u8BFA\u54E6\u6B27\u9E25\u6BB4\u85D5\u5455\u5076\u6CA4\u556A\u8DB4\u722C\u5E15\u6015\u7436\u62CD\u6392\u724C\u5F98\u6E43\u6D3E\u6500\u6F58\u76D8\u78D0\u76FC\u7554\u5224\u53DB\u4E53\u5E9E\u65C1\u802A\u80D6\u629B\u5486\u5228\u70AE\u888D\u8DD1\u6CE1\u5478\u80DA\u57F9\u88F4\u8D54\u966A\u914D\u4F69\u6C9B\u55B7\u76C6\u7830\u62A8\u70F9\u6F8E\u5F6D\u84EC\u68DA\u787C\u7BF7\u81A8\u670B\u9E4F\u6367\u78B0\u576F\u7812\u9739\u6279\u62AB\u5288\u7435\u6BD7"], + ["c640", "\u826A\u826B\u826C\u826D\u8271\u8275\u8276\u8277\u8278\u827B\u827C\u8280\u8281\u8283\u8285\u8286\u8287\u8289\u828C\u8290\u8293\u8294\u8295\u8296\u829A\u829B\u829E\u82A0\u82A2\u82A3\u82A7\u82B2\u82B5\u82B6\u82BA\u82BB\u82BC\u82BF\u82C0\u82C2\u82C3\u82C5\u82C6\u82C9\u82D0\u82D6\u82D9\u82DA\u82DD\u82E2\u82E7\u82E8\u82E9\u82EA\u82EC\u82ED\u82EE\u82F0\u82F2\u82F3\u82F5\u82F6\u82F8"], + ["c680", "\u82FA\u82FC", 4, "\u830A\u830B\u830D\u8310\u8312\u8313\u8316\u8318\u8319\u831D", 9, "\u8329\u832A\u832E\u8330\u8332\u8337\u833B\u833D\u5564\u813E\u75B2\u76AE\u5339\u75DE\u50FB\u5C41\u8B6C\u7BC7\u504F\u7247\u9A97\u98D8\u6F02\u74E2\u7968\u6487\u77A5\u62FC\u9891\u8D2B\u54C1\u8058\u4E52\u576A\u82F9\u840D\u5E73\u51ED\u74F6\u8BC4\u5C4F\u5761\u6CFC\u9887\u5A46\u7834\u9B44\u8FEB\u7C95\u5256\u6251\u94FA\u4EC6\u8386\u8461\u83E9\u84B2\u57D4\u6734\u5703\u666E\u6D66\u8C31\u66DD\u7011\u671F\u6B3A\u6816\u621A\u59BB\u4E03\u51C4\u6F06\u67D2\u6C8F\u5176\u68CB\u5947\u6B67\u7566\u5D0E\u8110\u9F50\u65D7\u7948\u7941\u9A91\u8D77\u5C82\u4E5E\u4F01\u542F\u5951\u780C\u5668\u6C14\u8FC4\u5F03\u6C7D\u6CE3\u8BAB\u6390"], + ["c740", "\u833E\u833F\u8341\u8342\u8344\u8345\u8348\u834A", 4, "\u8353\u8355", 4, "\u835D\u8362\u8370", 6, "\u8379\u837A\u837E", 6, "\u8387\u8388\u838A\u838B\u838C\u838D\u838F\u8390\u8391\u8394\u8395\u8396\u8397\u8399\u839A\u839D\u839F\u83A1", 6, "\u83AC\u83AD\u83AE"], + ["c780", "\u83AF\u83B5\u83BB\u83BE\u83BF\u83C2\u83C3\u83C4\u83C6\u83C8\u83C9\u83CB\u83CD\u83CE\u83D0\u83D1\u83D2\u83D3\u83D5\u83D7\u83D9\u83DA\u83DB\u83DE\u83E2\u83E3\u83E4\u83E6\u83E7\u83E8\u83EB\u83EC\u83ED\u6070\u6D3D\u7275\u6266\u948E\u94C5\u5343\u8FC1\u7B7E\u4EDF\u8C26\u4E7E\u9ED4\u94B1\u94B3\u524D\u6F5C\u9063\u6D45\u8C34\u5811\u5D4C\u6B20\u6B49\u67AA\u545B\u8154\u7F8C\u5899\u8537\u5F3A\u62A2\u6A47\u9539\u6572\u6084\u6865\u77A7\u4E54\u4FA8\u5DE7\u9798\u64AC\u7FD8\u5CED\u4FCF\u7A8D\u5207\u8304\u4E14\u602F\u7A83\u94A6\u4FB5\u4EB2\u79E6\u7434\u52E4\u82B9\u64D2\u79BD\u5BDD\u6C81\u9752\u8F7B\u6C22\u503E\u537F\u6E05\u64CE\u6674\u6C30\u60C5\u9877\u8BF7\u5E86\u743C\u7A77\u79CB\u4E18\u90B1\u7403\u6C42\u56DA\u914B\u6CC5\u8D8B\u533A\u86C6\u66F2\u8EAF\u5C48\u9A71\u6E20"], + ["c840", "\u83EE\u83EF\u83F3", 4, "\u83FA\u83FB\u83FC\u83FE\u83FF\u8400\u8402\u8405\u8407\u8408\u8409\u840A\u8410\u8412", 5, "\u8419\u841A\u841B\u841E", 5, "\u8429", 7, "\u8432", 5, "\u8439\u843A\u843B\u843E", 7, "\u8447\u8448\u8449"], + ["c880", "\u844A", 6, "\u8452", 4, "\u8458\u845D\u845E\u845F\u8460\u8462\u8464", 4, "\u846A\u846E\u846F\u8470\u8472\u8474\u8477\u8479\u847B\u847C\u53D6\u5A36\u9F8B\u8DA3\u53BB\u5708\u98A7\u6743\u919B\u6CC9\u5168\u75CA\u62F3\u72AC\u5238\u529D\u7F3A\u7094\u7638\u5374\u9E4A\u69B7\u786E\u96C0\u88D9\u7FA4\u7136\u71C3\u5189\u67D3\u74E4\u58E4\u6518\u56B7\u8BA9\u9976\u6270\u7ED5\u60F9\u70ED\u58EC\u4EC1\u4EBA\u5FCD\u97E7\u4EFB\u8BA4\u5203\u598A\u7EAB\u6254\u4ECD\u65E5\u620E\u8338\u84C9\u8363\u878D\u7194\u6EB6\u5BB9\u7ED2\u5197\u63C9\u67D4\u8089\u8339\u8815\u5112\u5B7A\u5982\u8FB1\u4E73\u6C5D\u5165\u8925\u8F6F\u962E\u854A\u745E\u9510\u95F0\u6DA6\u82E5\u5F31\u6492\u6D12\u8428\u816E\u9CC3\u585E\u8D5B\u4E09\u53C1"], + ["c940", "\u847D", 4, "\u8483\u8484\u8485\u8486\u848A\u848D\u848F", 7, "\u8498\u849A\u849B\u849D\u849E\u849F\u84A0\u84A2", 12, "\u84B0\u84B1\u84B3\u84B5\u84B6\u84B7\u84BB\u84BC\u84BE\u84C0\u84C2\u84C3\u84C5\u84C6\u84C7\u84C8\u84CB\u84CC\u84CE\u84CF\u84D2\u84D4\u84D5\u84D7"], + ["c980", "\u84D8", 4, "\u84DE\u84E1\u84E2\u84E4\u84E7", 4, "\u84ED\u84EE\u84EF\u84F1", 10, "\u84FD\u84FE\u8500\u8501\u8502\u4F1E\u6563\u6851\u55D3\u4E27\u6414\u9A9A\u626B\u5AC2\u745F\u8272\u6DA9\u68EE\u50E7\u838E\u7802\u6740\u5239\u6C99\u7EB1\u50BB\u5565\u715E\u7B5B\u6652\u73CA\u82EB\u6749\u5C71\u5220\u717D\u886B\u95EA\u9655\u64C5\u8D61\u81B3\u5584\u6C55\u6247\u7F2E\u5892\u4F24\u5546\u8D4F\u664C\u4E0A\u5C1A\u88F3\u68A2\u634E\u7A0D\u70E7\u828D\u52FA\u97F6\u5C11\u54E8\u90B5\u7ECD\u5962\u8D4A\u86C7\u820C\u820D\u8D66\u6444\u5C04\u6151\u6D89\u793E\u8BBE\u7837\u7533\u547B\u4F38\u8EAB\u6DF1\u5A20\u7EC5\u795E\u6C88\u5BA1\u5A76\u751A\u80BE\u614E\u6E17\u58F0\u751F\u7525\u7272\u5347\u7EF3"], + ["ca40", "\u8503", 8, "\u850D\u850E\u850F\u8510\u8512\u8514\u8515\u8516\u8518\u8519\u851B\u851C\u851D\u851E\u8520\u8522", 8, "\u852D", 9, "\u853E", 4, "\u8544\u8545\u8546\u8547\u854B", 10], + ["ca80", "\u8557\u8558\u855A\u855B\u855C\u855D\u855F", 4, "\u8565\u8566\u8567\u8569", 8, "\u8573\u8575\u8576\u8577\u8578\u857C\u857D\u857F\u8580\u8581\u7701\u76DB\u5269\u80DC\u5723\u5E08\u5931\u72EE\u65BD\u6E7F\u8BD7\u5C38\u8671\u5341\u77F3\u62FE\u65F6\u4EC0\u98DF\u8680\u5B9E\u8BC6\u53F2\u77E2\u4F7F\u5C4E\u9A76\u59CB\u5F0F\u793A\u58EB\u4E16\u67FF\u4E8B\u62ED\u8A93\u901D\u52BF\u662F\u55DC\u566C\u9002\u4ED5\u4F8D\u91CA\u9970\u6C0F\u5E02\u6043\u5BA4\u89C6\u8BD5\u6536\u624B\u9996\u5B88\u5BFF\u6388\u552E\u53D7\u7626\u517D\u852C\u67A2\u68B3\u6B8A\u6292\u8F93\u53D4\u8212\u6DD1\u758F\u4E66\u8D4E\u5B70\u719F\u85AF\u6691\u66D9\u7F72\u8700\u9ECD\u9F20\u5C5E\u672F\u8FF0\u6811\u675F\u620D\u7AD6\u5885\u5EB6\u6570\u6F31"], + ["cb40", "\u8582\u8583\u8586\u8588", 6, "\u8590", 10, "\u859D", 6, "\u85A5\u85A6\u85A7\u85A9\u85AB\u85AC\u85AD\u85B1", 5, "\u85B8\u85BA", 6, "\u85C2", 6, "\u85CA", 4, "\u85D1\u85D2"], + ["cb80", "\u85D4\u85D6", 5, "\u85DD", 6, "\u85E5\u85E6\u85E7\u85E8\u85EA", 14, "\u6055\u5237\u800D\u6454\u8870\u7529\u5E05\u6813\u62F4\u971C\u53CC\u723D\u8C01\u6C34\u7761\u7A0E\u542E\u77AC\u987A\u821C\u8BF4\u7855\u6714\u70C1\u65AF\u6495\u5636\u601D\u79C1\u53F8\u4E1D\u6B7B\u8086\u5BFA\u55E3\u56DB\u4F3A\u4F3C\u9972\u5DF3\u677E\u8038\u6002\u9882\u9001\u5B8B\u8BBC\u8BF5\u641C\u8258\u64DE\u55FD\u82CF\u9165\u4FD7\u7D20\u901F\u7C9F\u50F3\u5851\u6EAF\u5BBF\u8BC9\u8083\u9178\u849C\u7B97\u867D\u968B\u968F\u7EE5\u9AD3\u788E\u5C81\u7A57\u9042\u96A7\u795F\u5B59\u635F\u7B0B\u84D1\u68AD\u5506\u7F29\u7410\u7D22\u9501\u6240\u584C\u4ED6\u5B83\u5979\u5854"], + ["cc40", "\u85F9\u85FA\u85FC\u85FD\u85FE\u8600", 4, "\u8606", 10, "\u8612\u8613\u8614\u8615\u8617", 15, "\u8628\u862A", 13, "\u8639\u863A\u863B\u863D\u863E\u863F\u8640"], + ["cc80", "\u8641", 11, "\u8652\u8653\u8655", 4, "\u865B\u865C\u865D\u865F\u8660\u8661\u8663", 7, "\u736D\u631E\u8E4B\u8E0F\u80CE\u82D4\u62AC\u53F0\u6CF0\u915E\u592A\u6001\u6C70\u574D\u644A\u8D2A\u762B\u6EE9\u575B\u6A80\u75F0\u6F6D\u8C2D\u8C08\u5766\u6BEF\u8892\u78B3\u63A2\u53F9\u70AD\u6C64\u5858\u642A\u5802\u68E0\u819B\u5510\u7CD6\u5018\u8EBA\u6DCC\u8D9F\u70EB\u638F\u6D9B\u6ED4\u7EE6\u8404\u6843\u9003\u6DD8\u9676\u8BA8\u5957\u7279\u85E4\u817E\u75BC\u8A8A\u68AF\u5254\u8E22\u9511\u63D0\u9898\u8E44\u557C\u4F53\u66FF\u568F\u60D5\u6D95\u5243\u5C49\u5929\u6DFB\u586B\u7530\u751C\u606C\u8214\u8146\u6311\u6761\u8FE2\u773A\u8DF3\u8D34\u94C1\u5E16\u5385\u542C\u70C3"], + ["cd40", "\u866D\u866F\u8670\u8672", 6, "\u8683", 6, "\u868E", 4, "\u8694\u8696", 5, "\u869E", 4, "\u86A5\u86A6\u86AB\u86AD\u86AE\u86B2\u86B3\u86B7\u86B8\u86B9\u86BB", 4, "\u86C1\u86C2\u86C3\u86C5\u86C8\u86CC\u86CD\u86D2\u86D3\u86D5\u86D6\u86D7\u86DA\u86DC"], + ["cd80", "\u86DD\u86E0\u86E1\u86E2\u86E3\u86E5\u86E6\u86E7\u86E8\u86EA\u86EB\u86EC\u86EF\u86F5\u86F6\u86F7\u86FA\u86FB\u86FC\u86FD\u86FF\u8701\u8704\u8705\u8706\u870B\u870C\u870E\u870F\u8710\u8711\u8714\u8716\u6C40\u5EF7\u505C\u4EAD\u5EAD\u633A\u8247\u901A\u6850\u916E\u77B3\u540C\u94DC\u5F64\u7AE5\u6876\u6345\u7B52\u7EDF\u75DB\u5077\u6295\u5934\u900F\u51F8\u79C3\u7A81\u56FE\u5F92\u9014\u6D82\u5C60\u571F\u5410\u5154\u6E4D\u56E2\u63A8\u9893\u817F\u8715\u892A\u9000\u541E\u5C6F\u81C0\u62D6\u6258\u8131\u9E35\u9640\u9A6E\u9A7C\u692D\u59A5\u62D3\u553E\u6316\u54C7\u86D9\u6D3C\u5A03\u74E6\u889C\u6B6A\u5916\u8C4C\u5F2F\u6E7E\u73A9\u987D\u4E38\u70F7\u5B8C\u7897\u633D\u665A\u7696\u60CB\u5B9B\u5A49\u4E07\u8155\u6C6A\u738B\u4EA1\u6789\u7F51\u5F80\u65FA\u671B\u5FD8\u5984\u5A01"], + ["ce40", "\u8719\u871B\u871D\u871F\u8720\u8724\u8726\u8727\u8728\u872A\u872B\u872C\u872D\u872F\u8730\u8732\u8733\u8735\u8736\u8738\u8739\u873A\u873C\u873D\u8740", 6, "\u874A\u874B\u874D\u874F\u8750\u8751\u8752\u8754\u8755\u8756\u8758\u875A", 5, "\u8761\u8762\u8766", 7, "\u876F\u8771\u8772\u8773\u8775"], + ["ce80", "\u8777\u8778\u8779\u877A\u877F\u8780\u8781\u8784\u8786\u8787\u8789\u878A\u878C\u878E", 4, "\u8794\u8795\u8796\u8798", 6, "\u87A0", 4, "\u5DCD\u5FAE\u5371\u97E6\u8FDD\u6845\u56F4\u552F\u60DF\u4E3A\u6F4D\u7EF4\u82C7\u840E\u59D4\u4F1F\u4F2A\u5C3E\u7EAC\u672A\u851A\u5473\u754F\u80C3\u5582\u9B4F\u4F4D\u6E2D\u8C13\u5C09\u6170\u536B\u761F\u6E29\u868A\u6587\u95FB\u7EB9\u543B\u7A33\u7D0A\u95EE\u55E1\u7FC1\u74EE\u631D\u8717\u6DA1\u7A9D\u6211\u65A1\u5367\u63E1\u6C83\u5DEB\u545C\u94A8\u4E4C\u6C61\u8BEC\u5C4B\u65E0\u829C\u68A7\u543E\u5434\u6BCB\u6B66\u4E94\u6342\u5348\u821E\u4F0D\u4FAE\u575E\u620A\u96FE\u6664\u7269\u52FF\u52A1\u609F\u8BEF\u6614\u7199\u6790\u897F\u7852\u77FD\u6670\u563B\u5438\u9521\u727A"], + ["cf40", "\u87A5\u87A6\u87A7\u87A9\u87AA\u87AE\u87B0\u87B1\u87B2\u87B4\u87B6\u87B7\u87B8\u87B9\u87BB\u87BC\u87BE\u87BF\u87C1", 4, "\u87C7\u87C8\u87C9\u87CC", 4, "\u87D4", 6, "\u87DC\u87DD\u87DE\u87DF\u87E1\u87E2\u87E3\u87E4\u87E6\u87E7\u87E8\u87E9\u87EB\u87EC\u87ED\u87EF", 9], + ["cf80", "\u87FA\u87FB\u87FC\u87FD\u87FF\u8800\u8801\u8802\u8804", 5, "\u880B", 7, "\u8814\u8817\u8818\u8819\u881A\u881C", 4, "\u8823\u7A00\u606F\u5E0C\u6089\u819D\u5915\u60DC\u7184\u70EF\u6EAA\u6C50\u7280\u6A84\u88AD\u5E2D\u4E60\u5AB3\u559C\u94E3\u6D17\u7CFB\u9699\u620F\u7EC6\u778E\u867E\u5323\u971E\u8F96\u6687\u5CE1\u4FA0\u72ED\u4E0B\u53A6\u590F\u5413\u6380\u9528\u5148\u4ED9\u9C9C\u7EA4\u54B8\u8D24\u8854\u8237\u95F2\u6D8E\u5F26\u5ACC\u663E\u9669\u73B0\u732E\u53BF\u817A\u9985\u7FA1\u5BAA\u9677\u9650\u7EBF\u76F8\u53A2\u9576\u9999\u7BB1\u8944\u6E58\u4E61\u7FD4\u7965\u8BE6\u60F3\u54CD\u4EAB\u9879\u5DF7\u6A61\u50CF\u5411\u8C61\u8427\u785D\u9704\u524A\u54EE\u56A3\u9500\u6D88\u5BB5\u6DC6\u6653"], + ["d040", "\u8824", 13, "\u8833", 5, "\u883A\u883B\u883D\u883E\u883F\u8841\u8842\u8843\u8846", 5, "\u884E", 5, "\u8855\u8856\u8858\u885A", 6, "\u8866\u8867\u886A\u886D\u886F\u8871\u8873\u8874\u8875\u8876\u8878\u8879\u887A"], + ["d080", "\u887B\u887C\u8880\u8883\u8886\u8887\u8889\u888A\u888C\u888E\u888F\u8890\u8891\u8893\u8894\u8895\u8897", 4, "\u889D", 4, "\u88A3\u88A5", 5, "\u5C0F\u5B5D\u6821\u8096\u5578\u7B11\u6548\u6954\u4E9B\u6B47\u874E\u978B\u534F\u631F\u643A\u90AA\u659C\u80C1\u8C10\u5199\u68B0\u5378\u87F9\u61C8\u6CC4\u6CFB\u8C22\u5C51\u85AA\u82AF\u950C\u6B23\u8F9B\u65B0\u5FFB\u5FC3\u4FE1\u8845\u661F\u8165\u7329\u60FA\u5174\u5211\u578B\u5F62\u90A2\u884C\u9192\u5E78\u674F\u6027\u59D3\u5144\u51F6\u80F8\u5308\u6C79\u96C4\u718A\u4F11\u4FEE\u7F9E\u673D\u55C5\u9508\u79C0\u8896\u7EE3\u589F\u620C\u9700\u865A\u5618\u987B\u5F90\u8BB8\u84C4\u9157\u53D9\u65ED\u5E8F\u755C\u6064\u7D6E\u5A7F\u7EEA\u7EED\u8F69\u55A7\u5BA3\u60AC\u65CB\u7384"], + ["d140", "\u88AC\u88AE\u88AF\u88B0\u88B2", 4, "\u88B8\u88B9\u88BA\u88BB\u88BD\u88BE\u88BF\u88C0\u88C3\u88C4\u88C7\u88C8\u88CA\u88CB\u88CC\u88CD\u88CF\u88D0\u88D1\u88D3\u88D6\u88D7\u88DA", 4, "\u88E0\u88E1\u88E6\u88E7\u88E9", 6, "\u88F2\u88F5\u88F6\u88F7\u88FA\u88FB\u88FD\u88FF\u8900\u8901\u8903", 5], + ["d180", "\u8909\u890B", 4, "\u8911\u8914", 4, "\u891C", 4, "\u8922\u8923\u8924\u8926\u8927\u8928\u8929\u892C\u892D\u892E\u892F\u8931\u8932\u8933\u8935\u8937\u9009\u7663\u7729\u7EDA\u9774\u859B\u5B66\u7A74\u96EA\u8840\u52CB\u718F\u5FAA\u65EC\u8BE2\u5BFB\u9A6F\u5DE1\u6B89\u6C5B\u8BAD\u8BAF\u900A\u8FC5\u538B\u62BC\u9E26\u9E2D\u5440\u4E2B\u82BD\u7259\u869C\u5D16\u8859\u6DAF\u96C5\u54D1\u4E9A\u8BB6\u7109\u54BD\u9609\u70DF\u6DF9\u76D0\u4E25\u7814\u8712\u5CA9\u5EF6\u8A00\u989C\u960E\u708E\u6CBF\u5944\u63A9\u773C\u884D\u6F14\u8273\u5830\u71D5\u538C\u781A\u96C1\u5501\u5F66\u7130\u5BB4\u8C1A\u9A8C\u6B83\u592E\u9E2F\u79E7\u6768\u626C\u4F6F\u75A1\u7F8A\u6D0B\u9633\u6C27\u4EF0\u75D2\u517B\u6837\u6F3E\u9080\u8170\u5996\u7476"], + ["d240", "\u8938", 8, "\u8942\u8943\u8945", 24, "\u8960", 5, "\u8967", 19, "\u897C"], + ["d280", "\u897D\u897E\u8980\u8982\u8984\u8985\u8987", 26, "\u6447\u5C27\u9065\u7A91\u8C23\u59DA\u54AC\u8200\u836F\u8981\u8000\u6930\u564E\u8036\u7237\u91CE\u51B6\u4E5F\u9875\u6396\u4E1A\u53F6\u66F3\u814B\u591C\u6DB2\u4E00\u58F9\u533B\u63D6\u94F1\u4F9D\u4F0A\u8863\u9890\u5937\u9057\u79FB\u4EEA\u80F0\u7591\u6C82\u5B9C\u59E8\u5F5D\u6905\u8681\u501A\u5DF2\u4E59\u77E3\u4EE5\u827A\u6291\u6613\u9091\u5C79\u4EBF\u5F79\u81C6\u9038\u8084\u75AB\u4EA6\u88D4\u610F\u6BC5\u5FC6\u4E49\u76CA\u6EA2\u8BE3\u8BAE\u8C0A\u8BD1\u5F02\u7FFC\u7FCC\u7ECE\u8335\u836B\u56E0\u6BB7\u97F3\u9634\u59FB\u541F\u94F6\u6DEB\u5BC5\u996E\u5C39\u5F15\u9690"], + ["d340", "\u89A2", 30, "\u89C3\u89CD\u89D3\u89D4\u89D5\u89D7\u89D8\u89D9\u89DB\u89DD\u89DF\u89E0\u89E1\u89E2\u89E4\u89E7\u89E8\u89E9\u89EA\u89EC\u89ED\u89EE\u89F0\u89F1\u89F2\u89F4", 6], + ["d380", "\u89FB", 4, "\u8A01", 5, "\u8A08", 21, "\u5370\u82F1\u6A31\u5A74\u9E70\u5E94\u7F28\u83B9\u8424\u8425\u8367\u8747\u8FCE\u8D62\u76C8\u5F71\u9896\u786C\u6620\u54DF\u62E5\u4F63\u81C3\u75C8\u5EB8\u96CD\u8E0A\u86F9\u548F\u6CF3\u6D8C\u6C38\u607F\u52C7\u7528\u5E7D\u4F18\u60A0\u5FE7\u5C24\u7531\u90AE\u94C0\u72B9\u6CB9\u6E38\u9149\u6709\u53CB\u53F3\u4F51\u91C9\u8BF1\u53C8\u5E7C\u8FC2\u6DE4\u4E8E\u76C2\u6986\u865E\u611A\u8206\u4F59\u4FDE\u903E\u9C7C\u6109\u6E1D\u6E14\u9685\u4E88\u5A31\u96E8\u4E0E\u5C7F\u79B9\u5B87\u8BED\u7FBD\u7389\u57DF\u828B\u90C1\u5401\u9047\u55BB\u5CEA\u5FA1\u6108\u6B32\u72F1\u80B2\u8A89"], + ["d440", "\u8A1E", 31, "\u8A3F", 8, "\u8A49", 21], + ["d480", "\u8A5F", 25, "\u8A7A", 6, "\u6D74\u5BD3\u88D5\u9884\u8C6B\u9A6D\u9E33\u6E0A\u51A4\u5143\u57A3\u8881\u539F\u63F4\u8F95\u56ED\u5458\u5706\u733F\u6E90\u7F18\u8FDC\u82D1\u613F\u6028\u9662\u66F0\u7EA6\u8D8A\u8DC3\u94A5\u5CB3\u7CA4\u6708\u60A6\u9605\u8018\u4E91\u90E7\u5300\u9668\u5141\u8FD0\u8574\u915D\u6655\u97F5\u5B55\u531D\u7838\u6742\u683D\u54C9\u707E\u5BB0\u8F7D\u518D\u5728\u54B1\u6512\u6682\u8D5E\u8D43\u810F\u846C\u906D\u7CDF\u51FF\u85FB\u67A3\u65E9\u6FA1\u86A4\u8E81\u566A\u9020\u7682\u7076\u71E5\u8D23\u62E9\u5219\u6CFD\u8D3C\u600E\u589E\u618E\u66FE\u8D60\u624E\u55B3\u6E23\u672D\u8F67"], + ["d540", "\u8A81", 7, "\u8A8B", 7, "\u8A94", 46], + ["d580", "\u8AC3", 32, "\u94E1\u95F8\u7728\u6805\u69A8\u548B\u4E4D\u70B8\u8BC8\u6458\u658B\u5B85\u7A84\u503A\u5BE8\u77BB\u6BE1\u8A79\u7C98\u6CBE\u76CF\u65A9\u8F97\u5D2D\u5C55\u8638\u6808\u5360\u6218\u7AD9\u6E5B\u7EFD\u6A1F\u7AE0\u5F70\u6F33\u5F20\u638C\u6DA8\u6756\u4E08\u5E10\u8D26\u4ED7\u80C0\u7634\u969C\u62DB\u662D\u627E\u6CBC\u8D75\u7167\u7F69\u5146\u8087\u53EC\u906E\u6298\u54F2\u86F0\u8F99\u8005\u9517\u8517\u8FD9\u6D59\u73CD\u659F\u771F\u7504\u7827\u81FB\u8D1E\u9488\u4FA6\u6795\u75B9\u8BCA\u9707\u632F\u9547\u9635\u84B8\u6323\u7741\u5F81\u72F0\u4E89\u6014\u6574\u62EF\u6B63\u653F"], + ["d640", "\u8AE4", 34, "\u8B08", 27], + ["d680", "\u8B24\u8B25\u8B27", 30, "\u5E27\u75C7\u90D1\u8BC1\u829D\u679D\u652F\u5431\u8718\u77E5\u80A2\u8102\u6C41\u4E4B\u7EC7\u804C\u76F4\u690D\u6B96\u6267\u503C\u4F84\u5740\u6307\u6B62\u8DBE\u53EA\u65E8\u7EB8\u5FD7\u631A\u63B7\u81F3\u81F4\u7F6E\u5E1C\u5CD9\u5236\u667A\u79E9\u7A1A\u8D28\u7099\u75D4\u6EDE\u6CBB\u7A92\u4E2D\u76C5\u5FE0\u949F\u8877\u7EC8\u79CD\u80BF\u91CD\u4EF2\u4F17\u821F\u5468\u5DDE\u6D32\u8BCC\u7CA5\u8F74\u8098\u5E1A\u5492\u76B1\u5B99\u663C\u9AA4\u73E0\u682A\u86DB\u6731\u732A\u8BF8\u8BDB\u9010\u7AF9\u70DB\u716E\u62C4\u77A9\u5631\u4E3B\u8457\u67F1\u52A9\u86C0\u8D2E\u94F8\u7B51"], + ["d740", "\u8B46", 31, "\u8B67", 4, "\u8B6D", 25], + ["d780", "\u8B87", 24, "\u8BAC\u8BB1\u8BBB\u8BC7\u8BD0\u8BEA\u8C09\u8C1E\u4F4F\u6CE8\u795D\u9A7B\u6293\u722A\u62FD\u4E13\u7816\u8F6C\u64B0\u8D5A\u7BC6\u6869\u5E84\u88C5\u5986\u649E\u58EE\u72B6\u690E\u9525\u8FFD\u8D58\u5760\u7F00\u8C06\u51C6\u6349\u62D9\u5353\u684C\u7422\u8301\u914C\u5544\u7740\u707C\u6D4A\u5179\u54A8\u8D44\u59FF\u6ECB\u6DC4\u5B5C\u7D2B\u4ED4\u7C7D\u6ED3\u5B50\u81EA\u6E0D\u5B57\u9B03\u68D5\u8E2A\u5B97\u7EFC\u603B\u7EB5\u90B9\u8D70\u594F\u63CD\u79DF\u8DB3\u5352\u65CF\u7956\u8BC5\u963B\u7EC4\u94BB\u7E82\u5634\u9189\u6700\u7F6A\u5C0A\u9075\u6628\u5DE6\u4F50\u67DE\u505A\u4F5C\u5750\u5EA7"], + ["d840", "\u8C38", 8, "\u8C42\u8C43\u8C44\u8C45\u8C48\u8C4A\u8C4B\u8C4D", 7, "\u8C56\u8C57\u8C58\u8C59\u8C5B", 5, "\u8C63", 6, "\u8C6C", 6, "\u8C74\u8C75\u8C76\u8C77\u8C7B", 6, "\u8C83\u8C84\u8C86\u8C87"], + ["d880", "\u8C88\u8C8B\u8C8D", 6, "\u8C95\u8C96\u8C97\u8C99", 20, "\u4E8D\u4E0C\u5140\u4E10\u5EFF\u5345\u4E15\u4E98\u4E1E\u9B32\u5B6C\u5669\u4E28\u79BA\u4E3F\u5315\u4E47\u592D\u723B\u536E\u6C10\u56DF\u80E4\u9997\u6BD3\u777E\u9F17\u4E36\u4E9F\u9F10\u4E5C\u4E69\u4E93\u8288\u5B5B\u556C\u560F\u4EC4\u538D\u539D\u53A3\u53A5\u53AE\u9765\u8D5D\u531A\u53F5\u5326\u532E\u533E\u8D5C\u5366\u5363\u5202\u5208\u520E\u522D\u5233\u523F\u5240\u524C\u525E\u5261\u525C\u84AF\u527D\u5282\u5281\u5290\u5293\u5182\u7F54\u4EBB\u4EC3\u4EC9\u4EC2\u4EE8\u4EE1\u4EEB\u4EDE\u4F1B\u4EF3\u4F22\u4F64\u4EF5\u4F25\u4F27\u4F09\u4F2B\u4F5E\u4F67\u6538\u4F5A\u4F5D"], + ["d940", "\u8CAE", 62], + ["d980", "\u8CED", 32, "\u4F5F\u4F57\u4F32\u4F3D\u4F76\u4F74\u4F91\u4F89\u4F83\u4F8F\u4F7E\u4F7B\u4FAA\u4F7C\u4FAC\u4F94\u4FE6\u4FE8\u4FEA\u4FC5\u4FDA\u4FE3\u4FDC\u4FD1\u4FDF\u4FF8\u5029\u504C\u4FF3\u502C\u500F\u502E\u502D\u4FFE\u501C\u500C\u5025\u5028\u507E\u5043\u5055\u5048\u504E\u506C\u507B\u50A5\u50A7\u50A9\u50BA\u50D6\u5106\u50ED\u50EC\u50E6\u50EE\u5107\u510B\u4EDD\u6C3D\u4F58\u4F65\u4FCE\u9FA0\u6C46\u7C74\u516E\u5DFD\u9EC9\u9998\u5181\u5914\u52F9\u530D\u8A07\u5310\u51EB\u5919\u5155\u4EA0\u5156\u4EB3\u886E\u88A4\u4EB5\u8114\u88D2\u7980\u5B34\u8803\u7FB8\u51AB\u51B1\u51BD\u51BC"], + ["da40", "\u8D0E", 14, "\u8D20\u8D51\u8D52\u8D57\u8D5F\u8D65\u8D68\u8D69\u8D6A\u8D6C\u8D6E\u8D6F\u8D71\u8D72\u8D78", 8, "\u8D82\u8D83\u8D86\u8D87\u8D88\u8D89\u8D8C", 4, "\u8D92\u8D93\u8D95", 9, "\u8DA0\u8DA1"], + ["da80", "\u8DA2\u8DA4", 12, "\u8DB2\u8DB6\u8DB7\u8DB9\u8DBB\u8DBD\u8DC0\u8DC1\u8DC2\u8DC5\u8DC7\u8DC8\u8DC9\u8DCA\u8DCD\u8DD0\u8DD2\u8DD3\u8DD4\u51C7\u5196\u51A2\u51A5\u8BA0\u8BA6\u8BA7\u8BAA\u8BB4\u8BB5\u8BB7\u8BC2\u8BC3\u8BCB\u8BCF\u8BCE\u8BD2\u8BD3\u8BD4\u8BD6\u8BD8\u8BD9\u8BDC\u8BDF\u8BE0\u8BE4\u8BE8\u8BE9\u8BEE\u8BF0\u8BF3\u8BF6\u8BF9\u8BFC\u8BFF\u8C00\u8C02\u8C04\u8C07\u8C0C\u8C0F\u8C11\u8C12\u8C14\u8C15\u8C16\u8C19\u8C1B\u8C18\u8C1D\u8C1F\u8C20\u8C21\u8C25\u8C27\u8C2A\u8C2B\u8C2E\u8C2F\u8C32\u8C33\u8C35\u8C36\u5369\u537A\u961D\u9622\u9621\u9631\u962A\u963D\u963C\u9642\u9649\u9654\u965F\u9667\u966C\u9672\u9674\u9688\u968D\u9697\u96B0\u9097\u909B\u909D\u9099\u90AC\u90A1\u90B4\u90B3\u90B6\u90BA"], + ["db40", "\u8DD5\u8DD8\u8DD9\u8DDC\u8DE0\u8DE1\u8DE2\u8DE5\u8DE6\u8DE7\u8DE9\u8DED\u8DEE\u8DF0\u8DF1\u8DF2\u8DF4\u8DF6\u8DFC\u8DFE", 6, "\u8E06\u8E07\u8E08\u8E0B\u8E0D\u8E0E\u8E10\u8E11\u8E12\u8E13\u8E15", 7, "\u8E20\u8E21\u8E24", 4, "\u8E2B\u8E2D\u8E30\u8E32\u8E33\u8E34\u8E36\u8E37\u8E38\u8E3B\u8E3C\u8E3E"], + ["db80", "\u8E3F\u8E43\u8E45\u8E46\u8E4C", 4, "\u8E53", 5, "\u8E5A", 11, "\u8E67\u8E68\u8E6A\u8E6B\u8E6E\u8E71\u90B8\u90B0\u90CF\u90C5\u90BE\u90D0\u90C4\u90C7\u90D3\u90E6\u90E2\u90DC\u90D7\u90DB\u90EB\u90EF\u90FE\u9104\u9122\u911E\u9123\u9131\u912F\u9139\u9143\u9146\u520D\u5942\u52A2\u52AC\u52AD\u52BE\u54FF\u52D0\u52D6\u52F0\u53DF\u71EE\u77CD\u5EF4\u51F5\u51FC\u9B2F\u53B6\u5F01\u755A\u5DEF\u574C\u57A9\u57A1\u587E\u58BC\u58C5\u58D1\u5729\u572C\u572A\u5733\u5739\u572E\u572F\u575C\u573B\u5742\u5769\u5785\u576B\u5786\u577C\u577B\u5768\u576D\u5776\u5773\u57AD\u57A4\u578C\u57B2\u57CF\u57A7\u57B4\u5793\u57A0\u57D5\u57D8\u57DA\u57D9\u57D2\u57B8\u57F4\u57EF\u57F8\u57E4\u57DD"], + ["dc40", "\u8E73\u8E75\u8E77", 4, "\u8E7D\u8E7E\u8E80\u8E82\u8E83\u8E84\u8E86\u8E88", 6, "\u8E91\u8E92\u8E93\u8E95", 6, "\u8E9D\u8E9F", 11, "\u8EAD\u8EAE\u8EB0\u8EB1\u8EB3", 6, "\u8EBB", 7], + ["dc80", "\u8EC3", 10, "\u8ECF", 21, "\u580B\u580D\u57FD\u57ED\u5800\u581E\u5819\u5844\u5820\u5865\u586C\u5881\u5889\u589A\u5880\u99A8\u9F19\u61FF\u8279\u827D\u827F\u828F\u828A\u82A8\u8284\u828E\u8291\u8297\u8299\u82AB\u82B8\u82BE\u82B0\u82C8\u82CA\u82E3\u8298\u82B7\u82AE\u82CB\u82CC\u82C1\u82A9\u82B4\u82A1\u82AA\u829F\u82C4\u82CE\u82A4\u82E1\u8309\u82F7\u82E4\u830F\u8307\u82DC\u82F4\u82D2\u82D8\u830C\u82FB\u82D3\u8311\u831A\u8306\u8314\u8315\u82E0\u82D5\u831C\u8351\u835B\u835C\u8308\u8392\u833C\u8334\u8331\u839B\u835E\u832F\u834F\u8347\u8343\u835F\u8340\u8317\u8360\u832D\u833A\u8333\u8366\u8365"], + ["dd40", "\u8EE5", 62], + ["dd80", "\u8F24", 32, "\u8368\u831B\u8369\u836C\u836A\u836D\u836E\u83B0\u8378\u83B3\u83B4\u83A0\u83AA\u8393\u839C\u8385\u837C\u83B6\u83A9\u837D\u83B8\u837B\u8398\u839E\u83A8\u83BA\u83BC\u83C1\u8401\u83E5\u83D8\u5807\u8418\u840B\u83DD\u83FD\u83D6\u841C\u8438\u8411\u8406\u83D4\u83DF\u840F\u8403\u83F8\u83F9\u83EA\u83C5\u83C0\u8426\u83F0\u83E1\u845C\u8451\u845A\u8459\u8473\u8487\u8488\u847A\u8489\u8478\u843C\u8446\u8469\u8476\u848C\u848E\u8431\u846D\u84C1\u84CD\u84D0\u84E6\u84BD\u84D3\u84CA\u84BF\u84BA\u84E0\u84A1\u84B9\u84B4\u8497\u84E5\u84E3\u850C\u750D\u8538\u84F0\u8539\u851F\u853A"], + ["de40", "\u8F45", 32, "\u8F6A\u8F80\u8F8C\u8F92\u8F9D\u8FA0\u8FA1\u8FA2\u8FA4\u8FA5\u8FA6\u8FA7\u8FAA\u8FAC\u8FAD\u8FAE\u8FAF\u8FB2\u8FB3\u8FB4\u8FB5\u8FB7\u8FB8\u8FBA\u8FBB\u8FBC\u8FBF\u8FC0\u8FC3\u8FC6"], + ["de80", "\u8FC9", 4, "\u8FCF\u8FD2\u8FD6\u8FD7\u8FDA\u8FE0\u8FE1\u8FE3\u8FE7\u8FEC\u8FEF\u8FF1\u8FF2\u8FF4\u8FF5\u8FF6\u8FFA\u8FFB\u8FFC\u8FFE\u8FFF\u9007\u9008\u900C\u900E\u9013\u9015\u9018\u8556\u853B\u84FF\u84FC\u8559\u8548\u8568\u8564\u855E\u857A\u77A2\u8543\u8572\u857B\u85A4\u85A8\u8587\u858F\u8579\u85AE\u859C\u8585\u85B9\u85B7\u85B0\u85D3\u85C1\u85DC\u85FF\u8627\u8605\u8629\u8616\u863C\u5EFE\u5F08\u593C\u5941\u8037\u5955\u595A\u5958\u530F\u5C22\u5C25\u5C2C\u5C34\u624C\u626A\u629F\u62BB\u62CA\u62DA\u62D7\u62EE\u6322\u62F6\u6339\u634B\u6343\u63AD\u63F6\u6371\u637A\u638E\u63B4\u636D\u63AC\u638A\u6369\u63AE\u63BC\u63F2\u63F8\u63E0\u63FF\u63C4\u63DE\u63CE\u6452\u63C6\u63BE\u6445\u6441\u640B\u641B\u6420\u640C\u6426\u6421\u645E\u6484\u646D\u6496"], + ["df40", "\u9019\u901C\u9023\u9024\u9025\u9027", 5, "\u9030", 4, "\u9037\u9039\u903A\u903D\u903F\u9040\u9043\u9045\u9046\u9048", 4, "\u904E\u9054\u9055\u9056\u9059\u905A\u905C", 5, "\u9064\u9066\u9067\u9069\u906A\u906B\u906C\u906F", 4, "\u9076", 6, "\u907E\u9081"], + ["df80", "\u9084\u9085\u9086\u9087\u9089\u908A\u908C", 4, "\u9092\u9094\u9096\u9098\u909A\u909C\u909E\u909F\u90A0\u90A4\u90A5\u90A7\u90A8\u90A9\u90AB\u90AD\u90B2\u90B7\u90BC\u90BD\u90BF\u90C0\u647A\u64B7\u64B8\u6499\u64BA\u64C0\u64D0\u64D7\u64E4\u64E2\u6509\u6525\u652E\u5F0B\u5FD2\u7519\u5F11\u535F\u53F1\u53FD\u53E9\u53E8\u53FB\u5412\u5416\u5406\u544B\u5452\u5453\u5454\u5456\u5443\u5421\u5457\u5459\u5423\u5432\u5482\u5494\u5477\u5471\u5464\u549A\u549B\u5484\u5476\u5466\u549D\u54D0\u54AD\u54C2\u54B4\u54D2\u54A7\u54A6\u54D3\u54D4\u5472\u54A3\u54D5\u54BB\u54BF\u54CC\u54D9\u54DA\u54DC\u54A9\u54AA\u54A4\u54DD\u54CF\u54DE\u551B\u54E7\u5520\u54FD\u5514\u54F3\u5522\u5523\u550F\u5511\u5527\u552A\u5567\u558F\u55B5\u5549\u556D\u5541\u5555\u553F\u5550\u553C"], + ["e040", "\u90C2\u90C3\u90C6\u90C8\u90C9\u90CB\u90CC\u90CD\u90D2\u90D4\u90D5\u90D6\u90D8\u90D9\u90DA\u90DE\u90DF\u90E0\u90E3\u90E4\u90E5\u90E9\u90EA\u90EC\u90EE\u90F0\u90F1\u90F2\u90F3\u90F5\u90F6\u90F7\u90F9\u90FA\u90FB\u90FC\u90FF\u9100\u9101\u9103\u9105", 19, "\u911A\u911B\u911C"], + ["e080", "\u911D\u911F\u9120\u9121\u9124", 10, "\u9130\u9132", 6, "\u913A", 8, "\u9144\u5537\u5556\u5575\u5576\u5577\u5533\u5530\u555C\u558B\u55D2\u5583\u55B1\u55B9\u5588\u5581\u559F\u557E\u55D6\u5591\u557B\u55DF\u55BD\u55BE\u5594\u5599\u55EA\u55F7\u55C9\u561F\u55D1\u55EB\u55EC\u55D4\u55E6\u55DD\u55C4\u55EF\u55E5\u55F2\u55F3\u55CC\u55CD\u55E8\u55F5\u55E4\u8F94\u561E\u5608\u560C\u5601\u5624\u5623\u55FE\u5600\u5627\u562D\u5658\u5639\u5657\u562C\u564D\u5662\u5659\u565C\u564C\u5654\u5686\u5664\u5671\u566B\u567B\u567C\u5685\u5693\u56AF\u56D4\u56D7\u56DD\u56E1\u56F5\u56EB\u56F9\u56FF\u5704\u570A\u5709\u571C\u5E0F\u5E19\u5E14\u5E11\u5E31\u5E3B\u5E3C"], + ["e140", "\u9145\u9147\u9148\u9151\u9153\u9154\u9155\u9156\u9158\u9159\u915B\u915C\u915F\u9160\u9166\u9167\u9168\u916B\u916D\u9173\u917A\u917B\u917C\u9180", 4, "\u9186\u9188\u918A\u918E\u918F\u9193", 6, "\u919C", 5, "\u91A4", 5, "\u91AB\u91AC\u91B0\u91B1\u91B2\u91B3\u91B6\u91B7\u91B8\u91B9\u91BB"], + ["e180", "\u91BC", 10, "\u91C8\u91CB\u91D0\u91D2", 9, "\u91DD", 8, "\u5E37\u5E44\u5E54\u5E5B\u5E5E\u5E61\u5C8C\u5C7A\u5C8D\u5C90\u5C96\u5C88\u5C98\u5C99\u5C91\u5C9A\u5C9C\u5CB5\u5CA2\u5CBD\u5CAC\u5CAB\u5CB1\u5CA3\u5CC1\u5CB7\u5CC4\u5CD2\u5CE4\u5CCB\u5CE5\u5D02\u5D03\u5D27\u5D26\u5D2E\u5D24\u5D1E\u5D06\u5D1B\u5D58\u5D3E\u5D34\u5D3D\u5D6C\u5D5B\u5D6F\u5D5D\u5D6B\u5D4B\u5D4A\u5D69\u5D74\u5D82\u5D99\u5D9D\u8C73\u5DB7\u5DC5\u5F73\u5F77\u5F82\u5F87\u5F89\u5F8C\u5F95\u5F99\u5F9C\u5FA8\u5FAD\u5FB5\u5FBC\u8862\u5F61\u72AD\u72B0\u72B4\u72B7\u72B8\u72C3\u72C1\u72CE\u72CD\u72D2\u72E8\u72EF\u72E9\u72F2\u72F4\u72F7\u7301\u72F3\u7303\u72FA"], + ["e240", "\u91E6", 62], + ["e280", "\u9225", 32, "\u72FB\u7317\u7313\u7321\u730A\u731E\u731D\u7315\u7322\u7339\u7325\u732C\u7338\u7331\u7350\u734D\u7357\u7360\u736C\u736F\u737E\u821B\u5925\u98E7\u5924\u5902\u9963\u9967", 5, "\u9974\u9977\u997D\u9980\u9984\u9987\u998A\u998D\u9990\u9991\u9993\u9994\u9995\u5E80\u5E91\u5E8B\u5E96\u5EA5\u5EA0\u5EB9\u5EB5\u5EBE\u5EB3\u8D53\u5ED2\u5ED1\u5EDB\u5EE8\u5EEA\u81BA\u5FC4\u5FC9\u5FD6\u5FCF\u6003\u5FEE\u6004\u5FE1\u5FE4\u5FFE\u6005\u6006\u5FEA\u5FED\u5FF8\u6019\u6035\u6026\u601B\u600F\u600D\u6029\u602B\u600A\u603F\u6021\u6078\u6079\u607B\u607A\u6042"], + ["e340", "\u9246", 45, "\u9275", 16], + ["e380", "\u9286", 7, "\u928F", 24, "\u606A\u607D\u6096\u609A\u60AD\u609D\u6083\u6092\u608C\u609B\u60EC\u60BB\u60B1\u60DD\u60D8\u60C6\u60DA\u60B4\u6120\u6126\u6115\u6123\u60F4\u6100\u610E\u612B\u614A\u6175\u61AC\u6194\u61A7\u61B7\u61D4\u61F5\u5FDD\u96B3\u95E9\u95EB\u95F1\u95F3\u95F5\u95F6\u95FC\u95FE\u9603\u9604\u9606\u9608\u960A\u960B\u960C\u960D\u960F\u9612\u9615\u9616\u9617\u9619\u961A\u4E2C\u723F\u6215\u6C35\u6C54\u6C5C\u6C4A\u6CA3\u6C85\u6C90\u6C94\u6C8C\u6C68\u6C69\u6C74\u6C76\u6C86\u6CA9\u6CD0\u6CD4\u6CAD\u6CF7\u6CF8\u6CF1\u6CD7\u6CB2\u6CE0\u6CD6\u6CFA\u6CEB\u6CEE\u6CB1\u6CD3\u6CEF\u6CFE"], + ["e440", "\u92A8", 5, "\u92AF", 24, "\u92C9", 31], + ["e480", "\u92E9", 32, "\u6D39\u6D27\u6D0C\u6D43\u6D48\u6D07\u6D04\u6D19\u6D0E\u6D2B\u6D4D\u6D2E\u6D35\u6D1A\u6D4F\u6D52\u6D54\u6D33\u6D91\u6D6F\u6D9E\u6DA0\u6D5E\u6D93\u6D94\u6D5C\u6D60\u6D7C\u6D63\u6E1A\u6DC7\u6DC5\u6DDE\u6E0E\u6DBF\u6DE0\u6E11\u6DE6\u6DDD\u6DD9\u6E16\u6DAB\u6E0C\u6DAE\u6E2B\u6E6E\u6E4E\u6E6B\u6EB2\u6E5F\u6E86\u6E53\u6E54\u6E32\u6E25\u6E44\u6EDF\u6EB1\u6E98\u6EE0\u6F2D\u6EE2\u6EA5\u6EA7\u6EBD\u6EBB\u6EB7\u6ED7\u6EB4\u6ECF\u6E8F\u6EC2\u6E9F\u6F62\u6F46\u6F47\u6F24\u6F15\u6EF9\u6F2F\u6F36\u6F4B\u6F74\u6F2A\u6F09\u6F29\u6F89\u6F8D\u6F8C\u6F78\u6F72\u6F7C\u6F7A\u6FD1"], + ["e540", "\u930A", 51, "\u933F", 10], + ["e580", "\u934A", 31, "\u936B\u6FC9\u6FA7\u6FB9\u6FB6\u6FC2\u6FE1\u6FEE\u6FDE\u6FE0\u6FEF\u701A\u7023\u701B\u7039\u7035\u704F\u705E\u5B80\u5B84\u5B95\u5B93\u5BA5\u5BB8\u752F\u9A9E\u6434\u5BE4\u5BEE\u8930\u5BF0\u8E47\u8B07\u8FB6\u8FD3\u8FD5\u8FE5\u8FEE\u8FE4\u8FE9\u8FE6\u8FF3\u8FE8\u9005\u9004\u900B\u9026\u9011\u900D\u9016\u9021\u9035\u9036\u902D\u902F\u9044\u9051\u9052\u9050\u9068\u9058\u9062\u905B\u66B9\u9074\u907D\u9082\u9088\u9083\u908B\u5F50\u5F57\u5F56\u5F58\u5C3B\u54AB\u5C50\u5C59\u5B71\u5C63\u5C66\u7FBC\u5F2A\u5F29\u5F2D\u8274\u5F3C\u9B3B\u5C6E\u5981\u5983\u598D\u59A9\u59AA\u59A3"], + ["e640", "\u936C", 34, "\u9390", 27], + ["e680", "\u93AC", 29, "\u93CB\u93CC\u93CD\u5997\u59CA\u59AB\u599E\u59A4\u59D2\u59B2\u59AF\u59D7\u59BE\u5A05\u5A06\u59DD\u5A08\u59E3\u59D8\u59F9\u5A0C\u5A09\u5A32\u5A34\u5A11\u5A23\u5A13\u5A40\u5A67\u5A4A\u5A55\u5A3C\u5A62\u5A75\u80EC\u5AAA\u5A9B\u5A77\u5A7A\u5ABE\u5AEB\u5AB2\u5AD2\u5AD4\u5AB8\u5AE0\u5AE3\u5AF1\u5AD6\u5AE6\u5AD8\u5ADC\u5B09\u5B17\u5B16\u5B32\u5B37\u5B40\u5C15\u5C1C\u5B5A\u5B65\u5B73\u5B51\u5B53\u5B62\u9A75\u9A77\u9A78\u9A7A\u9A7F\u9A7D\u9A80\u9A81\u9A85\u9A88\u9A8A\u9A90\u9A92\u9A93\u9A96\u9A98\u9A9B\u9A9C\u9A9D\u9A9F\u9AA0\u9AA2\u9AA3\u9AA5\u9AA7\u7E9F\u7EA1\u7EA3\u7EA5\u7EA8\u7EA9"], + ["e740", "\u93CE", 7, "\u93D7", 54], + ["e780", "\u940E", 32, "\u7EAD\u7EB0\u7EBE\u7EC0\u7EC1\u7EC2\u7EC9\u7ECB\u7ECC\u7ED0\u7ED4\u7ED7\u7EDB\u7EE0\u7EE1\u7EE8\u7EEB\u7EEE\u7EEF\u7EF1\u7EF2\u7F0D\u7EF6\u7EFA\u7EFB\u7EFE\u7F01\u7F02\u7F03\u7F07\u7F08\u7F0B\u7F0C\u7F0F\u7F11\u7F12\u7F17\u7F19\u7F1C\u7F1B\u7F1F\u7F21", 6, "\u7F2A\u7F2B\u7F2C\u7F2D\u7F2F", 4, "\u7F35\u5E7A\u757F\u5DDB\u753E\u9095\u738E\u7391\u73AE\u73A2\u739F\u73CF\u73C2\u73D1\u73B7\u73B3\u73C0\u73C9\u73C8\u73E5\u73D9\u987C\u740A\u73E9\u73E7\u73DE\u73BA\u73F2\u740F\u742A\u745B\u7426\u7425\u7428\u7430\u742E\u742C"], + ["e840", "\u942F", 14, "\u943F", 43, "\u946C\u946D\u946E\u946F"], + ["e880", "\u9470", 20, "\u9491\u9496\u9498\u94C7\u94CF\u94D3\u94D4\u94DA\u94E6\u94FB\u951C\u9520\u741B\u741A\u7441\u745C\u7457\u7455\u7459\u7477\u746D\u747E\u749C\u748E\u7480\u7481\u7487\u748B\u749E\u74A8\u74A9\u7490\u74A7\u74D2\u74BA\u97EA\u97EB\u97EC\u674C\u6753\u675E\u6748\u6769\u67A5\u6787\u676A\u6773\u6798\u67A7\u6775\u67A8\u679E\u67AD\u678B\u6777\u677C\u67F0\u6809\u67D8\u680A\u67E9\u67B0\u680C\u67D9\u67B5\u67DA\u67B3\u67DD\u6800\u67C3\u67B8\u67E2\u680E\u67C1\u67FD\u6832\u6833\u6860\u6861\u684E\u6862\u6844\u6864\u6883\u681D\u6855\u6866\u6841\u6867\u6840\u683E\u684A\u6849\u6829\u68B5\u688F\u6874\u6877\u6893\u686B\u68C2\u696E\u68FC\u691F\u6920\u68F9"], + ["e940", "\u9527\u9533\u953D\u9543\u9548\u954B\u9555\u955A\u9560\u956E\u9574\u9575\u9577", 7, "\u9580", 42], + ["e980", "\u95AB", 32, "\u6924\u68F0\u690B\u6901\u6957\u68E3\u6910\u6971\u6939\u6960\u6942\u695D\u6984\u696B\u6980\u6998\u6978\u6934\u69CC\u6987\u6988\u69CE\u6989\u6966\u6963\u6979\u699B\u69A7\u69BB\u69AB\u69AD\u69D4\u69B1\u69C1\u69CA\u69DF\u6995\u69E0\u698D\u69FF\u6A2F\u69ED\u6A17\u6A18\u6A65\u69F2\u6A44\u6A3E\u6AA0\u6A50\u6A5B\u6A35\u6A8E\u6A79\u6A3D\u6A28\u6A58\u6A7C\u6A91\u6A90\u6AA9\u6A97\u6AAB\u7337\u7352\u6B81\u6B82\u6B87\u6B84\u6B92\u6B93\u6B8D\u6B9A\u6B9B\u6BA1\u6BAA\u8F6B\u8F6D\u8F71\u8F72\u8F73\u8F75\u8F76\u8F78\u8F77\u8F79\u8F7A\u8F7C\u8F7E\u8F81\u8F82\u8F84\u8F87\u8F8B"], + ["ea40", "\u95CC", 27, "\u95EC\u95FF\u9607\u9613\u9618\u961B\u961E\u9620\u9623", 6, "\u962B\u962C\u962D\u962F\u9630\u9637\u9638\u9639\u963A\u963E\u9641\u9643\u964A\u964E\u964F\u9651\u9652\u9653\u9656\u9657"], + ["ea80", "\u9658\u9659\u965A\u965C\u965D\u965E\u9660\u9663\u9665\u9666\u966B\u966D", 4, "\u9673\u9678", 12, "\u9687\u9689\u968A\u8F8D\u8F8E\u8F8F\u8F98\u8F9A\u8ECE\u620B\u6217\u621B\u621F\u6222\u6221\u6225\u6224\u622C\u81E7\u74EF\u74F4\u74FF\u750F\u7511\u7513\u6534\u65EE\u65EF\u65F0\u660A\u6619\u6772\u6603\u6615\u6600\u7085\u66F7\u661D\u6634\u6631\u6636\u6635\u8006\u665F\u6654\u6641\u664F\u6656\u6661\u6657\u6677\u6684\u668C\u66A7\u669D\u66BE\u66DB\u66DC\u66E6\u66E9\u8D32\u8D33\u8D36\u8D3B\u8D3D\u8D40\u8D45\u8D46\u8D48\u8D49\u8D47\u8D4D\u8D55\u8D59\u89C7\u89CA\u89CB\u89CC\u89CE\u89CF\u89D0\u89D1\u726E\u729F\u725D\u7266\u726F\u727E\u727F\u7284\u728B\u728D\u728F\u7292\u6308\u6332\u63B0"], + ["eb40", "\u968C\u968E\u9691\u9692\u9693\u9695\u9696\u969A\u969B\u969D", 9, "\u96A8", 7, "\u96B1\u96B2\u96B4\u96B5\u96B7\u96B8\u96BA\u96BB\u96BF\u96C2\u96C3\u96C8\u96CA\u96CB\u96D0\u96D1\u96D3\u96D4\u96D6", 9, "\u96E1", 6, "\u96EB"], + ["eb80", "\u96EC\u96ED\u96EE\u96F0\u96F1\u96F2\u96F4\u96F5\u96F8\u96FA\u96FB\u96FC\u96FD\u96FF\u9702\u9703\u9705\u970A\u970B\u970C\u9710\u9711\u9712\u9714\u9715\u9717", 4, "\u971D\u971F\u9720\u643F\u64D8\u8004\u6BEA\u6BF3\u6BFD\u6BF5\u6BF9\u6C05\u6C07\u6C06\u6C0D\u6C15\u6C18\u6C19\u6C1A\u6C21\u6C29\u6C24\u6C2A\u6C32\u6535\u6555\u656B\u724D\u7252\u7256\u7230\u8662\u5216\u809F\u809C\u8093\u80BC\u670A\u80BD\u80B1\u80AB\u80AD\u80B4\u80B7\u80E7\u80E8\u80E9\u80EA\u80DB\u80C2\u80C4\u80D9\u80CD\u80D7\u6710\u80DD\u80EB\u80F1\u80F4\u80ED\u810D\u810E\u80F2\u80FC\u6715\u8112\u8C5A\u8136\u811E\u812C\u8118\u8132\u8148\u814C\u8153\u8174\u8159\u815A\u8171\u8160\u8169\u817C\u817D\u816D\u8167\u584D\u5AB5\u8188\u8182\u8191\u6ED5\u81A3\u81AA\u81CC\u6726\u81CA\u81BB"], + ["ec40", "\u9721", 8, "\u972B\u972C\u972E\u972F\u9731\u9733", 4, "\u973A\u973B\u973C\u973D\u973F", 18, "\u9754\u9755\u9757\u9758\u975A\u975C\u975D\u975F\u9763\u9764\u9766\u9767\u9768\u976A", 7], + ["ec80", "\u9772\u9775\u9777", 4, "\u977D", 7, "\u9786", 4, "\u978C\u978E\u978F\u9790\u9793\u9795\u9796\u9797\u9799", 4, "\u81C1\u81A6\u6B24\u6B37\u6B39\u6B43\u6B46\u6B59\u98D1\u98D2\u98D3\u98D5\u98D9\u98DA\u6BB3\u5F40\u6BC2\u89F3\u6590\u9F51\u6593\u65BC\u65C6\u65C4\u65C3\u65CC\u65CE\u65D2\u65D6\u7080\u709C\u7096\u709D\u70BB\u70C0\u70B7\u70AB\u70B1\u70E8\u70CA\u7110\u7113\u7116\u712F\u7131\u7173\u715C\u7168\u7145\u7172\u714A\u7178\u717A\u7198\u71B3\u71B5\u71A8\u71A0\u71E0\u71D4\u71E7\u71F9\u721D\u7228\u706C\u7118\u7166\u71B9\u623E\u623D\u6243\u6248\u6249\u793B\u7940\u7946\u7949\u795B\u795C\u7953\u795A\u7962\u7957\u7960\u796F\u7967\u797A\u7985\u798A\u799A\u79A7\u79B3\u5FD1\u5FD0"], + ["ed40", "\u979E\u979F\u97A1\u97A2\u97A4", 6, "\u97AC\u97AE\u97B0\u97B1\u97B3\u97B5", 46], + ["ed80", "\u97E4\u97E5\u97E8\u97EE", 4, "\u97F4\u97F7", 23, "\u603C\u605D\u605A\u6067\u6041\u6059\u6063\u60AB\u6106\u610D\u615D\u61A9\u619D\u61CB\u61D1\u6206\u8080\u807F\u6C93\u6CF6\u6DFC\u77F6\u77F8\u7800\u7809\u7817\u7818\u7811\u65AB\u782D\u781C\u781D\u7839\u783A\u783B\u781F\u783C\u7825\u782C\u7823\u7829\u784E\u786D\u7856\u7857\u7826\u7850\u7847\u784C\u786A\u789B\u7893\u789A\u7887\u789C\u78A1\u78A3\u78B2\u78B9\u78A5\u78D4\u78D9\u78C9\u78EC\u78F2\u7905\u78F4\u7913\u7924\u791E\u7934\u9F9B\u9EF9\u9EFB\u9EFC\u76F1\u7704\u770D\u76F9\u7707\u7708\u771A\u7722\u7719\u772D\u7726\u7735\u7738\u7750\u7751\u7747\u7743\u775A\u7768"], + ["ee40", "\u980F", 62], + ["ee80", "\u984E", 32, "\u7762\u7765\u777F\u778D\u777D\u7780\u778C\u7791\u779F\u77A0\u77B0\u77B5\u77BD\u753A\u7540\u754E\u754B\u7548\u755B\u7572\u7579\u7583\u7F58\u7F61\u7F5F\u8A48\u7F68\u7F74\u7F71\u7F79\u7F81\u7F7E\u76CD\u76E5\u8832\u9485\u9486\u9487\u948B\u948A\u948C\u948D\u948F\u9490\u9494\u9497\u9495\u949A\u949B\u949C\u94A3\u94A4\u94AB\u94AA\u94AD\u94AC\u94AF\u94B0\u94B2\u94B4\u94B6", 4, "\u94BC\u94BD\u94BF\u94C4\u94C8", 6, "\u94D0\u94D1\u94D2\u94D5\u94D6\u94D7\u94D9\u94D8\u94DB\u94DE\u94DF\u94E0\u94E2\u94E4\u94E5\u94E7\u94E8\u94EA"], + ["ef40", "\u986F", 5, "\u988B\u988E\u9892\u9895\u9899\u98A3\u98A8", 37, "\u98CF\u98D0\u98D4\u98D6\u98D7\u98DB\u98DC\u98DD\u98E0", 4], + ["ef80", "\u98E5\u98E6\u98E9", 30, "\u94E9\u94EB\u94EE\u94EF\u94F3\u94F4\u94F5\u94F7\u94F9\u94FC\u94FD\u94FF\u9503\u9502\u9506\u9507\u9509\u950A\u950D\u950E\u950F\u9512", 4, "\u9518\u951B\u951D\u951E\u951F\u9522\u952A\u952B\u9529\u952C\u9531\u9532\u9534\u9536\u9537\u9538\u953C\u953E\u953F\u9542\u9535\u9544\u9545\u9546\u9549\u954C\u954E\u954F\u9552\u9553\u9554\u9556\u9557\u9558\u9559\u955B\u955E\u955F\u955D\u9561\u9562\u9564", 8, "\u956F\u9571\u9572\u9573\u953A\u77E7\u77EC\u96C9\u79D5\u79ED\u79E3\u79EB\u7A06\u5D47\u7A03\u7A02\u7A1E\u7A14"], + ["f040", "\u9908", 4, "\u990E\u990F\u9911", 28, "\u992F", 26], + ["f080", "\u994A", 9, "\u9956", 12, "\u9964\u9966\u9973\u9978\u9979\u997B\u997E\u9982\u9983\u9989\u7A39\u7A37\u7A51\u9ECF\u99A5\u7A70\u7688\u768E\u7693\u7699\u76A4\u74DE\u74E0\u752C\u9E20\u9E22\u9E28", 4, "\u9E32\u9E31\u9E36\u9E38\u9E37\u9E39\u9E3A\u9E3E\u9E41\u9E42\u9E44\u9E46\u9E47\u9E48\u9E49\u9E4B\u9E4C\u9E4E\u9E51\u9E55\u9E57\u9E5A\u9E5B\u9E5C\u9E5E\u9E63\u9E66", 6, "\u9E71\u9E6D\u9E73\u7592\u7594\u7596\u75A0\u759D\u75AC\u75A3\u75B3\u75B4\u75B8\u75C4\u75B1\u75B0\u75C3\u75C2\u75D6\u75CD\u75E3\u75E8\u75E6\u75E4\u75EB\u75E7\u7603\u75F1\u75FC\u75FF\u7610\u7600\u7605\u760C\u7617\u760A\u7625\u7618\u7615\u7619"], + ["f140", "\u998C\u998E\u999A", 10, "\u99A6\u99A7\u99A9", 47], + ["f180", "\u99D9", 32, "\u761B\u763C\u7622\u7620\u7640\u762D\u7630\u763F\u7635\u7643\u763E\u7633\u764D\u765E\u7654\u765C\u7656\u766B\u766F\u7FCA\u7AE6\u7A78\u7A79\u7A80\u7A86\u7A88\u7A95\u7AA6\u7AA0\u7AAC\u7AA8\u7AAD\u7AB3\u8864\u8869\u8872\u887D\u887F\u8882\u88A2\u88C6\u88B7\u88BC\u88C9\u88E2\u88CE\u88E3\u88E5\u88F1\u891A\u88FC\u88E8\u88FE\u88F0\u8921\u8919\u8913\u891B\u890A\u8934\u892B\u8936\u8941\u8966\u897B\u758B\u80E5\u76B2\u76B4\u77DC\u8012\u8014\u8016\u801C\u8020\u8022\u8025\u8026\u8027\u8029\u8028\u8031\u800B\u8035\u8043\u8046\u804D\u8052\u8069\u8071\u8983\u9878\u9880\u9883"], + ["f240", "\u99FA", 62], + ["f280", "\u9A39", 32, "\u9889\u988C\u988D\u988F\u9894\u989A\u989B\u989E\u989F\u98A1\u98A2\u98A5\u98A6\u864D\u8654\u866C\u866E\u867F\u867A\u867C\u867B\u86A8\u868D\u868B\u86AC\u869D\u86A7\u86A3\u86AA\u8693\u86A9\u86B6\u86C4\u86B5\u86CE\u86B0\u86BA\u86B1\u86AF\u86C9\u86CF\u86B4\u86E9\u86F1\u86F2\u86ED\u86F3\u86D0\u8713\u86DE\u86F4\u86DF\u86D8\u86D1\u8703\u8707\u86F8\u8708\u870A\u870D\u8709\u8723\u873B\u871E\u8725\u872E\u871A\u873E\u8748\u8734\u8731\u8729\u8737\u873F\u8782\u8722\u877D\u877E\u877B\u8760\u8770\u874C\u876E\u878B\u8753\u8763\u877C\u8764\u8759\u8765\u8793\u87AF\u87A8\u87D2"], + ["f340", "\u9A5A", 17, "\u9A72\u9A83\u9A89\u9A8D\u9A8E\u9A94\u9A95\u9A99\u9AA6\u9AA9", 6, "\u9AB2\u9AB3\u9AB4\u9AB5\u9AB9\u9ABB\u9ABD\u9ABE\u9ABF\u9AC3\u9AC4\u9AC6", 4, "\u9ACD\u9ACE\u9ACF\u9AD0\u9AD2\u9AD4\u9AD5\u9AD6\u9AD7\u9AD9\u9ADA\u9ADB\u9ADC"], + ["f380", "\u9ADD\u9ADE\u9AE0\u9AE2\u9AE3\u9AE4\u9AE5\u9AE7\u9AE8\u9AE9\u9AEA\u9AEC\u9AEE\u9AF0", 8, "\u9AFA\u9AFC", 6, "\u9B04\u9B05\u9B06\u87C6\u8788\u8785\u87AD\u8797\u8783\u87AB\u87E5\u87AC\u87B5\u87B3\u87CB\u87D3\u87BD\u87D1\u87C0\u87CA\u87DB\u87EA\u87E0\u87EE\u8816\u8813\u87FE\u880A\u881B\u8821\u8839\u883C\u7F36\u7F42\u7F44\u7F45\u8210\u7AFA\u7AFD\u7B08\u7B03\u7B04\u7B15\u7B0A\u7B2B\u7B0F\u7B47\u7B38\u7B2A\u7B19\u7B2E\u7B31\u7B20\u7B25\u7B24\u7B33\u7B3E\u7B1E\u7B58\u7B5A\u7B45\u7B75\u7B4C\u7B5D\u7B60\u7B6E\u7B7B\u7B62\u7B72\u7B71\u7B90\u7BA6\u7BA7\u7BB8\u7BAC\u7B9D\u7BA8\u7B85\u7BAA\u7B9C\u7BA2\u7BAB\u7BB4\u7BD1\u7BC1\u7BCC\u7BDD\u7BDA\u7BE5\u7BE6\u7BEA\u7C0C\u7BFE\u7BFC\u7C0F\u7C16\u7C0B"], + ["f440", "\u9B07\u9B09", 5, "\u9B10\u9B11\u9B12\u9B14", 10, "\u9B20\u9B21\u9B22\u9B24", 10, "\u9B30\u9B31\u9B33", 7, "\u9B3D\u9B3E\u9B3F\u9B40\u9B46\u9B4A\u9B4B\u9B4C\u9B4E\u9B50\u9B52\u9B53\u9B55", 5], + ["f480", "\u9B5B", 32, "\u7C1F\u7C2A\u7C26\u7C38\u7C41\u7C40\u81FE\u8201\u8202\u8204\u81EC\u8844\u8221\u8222\u8223\u822D\u822F\u8228\u822B\u8238\u823B\u8233\u8234\u823E\u8244\u8249\u824B\u824F\u825A\u825F\u8268\u887E\u8885\u8888\u88D8\u88DF\u895E\u7F9D\u7F9F\u7FA7\u7FAF\u7FB0\u7FB2\u7C7C\u6549\u7C91\u7C9D\u7C9C\u7C9E\u7CA2\u7CB2\u7CBC\u7CBD\u7CC1\u7CC7\u7CCC\u7CCD\u7CC8\u7CC5\u7CD7\u7CE8\u826E\u66A8\u7FBF\u7FCE\u7FD5\u7FE5\u7FE1\u7FE6\u7FE9\u7FEE\u7FF3\u7CF8\u7D77\u7DA6\u7DAE\u7E47\u7E9B\u9EB8\u9EB4\u8D73\u8D84\u8D94\u8D91\u8DB1\u8D67\u8D6D\u8C47\u8C49\u914A\u9150\u914E\u914F\u9164"], + ["f540", "\u9B7C", 62], + ["f580", "\u9BBB", 32, "\u9162\u9161\u9170\u9169\u916F\u917D\u917E\u9172\u9174\u9179\u918C\u9185\u9190\u918D\u9191\u91A2\u91A3\u91AA\u91AD\u91AE\u91AF\u91B5\u91B4\u91BA\u8C55\u9E7E\u8DB8\u8DEB\u8E05\u8E59\u8E69\u8DB5\u8DBF\u8DBC\u8DBA\u8DC4\u8DD6\u8DD7\u8DDA\u8DDE\u8DCE\u8DCF\u8DDB\u8DC6\u8DEC\u8DF7\u8DF8\u8DE3\u8DF9\u8DFB\u8DE4\u8E09\u8DFD\u8E14\u8E1D\u8E1F\u8E2C\u8E2E\u8E23\u8E2F\u8E3A\u8E40\u8E39\u8E35\u8E3D\u8E31\u8E49\u8E41\u8E42\u8E51\u8E52\u8E4A\u8E70\u8E76\u8E7C\u8E6F\u8E74\u8E85\u8E8F\u8E94\u8E90\u8E9C\u8E9E\u8C78\u8C82\u8C8A\u8C85\u8C98\u8C94\u659B\u89D6\u89DE\u89DA\u89DC"], + ["f640", "\u9BDC", 62], + ["f680", "\u9C1B", 32, "\u89E5\u89EB\u89EF\u8A3E\u8B26\u9753\u96E9\u96F3\u96EF\u9706\u9701\u9708\u970F\u970E\u972A\u972D\u9730\u973E\u9F80\u9F83\u9F85", 5, "\u9F8C\u9EFE\u9F0B\u9F0D\u96B9\u96BC\u96BD\u96CE\u96D2\u77BF\u96E0\u928E\u92AE\u92C8\u933E\u936A\u93CA\u938F\u943E\u946B\u9C7F\u9C82\u9C85\u9C86\u9C87\u9C88\u7A23\u9C8B\u9C8E\u9C90\u9C91\u9C92\u9C94\u9C95\u9C9A\u9C9B\u9C9E", 5, "\u9CA5", 4, "\u9CAB\u9CAD\u9CAE\u9CB0", 7, "\u9CBA\u9CBB\u9CBC\u9CBD\u9CC4\u9CC5\u9CC6\u9CC7\u9CCA\u9CCB"], + ["f740", "\u9C3C", 62], + ["f780", "\u9C7B\u9C7D\u9C7E\u9C80\u9C83\u9C84\u9C89\u9C8A\u9C8C\u9C8F\u9C93\u9C96\u9C97\u9C98\u9C99\u9C9D\u9CAA\u9CAC\u9CAF\u9CB9\u9CBE", 4, "\u9CC8\u9CC9\u9CD1\u9CD2\u9CDA\u9CDB\u9CE0\u9CE1\u9CCC", 4, "\u9CD3\u9CD4\u9CD5\u9CD7\u9CD8\u9CD9\u9CDC\u9CDD\u9CDF\u9CE2\u977C\u9785\u9791\u9792\u9794\u97AF\u97AB\u97A3\u97B2\u97B4\u9AB1\u9AB0\u9AB7\u9E58\u9AB6\u9ABA\u9ABC\u9AC1\u9AC0\u9AC5\u9AC2\u9ACB\u9ACC\u9AD1\u9B45\u9B43\u9B47\u9B49\u9B48\u9B4D\u9B51\u98E8\u990D\u992E\u9955\u9954\u9ADF\u9AE1\u9AE6\u9AEF\u9AEB\u9AFB\u9AED\u9AF9\u9B08\u9B0F\u9B13\u9B1F\u9B23\u9EBD\u9EBE\u7E3B\u9E82\u9E87\u9E88\u9E8B\u9E92\u93D6\u9E9D\u9E9F\u9EDB\u9EDC\u9EDD\u9EE0\u9EDF\u9EE2\u9EE9\u9EE7\u9EE5\u9EEA\u9EEF\u9F22\u9F2C\u9F2F\u9F39\u9F37\u9F3D\u9F3E\u9F44"], + ["f840", "\u9CE3", 62], + ["f880", "\u9D22", 32], + ["f940", "\u9D43", 62], + ["f980", "\u9D82", 32], + ["fa40", "\u9DA3", 62], + ["fa80", "\u9DE2", 32], + ["fb40", "\u9E03", 27, "\u9E24\u9E27\u9E2E\u9E30\u9E34\u9E3B\u9E3C\u9E40\u9E4D\u9E50\u9E52\u9E53\u9E54\u9E56\u9E59\u9E5D\u9E5F\u9E60\u9E61\u9E62\u9E65\u9E6E\u9E6F\u9E72\u9E74", 9, "\u9E80"], + ["fb80", "\u9E81\u9E83\u9E84\u9E85\u9E86\u9E89\u9E8A\u9E8C", 5, "\u9E94", 8, "\u9E9E\u9EA0", 5, "\u9EA7\u9EA8\u9EA9\u9EAA"], + ["fc40", "\u9EAB", 8, "\u9EB5\u9EB6\u9EB7\u9EB9\u9EBA\u9EBC\u9EBF", 4, "\u9EC5\u9EC6\u9EC7\u9EC8\u9ECA\u9ECB\u9ECC\u9ED0\u9ED2\u9ED3\u9ED5\u9ED6\u9ED7\u9ED9\u9EDA\u9EDE\u9EE1\u9EE3\u9EE4\u9EE6\u9EE8\u9EEB\u9EEC\u9EED\u9EEE\u9EF0", 8, "\u9EFA\u9EFD\u9EFF", 6], + ["fc80", "\u9F06", 4, "\u9F0C\u9F0F\u9F11\u9F12\u9F14\u9F15\u9F16\u9F18\u9F1A", 5, "\u9F21\u9F23", 8, "\u9F2D\u9F2E\u9F30\u9F31"], + ["fd40", "\u9F32", 4, "\u9F38\u9F3A\u9F3C\u9F3F", 4, "\u9F45", 10, "\u9F52", 38], + ["fd80", "\u9F79", 5, "\u9F81\u9F82\u9F8D", 11, "\u9F9C\u9F9D\u9F9E\u9FA1", 4, "\uF92C\uF979\uF995\uF9E7\uF9F1"], + ["fe40", "\uFA0C\uFA0D\uFA0E\uFA0F\uFA11\uFA13\uFA14\uFA18\uFA1F\uFA20\uFA21\uFA23\uFA24\uFA27\uFA28\uFA29"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/gbk-added.json +var require_gbk_added = __commonJS({ + "node_modules/iconv-lite/encodings/tables/gbk-added.json"(exports2, module2) { + module2.exports = [ + ["a140", "\uE4C6", 62], + ["a180", "\uE505", 32], + ["a240", "\uE526", 62], + ["a280", "\uE565", 32], + ["a2ab", "\uE766", 5], + ["a2e3", "\u20AC\uE76D"], + ["a2ef", "\uE76E\uE76F"], + ["a2fd", "\uE770\uE771"], + ["a340", "\uE586", 62], + ["a380", "\uE5C5", 31, "\u3000"], + ["a440", "\uE5E6", 62], + ["a480", "\uE625", 32], + ["a4f4", "\uE772", 10], + ["a540", "\uE646", 62], + ["a580", "\uE685", 32], + ["a5f7", "\uE77D", 7], + ["a640", "\uE6A6", 62], + ["a680", "\uE6E5", 32], + ["a6b9", "\uE785", 7], + ["a6d9", "\uE78D", 6], + ["a6ec", "\uE794\uE795"], + ["a6f3", "\uE796"], + ["a6f6", "\uE797", 8], + ["a740", "\uE706", 62], + ["a780", "\uE745", 32], + ["a7c2", "\uE7A0", 14], + ["a7f2", "\uE7AF", 12], + ["a896", "\uE7BC", 10], + ["a8bc", "\u1E3F"], + ["a8bf", "\u01F9"], + ["a8c1", "\uE7C9\uE7CA\uE7CB\uE7CC"], + ["a8ea", "\uE7CD", 20], + ["a958", "\uE7E2"], + ["a95b", "\uE7E3"], + ["a95d", "\uE7E4\uE7E5\uE7E6"], + ["a989", "\u303E\u2FF0", 11], + ["a997", "\uE7F4", 12], + ["a9f0", "\uE801", 14], + ["aaa1", "\uE000", 93], + ["aba1", "\uE05E", 93], + ["aca1", "\uE0BC", 93], + ["ada1", "\uE11A", 93], + ["aea1", "\uE178", 93], + ["afa1", "\uE1D6", 93], + ["d7fa", "\uE810", 4], + ["f8a1", "\uE234", 93], + ["f9a1", "\uE292", 93], + ["faa1", "\uE2F0", 93], + ["fba1", "\uE34E", 93], + ["fca1", "\uE3AC", 93], + ["fda1", "\uE40A", 93], + ["fe50", "\u2E81\uE816\uE817\uE818\u2E84\u3473\u3447\u2E88\u2E8B\uE81E\u359E\u361A\u360E\u2E8C\u2E97\u396E\u3918\uE826\u39CF\u39DF\u3A73\u39D0\uE82B\uE82C\u3B4E\u3C6E\u3CE0\u2EA7\uE831\uE832\u2EAA\u4056\u415F\u2EAE\u4337\u2EB3\u2EB6\u2EB7\uE83B\u43B1\u43AC\u2EBB\u43DD\u44D6\u4661\u464C\uE843"], + ["fe80", "\u4723\u4729\u477C\u478D\u2ECA\u4947\u497A\u497D\u4982\u4983\u4985\u4986\u499F\u499B\u49B7\u49B6\uE854\uE855\u4CA3\u4C9F\u4CA0\u4CA1\u4C77\u4CA2\u4D13", 6, "\u4DAE\uE864\uE468", 93], + ["8135f437", "\uE7C7"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/gb18030-ranges.json +var require_gb18030_ranges = __commonJS({ + "node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module2) { + module2.exports = { uChars: [128, 165, 169, 178, 184, 216, 226, 235, 238, 244, 248, 251, 253, 258, 276, 284, 300, 325, 329, 334, 364, 463, 465, 467, 469, 471, 473, 475, 477, 506, 594, 610, 712, 716, 730, 930, 938, 962, 970, 1026, 1104, 1106, 8209, 8215, 8218, 8222, 8231, 8241, 8244, 8246, 8252, 8365, 8452, 8454, 8458, 8471, 8482, 8556, 8570, 8596, 8602, 8713, 8720, 8722, 8726, 8731, 8737, 8740, 8742, 8748, 8751, 8760, 8766, 8777, 8781, 8787, 8802, 8808, 8816, 8854, 8858, 8870, 8896, 8979, 9322, 9372, 9548, 9588, 9616, 9622, 9634, 9652, 9662, 9672, 9676, 9680, 9702, 9735, 9738, 9793, 9795, 11906, 11909, 11913, 11917, 11928, 11944, 11947, 11951, 11956, 11960, 11964, 11979, 12284, 12292, 12312, 12319, 12330, 12351, 12436, 12447, 12535, 12543, 12586, 12842, 12850, 12964, 13200, 13215, 13218, 13253, 13263, 13267, 13270, 13384, 13428, 13727, 13839, 13851, 14617, 14703, 14801, 14816, 14964, 15183, 15471, 15585, 16471, 16736, 17208, 17325, 17330, 17374, 17623, 17997, 18018, 18212, 18218, 18301, 18318, 18760, 18811, 18814, 18820, 18823, 18844, 18848, 18872, 19576, 19620, 19738, 19887, 40870, 59244, 59336, 59367, 59413, 59417, 59423, 59431, 59437, 59443, 59452, 59460, 59478, 59493, 63789, 63866, 63894, 63976, 63986, 64016, 64018, 64021, 64025, 64034, 64037, 64042, 65074, 65093, 65107, 65112, 65127, 65132, 65375, 65510, 65536], gbChars: [0, 36, 38, 45, 50, 81, 89, 95, 96, 100, 103, 104, 105, 109, 126, 133, 148, 172, 175, 179, 208, 306, 307, 308, 309, 310, 311, 312, 313, 341, 428, 443, 544, 545, 558, 741, 742, 749, 750, 805, 819, 820, 7922, 7924, 7925, 7927, 7934, 7943, 7944, 7945, 7950, 8062, 8148, 8149, 8152, 8164, 8174, 8236, 8240, 8262, 8264, 8374, 8380, 8381, 8384, 8388, 8390, 8392, 8393, 8394, 8396, 8401, 8406, 8416, 8419, 8424, 8437, 8439, 8445, 8482, 8485, 8496, 8521, 8603, 8936, 8946, 9046, 9050, 9063, 9066, 9076, 9092, 9100, 9108, 9111, 9113, 9131, 9162, 9164, 9218, 9219, 11329, 11331, 11334, 11336, 11346, 11361, 11363, 11366, 11370, 11372, 11375, 11389, 11682, 11686, 11687, 11692, 11694, 11714, 11716, 11723, 11725, 11730, 11736, 11982, 11989, 12102, 12336, 12348, 12350, 12384, 12393, 12395, 12397, 12510, 12553, 12851, 12962, 12973, 13738, 13823, 13919, 13933, 14080, 14298, 14585, 14698, 15583, 15847, 16318, 16434, 16438, 16481, 16729, 17102, 17122, 17315, 17320, 17402, 17418, 17859, 17909, 17911, 17915, 17916, 17936, 17939, 17961, 18664, 18703, 18814, 18962, 19043, 33469, 33470, 33471, 33484, 33485, 33490, 33497, 33501, 33505, 33513, 33520, 33536, 33550, 37845, 37921, 37948, 38029, 38038, 38064, 38065, 38066, 38069, 38075, 38076, 38078, 39108, 39109, 39113, 39114, 39115, 39116, 39265, 39394, 189e3] }; + } +}); + +// node_modules/iconv-lite/encodings/tables/cp949.json +var require_cp949 = __commonJS({ + "node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module2) { + module2.exports = [ + ["0", "\0", 127], + ["8141", "\uAC02\uAC03\uAC05\uAC06\uAC0B", 4, "\uAC18\uAC1E\uAC1F\uAC21\uAC22\uAC23\uAC25", 6, "\uAC2E\uAC32\uAC33\uAC34"], + ["8161", "\uAC35\uAC36\uAC37\uAC3A\uAC3B\uAC3D\uAC3E\uAC3F\uAC41", 9, "\uAC4C\uAC4E", 5, "\uAC55"], + ["8181", "\uAC56\uAC57\uAC59\uAC5A\uAC5B\uAC5D", 18, "\uAC72\uAC73\uAC75\uAC76\uAC79\uAC7B", 4, "\uAC82\uAC87\uAC88\uAC8D\uAC8E\uAC8F\uAC91\uAC92\uAC93\uAC95", 6, "\uAC9E\uACA2", 5, "\uACAB\uACAD\uACAE\uACB1", 6, "\uACBA\uACBE\uACBF\uACC0\uACC2\uACC3\uACC5\uACC6\uACC7\uACC9\uACCA\uACCB\uACCD", 7, "\uACD6\uACD8", 7, "\uACE2\uACE3\uACE5\uACE6\uACE9\uACEB\uACED\uACEE\uACF2\uACF4\uACF7", 4, "\uACFE\uACFF\uAD01\uAD02\uAD03\uAD05\uAD07", 4, "\uAD0E\uAD10\uAD12\uAD13"], + ["8241", "\uAD14\uAD15\uAD16\uAD17\uAD19\uAD1A\uAD1B\uAD1D\uAD1E\uAD1F\uAD21", 7, "\uAD2A\uAD2B\uAD2E", 5], + ["8261", "\uAD36\uAD37\uAD39\uAD3A\uAD3B\uAD3D", 6, "\uAD46\uAD48\uAD4A", 5, "\uAD51\uAD52\uAD53\uAD55\uAD56\uAD57"], + ["8281", "\uAD59", 7, "\uAD62\uAD64", 7, "\uAD6E\uAD6F\uAD71\uAD72\uAD77\uAD78\uAD79\uAD7A\uAD7E\uAD80\uAD83", 4, "\uAD8A\uAD8B\uAD8D\uAD8E\uAD8F\uAD91", 10, "\uAD9E", 5, "\uADA5", 17, "\uADB8", 7, "\uADC2\uADC3\uADC5\uADC6\uADC7\uADC9", 6, "\uADD2\uADD4", 7, "\uADDD\uADDE\uADDF\uADE1\uADE2\uADE3\uADE5", 18], + ["8341", "\uADFA\uADFB\uADFD\uADFE\uAE02", 5, "\uAE0A\uAE0C\uAE0E", 5, "\uAE15", 7], + ["8361", "\uAE1D", 18, "\uAE32\uAE33\uAE35\uAE36\uAE39\uAE3B\uAE3C"], + ["8381", "\uAE3D\uAE3E\uAE3F\uAE42\uAE44\uAE47\uAE48\uAE49\uAE4B\uAE4F\uAE51\uAE52\uAE53\uAE55\uAE57", 4, "\uAE5E\uAE62\uAE63\uAE64\uAE66\uAE67\uAE6A\uAE6B\uAE6D\uAE6E\uAE6F\uAE71", 6, "\uAE7A\uAE7E", 5, "\uAE86", 5, "\uAE8D", 46, "\uAEBF\uAEC1\uAEC2\uAEC3\uAEC5", 6, "\uAECE\uAED2", 5, "\uAEDA\uAEDB\uAEDD", 8], + ["8441", "\uAEE6\uAEE7\uAEE9\uAEEA\uAEEC\uAEEE", 5, "\uAEF5\uAEF6\uAEF7\uAEF9\uAEFA\uAEFB\uAEFD", 8], + ["8461", "\uAF06\uAF09\uAF0A\uAF0B\uAF0C\uAF0E\uAF0F\uAF11", 18], + ["8481", "\uAF24", 7, "\uAF2E\uAF2F\uAF31\uAF33\uAF35", 6, "\uAF3E\uAF40\uAF44\uAF45\uAF46\uAF47\uAF4A", 5, "\uAF51", 10, "\uAF5E", 5, "\uAF66", 18, "\uAF7A", 5, "\uAF81\uAF82\uAF83\uAF85\uAF86\uAF87\uAF89", 6, "\uAF92\uAF93\uAF94\uAF96", 5, "\uAF9D", 26, "\uAFBA\uAFBB\uAFBD\uAFBE"], + ["8541", "\uAFBF\uAFC1", 5, "\uAFCA\uAFCC\uAFCF", 4, "\uAFD5", 6, "\uAFDD", 4], + ["8561", "\uAFE2", 5, "\uAFEA", 5, "\uAFF2\uAFF3\uAFF5\uAFF6\uAFF7\uAFF9", 6, "\uB002\uB003"], + ["8581", "\uB005", 6, "\uB00D\uB00E\uB00F\uB011\uB012\uB013\uB015", 6, "\uB01E", 9, "\uB029", 26, "\uB046\uB047\uB049\uB04B\uB04D\uB04F\uB050\uB051\uB052\uB056\uB058\uB05A\uB05B\uB05C\uB05E", 29, "\uB07E\uB07F\uB081\uB082\uB083\uB085", 6, "\uB08E\uB090\uB092", 5, "\uB09B\uB09D\uB09E\uB0A3\uB0A4"], + ["8641", "\uB0A5\uB0A6\uB0A7\uB0AA\uB0B0\uB0B2\uB0B6\uB0B7\uB0B9\uB0BA\uB0BB\uB0BD", 6, "\uB0C6\uB0CA", 5, "\uB0D2"], + ["8661", "\uB0D3\uB0D5\uB0D6\uB0D7\uB0D9", 6, "\uB0E1\uB0E2\uB0E3\uB0E4\uB0E6", 10], + ["8681", "\uB0F1", 22, "\uB10A\uB10D\uB10E\uB10F\uB111\uB114\uB115\uB116\uB117\uB11A\uB11E", 4, "\uB126\uB127\uB129\uB12A\uB12B\uB12D", 6, "\uB136\uB13A", 5, "\uB142\uB143\uB145\uB146\uB147\uB149", 6, "\uB152\uB153\uB156\uB157\uB159\uB15A\uB15B\uB15D\uB15E\uB15F\uB161", 22, "\uB17A\uB17B\uB17D\uB17E\uB17F\uB181\uB183", 4, "\uB18A\uB18C\uB18E\uB18F\uB190\uB191\uB195\uB196\uB197\uB199\uB19A\uB19B\uB19D"], + ["8741", "\uB19E", 9, "\uB1A9", 15], + ["8761", "\uB1B9", 18, "\uB1CD\uB1CE\uB1CF\uB1D1\uB1D2\uB1D3\uB1D5"], + ["8781", "\uB1D6", 5, "\uB1DE\uB1E0", 7, "\uB1EA\uB1EB\uB1ED\uB1EE\uB1EF\uB1F1", 7, "\uB1FA\uB1FC\uB1FE", 5, "\uB206\uB207\uB209\uB20A\uB20D", 6, "\uB216\uB218\uB21A", 5, "\uB221", 18, "\uB235", 6, "\uB23D", 26, "\uB259\uB25A\uB25B\uB25D\uB25E\uB25F\uB261", 6, "\uB26A", 4], + ["8841", "\uB26F", 4, "\uB276", 5, "\uB27D", 6, "\uB286\uB287\uB288\uB28A", 4], + ["8861", "\uB28F\uB292\uB293\uB295\uB296\uB297\uB29B", 4, "\uB2A2\uB2A4\uB2A7\uB2A8\uB2A9\uB2AB\uB2AD\uB2AE\uB2AF\uB2B1\uB2B2\uB2B3\uB2B5\uB2B6\uB2B7"], + ["8881", "\uB2B8", 15, "\uB2CA\uB2CB\uB2CD\uB2CE\uB2CF\uB2D1\uB2D3", 4, "\uB2DA\uB2DC\uB2DE\uB2DF\uB2E0\uB2E1\uB2E3\uB2E7\uB2E9\uB2EA\uB2F0\uB2F1\uB2F2\uB2F6\uB2FC\uB2FD\uB2FE\uB302\uB303\uB305\uB306\uB307\uB309", 6, "\uB312\uB316", 5, "\uB31D", 54, "\uB357\uB359\uB35A\uB35D\uB360\uB361\uB362\uB363"], + ["8941", "\uB366\uB368\uB36A\uB36C\uB36D\uB36F\uB372\uB373\uB375\uB376\uB377\uB379", 6, "\uB382\uB386", 5, "\uB38D"], + ["8961", "\uB38E\uB38F\uB391\uB392\uB393\uB395", 10, "\uB3A2", 5, "\uB3A9\uB3AA\uB3AB\uB3AD"], + ["8981", "\uB3AE", 21, "\uB3C6\uB3C7\uB3C9\uB3CA\uB3CD\uB3CF\uB3D1\uB3D2\uB3D3\uB3D6\uB3D8\uB3DA\uB3DC\uB3DE\uB3DF\uB3E1\uB3E2\uB3E3\uB3E5\uB3E6\uB3E7\uB3E9", 18, "\uB3FD", 18, "\uB411", 6, "\uB419\uB41A\uB41B\uB41D\uB41E\uB41F\uB421", 6, "\uB42A\uB42C", 7, "\uB435", 15], + ["8a41", "\uB445", 10, "\uB452\uB453\uB455\uB456\uB457\uB459", 6, "\uB462\uB464\uB466"], + ["8a61", "\uB467", 4, "\uB46D", 18, "\uB481\uB482"], + ["8a81", "\uB483", 4, "\uB489", 19, "\uB49E", 5, "\uB4A5\uB4A6\uB4A7\uB4A9\uB4AA\uB4AB\uB4AD", 7, "\uB4B6\uB4B8\uB4BA", 5, "\uB4C1\uB4C2\uB4C3\uB4C5\uB4C6\uB4C7\uB4C9", 6, "\uB4D1\uB4D2\uB4D3\uB4D4\uB4D6", 5, "\uB4DE\uB4DF\uB4E1\uB4E2\uB4E5\uB4E7", 4, "\uB4EE\uB4F0\uB4F2", 5, "\uB4F9", 26, "\uB516\uB517\uB519\uB51A\uB51D"], + ["8b41", "\uB51E", 5, "\uB526\uB52B", 4, "\uB532\uB533\uB535\uB536\uB537\uB539", 6, "\uB542\uB546"], + ["8b61", "\uB547\uB548\uB549\uB54A\uB54E\uB54F\uB551\uB552\uB553\uB555", 6, "\uB55E\uB562", 8], + ["8b81", "\uB56B", 52, "\uB5A2\uB5A3\uB5A5\uB5A6\uB5A7\uB5A9\uB5AC\uB5AD\uB5AE\uB5AF\uB5B2\uB5B6", 4, "\uB5BE\uB5BF\uB5C1\uB5C2\uB5C3\uB5C5", 6, "\uB5CE\uB5D2", 5, "\uB5D9", 18, "\uB5ED", 18], + ["8c41", "\uB600", 15, "\uB612\uB613\uB615\uB616\uB617\uB619", 4], + ["8c61", "\uB61E", 6, "\uB626", 5, "\uB62D", 6, "\uB635", 5], + ["8c81", "\uB63B", 12, "\uB649", 26, "\uB665\uB666\uB667\uB669", 50, "\uB69E\uB69F\uB6A1\uB6A2\uB6A3\uB6A5", 5, "\uB6AD\uB6AE\uB6AF\uB6B0\uB6B2", 16], + ["8d41", "\uB6C3", 16, "\uB6D5", 8], + ["8d61", "\uB6DE", 17, "\uB6F1\uB6F2\uB6F3\uB6F5\uB6F6\uB6F7\uB6F9\uB6FA"], + ["8d81", "\uB6FB", 4, "\uB702\uB703\uB704\uB706", 33, "\uB72A\uB72B\uB72D\uB72E\uB731", 6, "\uB73A\uB73C", 7, "\uB745\uB746\uB747\uB749\uB74A\uB74B\uB74D", 6, "\uB756", 9, "\uB761\uB762\uB763\uB765\uB766\uB767\uB769", 6, "\uB772\uB774\uB776", 5, "\uB77E\uB77F\uB781\uB782\uB783\uB785", 6, "\uB78E\uB793\uB794\uB795\uB79A\uB79B\uB79D\uB79E"], + ["8e41", "\uB79F\uB7A1", 6, "\uB7AA\uB7AE", 5, "\uB7B6\uB7B7\uB7B9", 8], + ["8e61", "\uB7C2", 4, "\uB7C8\uB7CA", 19], + ["8e81", "\uB7DE", 13, "\uB7EE\uB7EF\uB7F1\uB7F2\uB7F3\uB7F5", 6, "\uB7FE\uB802", 4, "\uB80A\uB80B\uB80D\uB80E\uB80F\uB811", 6, "\uB81A\uB81C\uB81E", 5, "\uB826\uB827\uB829\uB82A\uB82B\uB82D", 6, "\uB836\uB83A", 5, "\uB841\uB842\uB843\uB845", 11, "\uB852\uB854", 7, "\uB85E\uB85F\uB861\uB862\uB863\uB865", 6, "\uB86E\uB870\uB872", 5, "\uB879\uB87A\uB87B\uB87D", 7], + ["8f41", "\uB885", 7, "\uB88E", 17], + ["8f61", "\uB8A0", 7, "\uB8A9", 6, "\uB8B1\uB8B2\uB8B3\uB8B5\uB8B6\uB8B7\uB8B9", 4], + ["8f81", "\uB8BE\uB8BF\uB8C2\uB8C4\uB8C6", 5, "\uB8CD\uB8CE\uB8CF\uB8D1\uB8D2\uB8D3\uB8D5", 7, "\uB8DE\uB8E0\uB8E2", 5, "\uB8EA\uB8EB\uB8ED\uB8EE\uB8EF\uB8F1", 6, "\uB8FA\uB8FC\uB8FE", 5, "\uB905", 18, "\uB919", 6, "\uB921", 26, "\uB93E\uB93F\uB941\uB942\uB943\uB945", 6, "\uB94D\uB94E\uB950\uB952", 5], + ["9041", "\uB95A\uB95B\uB95D\uB95E\uB95F\uB961", 6, "\uB96A\uB96C\uB96E", 5, "\uB976\uB977\uB979\uB97A\uB97B\uB97D"], + ["9061", "\uB97E", 5, "\uB986\uB988\uB98B\uB98C\uB98F", 15], + ["9081", "\uB99F", 12, "\uB9AE\uB9AF\uB9B1\uB9B2\uB9B3\uB9B5", 6, "\uB9BE\uB9C0\uB9C2", 5, "\uB9CA\uB9CB\uB9CD\uB9D3", 4, "\uB9DA\uB9DC\uB9DF\uB9E0\uB9E2\uB9E6\uB9E7\uB9E9\uB9EA\uB9EB\uB9ED", 6, "\uB9F6\uB9FB", 4, "\uBA02", 5, "\uBA09", 11, "\uBA16", 33, "\uBA3A\uBA3B\uBA3D\uBA3E\uBA3F\uBA41\uBA43\uBA44\uBA45\uBA46"], + ["9141", "\uBA47\uBA4A\uBA4C\uBA4F\uBA50\uBA51\uBA52\uBA56\uBA57\uBA59\uBA5A\uBA5B\uBA5D", 6, "\uBA66\uBA6A", 5], + ["9161", "\uBA72\uBA73\uBA75\uBA76\uBA77\uBA79", 9, "\uBA86\uBA88\uBA89\uBA8A\uBA8B\uBA8D", 5], + ["9181", "\uBA93", 20, "\uBAAA\uBAAD\uBAAE\uBAAF\uBAB1\uBAB3", 4, "\uBABA\uBABC\uBABE", 5, "\uBAC5\uBAC6\uBAC7\uBAC9", 14, "\uBADA", 33, "\uBAFD\uBAFE\uBAFF\uBB01\uBB02\uBB03\uBB05", 7, "\uBB0E\uBB10\uBB12", 5, "\uBB19\uBB1A\uBB1B\uBB1D\uBB1E\uBB1F\uBB21", 6], + ["9241", "\uBB28\uBB2A\uBB2C", 7, "\uBB37\uBB39\uBB3A\uBB3F", 4, "\uBB46\uBB48\uBB4A\uBB4B\uBB4C\uBB4E\uBB51\uBB52"], + ["9261", "\uBB53\uBB55\uBB56\uBB57\uBB59", 7, "\uBB62\uBB64", 7, "\uBB6D", 4], + ["9281", "\uBB72", 21, "\uBB89\uBB8A\uBB8B\uBB8D\uBB8E\uBB8F\uBB91", 18, "\uBBA5\uBBA6\uBBA7\uBBA9\uBBAA\uBBAB\uBBAD", 6, "\uBBB5\uBBB6\uBBB8", 7, "\uBBC1\uBBC2\uBBC3\uBBC5\uBBC6\uBBC7\uBBC9", 6, "\uBBD1\uBBD2\uBBD4", 35, "\uBBFA\uBBFB\uBBFD\uBBFE\uBC01"], + ["9341", "\uBC03", 4, "\uBC0A\uBC0E\uBC10\uBC12\uBC13\uBC19\uBC1A\uBC20\uBC21\uBC22\uBC23\uBC26\uBC28\uBC2A\uBC2B\uBC2C\uBC2E\uBC2F\uBC32\uBC33\uBC35"], + ["9361", "\uBC36\uBC37\uBC39", 6, "\uBC42\uBC46\uBC47\uBC48\uBC4A\uBC4B\uBC4E\uBC4F\uBC51", 8], + ["9381", "\uBC5A\uBC5B\uBC5C\uBC5E", 37, "\uBC86\uBC87\uBC89\uBC8A\uBC8D\uBC8F", 4, "\uBC96\uBC98\uBC9B", 4, "\uBCA2\uBCA3\uBCA5\uBCA6\uBCA9", 6, "\uBCB2\uBCB6", 5, "\uBCBE\uBCBF\uBCC1\uBCC2\uBCC3\uBCC5", 7, "\uBCCE\uBCD2\uBCD3\uBCD4\uBCD6\uBCD7\uBCD9\uBCDA\uBCDB\uBCDD", 22, "\uBCF7\uBCF9\uBCFA\uBCFB\uBCFD"], + ["9441", "\uBCFE", 5, "\uBD06\uBD08\uBD0A", 5, "\uBD11\uBD12\uBD13\uBD15", 8], + ["9461", "\uBD1E", 5, "\uBD25", 6, "\uBD2D", 12], + ["9481", "\uBD3A", 5, "\uBD41", 6, "\uBD4A\uBD4B\uBD4D\uBD4E\uBD4F\uBD51", 6, "\uBD5A", 9, "\uBD65\uBD66\uBD67\uBD69", 22, "\uBD82\uBD83\uBD85\uBD86\uBD8B", 4, "\uBD92\uBD94\uBD96\uBD97\uBD98\uBD9B\uBD9D", 6, "\uBDA5", 10, "\uBDB1", 6, "\uBDB9", 24], + ["9541", "\uBDD2\uBDD3\uBDD6\uBDD7\uBDD9\uBDDA\uBDDB\uBDDD", 11, "\uBDEA", 5, "\uBDF1"], + ["9561", "\uBDF2\uBDF3\uBDF5\uBDF6\uBDF7\uBDF9", 6, "\uBE01\uBE02\uBE04\uBE06", 5, "\uBE0E\uBE0F\uBE11\uBE12\uBE13"], + ["9581", "\uBE15", 6, "\uBE1E\uBE20", 35, "\uBE46\uBE47\uBE49\uBE4A\uBE4B\uBE4D\uBE4F", 4, "\uBE56\uBE58\uBE5C\uBE5D\uBE5E\uBE5F\uBE62\uBE63\uBE65\uBE66\uBE67\uBE69\uBE6B", 4, "\uBE72\uBE76", 4, "\uBE7E\uBE7F\uBE81\uBE82\uBE83\uBE85", 6, "\uBE8E\uBE92", 5, "\uBE9A", 13, "\uBEA9", 14], + ["9641", "\uBEB8", 23, "\uBED2\uBED3"], + ["9661", "\uBED5\uBED6\uBED9", 6, "\uBEE1\uBEE2\uBEE6", 5, "\uBEED", 8], + ["9681", "\uBEF6", 10, "\uBF02", 5, "\uBF0A", 13, "\uBF1A\uBF1E", 33, "\uBF42\uBF43\uBF45\uBF46\uBF47\uBF49", 6, "\uBF52\uBF53\uBF54\uBF56", 44], + ["9741", "\uBF83", 16, "\uBF95", 8], + ["9761", "\uBF9E", 17, "\uBFB1", 7], + ["9781", "\uBFB9", 11, "\uBFC6", 5, "\uBFCE\uBFCF\uBFD1\uBFD2\uBFD3\uBFD5", 6, "\uBFDD\uBFDE\uBFE0\uBFE2", 89, "\uC03D\uC03E\uC03F"], + ["9841", "\uC040", 16, "\uC052", 5, "\uC059\uC05A\uC05B"], + ["9861", "\uC05D\uC05E\uC05F\uC061", 6, "\uC06A", 15], + ["9881", "\uC07A", 21, "\uC092\uC093\uC095\uC096\uC097\uC099", 6, "\uC0A2\uC0A4\uC0A6", 5, "\uC0AE\uC0B1\uC0B2\uC0B7", 4, "\uC0BE\uC0C2\uC0C3\uC0C4\uC0C6\uC0C7\uC0CA\uC0CB\uC0CD\uC0CE\uC0CF\uC0D1", 6, "\uC0DA\uC0DE", 5, "\uC0E6\uC0E7\uC0E9\uC0EA\uC0EB\uC0ED", 6, "\uC0F6\uC0F8\uC0FA", 5, "\uC101\uC102\uC103\uC105\uC106\uC107\uC109", 6, "\uC111\uC112\uC113\uC114\uC116", 5, "\uC121\uC122\uC125\uC128\uC129\uC12A\uC12B\uC12E"], + ["9941", "\uC132\uC133\uC134\uC135\uC137\uC13A\uC13B\uC13D\uC13E\uC13F\uC141", 6, "\uC14A\uC14E", 5, "\uC156\uC157"], + ["9961", "\uC159\uC15A\uC15B\uC15D", 6, "\uC166\uC16A", 5, "\uC171\uC172\uC173\uC175\uC176\uC177\uC179\uC17A\uC17B"], + ["9981", "\uC17C", 8, "\uC186", 5, "\uC18F\uC191\uC192\uC193\uC195\uC197", 4, "\uC19E\uC1A0\uC1A2\uC1A3\uC1A4\uC1A6\uC1A7\uC1AA\uC1AB\uC1AD\uC1AE\uC1AF\uC1B1", 11, "\uC1BE", 5, "\uC1C5\uC1C6\uC1C7\uC1C9\uC1CA\uC1CB\uC1CD", 6, "\uC1D5\uC1D6\uC1D9", 6, "\uC1E1\uC1E2\uC1E3\uC1E5\uC1E6\uC1E7\uC1E9", 6, "\uC1F2\uC1F4", 7, "\uC1FE\uC1FF\uC201\uC202\uC203\uC205", 6, "\uC20E\uC210\uC212", 5, "\uC21A\uC21B\uC21D\uC21E\uC221\uC222\uC223"], + ["9a41", "\uC224\uC225\uC226\uC227\uC22A\uC22C\uC22E\uC230\uC233\uC235", 16], + ["9a61", "\uC246\uC247\uC249", 6, "\uC252\uC253\uC255\uC256\uC257\uC259", 6, "\uC261\uC262\uC263\uC264\uC266"], + ["9a81", "\uC267", 4, "\uC26E\uC26F\uC271\uC272\uC273\uC275", 6, "\uC27E\uC280\uC282", 5, "\uC28A", 5, "\uC291", 6, "\uC299\uC29A\uC29C\uC29E", 5, "\uC2A6\uC2A7\uC2A9\uC2AA\uC2AB\uC2AE", 5, "\uC2B6\uC2B8\uC2BA", 33, "\uC2DE\uC2DF\uC2E1\uC2E2\uC2E5", 5, "\uC2EE\uC2F0\uC2F2\uC2F3\uC2F4\uC2F5\uC2F7\uC2FA\uC2FD\uC2FE\uC2FF\uC301", 6, "\uC30A\uC30B\uC30E\uC30F"], + ["9b41", "\uC310\uC311\uC312\uC316\uC317\uC319\uC31A\uC31B\uC31D", 6, "\uC326\uC327\uC32A", 8], + ["9b61", "\uC333", 17, "\uC346", 7], + ["9b81", "\uC34E", 25, "\uC36A\uC36B\uC36D\uC36E\uC36F\uC371\uC373", 4, "\uC37A\uC37B\uC37E", 5, "\uC385\uC386\uC387\uC389\uC38A\uC38B\uC38D", 50, "\uC3C1", 22, "\uC3DA"], + ["9c41", "\uC3DB\uC3DD\uC3DE\uC3E1\uC3E3", 4, "\uC3EA\uC3EB\uC3EC\uC3EE", 5, "\uC3F6\uC3F7\uC3F9", 5], + ["9c61", "\uC3FF", 8, "\uC409", 6, "\uC411", 9], + ["9c81", "\uC41B", 8, "\uC425", 6, "\uC42D\uC42E\uC42F\uC431\uC432\uC433\uC435", 6, "\uC43E", 9, "\uC449", 26, "\uC466\uC467\uC469\uC46A\uC46B\uC46D", 6, "\uC476\uC477\uC478\uC47A", 5, "\uC481", 18, "\uC495", 6, "\uC49D", 12], + ["9d41", "\uC4AA", 13, "\uC4B9\uC4BA\uC4BB\uC4BD", 8], + ["9d61", "\uC4C6", 25], + ["9d81", "\uC4E0", 8, "\uC4EA", 5, "\uC4F2\uC4F3\uC4F5\uC4F6\uC4F7\uC4F9\uC4FB\uC4FC\uC4FD\uC4FE\uC502", 9, "\uC50D\uC50E\uC50F\uC511\uC512\uC513\uC515", 6, "\uC51D", 10, "\uC52A\uC52B\uC52D\uC52E\uC52F\uC531", 6, "\uC53A\uC53C\uC53E", 5, "\uC546\uC547\uC54B\uC54F\uC550\uC551\uC552\uC556\uC55A\uC55B\uC55C\uC55F\uC562\uC563\uC565\uC566\uC567\uC569", 6, "\uC572\uC576", 5, "\uC57E\uC57F\uC581\uC582\uC583\uC585\uC586\uC588\uC589\uC58A\uC58B\uC58E\uC590\uC592\uC593\uC594"], + ["9e41", "\uC596\uC599\uC59A\uC59B\uC59D\uC59E\uC59F\uC5A1", 7, "\uC5AA", 9, "\uC5B6"], + ["9e61", "\uC5B7\uC5BA\uC5BF", 4, "\uC5CB\uC5CD\uC5CF\uC5D2\uC5D3\uC5D5\uC5D6\uC5D7\uC5D9", 6, "\uC5E2\uC5E4\uC5E6\uC5E7"], + ["9e81", "\uC5E8\uC5E9\uC5EA\uC5EB\uC5EF\uC5F1\uC5F2\uC5F3\uC5F5\uC5F8\uC5F9\uC5FA\uC5FB\uC602\uC603\uC604\uC609\uC60A\uC60B\uC60D\uC60E\uC60F\uC611", 6, "\uC61A\uC61D", 6, "\uC626\uC627\uC629\uC62A\uC62B\uC62F\uC631\uC632\uC636\uC638\uC63A\uC63C\uC63D\uC63E\uC63F\uC642\uC643\uC645\uC646\uC647\uC649", 6, "\uC652\uC656", 5, "\uC65E\uC65F\uC661", 10, "\uC66D\uC66E\uC670\uC672", 5, "\uC67A\uC67B\uC67D\uC67E\uC67F\uC681", 6, "\uC68A\uC68C\uC68E", 5, "\uC696\uC697\uC699\uC69A\uC69B\uC69D", 6, "\uC6A6"], + ["9f41", "\uC6A8\uC6AA", 5, "\uC6B2\uC6B3\uC6B5\uC6B6\uC6B7\uC6BB", 4, "\uC6C2\uC6C4\uC6C6", 5, "\uC6CE"], + ["9f61", "\uC6CF\uC6D1\uC6D2\uC6D3\uC6D5", 6, "\uC6DE\uC6DF\uC6E2", 5, "\uC6EA\uC6EB\uC6ED\uC6EE\uC6EF\uC6F1\uC6F2"], + ["9f81", "\uC6F3", 4, "\uC6FA\uC6FB\uC6FC\uC6FE", 5, "\uC706\uC707\uC709\uC70A\uC70B\uC70D", 6, "\uC716\uC718\uC71A", 5, "\uC722\uC723\uC725\uC726\uC727\uC729", 6, "\uC732\uC734\uC736\uC738\uC739\uC73A\uC73B\uC73E\uC73F\uC741\uC742\uC743\uC745", 4, "\uC74B\uC74E\uC750\uC759\uC75A\uC75B\uC75D\uC75E\uC75F\uC761", 6, "\uC769\uC76A\uC76C", 7, "\uC776\uC777\uC779\uC77A\uC77B\uC77F\uC780\uC781\uC782\uC786\uC78B\uC78C\uC78D\uC78F\uC792\uC793\uC795\uC799\uC79B", 4, "\uC7A2\uC7A7", 4, "\uC7AE\uC7AF\uC7B1\uC7B2\uC7B3\uC7B5\uC7B6\uC7B7"], + ["a041", "\uC7B8\uC7B9\uC7BA\uC7BB\uC7BE\uC7C2", 5, "\uC7CA\uC7CB\uC7CD\uC7CF\uC7D1", 6, "\uC7D9\uC7DA\uC7DB\uC7DC"], + ["a061", "\uC7DE", 5, "\uC7E5\uC7E6\uC7E7\uC7E9\uC7EA\uC7EB\uC7ED", 13], + ["a081", "\uC7FB", 4, "\uC802\uC803\uC805\uC806\uC807\uC809\uC80B", 4, "\uC812\uC814\uC817", 4, "\uC81E\uC81F\uC821\uC822\uC823\uC825", 6, "\uC82E\uC830\uC832", 5, "\uC839\uC83A\uC83B\uC83D\uC83E\uC83F\uC841", 6, "\uC84A\uC84B\uC84E", 5, "\uC855", 26, "\uC872\uC873\uC875\uC876\uC877\uC879\uC87B", 4, "\uC882\uC884\uC888\uC889\uC88A\uC88E", 5, "\uC895", 7, "\uC89E\uC8A0\uC8A2\uC8A3\uC8A4"], + ["a141", "\uC8A5\uC8A6\uC8A7\uC8A9", 18, "\uC8BE\uC8BF\uC8C0\uC8C1"], + ["a161", "\uC8C2\uC8C3\uC8C5\uC8C6\uC8C7\uC8C9\uC8CA\uC8CB\uC8CD", 6, "\uC8D6\uC8D8\uC8DA", 5, "\uC8E2\uC8E3\uC8E5"], + ["a181", "\uC8E6", 14, "\uC8F6", 5, "\uC8FE\uC8FF\uC901\uC902\uC903\uC907", 4, "\uC90E\u3000\u3001\u3002\xB7\u2025\u2026\xA8\u3003\xAD\u2015\u2225\uFF3C\u223C\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 9, "\xB1\xD7\xF7\u2260\u2264\u2265\u221E\u2234\xB0\u2032\u2033\u2103\u212B\uFFE0\uFFE1\uFFE5\u2642\u2640\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\xA7\u203B\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u2192\u2190\u2191\u2193\u2194\u3013\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229\u2227\u2228\uFFE2"], + ["a241", "\uC910\uC912", 5, "\uC919", 18], + ["a261", "\uC92D", 6, "\uC935", 18], + ["a281", "\uC948", 7, "\uC952\uC953\uC955\uC956\uC957\uC959", 6, "\uC962\uC964", 7, "\uC96D\uC96E\uC96F\u21D2\u21D4\u2200\u2203\xB4\uFF5E\u02C7\u02D8\u02DD\u02DA\u02D9\xB8\u02DB\xA1\xBF\u02D0\u222E\u2211\u220F\xA4\u2109\u2030\u25C1\u25C0\u25B7\u25B6\u2664\u2660\u2661\u2665\u2667\u2663\u2299\u25C8\u25A3\u25D0\u25D1\u2592\u25A4\u25A5\u25A8\u25A7\u25A6\u25A9\u2668\u260F\u260E\u261C\u261E\xB6\u2020\u2021\u2195\u2197\u2199\u2196\u2198\u266D\u2669\u266A\u266C\u327F\u321C\u2116\u33C7\u2122\u33C2\u33D8\u2121\u20AC\xAE"], + ["a341", "\uC971\uC972\uC973\uC975", 6, "\uC97D", 10, "\uC98A\uC98B\uC98D\uC98E\uC98F"], + ["a361", "\uC991", 6, "\uC99A\uC99C\uC99E", 16], + ["a381", "\uC9AF", 16, "\uC9C2\uC9C3\uC9C5\uC9C6\uC9C9\uC9CB", 4, "\uC9D2\uC9D4\uC9D7\uC9D8\uC9DB\uFF01", 58, "\uFFE6\uFF3D", 32, "\uFFE3"], + ["a441", "\uC9DE\uC9DF\uC9E1\uC9E3\uC9E5\uC9E6\uC9E8\uC9E9\uC9EA\uC9EB\uC9EE\uC9F2", 5, "\uC9FA\uC9FB\uC9FD\uC9FE\uC9FF\uCA01\uCA02\uCA03\uCA04"], + ["a461", "\uCA05\uCA06\uCA07\uCA0A\uCA0E", 5, "\uCA15\uCA16\uCA17\uCA19", 12], + ["a481", "\uCA26\uCA27\uCA28\uCA2A", 28, "\u3131", 93], + ["a541", "\uCA47", 4, "\uCA4E\uCA4F\uCA51\uCA52\uCA53\uCA55", 6, "\uCA5E\uCA62", 5, "\uCA69\uCA6A"], + ["a561", "\uCA6B", 17, "\uCA7E", 5, "\uCA85\uCA86"], + ["a581", "\uCA87", 16, "\uCA99", 14, "\u2170", 9], + ["a5b0", "\u2160", 9], + ["a5c1", "\u0391", 16, "\u03A3", 6], + ["a5e1", "\u03B1", 16, "\u03C3", 6], + ["a641", "\uCAA8", 19, "\uCABE\uCABF\uCAC1\uCAC2\uCAC3\uCAC5"], + ["a661", "\uCAC6", 5, "\uCACE\uCAD0\uCAD2\uCAD4\uCAD5\uCAD6\uCAD7\uCADA", 5, "\uCAE1", 6], + ["a681", "\uCAE8\uCAE9\uCAEA\uCAEB\uCAED", 6, "\uCAF5", 18, "\uCB09\uCB0A\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542\u2512\u2511\u251A\u2519\u2516\u2515\u250E\u250D\u251E\u251F\u2521\u2522\u2526\u2527\u2529\u252A\u252D\u252E\u2531\u2532\u2535\u2536\u2539\u253A\u253D\u253E\u2540\u2541\u2543", 7], + ["a741", "\uCB0B", 4, "\uCB11\uCB12\uCB13\uCB15\uCB16\uCB17\uCB19", 6, "\uCB22", 7], + ["a761", "\uCB2A", 22, "\uCB42\uCB43\uCB44"], + ["a781", "\uCB45\uCB46\uCB47\uCB4A\uCB4B\uCB4D\uCB4E\uCB4F\uCB51", 6, "\uCB5A\uCB5B\uCB5C\uCB5E", 5, "\uCB65", 7, "\u3395\u3396\u3397\u2113\u3398\u33C4\u33A3\u33A4\u33A5\u33A6\u3399", 9, "\u33CA\u338D\u338E\u338F\u33CF\u3388\u3389\u33C8\u33A7\u33A8\u33B0", 9, "\u3380", 4, "\u33BA", 5, "\u3390", 4, "\u2126\u33C0\u33C1\u338A\u338B\u338C\u33D6\u33C5\u33AD\u33AE\u33AF\u33DB\u33A9\u33AA\u33AB\u33AC\u33DD\u33D0\u33D3\u33C3\u33C9\u33DC\u33C6"], + ["a841", "\uCB6D", 10, "\uCB7A", 14], + ["a861", "\uCB89", 18, "\uCB9D", 6], + ["a881", "\uCBA4", 19, "\uCBB9", 11, "\xC6\xD0\xAA\u0126"], + ["a8a6", "\u0132"], + ["a8a8", "\u013F\u0141\xD8\u0152\xBA\xDE\u0166\u014A"], + ["a8b1", "\u3260", 27, "\u24D0", 25, "\u2460", 14, "\xBD\u2153\u2154\xBC\xBE\u215B\u215C\u215D\u215E"], + ["a941", "\uCBC5", 14, "\uCBD5", 10], + ["a961", "\uCBE0\uCBE1\uCBE2\uCBE3\uCBE5\uCBE6\uCBE8\uCBEA", 18], + ["a981", "\uCBFD", 14, "\uCC0E\uCC0F\uCC11\uCC12\uCC13\uCC15", 6, "\uCC1E\uCC1F\uCC20\uCC23\uCC24\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0140\u0142\xF8\u0153\xDF\xFE\u0167\u014B\u0149\u3200", 27, "\u249C", 25, "\u2474", 14, "\xB9\xB2\xB3\u2074\u207F\u2081\u2082\u2083\u2084"], + ["aa41", "\uCC25\uCC26\uCC2A\uCC2B\uCC2D\uCC2F\uCC31", 6, "\uCC3A\uCC3F", 4, "\uCC46\uCC47\uCC49\uCC4A\uCC4B\uCC4D\uCC4E"], + ["aa61", "\uCC4F", 4, "\uCC56\uCC5A", 5, "\uCC61\uCC62\uCC63\uCC65\uCC67\uCC69", 6, "\uCC71\uCC72"], + ["aa81", "\uCC73\uCC74\uCC76", 29, "\u3041", 82], + ["ab41", "\uCC94\uCC95\uCC96\uCC97\uCC9A\uCC9B\uCC9D\uCC9E\uCC9F\uCCA1", 6, "\uCCAA\uCCAE", 5, "\uCCB6\uCCB7\uCCB9"], + ["ab61", "\uCCBA\uCCBB\uCCBD", 6, "\uCCC6\uCCC8\uCCCA", 5, "\uCCD1\uCCD2\uCCD3\uCCD5", 5], + ["ab81", "\uCCDB", 8, "\uCCE5", 6, "\uCCED\uCCEE\uCCEF\uCCF1", 12, "\u30A1", 85], + ["ac41", "\uCCFE\uCCFF\uCD00\uCD02", 5, "\uCD0A\uCD0B\uCD0D\uCD0E\uCD0F\uCD11", 6, "\uCD1A\uCD1C\uCD1E\uCD1F\uCD20"], + ["ac61", "\uCD21\uCD22\uCD23\uCD25\uCD26\uCD27\uCD29\uCD2A\uCD2B\uCD2D", 11, "\uCD3A", 4], + ["ac81", "\uCD3F", 28, "\uCD5D\uCD5E\uCD5F\u0410", 5, "\u0401\u0416", 25], + ["acd1", "\u0430", 5, "\u0451\u0436", 25], + ["ad41", "\uCD61\uCD62\uCD63\uCD65", 6, "\uCD6E\uCD70\uCD72", 5, "\uCD79", 7], + ["ad61", "\uCD81", 6, "\uCD89", 10, "\uCD96\uCD97\uCD99\uCD9A\uCD9B\uCD9D\uCD9E\uCD9F"], + ["ad81", "\uCDA0\uCDA1\uCDA2\uCDA3\uCDA6\uCDA8\uCDAA", 5, "\uCDB1", 18, "\uCDC5"], + ["ae41", "\uCDC6", 5, "\uCDCD\uCDCE\uCDCF\uCDD1", 16], + ["ae61", "\uCDE2", 5, "\uCDE9\uCDEA\uCDEB\uCDED\uCDEE\uCDEF\uCDF1", 6, "\uCDFA\uCDFC\uCDFE", 4], + ["ae81", "\uCE03\uCE05\uCE06\uCE07\uCE09\uCE0A\uCE0B\uCE0D", 6, "\uCE15\uCE16\uCE17\uCE18\uCE1A", 5, "\uCE22\uCE23\uCE25\uCE26\uCE27\uCE29\uCE2A\uCE2B"], + ["af41", "\uCE2C\uCE2D\uCE2E\uCE2F\uCE32\uCE34\uCE36", 19], + ["af61", "\uCE4A", 13, "\uCE5A\uCE5B\uCE5D\uCE5E\uCE62", 5, "\uCE6A\uCE6C"], + ["af81", "\uCE6E", 5, "\uCE76\uCE77\uCE79\uCE7A\uCE7B\uCE7D", 6, "\uCE86\uCE88\uCE8A", 5, "\uCE92\uCE93\uCE95\uCE96\uCE97\uCE99"], + ["b041", "\uCE9A", 5, "\uCEA2\uCEA6", 5, "\uCEAE", 12], + ["b061", "\uCEBB", 5, "\uCEC2", 19], + ["b081", "\uCED6", 13, "\uCEE6\uCEE7\uCEE9\uCEEA\uCEED", 6, "\uCEF6\uCEFA", 5, "\uAC00\uAC01\uAC04\uAC07\uAC08\uAC09\uAC0A\uAC10", 7, "\uAC19", 4, "\uAC20\uAC24\uAC2C\uAC2D\uAC2F\uAC30\uAC31\uAC38\uAC39\uAC3C\uAC40\uAC4B\uAC4D\uAC54\uAC58\uAC5C\uAC70\uAC71\uAC74\uAC77\uAC78\uAC7A\uAC80\uAC81\uAC83\uAC84\uAC85\uAC86\uAC89\uAC8A\uAC8B\uAC8C\uAC90\uAC94\uAC9C\uAC9D\uAC9F\uACA0\uACA1\uACA8\uACA9\uACAA\uACAC\uACAF\uACB0\uACB8\uACB9\uACBB\uACBC\uACBD\uACC1\uACC4\uACC8\uACCC\uACD5\uACD7\uACE0\uACE1\uACE4\uACE7\uACE8\uACEA\uACEC\uACEF\uACF0\uACF1\uACF3\uACF5\uACF6\uACFC\uACFD\uAD00\uAD04\uAD06"], + ["b141", "\uCF02\uCF03\uCF05\uCF06\uCF07\uCF09", 6, "\uCF12\uCF14\uCF16", 5, "\uCF1D\uCF1E\uCF1F\uCF21\uCF22\uCF23"], + ["b161", "\uCF25", 6, "\uCF2E\uCF32", 5, "\uCF39", 11], + ["b181", "\uCF45", 14, "\uCF56\uCF57\uCF59\uCF5A\uCF5B\uCF5D", 6, "\uCF66\uCF68\uCF6A\uCF6B\uCF6C\uAD0C\uAD0D\uAD0F\uAD11\uAD18\uAD1C\uAD20\uAD29\uAD2C\uAD2D\uAD34\uAD35\uAD38\uAD3C\uAD44\uAD45\uAD47\uAD49\uAD50\uAD54\uAD58\uAD61\uAD63\uAD6C\uAD6D\uAD70\uAD73\uAD74\uAD75\uAD76\uAD7B\uAD7C\uAD7D\uAD7F\uAD81\uAD82\uAD88\uAD89\uAD8C\uAD90\uAD9C\uAD9D\uADA4\uADB7\uADC0\uADC1\uADC4\uADC8\uADD0\uADD1\uADD3\uADDC\uADE0\uADE4\uADF8\uADF9\uADFC\uADFF\uAE00\uAE01\uAE08\uAE09\uAE0B\uAE0D\uAE14\uAE30\uAE31\uAE34\uAE37\uAE38\uAE3A\uAE40\uAE41\uAE43\uAE45\uAE46\uAE4A\uAE4C\uAE4D\uAE4E\uAE50\uAE54\uAE56\uAE5C\uAE5D\uAE5F\uAE60\uAE61\uAE65\uAE68\uAE69\uAE6C\uAE70\uAE78"], + ["b241", "\uCF6D\uCF6E\uCF6F\uCF72\uCF73\uCF75\uCF76\uCF77\uCF79", 6, "\uCF81\uCF82\uCF83\uCF84\uCF86", 5, "\uCF8D"], + ["b261", "\uCF8E", 18, "\uCFA2", 5, "\uCFA9"], + ["b281", "\uCFAA", 5, "\uCFB1", 18, "\uCFC5", 6, "\uAE79\uAE7B\uAE7C\uAE7D\uAE84\uAE85\uAE8C\uAEBC\uAEBD\uAEBE\uAEC0\uAEC4\uAECC\uAECD\uAECF\uAED0\uAED1\uAED8\uAED9\uAEDC\uAEE8\uAEEB\uAEED\uAEF4\uAEF8\uAEFC\uAF07\uAF08\uAF0D\uAF10\uAF2C\uAF2D\uAF30\uAF32\uAF34\uAF3C\uAF3D\uAF3F\uAF41\uAF42\uAF43\uAF48\uAF49\uAF50\uAF5C\uAF5D\uAF64\uAF65\uAF79\uAF80\uAF84\uAF88\uAF90\uAF91\uAF95\uAF9C\uAFB8\uAFB9\uAFBC\uAFC0\uAFC7\uAFC8\uAFC9\uAFCB\uAFCD\uAFCE\uAFD4\uAFDC\uAFE8\uAFE9\uAFF0\uAFF1\uAFF4\uAFF8\uB000\uB001\uB004\uB00C\uB010\uB014\uB01C\uB01D\uB028\uB044\uB045\uB048\uB04A\uB04C\uB04E\uB053\uB054\uB055\uB057\uB059"], + ["b341", "\uCFCC", 19, "\uCFE2\uCFE3\uCFE5\uCFE6\uCFE7\uCFE9"], + ["b361", "\uCFEA", 5, "\uCFF2\uCFF4\uCFF6", 5, "\uCFFD\uCFFE\uCFFF\uD001\uD002\uD003\uD005", 5], + ["b381", "\uD00B", 5, "\uD012", 5, "\uD019", 19, "\uB05D\uB07C\uB07D\uB080\uB084\uB08C\uB08D\uB08F\uB091\uB098\uB099\uB09A\uB09C\uB09F\uB0A0\uB0A1\uB0A2\uB0A8\uB0A9\uB0AB", 4, "\uB0B1\uB0B3\uB0B4\uB0B5\uB0B8\uB0BC\uB0C4\uB0C5\uB0C7\uB0C8\uB0C9\uB0D0\uB0D1\uB0D4\uB0D8\uB0E0\uB0E5\uB108\uB109\uB10B\uB10C\uB110\uB112\uB113\uB118\uB119\uB11B\uB11C\uB11D\uB123\uB124\uB125\uB128\uB12C\uB134\uB135\uB137\uB138\uB139\uB140\uB141\uB144\uB148\uB150\uB151\uB154\uB155\uB158\uB15C\uB160\uB178\uB179\uB17C\uB180\uB182\uB188\uB189\uB18B\uB18D\uB192\uB193\uB194\uB198\uB19C\uB1A8\uB1CC\uB1D0\uB1D4\uB1DC\uB1DD"], + ["b441", "\uD02E", 5, "\uD036\uD037\uD039\uD03A\uD03B\uD03D", 6, "\uD046\uD048\uD04A", 5], + ["b461", "\uD051\uD052\uD053\uD055\uD056\uD057\uD059", 6, "\uD061", 10, "\uD06E\uD06F"], + ["b481", "\uD071\uD072\uD073\uD075", 6, "\uD07E\uD07F\uD080\uD082", 18, "\uB1DF\uB1E8\uB1E9\uB1EC\uB1F0\uB1F9\uB1FB\uB1FD\uB204\uB205\uB208\uB20B\uB20C\uB214\uB215\uB217\uB219\uB220\uB234\uB23C\uB258\uB25C\uB260\uB268\uB269\uB274\uB275\uB27C\uB284\uB285\uB289\uB290\uB291\uB294\uB298\uB299\uB29A\uB2A0\uB2A1\uB2A3\uB2A5\uB2A6\uB2AA\uB2AC\uB2B0\uB2B4\uB2C8\uB2C9\uB2CC\uB2D0\uB2D2\uB2D8\uB2D9\uB2DB\uB2DD\uB2E2\uB2E4\uB2E5\uB2E6\uB2E8\uB2EB", 4, "\uB2F3\uB2F4\uB2F5\uB2F7", 4, "\uB2FF\uB300\uB301\uB304\uB308\uB310\uB311\uB313\uB314\uB315\uB31C\uB354\uB355\uB356\uB358\uB35B\uB35C\uB35E\uB35F\uB364\uB365"], + ["b541", "\uD095", 14, "\uD0A6\uD0A7\uD0A9\uD0AA\uD0AB\uD0AD", 5], + ["b561", "\uD0B3\uD0B6\uD0B8\uD0BA", 5, "\uD0C2\uD0C3\uD0C5\uD0C6\uD0C7\uD0CA", 5, "\uD0D2\uD0D6", 4], + ["b581", "\uD0DB\uD0DE\uD0DF\uD0E1\uD0E2\uD0E3\uD0E5", 6, "\uD0EE\uD0F2", 5, "\uD0F9", 11, "\uB367\uB369\uB36B\uB36E\uB370\uB371\uB374\uB378\uB380\uB381\uB383\uB384\uB385\uB38C\uB390\uB394\uB3A0\uB3A1\uB3A8\uB3AC\uB3C4\uB3C5\uB3C8\uB3CB\uB3CC\uB3CE\uB3D0\uB3D4\uB3D5\uB3D7\uB3D9\uB3DB\uB3DD\uB3E0\uB3E4\uB3E8\uB3FC\uB410\uB418\uB41C\uB420\uB428\uB429\uB42B\uB434\uB450\uB451\uB454\uB458\uB460\uB461\uB463\uB465\uB46C\uB480\uB488\uB49D\uB4A4\uB4A8\uB4AC\uB4B5\uB4B7\uB4B9\uB4C0\uB4C4\uB4C8\uB4D0\uB4D5\uB4DC\uB4DD\uB4E0\uB4E3\uB4E4\uB4E6\uB4EC\uB4ED\uB4EF\uB4F1\uB4F8\uB514\uB515\uB518\uB51B\uB51C\uB524\uB525\uB527\uB528\uB529\uB52A\uB530\uB531\uB534\uB538"], + ["b641", "\uD105", 7, "\uD10E", 17], + ["b661", "\uD120", 15, "\uD132\uD133\uD135\uD136\uD137\uD139\uD13B\uD13C\uD13D\uD13E"], + ["b681", "\uD13F\uD142\uD146", 5, "\uD14E\uD14F\uD151\uD152\uD153\uD155", 6, "\uD15E\uD160\uD162", 5, "\uD169\uD16A\uD16B\uD16D\uB540\uB541\uB543\uB544\uB545\uB54B\uB54C\uB54D\uB550\uB554\uB55C\uB55D\uB55F\uB560\uB561\uB5A0\uB5A1\uB5A4\uB5A8\uB5AA\uB5AB\uB5B0\uB5B1\uB5B3\uB5B4\uB5B5\uB5BB\uB5BC\uB5BD\uB5C0\uB5C4\uB5CC\uB5CD\uB5CF\uB5D0\uB5D1\uB5D8\uB5EC\uB610\uB611\uB614\uB618\uB625\uB62C\uB634\uB648\uB664\uB668\uB69C\uB69D\uB6A0\uB6A4\uB6AB\uB6AC\uB6B1\uB6D4\uB6F0\uB6F4\uB6F8\uB700\uB701\uB705\uB728\uB729\uB72C\uB72F\uB730\uB738\uB739\uB73B\uB744\uB748\uB74C\uB754\uB755\uB760\uB764\uB768\uB770\uB771\uB773\uB775\uB77C\uB77D\uB780\uB784\uB78C\uB78D\uB78F\uB790\uB791\uB792\uB796\uB797"], + ["b741", "\uD16E", 13, "\uD17D", 6, "\uD185\uD186\uD187\uD189\uD18A"], + ["b761", "\uD18B", 20, "\uD1A2\uD1A3\uD1A5\uD1A6\uD1A7"], + ["b781", "\uD1A9", 6, "\uD1B2\uD1B4\uD1B6\uD1B7\uD1B8\uD1B9\uD1BB\uD1BD\uD1BE\uD1BF\uD1C1", 14, "\uB798\uB799\uB79C\uB7A0\uB7A8\uB7A9\uB7AB\uB7AC\uB7AD\uB7B4\uB7B5\uB7B8\uB7C7\uB7C9\uB7EC\uB7ED\uB7F0\uB7F4\uB7FC\uB7FD\uB7FF\uB800\uB801\uB807\uB808\uB809\uB80C\uB810\uB818\uB819\uB81B\uB81D\uB824\uB825\uB828\uB82C\uB834\uB835\uB837\uB838\uB839\uB840\uB844\uB851\uB853\uB85C\uB85D\uB860\uB864\uB86C\uB86D\uB86F\uB871\uB878\uB87C\uB88D\uB8A8\uB8B0\uB8B4\uB8B8\uB8C0\uB8C1\uB8C3\uB8C5\uB8CC\uB8D0\uB8D4\uB8DD\uB8DF\uB8E1\uB8E8\uB8E9\uB8EC\uB8F0\uB8F8\uB8F9\uB8FB\uB8FD\uB904\uB918\uB920\uB93C\uB93D\uB940\uB944\uB94C\uB94F\uB951\uB958\uB959\uB95C\uB960\uB968\uB969"], + ["b841", "\uD1D0", 7, "\uD1D9", 17], + ["b861", "\uD1EB", 8, "\uD1F5\uD1F6\uD1F7\uD1F9", 13], + ["b881", "\uD208\uD20A", 5, "\uD211", 24, "\uB96B\uB96D\uB974\uB975\uB978\uB97C\uB984\uB985\uB987\uB989\uB98A\uB98D\uB98E\uB9AC\uB9AD\uB9B0\uB9B4\uB9BC\uB9BD\uB9BF\uB9C1\uB9C8\uB9C9\uB9CC\uB9CE", 4, "\uB9D8\uB9D9\uB9DB\uB9DD\uB9DE\uB9E1\uB9E3\uB9E4\uB9E5\uB9E8\uB9EC\uB9F4\uB9F5\uB9F7\uB9F8\uB9F9\uB9FA\uBA00\uBA01\uBA08\uBA15\uBA38\uBA39\uBA3C\uBA40\uBA42\uBA48\uBA49\uBA4B\uBA4D\uBA4E\uBA53\uBA54\uBA55\uBA58\uBA5C\uBA64\uBA65\uBA67\uBA68\uBA69\uBA70\uBA71\uBA74\uBA78\uBA83\uBA84\uBA85\uBA87\uBA8C\uBAA8\uBAA9\uBAAB\uBAAC\uBAB0\uBAB2\uBAB8\uBAB9\uBABB\uBABD\uBAC4\uBAC8\uBAD8\uBAD9\uBAFC"], + ["b941", "\uD22A\uD22B\uD22E\uD22F\uD231\uD232\uD233\uD235", 6, "\uD23E\uD240\uD242", 5, "\uD249\uD24A\uD24B\uD24C"], + ["b961", "\uD24D", 14, "\uD25D", 6, "\uD265\uD266\uD267\uD268"], + ["b981", "\uD269", 22, "\uD282\uD283\uD285\uD286\uD287\uD289\uD28A\uD28B\uD28C\uBB00\uBB04\uBB0D\uBB0F\uBB11\uBB18\uBB1C\uBB20\uBB29\uBB2B\uBB34\uBB35\uBB36\uBB38\uBB3B\uBB3C\uBB3D\uBB3E\uBB44\uBB45\uBB47\uBB49\uBB4D\uBB4F\uBB50\uBB54\uBB58\uBB61\uBB63\uBB6C\uBB88\uBB8C\uBB90\uBBA4\uBBA8\uBBAC\uBBB4\uBBB7\uBBC0\uBBC4\uBBC8\uBBD0\uBBD3\uBBF8\uBBF9\uBBFC\uBBFF\uBC00\uBC02\uBC08\uBC09\uBC0B\uBC0C\uBC0D\uBC0F\uBC11\uBC14", 4, "\uBC1B", 4, "\uBC24\uBC25\uBC27\uBC29\uBC2D\uBC30\uBC31\uBC34\uBC38\uBC40\uBC41\uBC43\uBC44\uBC45\uBC49\uBC4C\uBC4D\uBC50\uBC5D\uBC84\uBC85\uBC88\uBC8B\uBC8C\uBC8E\uBC94\uBC95\uBC97"], + ["ba41", "\uD28D\uD28E\uD28F\uD292\uD293\uD294\uD296", 5, "\uD29D\uD29E\uD29F\uD2A1\uD2A2\uD2A3\uD2A5", 6, "\uD2AD"], + ["ba61", "\uD2AE\uD2AF\uD2B0\uD2B2", 5, "\uD2BA\uD2BB\uD2BD\uD2BE\uD2C1\uD2C3", 4, "\uD2CA\uD2CC", 5], + ["ba81", "\uD2D2\uD2D3\uD2D5\uD2D6\uD2D7\uD2D9\uD2DA\uD2DB\uD2DD", 6, "\uD2E6", 9, "\uD2F2\uD2F3\uD2F5\uD2F6\uD2F7\uD2F9\uD2FA\uBC99\uBC9A\uBCA0\uBCA1\uBCA4\uBCA7\uBCA8\uBCB0\uBCB1\uBCB3\uBCB4\uBCB5\uBCBC\uBCBD\uBCC0\uBCC4\uBCCD\uBCCF\uBCD0\uBCD1\uBCD5\uBCD8\uBCDC\uBCF4\uBCF5\uBCF6\uBCF8\uBCFC\uBD04\uBD05\uBD07\uBD09\uBD10\uBD14\uBD24\uBD2C\uBD40\uBD48\uBD49\uBD4C\uBD50\uBD58\uBD59\uBD64\uBD68\uBD80\uBD81\uBD84\uBD87\uBD88\uBD89\uBD8A\uBD90\uBD91\uBD93\uBD95\uBD99\uBD9A\uBD9C\uBDA4\uBDB0\uBDB8\uBDD4\uBDD5\uBDD8\uBDDC\uBDE9\uBDF0\uBDF4\uBDF8\uBE00\uBE03\uBE05\uBE0C\uBE0D\uBE10\uBE14\uBE1C\uBE1D\uBE1F\uBE44\uBE45\uBE48\uBE4C\uBE4E\uBE54\uBE55\uBE57\uBE59\uBE5A\uBE5B\uBE60\uBE61\uBE64"], + ["bb41", "\uD2FB", 4, "\uD302\uD304\uD306", 5, "\uD30F\uD311\uD312\uD313\uD315\uD317", 4, "\uD31E\uD322\uD323"], + ["bb61", "\uD324\uD326\uD327\uD32A\uD32B\uD32D\uD32E\uD32F\uD331", 6, "\uD33A\uD33E", 5, "\uD346\uD347\uD348\uD349"], + ["bb81", "\uD34A", 31, "\uBE68\uBE6A\uBE70\uBE71\uBE73\uBE74\uBE75\uBE7B\uBE7C\uBE7D\uBE80\uBE84\uBE8C\uBE8D\uBE8F\uBE90\uBE91\uBE98\uBE99\uBEA8\uBED0\uBED1\uBED4\uBED7\uBED8\uBEE0\uBEE3\uBEE4\uBEE5\uBEEC\uBF01\uBF08\uBF09\uBF18\uBF19\uBF1B\uBF1C\uBF1D\uBF40\uBF41\uBF44\uBF48\uBF50\uBF51\uBF55\uBF94\uBFB0\uBFC5\uBFCC\uBFCD\uBFD0\uBFD4\uBFDC\uBFDF\uBFE1\uC03C\uC051\uC058\uC05C\uC060\uC068\uC069\uC090\uC091\uC094\uC098\uC0A0\uC0A1\uC0A3\uC0A5\uC0AC\uC0AD\uC0AF\uC0B0\uC0B3\uC0B4\uC0B5\uC0B6\uC0BC\uC0BD\uC0BF\uC0C0\uC0C1\uC0C5\uC0C8\uC0C9\uC0CC\uC0D0\uC0D8\uC0D9\uC0DB\uC0DC\uC0DD\uC0E4"], + ["bc41", "\uD36A", 17, "\uD37E\uD37F\uD381\uD382\uD383\uD385\uD386\uD387"], + ["bc61", "\uD388\uD389\uD38A\uD38B\uD38E\uD392", 5, "\uD39A\uD39B\uD39D\uD39E\uD39F\uD3A1", 6, "\uD3AA\uD3AC\uD3AE"], + ["bc81", "\uD3AF", 4, "\uD3B5\uD3B6\uD3B7\uD3B9\uD3BA\uD3BB\uD3BD", 6, "\uD3C6\uD3C7\uD3CA", 5, "\uD3D1", 5, "\uC0E5\uC0E8\uC0EC\uC0F4\uC0F5\uC0F7\uC0F9\uC100\uC104\uC108\uC110\uC115\uC11C", 4, "\uC123\uC124\uC126\uC127\uC12C\uC12D\uC12F\uC130\uC131\uC136\uC138\uC139\uC13C\uC140\uC148\uC149\uC14B\uC14C\uC14D\uC154\uC155\uC158\uC15C\uC164\uC165\uC167\uC168\uC169\uC170\uC174\uC178\uC185\uC18C\uC18D\uC18E\uC190\uC194\uC196\uC19C\uC19D\uC19F\uC1A1\uC1A5\uC1A8\uC1A9\uC1AC\uC1B0\uC1BD\uC1C4\uC1C8\uC1CC\uC1D4\uC1D7\uC1D8\uC1E0\uC1E4\uC1E8\uC1F0\uC1F1\uC1F3\uC1FC\uC1FD\uC200\uC204\uC20C\uC20D\uC20F\uC211\uC218\uC219\uC21C\uC21F\uC220\uC228\uC229\uC22B\uC22D"], + ["bd41", "\uD3D7\uD3D9", 7, "\uD3E2\uD3E4", 7, "\uD3EE\uD3EF\uD3F1\uD3F2\uD3F3\uD3F5\uD3F6\uD3F7"], + ["bd61", "\uD3F8\uD3F9\uD3FA\uD3FB\uD3FE\uD400\uD402", 5, "\uD409", 13], + ["bd81", "\uD417", 5, "\uD41E", 25, "\uC22F\uC231\uC232\uC234\uC248\uC250\uC251\uC254\uC258\uC260\uC265\uC26C\uC26D\uC270\uC274\uC27C\uC27D\uC27F\uC281\uC288\uC289\uC290\uC298\uC29B\uC29D\uC2A4\uC2A5\uC2A8\uC2AC\uC2AD\uC2B4\uC2B5\uC2B7\uC2B9\uC2DC\uC2DD\uC2E0\uC2E3\uC2E4\uC2EB\uC2EC\uC2ED\uC2EF\uC2F1\uC2F6\uC2F8\uC2F9\uC2FB\uC2FC\uC300\uC308\uC309\uC30C\uC30D\uC313\uC314\uC315\uC318\uC31C\uC324\uC325\uC328\uC329\uC345\uC368\uC369\uC36C\uC370\uC372\uC378\uC379\uC37C\uC37D\uC384\uC388\uC38C\uC3C0\uC3D8\uC3D9\uC3DC\uC3DF\uC3E0\uC3E2\uC3E8\uC3E9\uC3ED\uC3F4\uC3F5\uC3F8\uC408\uC410\uC424\uC42C\uC430"], + ["be41", "\uD438", 7, "\uD441\uD442\uD443\uD445", 14], + ["be61", "\uD454", 7, "\uD45D\uD45E\uD45F\uD461\uD462\uD463\uD465", 7, "\uD46E\uD470\uD471\uD472"], + ["be81", "\uD473", 4, "\uD47A\uD47B\uD47D\uD47E\uD481\uD483", 4, "\uD48A\uD48C\uD48E", 5, "\uD495", 8, "\uC434\uC43C\uC43D\uC448\uC464\uC465\uC468\uC46C\uC474\uC475\uC479\uC480\uC494\uC49C\uC4B8\uC4BC\uC4E9\uC4F0\uC4F1\uC4F4\uC4F8\uC4FA\uC4FF\uC500\uC501\uC50C\uC510\uC514\uC51C\uC528\uC529\uC52C\uC530\uC538\uC539\uC53B\uC53D\uC544\uC545\uC548\uC549\uC54A\uC54C\uC54D\uC54E\uC553\uC554\uC555\uC557\uC558\uC559\uC55D\uC55E\uC560\uC561\uC564\uC568\uC570\uC571\uC573\uC574\uC575\uC57C\uC57D\uC580\uC584\uC587\uC58C\uC58D\uC58F\uC591\uC595\uC597\uC598\uC59C\uC5A0\uC5A9\uC5B4\uC5B5\uC5B8\uC5B9\uC5BB\uC5BC\uC5BD\uC5BE\uC5C4", 6, "\uC5CC\uC5CE"], + ["bf41", "\uD49E", 10, "\uD4AA", 14], + ["bf61", "\uD4B9", 18, "\uD4CD\uD4CE\uD4CF\uD4D1\uD4D2\uD4D3\uD4D5"], + ["bf81", "\uD4D6", 5, "\uD4DD\uD4DE\uD4E0", 7, "\uD4E9\uD4EA\uD4EB\uD4ED\uD4EE\uD4EF\uD4F1", 6, "\uD4F9\uD4FA\uD4FC\uC5D0\uC5D1\uC5D4\uC5D8\uC5E0\uC5E1\uC5E3\uC5E5\uC5EC\uC5ED\uC5EE\uC5F0\uC5F4\uC5F6\uC5F7\uC5FC", 5, "\uC605\uC606\uC607\uC608\uC60C\uC610\uC618\uC619\uC61B\uC61C\uC624\uC625\uC628\uC62C\uC62D\uC62E\uC630\uC633\uC634\uC635\uC637\uC639\uC63B\uC640\uC641\uC644\uC648\uC650\uC651\uC653\uC654\uC655\uC65C\uC65D\uC660\uC66C\uC66F\uC671\uC678\uC679\uC67C\uC680\uC688\uC689\uC68B\uC68D\uC694\uC695\uC698\uC69C\uC6A4\uC6A5\uC6A7\uC6A9\uC6B0\uC6B1\uC6B4\uC6B8\uC6B9\uC6BA\uC6C0\uC6C1\uC6C3\uC6C5\uC6CC\uC6CD\uC6D0\uC6D4\uC6DC\uC6DD\uC6E0\uC6E1\uC6E8"], + ["c041", "\uD4FE", 5, "\uD505\uD506\uD507\uD509\uD50A\uD50B\uD50D", 6, "\uD516\uD518", 5], + ["c061", "\uD51E", 25], + ["c081", "\uD538\uD539\uD53A\uD53B\uD53E\uD53F\uD541\uD542\uD543\uD545", 6, "\uD54E\uD550\uD552", 5, "\uD55A\uD55B\uD55D\uD55E\uD55F\uD561\uD562\uD563\uC6E9\uC6EC\uC6F0\uC6F8\uC6F9\uC6FD\uC704\uC705\uC708\uC70C\uC714\uC715\uC717\uC719\uC720\uC721\uC724\uC728\uC730\uC731\uC733\uC735\uC737\uC73C\uC73D\uC740\uC744\uC74A\uC74C\uC74D\uC74F\uC751", 7, "\uC75C\uC760\uC768\uC76B\uC774\uC775\uC778\uC77C\uC77D\uC77E\uC783\uC784\uC785\uC787\uC788\uC789\uC78A\uC78E\uC790\uC791\uC794\uC796\uC797\uC798\uC79A\uC7A0\uC7A1\uC7A3\uC7A4\uC7A5\uC7A6\uC7AC\uC7AD\uC7B0\uC7B4\uC7BC\uC7BD\uC7BF\uC7C0\uC7C1\uC7C8\uC7C9\uC7CC\uC7CE\uC7D0\uC7D8\uC7DD\uC7E4\uC7E8\uC7EC\uC800\uC801\uC804\uC808\uC80A"], + ["c141", "\uD564\uD566\uD567\uD56A\uD56C\uD56E", 5, "\uD576\uD577\uD579\uD57A\uD57B\uD57D", 6, "\uD586\uD58A\uD58B"], + ["c161", "\uD58C\uD58D\uD58E\uD58F\uD591", 19, "\uD5A6\uD5A7"], + ["c181", "\uD5A8", 31, "\uC810\uC811\uC813\uC815\uC816\uC81C\uC81D\uC820\uC824\uC82C\uC82D\uC82F\uC831\uC838\uC83C\uC840\uC848\uC849\uC84C\uC84D\uC854\uC870\uC871\uC874\uC878\uC87A\uC880\uC881\uC883\uC885\uC886\uC887\uC88B\uC88C\uC88D\uC894\uC89D\uC89F\uC8A1\uC8A8\uC8BC\uC8BD\uC8C4\uC8C8\uC8CC\uC8D4\uC8D5\uC8D7\uC8D9\uC8E0\uC8E1\uC8E4\uC8F5\uC8FC\uC8FD\uC900\uC904\uC905\uC906\uC90C\uC90D\uC90F\uC911\uC918\uC92C\uC934\uC950\uC951\uC954\uC958\uC960\uC961\uC963\uC96C\uC970\uC974\uC97C\uC988\uC989\uC98C\uC990\uC998\uC999\uC99B\uC99D\uC9C0\uC9C1\uC9C4\uC9C7\uC9C8\uC9CA\uC9D0\uC9D1\uC9D3"], + ["c241", "\uD5CA\uD5CB\uD5CD\uD5CE\uD5CF\uD5D1\uD5D3", 4, "\uD5DA\uD5DC\uD5DE", 5, "\uD5E6\uD5E7\uD5E9\uD5EA\uD5EB\uD5ED\uD5EE"], + ["c261", "\uD5EF", 4, "\uD5F6\uD5F8\uD5FA", 5, "\uD602\uD603\uD605\uD606\uD607\uD609", 6, "\uD612"], + ["c281", "\uD616", 5, "\uD61D\uD61E\uD61F\uD621\uD622\uD623\uD625", 7, "\uD62E", 9, "\uD63A\uD63B\uC9D5\uC9D6\uC9D9\uC9DA\uC9DC\uC9DD\uC9E0\uC9E2\uC9E4\uC9E7\uC9EC\uC9ED\uC9EF\uC9F0\uC9F1\uC9F8\uC9F9\uC9FC\uCA00\uCA08\uCA09\uCA0B\uCA0C\uCA0D\uCA14\uCA18\uCA29\uCA4C\uCA4D\uCA50\uCA54\uCA5C\uCA5D\uCA5F\uCA60\uCA61\uCA68\uCA7D\uCA84\uCA98\uCABC\uCABD\uCAC0\uCAC4\uCACC\uCACD\uCACF\uCAD1\uCAD3\uCAD8\uCAD9\uCAE0\uCAEC\uCAF4\uCB08\uCB10\uCB14\uCB18\uCB20\uCB21\uCB41\uCB48\uCB49\uCB4C\uCB50\uCB58\uCB59\uCB5D\uCB64\uCB78\uCB79\uCB9C\uCBB8\uCBD4\uCBE4\uCBE7\uCBE9\uCC0C\uCC0D\uCC10\uCC14\uCC1C\uCC1D\uCC21\uCC22\uCC27\uCC28\uCC29\uCC2C\uCC2E\uCC30\uCC38\uCC39\uCC3B"], + ["c341", "\uD63D\uD63E\uD63F\uD641\uD642\uD643\uD644\uD646\uD647\uD64A\uD64C\uD64E\uD64F\uD650\uD652\uD653\uD656\uD657\uD659\uD65A\uD65B\uD65D", 4], + ["c361", "\uD662", 4, "\uD668\uD66A", 5, "\uD672\uD673\uD675", 11], + ["c381", "\uD681\uD682\uD684\uD686", 5, "\uD68E\uD68F\uD691\uD692\uD693\uD695", 7, "\uD69E\uD6A0\uD6A2", 5, "\uD6A9\uD6AA\uCC3C\uCC3D\uCC3E\uCC44\uCC45\uCC48\uCC4C\uCC54\uCC55\uCC57\uCC58\uCC59\uCC60\uCC64\uCC66\uCC68\uCC70\uCC75\uCC98\uCC99\uCC9C\uCCA0\uCCA8\uCCA9\uCCAB\uCCAC\uCCAD\uCCB4\uCCB5\uCCB8\uCCBC\uCCC4\uCCC5\uCCC7\uCCC9\uCCD0\uCCD4\uCCE4\uCCEC\uCCF0\uCD01\uCD08\uCD09\uCD0C\uCD10\uCD18\uCD19\uCD1B\uCD1D\uCD24\uCD28\uCD2C\uCD39\uCD5C\uCD60\uCD64\uCD6C\uCD6D\uCD6F\uCD71\uCD78\uCD88\uCD94\uCD95\uCD98\uCD9C\uCDA4\uCDA5\uCDA7\uCDA9\uCDB0\uCDC4\uCDCC\uCDD0\uCDE8\uCDEC\uCDF0\uCDF8\uCDF9\uCDFB\uCDFD\uCE04\uCE08\uCE0C\uCE14\uCE19\uCE20\uCE21\uCE24\uCE28\uCE30\uCE31\uCE33\uCE35"], + ["c441", "\uD6AB\uD6AD\uD6AE\uD6AF\uD6B1", 7, "\uD6BA\uD6BC", 7, "\uD6C6\uD6C7\uD6C9\uD6CA\uD6CB"], + ["c461", "\uD6CD\uD6CE\uD6CF\uD6D0\uD6D2\uD6D3\uD6D5\uD6D6\uD6D8\uD6DA", 5, "\uD6E1\uD6E2\uD6E3\uD6E5\uD6E6\uD6E7\uD6E9", 4], + ["c481", "\uD6EE\uD6EF\uD6F1\uD6F2\uD6F3\uD6F4\uD6F6", 5, "\uD6FE\uD6FF\uD701\uD702\uD703\uD705", 11, "\uD712\uD713\uD714\uCE58\uCE59\uCE5C\uCE5F\uCE60\uCE61\uCE68\uCE69\uCE6B\uCE6D\uCE74\uCE75\uCE78\uCE7C\uCE84\uCE85\uCE87\uCE89\uCE90\uCE91\uCE94\uCE98\uCEA0\uCEA1\uCEA3\uCEA4\uCEA5\uCEAC\uCEAD\uCEC1\uCEE4\uCEE5\uCEE8\uCEEB\uCEEC\uCEF4\uCEF5\uCEF7\uCEF8\uCEF9\uCF00\uCF01\uCF04\uCF08\uCF10\uCF11\uCF13\uCF15\uCF1C\uCF20\uCF24\uCF2C\uCF2D\uCF2F\uCF30\uCF31\uCF38\uCF54\uCF55\uCF58\uCF5C\uCF64\uCF65\uCF67\uCF69\uCF70\uCF71\uCF74\uCF78\uCF80\uCF85\uCF8C\uCFA1\uCFA8\uCFB0\uCFC4\uCFE0\uCFE1\uCFE4\uCFE8\uCFF0\uCFF1\uCFF3\uCFF5\uCFFC\uD000\uD004\uD011\uD018\uD02D\uD034\uD035\uD038\uD03C"], + ["c541", "\uD715\uD716\uD717\uD71A\uD71B\uD71D\uD71E\uD71F\uD721", 6, "\uD72A\uD72C\uD72E", 5, "\uD736\uD737\uD739"], + ["c561", "\uD73A\uD73B\uD73D", 6, "\uD745\uD746\uD748\uD74A", 5, "\uD752\uD753\uD755\uD75A", 4], + ["c581", "\uD75F\uD762\uD764\uD766\uD767\uD768\uD76A\uD76B\uD76D\uD76E\uD76F\uD771\uD772\uD773\uD775", 6, "\uD77E\uD77F\uD780\uD782", 5, "\uD78A\uD78B\uD044\uD045\uD047\uD049\uD050\uD054\uD058\uD060\uD06C\uD06D\uD070\uD074\uD07C\uD07D\uD081\uD0A4\uD0A5\uD0A8\uD0AC\uD0B4\uD0B5\uD0B7\uD0B9\uD0C0\uD0C1\uD0C4\uD0C8\uD0C9\uD0D0\uD0D1\uD0D3\uD0D4\uD0D5\uD0DC\uD0DD\uD0E0\uD0E4\uD0EC\uD0ED\uD0EF\uD0F0\uD0F1\uD0F8\uD10D\uD130\uD131\uD134\uD138\uD13A\uD140\uD141\uD143\uD144\uD145\uD14C\uD14D\uD150\uD154\uD15C\uD15D\uD15F\uD161\uD168\uD16C\uD17C\uD184\uD188\uD1A0\uD1A1\uD1A4\uD1A8\uD1B0\uD1B1\uD1B3\uD1B5\uD1BA\uD1BC\uD1C0\uD1D8\uD1F4\uD1F8\uD207\uD209\uD210\uD22C\uD22D\uD230\uD234\uD23C\uD23D\uD23F\uD241\uD248\uD25C"], + ["c641", "\uD78D\uD78E\uD78F\uD791", 6, "\uD79A\uD79C\uD79E", 5], + ["c6a1", "\uD264\uD280\uD281\uD284\uD288\uD290\uD291\uD295\uD29C\uD2A0\uD2A4\uD2AC\uD2B1\uD2B8\uD2B9\uD2BC\uD2BF\uD2C0\uD2C2\uD2C8\uD2C9\uD2CB\uD2D4\uD2D8\uD2DC\uD2E4\uD2E5\uD2F0\uD2F1\uD2F4\uD2F8\uD300\uD301\uD303\uD305\uD30C\uD30D\uD30E\uD310\uD314\uD316\uD31C\uD31D\uD31F\uD320\uD321\uD325\uD328\uD329\uD32C\uD330\uD338\uD339\uD33B\uD33C\uD33D\uD344\uD345\uD37C\uD37D\uD380\uD384\uD38C\uD38D\uD38F\uD390\uD391\uD398\uD399\uD39C\uD3A0\uD3A8\uD3A9\uD3AB\uD3AD\uD3B4\uD3B8\uD3BC\uD3C4\uD3C5\uD3C8\uD3C9\uD3D0\uD3D8\uD3E1\uD3E3\uD3EC\uD3ED\uD3F0\uD3F4\uD3FC\uD3FD\uD3FF\uD401"], + ["c7a1", "\uD408\uD41D\uD440\uD444\uD45C\uD460\uD464\uD46D\uD46F\uD478\uD479\uD47C\uD47F\uD480\uD482\uD488\uD489\uD48B\uD48D\uD494\uD4A9\uD4CC\uD4D0\uD4D4\uD4DC\uD4DF\uD4E8\uD4EC\uD4F0\uD4F8\uD4FB\uD4FD\uD504\uD508\uD50C\uD514\uD515\uD517\uD53C\uD53D\uD540\uD544\uD54C\uD54D\uD54F\uD551\uD558\uD559\uD55C\uD560\uD565\uD568\uD569\uD56B\uD56D\uD574\uD575\uD578\uD57C\uD584\uD585\uD587\uD588\uD589\uD590\uD5A5\uD5C8\uD5C9\uD5CC\uD5D0\uD5D2\uD5D8\uD5D9\uD5DB\uD5DD\uD5E4\uD5E5\uD5E8\uD5EC\uD5F4\uD5F5\uD5F7\uD5F9\uD600\uD601\uD604\uD608\uD610\uD611\uD613\uD614\uD615\uD61C\uD620"], + ["c8a1", "\uD624\uD62D\uD638\uD639\uD63C\uD640\uD645\uD648\uD649\uD64B\uD64D\uD651\uD654\uD655\uD658\uD65C\uD667\uD669\uD670\uD671\uD674\uD683\uD685\uD68C\uD68D\uD690\uD694\uD69D\uD69F\uD6A1\uD6A8\uD6AC\uD6B0\uD6B9\uD6BB\uD6C4\uD6C5\uD6C8\uD6CC\uD6D1\uD6D4\uD6D7\uD6D9\uD6E0\uD6E4\uD6E8\uD6F0\uD6F5\uD6FC\uD6FD\uD700\uD704\uD711\uD718\uD719\uD71C\uD720\uD728\uD729\uD72B\uD72D\uD734\uD735\uD738\uD73C\uD744\uD747\uD749\uD750\uD751\uD754\uD756\uD757\uD758\uD759\uD760\uD761\uD763\uD765\uD769\uD76C\uD770\uD774\uD77C\uD77D\uD781\uD788\uD789\uD78C\uD790\uD798\uD799\uD79B\uD79D"], + ["caa1", "\u4F3D\u4F73\u5047\u50F9\u52A0\u53EF\u5475\u54E5\u5609\u5AC1\u5BB6\u6687\u67B6\u67B7\u67EF\u6B4C\u73C2\u75C2\u7A3C\u82DB\u8304\u8857\u8888\u8A36\u8CC8\u8DCF\u8EFB\u8FE6\u99D5\u523B\u5374\u5404\u606A\u6164\u6BBC\u73CF\u811A\u89BA\u89D2\u95A3\u4F83\u520A\u58BE\u5978\u59E6\u5E72\u5E79\u61C7\u63C0\u6746\u67EC\u687F\u6F97\u764E\u770B\u78F5\u7A08\u7AFF\u7C21\u809D\u826E\u8271\u8AEB\u9593\u4E6B\u559D\u66F7\u6E34\u78A3\u7AED\u845B\u8910\u874E\u97A8\u52D8\u574E\u582A\u5D4C\u611F\u61BE\u6221\u6562\u67D1\u6A44\u6E1B\u7518\u75B3\u76E3\u77B0\u7D3A\u90AF\u9451\u9452\u9F95"], + ["cba1", "\u5323\u5CAC\u7532\u80DB\u9240\u9598\u525B\u5808\u59DC\u5CA1\u5D17\u5EB7\u5F3A\u5F4A\u6177\u6C5F\u757A\u7586\u7CE0\u7D73\u7DB1\u7F8C\u8154\u8221\u8591\u8941\u8B1B\u92FC\u964D\u9C47\u4ECB\u4EF7\u500B\u51F1\u584F\u6137\u613E\u6168\u6539\u69EA\u6F11\u75A5\u7686\u76D6\u7B87\u82A5\u84CB\uF900\u93A7\u958B\u5580\u5BA2\u5751\uF901\u7CB3\u7FB9\u91B5\u5028\u53BB\u5C45\u5DE8\u62D2\u636E\u64DA\u64E7\u6E20\u70AC\u795B\u8DDD\u8E1E\uF902\u907D\u9245\u92F8\u4E7E\u4EF6\u5065\u5DFE\u5EFA\u6106\u6957\u8171\u8654\u8E47\u9375\u9A2B\u4E5E\u5091\u6770\u6840\u5109\u528D\u5292\u6AA2"], + ["cca1", "\u77BC\u9210\u9ED4\u52AB\u602F\u8FF2\u5048\u61A9\u63ED\u64CA\u683C\u6A84\u6FC0\u8188\u89A1\u9694\u5805\u727D\u72AC\u7504\u7D79\u7E6D\u80A9\u898B\u8B74\u9063\u9D51\u6289\u6C7A\u6F54\u7D50\u7F3A\u8A23\u517C\u614A\u7B9D\u8B19\u9257\u938C\u4EAC\u4FD3\u501E\u50BE\u5106\u52C1\u52CD\u537F\u5770\u5883\u5E9A\u5F91\u6176\u61AC\u64CE\u656C\u666F\u66BB\u66F4\u6897\u6D87\u7085\u70F1\u749F\u74A5\u74CA\u75D9\u786C\u78EC\u7ADF\u7AF6\u7D45\u7D93\u8015\u803F\u811B\u8396\u8B66\u8F15\u9015\u93E1\u9803\u9838\u9A5A\u9BE8\u4FC2\u5553\u583A\u5951\u5B63\u5C46\u60B8\u6212\u6842\u68B0"], + ["cda1", "\u68E8\u6EAA\u754C\u7678\u78CE\u7A3D\u7CFB\u7E6B\u7E7C\u8A08\u8AA1\u8C3F\u968E\u9DC4\u53E4\u53E9\u544A\u5471\u56FA\u59D1\u5B64\u5C3B\u5EAB\u62F7\u6537\u6545\u6572\u66A0\u67AF\u69C1\u6CBD\u75FC\u7690\u777E\u7A3F\u7F94\u8003\u80A1\u818F\u82E6\u82FD\u83F0\u85C1\u8831\u88B4\u8AA5\uF903\u8F9C\u932E\u96C7\u9867\u9AD8\u9F13\u54ED\u659B\u66F2\u688F\u7A40\u8C37\u9D60\u56F0\u5764\u5D11\u6606\u68B1\u68CD\u6EFE\u7428\u889E\u9BE4\u6C68\uF904\u9AA8\u4F9B\u516C\u5171\u529F\u5B54\u5DE5\u6050\u606D\u62F1\u63A7\u653B\u73D9\u7A7A\u86A3\u8CA2\u978F\u4E32\u5BE1\u6208\u679C\u74DC"], + ["cea1", "\u79D1\u83D3\u8A87\u8AB2\u8DE8\u904E\u934B\u9846\u5ED3\u69E8\u85FF\u90ED\uF905\u51A0\u5B98\u5BEC\u6163\u68FA\u6B3E\u704C\u742F\u74D8\u7BA1\u7F50\u83C5\u89C0\u8CAB\u95DC\u9928\u522E\u605D\u62EC\u9002\u4F8A\u5149\u5321\u58D9\u5EE3\u66E0\u6D38\u709A\u72C2\u73D6\u7B50\u80F1\u945B\u5366\u639B\u7F6B\u4E56\u5080\u584A\u58DE\u602A\u6127\u62D0\u69D0\u9B41\u5B8F\u7D18\u80B1\u8F5F\u4EA4\u50D1\u54AC\u55AC\u5B0C\u5DA0\u5DE7\u652A\u654E\u6821\u6A4B\u72E1\u768E\u77EF\u7D5E\u7FF9\u81A0\u854E\u86DF\u8F03\u8F4E\u90CA\u9903\u9A55\u9BAB\u4E18\u4E45\u4E5D\u4EC7\u4FF1\u5177\u52FE"], + ["cfa1", "\u5340\u53E3\u53E5\u548E\u5614\u5775\u57A2\u5BC7\u5D87\u5ED0\u61FC\u62D8\u6551\u67B8\u67E9\u69CB\u6B50\u6BC6\u6BEC\u6C42\u6E9D\u7078\u72D7\u7396\u7403\u77BF\u77E9\u7A76\u7D7F\u8009\u81FC\u8205\u820A\u82DF\u8862\u8B33\u8CFC\u8EC0\u9011\u90B1\u9264\u92B6\u99D2\u9A45\u9CE9\u9DD7\u9F9C\u570B\u5C40\u83CA\u97A0\u97AB\u9EB4\u541B\u7A98\u7FA4\u88D9\u8ECD\u90E1\u5800\u5C48\u6398\u7A9F\u5BAE\u5F13\u7A79\u7AAE\u828E\u8EAC\u5026\u5238\u52F8\u5377\u5708\u62F3\u6372\u6B0A\u6DC3\u7737\u53A5\u7357\u8568\u8E76\u95D5\u673A\u6AC3\u6F70\u8A6D\u8ECC\u994B\uF906\u6677\u6B78\u8CB4"], + ["d0a1", "\u9B3C\uF907\u53EB\u572D\u594E\u63C6\u69FB\u73EA\u7845\u7ABA\u7AC5\u7CFE\u8475\u898F\u8D73\u9035\u95A8\u52FB\u5747\u7547\u7B60\u83CC\u921E\uF908\u6A58\u514B\u524B\u5287\u621F\u68D8\u6975\u9699\u50C5\u52A4\u52E4\u61C3\u65A4\u6839\u69FF\u747E\u7B4B\u82B9\u83EB\u89B2\u8B39\u8FD1\u9949\uF909\u4ECA\u5997\u64D2\u6611\u6A8E\u7434\u7981\u79BD\u82A9\u887E\u887F\u895F\uF90A\u9326\u4F0B\u53CA\u6025\u6271\u6C72\u7D1A\u7D66\u4E98\u5162\u77DC\u80AF\u4F01\u4F0E\u5176\u5180\u55DC\u5668\u573B\u57FA\u57FC\u5914\u5947\u5993\u5BC4\u5C90\u5D0E\u5DF1\u5E7E\u5FCC\u6280\u65D7\u65E3"], + ["d1a1", "\u671E\u671F\u675E\u68CB\u68C4\u6A5F\u6B3A\u6C23\u6C7D\u6C82\u6DC7\u7398\u7426\u742A\u7482\u74A3\u7578\u757F\u7881\u78EF\u7941\u7947\u7948\u797A\u7B95\u7D00\u7DBA\u7F88\u8006\u802D\u808C\u8A18\u8B4F\u8C48\u8D77\u9321\u9324\u98E2\u9951\u9A0E\u9A0F\u9A65\u9E92\u7DCA\u4F76\u5409\u62EE\u6854\u91D1\u55AB\u513A\uF90B\uF90C\u5A1C\u61E6\uF90D\u62CF\u62FF\uF90E", 5, "\u90A3\uF914", 4, "\u8AFE\uF919\uF91A\uF91B\uF91C\u6696\uF91D\u7156\uF91E\uF91F\u96E3\uF920\u634F\u637A\u5357\uF921\u678F\u6960\u6E73\uF922\u7537\uF923\uF924\uF925"], + ["d2a1", "\u7D0D\uF926\uF927\u8872\u56CA\u5A18\uF928", 4, "\u4E43\uF92D\u5167\u5948\u67F0\u8010\uF92E\u5973\u5E74\u649A\u79CA\u5FF5\u606C\u62C8\u637B\u5BE7\u5BD7\u52AA\uF92F\u5974\u5F29\u6012\uF930\uF931\uF932\u7459\uF933", 5, "\u99D1\uF939", 10, "\u6FC3\uF944\uF945\u81BF\u8FB2\u60F1\uF946\uF947\u8166\uF948\uF949\u5C3F\uF94A", 7, "\u5AE9\u8A25\u677B\u7D10\uF952", 5, "\u80FD\uF958\uF959\u5C3C\u6CE5\u533F\u6EBA\u591A\u8336"], + ["d3a1", "\u4E39\u4EB6\u4F46\u55AE\u5718\u58C7\u5F56\u65B7\u65E6\u6A80\u6BB5\u6E4D\u77ED\u7AEF\u7C1E\u7DDE\u86CB\u8892\u9132\u935B\u64BB\u6FBE\u737A\u75B8\u9054\u5556\u574D\u61BA\u64D4\u66C7\u6DE1\u6E5B\u6F6D\u6FB9\u75F0\u8043\u81BD\u8541\u8983\u8AC7\u8B5A\u931F\u6C93\u7553\u7B54\u8E0F\u905D\u5510\u5802\u5858\u5E62\u6207\u649E\u68E0\u7576\u7CD6\u87B3\u9EE8\u4EE3\u5788\u576E\u5927\u5C0D\u5CB1\u5E36\u5F85\u6234\u64E1\u73B3\u81FA\u888B\u8CB8\u968A\u9EDB\u5B85\u5FB7\u60B3\u5012\u5200\u5230\u5716\u5835\u5857\u5C0E\u5C60\u5CF6\u5D8B\u5EA6\u5F92\u60BC\u6311\u6389\u6417\u6843"], + ["d4a1", "\u68F9\u6AC2\u6DD8\u6E21\u6ED4\u6FE4\u71FE\u76DC\u7779\u79B1\u7A3B\u8404\u89A9\u8CED\u8DF3\u8E48\u9003\u9014\u9053\u90FD\u934D\u9676\u97DC\u6BD2\u7006\u7258\u72A2\u7368\u7763\u79BF\u7BE4\u7E9B\u8B80\u58A9\u60C7\u6566\u65FD\u66BE\u6C8C\u711E\u71C9\u8C5A\u9813\u4E6D\u7A81\u4EDD\u51AC\u51CD\u52D5\u540C\u61A7\u6771\u6850\u68DF\u6D1E\u6F7C\u75BC\u77B3\u7AE5\u80F4\u8463\u9285\u515C\u6597\u675C\u6793\u75D8\u7AC7\u8373\uF95A\u8C46\u9017\u982D\u5C6F\u81C0\u829A\u9041\u906F\u920D\u5F97\u5D9D\u6A59\u71C8\u767B\u7B49\u85E4\u8B04\u9127\u9A30\u5587\u61F6\uF95B\u7669\u7F85"], + ["d5a1", "\u863F\u87BA\u88F8\u908F\uF95C\u6D1B\u70D9\u73DE\u7D61\u843D\uF95D\u916A\u99F1\uF95E\u4E82\u5375\u6B04\u6B12\u703E\u721B\u862D\u9E1E\u524C\u8FA3\u5D50\u64E5\u652C\u6B16\u6FEB\u7C43\u7E9C\u85CD\u8964\u89BD\u62C9\u81D8\u881F\u5ECA\u6717\u6D6A\u72FC\u7405\u746F\u8782\u90DE\u4F86\u5D0D\u5FA0\u840A\u51B7\u63A0\u7565\u4EAE\u5006\u5169\u51C9\u6881\u6A11\u7CAE\u7CB1\u7CE7\u826F\u8AD2\u8F1B\u91CF\u4FB6\u5137\u52F5\u5442\u5EEC\u616E\u623E\u65C5\u6ADA\u6FFE\u792A\u85DC\u8823\u95AD\u9A62\u9A6A\u9E97\u9ECE\u529B\u66C6\u6B77\u701D\u792B\u8F62\u9742\u6190\u6200\u6523\u6F23"], + ["d6a1", "\u7149\u7489\u7DF4\u806F\u84EE\u8F26\u9023\u934A\u51BD\u5217\u52A3\u6D0C\u70C8\u88C2\u5EC9\u6582\u6BAE\u6FC2\u7C3E\u7375\u4EE4\u4F36\u56F9\uF95F\u5CBA\u5DBA\u601C\u73B2\u7B2D\u7F9A\u7FCE\u8046\u901E\u9234\u96F6\u9748\u9818\u9F61\u4F8B\u6FA7\u79AE\u91B4\u96B7\u52DE\uF960\u6488\u64C4\u6AD3\u6F5E\u7018\u7210\u76E7\u8001\u8606\u865C\u8DEF\u8F05\u9732\u9B6F\u9DFA\u9E75\u788C\u797F\u7DA0\u83C9\u9304\u9E7F\u9E93\u8AD6\u58DF\u5F04\u6727\u7027\u74CF\u7C60\u807E\u5121\u7028\u7262\u78CA\u8CC2\u8CDA\u8CF4\u96F7\u4E86\u50DA\u5BEE\u5ED6\u6599\u71CE\u7642\u77AD\u804A\u84FC"], + ["d7a1", "\u907C\u9B27\u9F8D\u58D8\u5A41\u5C62\u6A13\u6DDA\u6F0F\u763B\u7D2F\u7E37\u851E\u8938\u93E4\u964B\u5289\u65D2\u67F3\u69B4\u6D41\u6E9C\u700F\u7409\u7460\u7559\u7624\u786B\u8B2C\u985E\u516D\u622E\u9678\u4F96\u502B\u5D19\u6DEA\u7DB8\u8F2A\u5F8B\u6144\u6817\uF961\u9686\u52D2\u808B\u51DC\u51CC\u695E\u7A1C\u7DBE\u83F1\u9675\u4FDA\u5229\u5398\u540F\u550E\u5C65\u60A7\u674E\u68A8\u6D6C\u7281\u72F8\u7406\u7483\uF962\u75E2\u7C6C\u7F79\u7FB8\u8389\u88CF\u88E1\u91CC\u91D0\u96E2\u9BC9\u541D\u6F7E\u71D0\u7498\u85FA\u8EAA\u96A3\u9C57\u9E9F\u6797\u6DCB\u7433\u81E8\u9716\u782C"], + ["d8a1", "\u7ACB\u7B20\u7C92\u6469\u746A\u75F2\u78BC\u78E8\u99AC\u9B54\u9EBB\u5BDE\u5E55\u6F20\u819C\u83AB\u9088\u4E07\u534D\u5A29\u5DD2\u5F4E\u6162\u633D\u6669\u66FC\u6EFF\u6F2B\u7063\u779E\u842C\u8513\u883B\u8F13\u9945\u9C3B\u551C\u62B9\u672B\u6CAB\u8309\u896A\u977A\u4EA1\u5984\u5FD8\u5FD9\u671B\u7DB2\u7F54\u8292\u832B\u83BD\u8F1E\u9099\u57CB\u59B9\u5A92\u5BD0\u6627\u679A\u6885\u6BCF\u7164\u7F75\u8CB7\u8CE3\u9081\u9B45\u8108\u8C8A\u964C\u9A40\u9EA5\u5B5F\u6C13\u731B\u76F2\u76DF\u840C\u51AA\u8993\u514D\u5195\u52C9\u68C9\u6C94\u7704\u7720\u7DBF\u7DEC\u9762\u9EB5\u6EC5"], + ["d9a1", "\u8511\u51A5\u540D\u547D\u660E\u669D\u6927\u6E9F\u76BF\u7791\u8317\u84C2\u879F\u9169\u9298\u9CF4\u8882\u4FAE\u5192\u52DF\u59C6\u5E3D\u6155\u6478\u6479\u66AE\u67D0\u6A21\u6BCD\u6BDB\u725F\u7261\u7441\u7738\u77DB\u8017\u82BC\u8305\u8B00\u8B28\u8C8C\u6728\u6C90\u7267\u76EE\u7766\u7A46\u9DA9\u6B7F\u6C92\u5922\u6726\u8499\u536F\u5893\u5999\u5EDF\u63CF\u6634\u6773\u6E3A\u732B\u7AD7\u82D7\u9328\u52D9\u5DEB\u61AE\u61CB\u620A\u62C7\u64AB\u65E0\u6959\u6B66\u6BCB\u7121\u73F7\u755D\u7E46\u821E\u8302\u856A\u8AA3\u8CBF\u9727\u9D61\u58A8\u9ED8\u5011\u520E\u543B\u554F\u6587"], + ["daa1", "\u6C76\u7D0A\u7D0B\u805E\u868A\u9580\u96EF\u52FF\u6C95\u7269\u5473\u5A9A\u5C3E\u5D4B\u5F4C\u5FAE\u672A\u68B6\u6963\u6E3C\u6E44\u7709\u7C73\u7F8E\u8587\u8B0E\u8FF7\u9761\u9EF4\u5CB7\u60B6\u610D\u61AB\u654F\u65FB\u65FC\u6C11\u6CEF\u739F\u73C9\u7DE1\u9594\u5BC6\u871C\u8B10\u525D\u535A\u62CD\u640F\u64B2\u6734\u6A38\u6CCA\u73C0\u749E\u7B94\u7C95\u7E1B\u818A\u8236\u8584\u8FEB\u96F9\u99C1\u4F34\u534A\u53CD\u53DB\u62CC\u642C\u6500\u6591\u69C3\u6CEE\u6F58\u73ED\u7554\u7622\u76E4\u76FC\u78D0\u78FB\u792C\u7D46\u822C\u87E0\u8FD4\u9812\u98EF\u52C3\u62D4\u64A5\u6E24\u6F51"], + ["dba1", "\u767C\u8DCB\u91B1\u9262\u9AEE\u9B43\u5023\u508D\u574A\u59A8\u5C28\u5E47\u5F77\u623F\u653E\u65B9\u65C1\u6609\u678B\u699C\u6EC2\u78C5\u7D21\u80AA\u8180\u822B\u82B3\u84A1\u868C\u8A2A\u8B17\u90A6\u9632\u9F90\u500D\u4FF3\uF963\u57F9\u5F98\u62DC\u6392\u676F\u6E43\u7119\u76C3\u80CC\u80DA\u88F4\u88F5\u8919\u8CE0\u8F29\u914D\u966A\u4F2F\u4F70\u5E1B\u67CF\u6822\u767D\u767E\u9B44\u5E61\u6A0A\u7169\u71D4\u756A\uF964\u7E41\u8543\u85E9\u98DC\u4F10\u7B4F\u7F70\u95A5\u51E1\u5E06\u68B5\u6C3E\u6C4E\u6CDB\u72AF\u7BC4\u8303\u6CD5\u743A\u50FB\u5288\u58C1\u64D8\u6A97\u74A7\u7656"], + ["dca1", "\u78A7\u8617\u95E2\u9739\uF965\u535E\u5F01\u8B8A\u8FA8\u8FAF\u908A\u5225\u77A5\u9C49\u9F08\u4E19\u5002\u5175\u5C5B\u5E77\u661E\u663A\u67C4\u68C5\u70B3\u7501\u75C5\u79C9\u7ADD\u8F27\u9920\u9A08\u4FDD\u5821\u5831\u5BF6\u666E\u6B65\u6D11\u6E7A\u6F7D\u73E4\u752B\u83E9\u88DC\u8913\u8B5C\u8F14\u4F0F\u50D5\u5310\u535C\u5B93\u5FA9\u670D\u798F\u8179\u832F\u8514\u8907\u8986\u8F39\u8F3B\u99A5\u9C12\u672C\u4E76\u4FF8\u5949\u5C01\u5CEF\u5CF0\u6367\u68D2\u70FD\u71A2\u742B\u7E2B\u84EC\u8702\u9022\u92D2\u9CF3\u4E0D\u4ED8\u4FEF\u5085\u5256\u526F\u5426\u5490\u57E0\u592B\u5A66"], + ["dda1", "\u5B5A\u5B75\u5BCC\u5E9C\uF966\u6276\u6577\u65A7\u6D6E\u6EA5\u7236\u7B26\u7C3F\u7F36\u8150\u8151\u819A\u8240\u8299\u83A9\u8A03\u8CA0\u8CE6\u8CFB\u8D74\u8DBA\u90E8\u91DC\u961C\u9644\u99D9\u9CE7\u5317\u5206\u5429\u5674\u58B3\u5954\u596E\u5FFF\u61A4\u626E\u6610\u6C7E\u711A\u76C6\u7C89\u7CDE\u7D1B\u82AC\u8CC1\u96F0\uF967\u4F5B\u5F17\u5F7F\u62C2\u5D29\u670B\u68DA\u787C\u7E43\u9D6C\u4E15\u5099\u5315\u532A\u5351\u5983\u5A62\u5E87\u60B2\u618A\u6249\u6279\u6590\u6787\u69A7\u6BD4\u6BD6\u6BD7\u6BD8\u6CB8\uF968\u7435\u75FA\u7812\u7891\u79D5\u79D8\u7C83\u7DCB\u7FE1\u80A5"], + ["dea1", "\u813E\u81C2\u83F2\u871A\u88E8\u8AB9\u8B6C\u8CBB\u9119\u975E\u98DB\u9F3B\u56AC\u5B2A\u5F6C\u658C\u6AB3\u6BAF\u6D5C\u6FF1\u7015\u725D\u73AD\u8CA7\u8CD3\u983B\u6191\u6C37\u8058\u9A01\u4E4D\u4E8B\u4E9B\u4ED5\u4F3A\u4F3C\u4F7F\u4FDF\u50FF\u53F2\u53F8\u5506\u55E3\u56DB\u58EB\u5962\u5A11\u5BEB\u5BFA\u5C04\u5DF3\u5E2B\u5F99\u601D\u6368\u659C\u65AF\u67F6\u67FB\u68AD\u6B7B\u6C99\u6CD7\u6E23\u7009\u7345\u7802\u793E\u7940\u7960\u79C1\u7BE9\u7D17\u7D72\u8086\u820D\u838E\u84D1\u86C7\u88DF\u8A50\u8A5E\u8B1D\u8CDC\u8D66\u8FAD\u90AA\u98FC\u99DF\u9E9D\u524A\uF969\u6714\uF96A"], + ["dfa1", "\u5098\u522A\u5C71\u6563\u6C55\u73CA\u7523\u759D\u7B97\u849C\u9178\u9730\u4E77\u6492\u6BBA\u715E\u85A9\u4E09\uF96B\u6749\u68EE\u6E17\u829F\u8518\u886B\u63F7\u6F81\u9212\u98AF\u4E0A\u50B7\u50CF\u511F\u5546\u55AA\u5617\u5B40\u5C19\u5CE0\u5E38\u5E8A\u5EA0\u5EC2\u60F3\u6851\u6A61\u6E58\u723D\u7240\u72C0\u76F8\u7965\u7BB1\u7FD4\u88F3\u89F4\u8A73\u8C61\u8CDE\u971C\u585E\u74BD\u8CFD\u55C7\uF96C\u7A61\u7D22\u8272\u7272\u751F\u7525\uF96D\u7B19\u5885\u58FB\u5DBC\u5E8F\u5EB6\u5F90\u6055\u6292\u637F\u654D\u6691\u66D9\u66F8\u6816\u68F2\u7280\u745E\u7B6E\u7D6E\u7DD6\u7F72"], + ["e0a1", "\u80E5\u8212\u85AF\u897F\u8A93\u901D\u92E4\u9ECD\u9F20\u5915\u596D\u5E2D\u60DC\u6614\u6673\u6790\u6C50\u6DC5\u6F5F\u77F3\u78A9\u84C6\u91CB\u932B\u4ED9\u50CA\u5148\u5584\u5B0B\u5BA3\u6247\u657E\u65CB\u6E32\u717D\u7401\u7444\u7487\u74BF\u766C\u79AA\u7DDA\u7E55\u7FA8\u817A\u81B3\u8239\u861A\u87EC\u8A75\u8DE3\u9078\u9291\u9425\u994D\u9BAE\u5368\u5C51\u6954\u6CC4\u6D29\u6E2B\u820C\u859B\u893B\u8A2D\u8AAA\u96EA\u9F67\u5261\u66B9\u6BB2\u7E96\u87FE\u8D0D\u9583\u965D\u651D\u6D89\u71EE\uF96E\u57CE\u59D3\u5BAC\u6027\u60FA\u6210\u661F\u665F\u7329\u73F9\u76DB\u7701\u7B6C"], + ["e1a1", "\u8056\u8072\u8165\u8AA0\u9192\u4E16\u52E2\u6B72\u6D17\u7A05\u7B39\u7D30\uF96F\u8CB0\u53EC\u562F\u5851\u5BB5\u5C0F\u5C11\u5DE2\u6240\u6383\u6414\u662D\u68B3\u6CBC\u6D88\u6EAF\u701F\u70A4\u71D2\u7526\u758F\u758E\u7619\u7B11\u7BE0\u7C2B\u7D20\u7D39\u852C\u856D\u8607\u8A34\u900D\u9061\u90B5\u92B7\u97F6\u9A37\u4FD7\u5C6C\u675F\u6D91\u7C9F\u7E8C\u8B16\u8D16\u901F\u5B6B\u5DFD\u640D\u84C0\u905C\u98E1\u7387\u5B8B\u609A\u677E\u6DDE\u8A1F\u8AA6\u9001\u980C\u5237\uF970\u7051\u788E\u9396\u8870\u91D7\u4FEE\u53D7\u55FD\u56DA\u5782\u58FD\u5AC2\u5B88\u5CAB\u5CC0\u5E25\u6101"], + ["e2a1", "\u620D\u624B\u6388\u641C\u6536\u6578\u6A39\u6B8A\u6C34\u6D19\u6F31\u71E7\u72E9\u7378\u7407\u74B2\u7626\u7761\u79C0\u7A57\u7AEA\u7CB9\u7D8F\u7DAC\u7E61\u7F9E\u8129\u8331\u8490\u84DA\u85EA\u8896\u8AB0\u8B90\u8F38\u9042\u9083\u916C\u9296\u92B9\u968B\u96A7\u96A8\u96D6\u9700\u9808\u9996\u9AD3\u9B1A\u53D4\u587E\u5919\u5B70\u5BBF\u6DD1\u6F5A\u719F\u7421\u74B9\u8085\u83FD\u5DE1\u5F87\u5FAA\u6042\u65EC\u6812\u696F\u6A53\u6B89\u6D35\u6DF3\u73E3\u76FE\u77AC\u7B4D\u7D14\u8123\u821C\u8340\u84F4\u8563\u8A62\u8AC4\u9187\u931E\u9806\u99B4\u620C\u8853\u8FF0\u9265\u5D07\u5D27"], + ["e3a1", "\u5D69\u745F\u819D\u8768\u6FD5\u62FE\u7FD2\u8936\u8972\u4E1E\u4E58\u50E7\u52DD\u5347\u627F\u6607\u7E69\u8805\u965E\u4F8D\u5319\u5636\u59CB\u5AA4\u5C38\u5C4E\u5C4D\u5E02\u5F11\u6043\u65BD\u662F\u6642\u67BE\u67F4\u731C\u77E2\u793A\u7FC5\u8494\u84CD\u8996\u8A66\u8A69\u8AE1\u8C55\u8C7A\u57F4\u5BD4\u5F0F\u606F\u62ED\u690D\u6B96\u6E5C\u7184\u7BD2\u8755\u8B58\u8EFE\u98DF\u98FE\u4F38\u4F81\u4FE1\u547B\u5A20\u5BB8\u613C\u65B0\u6668\u71FC\u7533\u795E\u7D33\u814E\u81E3\u8398\u85AA\u85CE\u8703\u8A0A\u8EAB\u8F9B\uF971\u8FC5\u5931\u5BA4\u5BE6\u6089\u5BE9\u5C0B\u5FC3\u6C81"], + ["e4a1", "\uF972\u6DF1\u700B\u751A\u82AF\u8AF6\u4EC0\u5341\uF973\u96D9\u6C0F\u4E9E\u4FC4\u5152\u555E\u5A25\u5CE8\u6211\u7259\u82BD\u83AA\u86FE\u8859\u8A1D\u963F\u96C5\u9913\u9D09\u9D5D\u580A\u5CB3\u5DBD\u5E44\u60E1\u6115\u63E1\u6A02\u6E25\u9102\u9354\u984E\u9C10\u9F77\u5B89\u5CB8\u6309\u664F\u6848\u773C\u96C1\u978D\u9854\u9B9F\u65A1\u8B01\u8ECB\u95BC\u5535\u5CA9\u5DD6\u5EB5\u6697\u764C\u83F4\u95C7\u58D3\u62BC\u72CE\u9D28\u4EF0\u592E\u600F\u663B\u6B83\u79E7\u9D26\u5393\u54C0\u57C3\u5D16\u611B\u66D6\u6DAF\u788D\u827E\u9698\u9744\u5384\u627C\u6396\u6DB2\u7E0A\u814B\u984D"], + ["e5a1", "\u6AFB\u7F4C\u9DAF\u9E1A\u4E5F\u503B\u51B6\u591C\u60F9\u63F6\u6930\u723A\u8036\uF974\u91CE\u5F31\uF975\uF976\u7D04\u82E5\u846F\u84BB\u85E5\u8E8D\uF977\u4F6F\uF978\uF979\u58E4\u5B43\u6059\u63DA\u6518\u656D\u6698\uF97A\u694A\u6A23\u6D0B\u7001\u716C\u75D2\u760D\u79B3\u7A70\uF97B\u7F8A\uF97C\u8944\uF97D\u8B93\u91C0\u967D\uF97E\u990A\u5704\u5FA1\u65BC\u6F01\u7600\u79A6\u8A9E\u99AD\u9B5A\u9F6C\u5104\u61B6\u6291\u6A8D\u81C6\u5043\u5830\u5F66\u7109\u8A00\u8AFA\u5B7C\u8616\u4FFA\u513C\u56B4\u5944\u63A9\u6DF9\u5DAA\u696D\u5186\u4E88\u4F59\uF97F\uF980\uF981\u5982\uF982"], + ["e6a1", "\uF983\u6B5F\u6C5D\uF984\u74B5\u7916\uF985\u8207\u8245\u8339\u8F3F\u8F5D\uF986\u9918\uF987\uF988\uF989\u4EA6\uF98A\u57DF\u5F79\u6613\uF98B\uF98C\u75AB\u7E79\u8B6F\uF98D\u9006\u9A5B\u56A5\u5827\u59F8\u5A1F\u5BB4\uF98E\u5EF6\uF98F\uF990\u6350\u633B\uF991\u693D\u6C87\u6CBF\u6D8E\u6D93\u6DF5\u6F14\uF992\u70DF\u7136\u7159\uF993\u71C3\u71D5\uF994\u784F\u786F\uF995\u7B75\u7DE3\uF996\u7E2F\uF997\u884D\u8EDF\uF998\uF999\uF99A\u925B\uF99B\u9CF6\uF99C\uF99D\uF99E\u6085\u6D85\uF99F\u71B1\uF9A0\uF9A1\u95B1\u53AD\uF9A2\uF9A3\uF9A4\u67D3\uF9A5\u708E\u7130\u7430\u8276\u82D2"], + ["e7a1", "\uF9A6\u95BB\u9AE5\u9E7D\u66C4\uF9A7\u71C1\u8449\uF9A8\uF9A9\u584B\uF9AA\uF9AB\u5DB8\u5F71\uF9AC\u6620\u668E\u6979\u69AE\u6C38\u6CF3\u6E36\u6F41\u6FDA\u701B\u702F\u7150\u71DF\u7370\uF9AD\u745B\uF9AE\u74D4\u76C8\u7A4E\u7E93\uF9AF\uF9B0\u82F1\u8A60\u8FCE\uF9B1\u9348\uF9B2\u9719\uF9B3\uF9B4\u4E42\u502A\uF9B5\u5208\u53E1\u66F3\u6C6D\u6FCA\u730A\u777F\u7A62\u82AE\u85DD\u8602\uF9B6\u88D4\u8A63\u8B7D\u8C6B\uF9B7\u92B3\uF9B8\u9713\u9810\u4E94\u4F0D\u4FC9\u50B2\u5348\u543E\u5433\u55DA\u5862\u58BA\u5967\u5A1B\u5BE4\u609F\uF9B9\u61CA\u6556\u65FF\u6664\u68A7\u6C5A\u6FB3"], + ["e8a1", "\u70CF\u71AC\u7352\u7B7D\u8708\u8AA4\u9C32\u9F07\u5C4B\u6C83\u7344\u7389\u923A\u6EAB\u7465\u761F\u7A69\u7E15\u860A\u5140\u58C5\u64C1\u74EE\u7515\u7670\u7FC1\u9095\u96CD\u9954\u6E26\u74E6\u7AA9\u7AAA\u81E5\u86D9\u8778\u8A1B\u5A49\u5B8C\u5B9B\u68A1\u6900\u6D63\u73A9\u7413\u742C\u7897\u7DE9\u7FEB\u8118\u8155\u839E\u8C4C\u962E\u9811\u66F0\u5F80\u65FA\u6789\u6C6A\u738B\u502D\u5A03\u6B6A\u77EE\u5916\u5D6C\u5DCD\u7325\u754F\uF9BA\uF9BB\u50E5\u51F9\u582F\u592D\u5996\u59DA\u5BE5\uF9BC\uF9BD\u5DA2\u62D7\u6416\u6493\u64FE\uF9BE\u66DC\uF9BF\u6A48\uF9C0\u71FF\u7464\uF9C1"], + ["e9a1", "\u7A88\u7AAF\u7E47\u7E5E\u8000\u8170\uF9C2\u87EF\u8981\u8B20\u9059\uF9C3\u9080\u9952\u617E\u6B32\u6D74\u7E1F\u8925\u8FB1\u4FD1\u50AD\u5197\u52C7\u57C7\u5889\u5BB9\u5EB8\u6142\u6995\u6D8C\u6E67\u6EB6\u7194\u7462\u7528\u752C\u8073\u8338\u84C9\u8E0A\u9394\u93DE\uF9C4\u4E8E\u4F51\u5076\u512A\u53C8\u53CB\u53F3\u5B87\u5BD3\u5C24\u611A\u6182\u65F4\u725B\u7397\u7440\u76C2\u7950\u7991\u79B9\u7D06\u7FBD\u828B\u85D5\u865E\u8FC2\u9047\u90F5\u91EA\u9685\u96E8\u96E9\u52D6\u5F67\u65ED\u6631\u682F\u715C\u7A36\u90C1\u980A\u4E91\uF9C5\u6A52\u6B9E\u6F90\u7189\u8018\u82B8\u8553"], + ["eaa1", "\u904B\u9695\u96F2\u97FB\u851A\u9B31\u4E90\u718A\u96C4\u5143\u539F\u54E1\u5713\u5712\u57A3\u5A9B\u5AC4\u5BC3\u6028\u613F\u63F4\u6C85\u6D39\u6E72\u6E90\u7230\u733F\u7457\u82D1\u8881\u8F45\u9060\uF9C6\u9662\u9858\u9D1B\u6708\u8D8A\u925E\u4F4D\u5049\u50DE\u5371\u570D\u59D4\u5A01\u5C09\u6170\u6690\u6E2D\u7232\u744B\u7DEF\u80C3\u840E\u8466\u853F\u875F\u885B\u8918\u8B02\u9055\u97CB\u9B4F\u4E73\u4F91\u5112\u516A\uF9C7\u552F\u55A9\u5B7A\u5BA5\u5E7C\u5E7D\u5EBE\u60A0\u60DF\u6108\u6109\u63C4\u6538\u6709\uF9C8\u67D4\u67DA\uF9C9\u6961\u6962\u6CB9\u6D27\uF9CA\u6E38\uF9CB"], + ["eba1", "\u6FE1\u7336\u7337\uF9CC\u745C\u7531\uF9CD\u7652\uF9CE\uF9CF\u7DAD\u81FE\u8438\u88D5\u8A98\u8ADB\u8AED\u8E30\u8E42\u904A\u903E\u907A\u9149\u91C9\u936E\uF9D0\uF9D1\u5809\uF9D2\u6BD3\u8089\u80B2\uF9D3\uF9D4\u5141\u596B\u5C39\uF9D5\uF9D6\u6F64\u73A7\u80E4\u8D07\uF9D7\u9217\u958F\uF9D8\uF9D9\uF9DA\uF9DB\u807F\u620E\u701C\u7D68\u878D\uF9DC\u57A0\u6069\u6147\u6BB7\u8ABE\u9280\u96B1\u4E59\u541F\u6DEB\u852D\u9670\u97F3\u98EE\u63D6\u6CE3\u9091\u51DD\u61C9\u81BA\u9DF9\u4F9D\u501A\u5100\u5B9C\u610F\u61FF\u64EC\u6905\u6BC5\u7591\u77E3\u7FA9\u8264\u858F\u87FB\u8863\u8ABC"], + ["eca1", "\u8B70\u91AB\u4E8C\u4EE5\u4F0A\uF9DD\uF9DE\u5937\u59E8\uF9DF\u5DF2\u5F1B\u5F5B\u6021\uF9E0\uF9E1\uF9E2\uF9E3\u723E\u73E5\uF9E4\u7570\u75CD\uF9E5\u79FB\uF9E6\u800C\u8033\u8084\u82E1\u8351\uF9E7\uF9E8\u8CBD\u8CB3\u9087\uF9E9\uF9EA\u98F4\u990C\uF9EB\uF9EC\u7037\u76CA\u7FCA\u7FCC\u7FFC\u8B1A\u4EBA\u4EC1\u5203\u5370\uF9ED\u54BD\u56E0\u59FB\u5BC5\u5F15\u5FCD\u6E6E\uF9EE\uF9EF\u7D6A\u8335\uF9F0\u8693\u8A8D\uF9F1\u976D\u9777\uF9F2\uF9F3\u4E00\u4F5A\u4F7E\u58F9\u65E5\u6EA2\u9038\u93B0\u99B9\u4EFB\u58EC\u598A\u59D9\u6041\uF9F4\uF9F5\u7A14\uF9F6\u834F\u8CC3\u5165\u5344"], + ["eda1", "\uF9F7\uF9F8\uF9F9\u4ECD\u5269\u5B55\u82BF\u4ED4\u523A\u54A8\u59C9\u59FF\u5B50\u5B57\u5B5C\u6063\u6148\u6ECB\u7099\u716E\u7386\u74F7\u75B5\u78C1\u7D2B\u8005\u81EA\u8328\u8517\u85C9\u8AEE\u8CC7\u96CC\u4F5C\u52FA\u56BC\u65AB\u6628\u707C\u70B8\u7235\u7DBD\u828D\u914C\u96C0\u9D72\u5B71\u68E7\u6B98\u6F7A\u76DE\u5C91\u66AB\u6F5B\u7BB4\u7C2A\u8836\u96DC\u4E08\u4ED7\u5320\u5834\u58BB\u58EF\u596C\u5C07\u5E33\u5E84\u5F35\u638C\u66B2\u6756\u6A1F\u6AA3\u6B0C\u6F3F\u7246\uF9FA\u7350\u748B\u7AE0\u7CA7\u8178\u81DF\u81E7\u838A\u846C\u8523\u8594\u85CF\u88DD\u8D13\u91AC\u9577"], + ["eea1", "\u969C\u518D\u54C9\u5728\u5BB0\u624D\u6750\u683D\u6893\u6E3D\u6ED3\u707D\u7E21\u88C1\u8CA1\u8F09\u9F4B\u9F4E\u722D\u7B8F\u8ACD\u931A\u4F47\u4F4E\u5132\u5480\u59D0\u5E95\u62B5\u6775\u696E\u6A17\u6CAE\u6E1A\u72D9\u732A\u75BD\u7BB8\u7D35\u82E7\u83F9\u8457\u85F7\u8A5B\u8CAF\u8E87\u9019\u90B8\u96CE\u9F5F\u52E3\u540A\u5AE1\u5BC2\u6458\u6575\u6EF4\u72C4\uF9FB\u7684\u7A4D\u7B1B\u7C4D\u7E3E\u7FDF\u837B\u8B2B\u8CCA\u8D64\u8DE1\u8E5F\u8FEA\u8FF9\u9069\u93D1\u4F43\u4F7A\u50B3\u5168\u5178\u524D\u526A\u5861\u587C\u5960\u5C08\u5C55\u5EDB\u609B\u6230\u6813\u6BBF\u6C08\u6FB1"], + ["efa1", "\u714E\u7420\u7530\u7538\u7551\u7672\u7B4C\u7B8B\u7BAD\u7BC6\u7E8F\u8A6E\u8F3E\u8F49\u923F\u9293\u9322\u942B\u96FB\u985A\u986B\u991E\u5207\u622A\u6298\u6D59\u7664\u7ACA\u7BC0\u7D76\u5360\u5CBE\u5E97\u6F38\u70B9\u7C98\u9711\u9B8E\u9EDE\u63A5\u647A\u8776\u4E01\u4E95\u4EAD\u505C\u5075\u5448\u59C3\u5B9A\u5E40\u5EAD\u5EF7\u5F81\u60C5\u633A\u653F\u6574\u65CC\u6676\u6678\u67FE\u6968\u6A89\u6B63\u6C40\u6DC0\u6DE8\u6E1F\u6E5E\u701E\u70A1\u738E\u73FD\u753A\u775B\u7887\u798E\u7A0B\u7A7D\u7CBE\u7D8E\u8247\u8A02\u8AEA\u8C9E\u912D\u914A\u91D8\u9266\u92CC\u9320\u9706\u9756"], + ["f0a1", "\u975C\u9802\u9F0E\u5236\u5291\u557C\u5824\u5E1D\u5F1F\u608C\u63D0\u68AF\u6FDF\u796D\u7B2C\u81CD\u85BA\u88FD\u8AF8\u8E44\u918D\u9664\u969B\u973D\u984C\u9F4A\u4FCE\u5146\u51CB\u52A9\u5632\u5F14\u5F6B\u63AA\u64CD\u65E9\u6641\u66FA\u66F9\u671D\u689D\u68D7\u69FD\u6F15\u6F6E\u7167\u71E5\u722A\u74AA\u773A\u7956\u795A\u79DF\u7A20\u7A95\u7C97\u7CDF\u7D44\u7E70\u8087\u85FB\u86A4\u8A54\u8ABF\u8D99\u8E81\u9020\u906D\u91E3\u963B\u96D5\u9CE5\u65CF\u7C07\u8DB3\u93C3\u5B58\u5C0A\u5352\u62D9\u731D\u5027\u5B97\u5F9E\u60B0\u616B\u68D5\u6DD9\u742E\u7A2E\u7D42\u7D9C\u7E31\u816B"], + ["f1a1", "\u8E2A\u8E35\u937E\u9418\u4F50\u5750\u5DE6\u5EA7\u632B\u7F6A\u4E3B\u4F4F\u4F8F\u505A\u59DD\u80C4\u546A\u5468\u55FE\u594F\u5B99\u5DDE\u5EDA\u665D\u6731\u67F1\u682A\u6CE8\u6D32\u6E4A\u6F8D\u70B7\u73E0\u7587\u7C4C\u7D02\u7D2C\u7DA2\u821F\u86DB\u8A3B\u8A85\u8D70\u8E8A\u8F33\u9031\u914E\u9152\u9444\u99D0\u7AF9\u7CA5\u4FCA\u5101\u51C6\u57C8\u5BEF\u5CFB\u6659\u6A3D\u6D5A\u6E96\u6FEC\u710C\u756F\u7AE3\u8822\u9021\u9075\u96CB\u99FF\u8301\u4E2D\u4EF2\u8846\u91CD\u537D\u6ADB\u696B\u6C41\u847A\u589E\u618E\u66FE\u62EF\u70DD\u7511\u75C7\u7E52\u84B8\u8B49\u8D08\u4E4B\u53EA"], + ["f2a1", "\u54AB\u5730\u5740\u5FD7\u6301\u6307\u646F\u652F\u65E8\u667A\u679D\u67B3\u6B62\u6C60\u6C9A\u6F2C\u77E5\u7825\u7949\u7957\u7D19\u80A2\u8102\u81F3\u829D\u82B7\u8718\u8A8C\uF9FC\u8D04\u8DBE\u9072\u76F4\u7A19\u7A37\u7E54\u8077\u5507\u55D4\u5875\u632F\u6422\u6649\u664B\u686D\u699B\u6B84\u6D25\u6EB1\u73CD\u7468\u74A1\u755B\u75B9\u76E1\u771E\u778B\u79E6\u7E09\u7E1D\u81FB\u852F\u8897\u8A3A\u8CD1\u8EEB\u8FB0\u9032\u93AD\u9663\u9673\u9707\u4F84\u53F1\u59EA\u5AC9\u5E19\u684E\u74C6\u75BE\u79E9\u7A92\u81A3\u86ED\u8CEA\u8DCC\u8FED\u659F\u6715\uF9FD\u57F7\u6F57\u7DDD\u8F2F"], + ["f3a1", "\u93F6\u96C6\u5FB5\u61F2\u6F84\u4E14\u4F98\u501F\u53C9\u55DF\u5D6F\u5DEE\u6B21\u6B64\u78CB\u7B9A\uF9FE\u8E49\u8ECA\u906E\u6349\u643E\u7740\u7A84\u932F\u947F\u9F6A\u64B0\u6FAF\u71E6\u74A8\u74DA\u7AC4\u7C12\u7E82\u7CB2\u7E98\u8B9A\u8D0A\u947D\u9910\u994C\u5239\u5BDF\u64E6\u672D\u7D2E\u50ED\u53C3\u5879\u6158\u6159\u61FA\u65AC\u7AD9\u8B92\u8B96\u5009\u5021\u5275\u5531\u5A3C\u5EE0\u5F70\u6134\u655E\u660C\u6636\u66A2\u69CD\u6EC4\u6F32\u7316\u7621\u7A93\u8139\u8259\u83D6\u84BC\u50B5\u57F0\u5BC0\u5BE8\u5F69\u63A1\u7826\u7DB5\u83DC\u8521\u91C7\u91F5\u518A\u67F5\u7B56"], + ["f4a1", "\u8CAC\u51C4\u59BB\u60BD\u8655\u501C\uF9FF\u5254\u5C3A\u617D\u621A\u62D3\u64F2\u65A5\u6ECC\u7620\u810A\u8E60\u965F\u96BB\u4EDF\u5343\u5598\u5929\u5DDD\u64C5\u6CC9\u6DFA\u7394\u7A7F\u821B\u85A6\u8CE4\u8E10\u9077\u91E7\u95E1\u9621\u97C6\u51F8\u54F2\u5586\u5FB9\u64A4\u6F88\u7DB4\u8F1F\u8F4D\u9435\u50C9\u5C16\u6CBE\u6DFB\u751B\u77BB\u7C3D\u7C64\u8A79\u8AC2\u581E\u59BE\u5E16\u6377\u7252\u758A\u776B\u8ADC\u8CBC\u8F12\u5EF3\u6674\u6DF8\u807D\u83C1\u8ACB\u9751\u9BD6\uFA00\u5243\u66FF\u6D95\u6EEF\u7DE0\u8AE6\u902E\u905E\u9AD4\u521D\u527F\u54E8\u6194\u6284\u62DB\u68A2"], + ["f5a1", "\u6912\u695A\u6A35\u7092\u7126\u785D\u7901\u790E\u79D2\u7A0D\u8096\u8278\u82D5\u8349\u8549\u8C82\u8D85\u9162\u918B\u91AE\u4FC3\u56D1\u71ED\u77D7\u8700\u89F8\u5BF8\u5FD6\u6751\u90A8\u53E2\u585A\u5BF5\u60A4\u6181\u6460\u7E3D\u8070\u8525\u9283\u64AE\u50AC\u5D14\u6700\u589C\u62BD\u63A8\u690E\u6978\u6A1E\u6E6B\u76BA\u79CB\u82BB\u8429\u8ACF\u8DA8\u8FFD\u9112\u914B\u919C\u9310\u9318\u939A\u96DB\u9A36\u9C0D\u4E11\u755C\u795D\u7AFA\u7B51\u7BC9\u7E2E\u84C4\u8E59\u8E74\u8EF8\u9010\u6625\u693F\u7443\u51FA\u672E\u9EDC\u5145\u5FE0\u6C96\u87F2\u885D\u8877\u60B4\u81B5\u8403"], + ["f6a1", "\u8D05\u53D6\u5439\u5634\u5A36\u5C31\u708A\u7FE0\u805A\u8106\u81ED\u8DA3\u9189\u9A5F\u9DF2\u5074\u4EC4\u53A0\u60FB\u6E2C\u5C64\u4F88\u5024\u55E4\u5CD9\u5E5F\u6065\u6894\u6CBB\u6DC4\u71BE\u75D4\u75F4\u7661\u7A1A\u7A49\u7DC7\u7DFB\u7F6E\u81F4\u86A9\u8F1C\u96C9\u99B3\u9F52\u5247\u52C5\u98ED\u89AA\u4E03\u67D2\u6F06\u4FB5\u5BE2\u6795\u6C88\u6D78\u741B\u7827\u91DD\u937C\u87C4\u79E4\u7A31\u5FEB\u4ED6\u54A4\u553E\u58AE\u59A5\u60F0\u6253\u62D6\u6736\u6955\u8235\u9640\u99B1\u99DD\u502C\u5353\u5544\u577C\uFA01\u6258\uFA02\u64E2\u666B\u67DD\u6FC1\u6FEF\u7422\u7438\u8A17"], + ["f7a1", "\u9438\u5451\u5606\u5766\u5F48\u619A\u6B4E\u7058\u70AD\u7DBB\u8A95\u596A\u812B\u63A2\u7708\u803D\u8CAA\u5854\u642D\u69BB\u5B95\u5E11\u6E6F\uFA03\u8569\u514C\u53F0\u592A\u6020\u614B\u6B86\u6C70\u6CF0\u7B1E\u80CE\u82D4\u8DC6\u90B0\u98B1\uFA04\u64C7\u6FA4\u6491\u6504\u514E\u5410\u571F\u8A0E\u615F\u6876\uFA05\u75DB\u7B52\u7D71\u901A\u5806\u69CC\u817F\u892A\u9000\u9839\u5078\u5957\u59AC\u6295\u900F\u9B2A\u615D\u7279\u95D6\u5761\u5A46\u5DF4\u628A\u64AD\u64FA\u6777\u6CE2\u6D3E\u722C\u7436\u7834\u7F77\u82AD\u8DDB\u9817\u5224\u5742\u677F\u7248\u74E3\u8CA9\u8FA6\u9211"], + ["f8a1", "\u962A\u516B\u53ED\u634C\u4F69\u5504\u6096\u6557\u6C9B\u6D7F\u724C\u72FD\u7A17\u8987\u8C9D\u5F6D\u6F8E\u70F9\u81A8\u610E\u4FBF\u504F\u6241\u7247\u7BC7\u7DE8\u7FE9\u904D\u97AD\u9A19\u8CB6\u576A\u5E73\u67B0\u840D\u8A55\u5420\u5B16\u5E63\u5EE2\u5F0A\u6583\u80BA\u853D\u9589\u965B\u4F48\u5305\u530D\u530F\u5486\u54FA\u5703\u5E03\u6016\u629B\u62B1\u6355\uFA06\u6CE1\u6D66\u75B1\u7832\u80DE\u812F\u82DE\u8461\u84B2\u888D\u8912\u900B\u92EA\u98FD\u9B91\u5E45\u66B4\u66DD\u7011\u7206\uFA07\u4FF5\u527D\u5F6A\u6153\u6753\u6A19\u6F02\u74E2\u7968\u8868\u8C79\u98C7\u98C4\u9A43"], + ["f9a1", "\u54C1\u7A1F\u6953\u8AF7\u8C4A\u98A8\u99AE\u5F7C\u62AB\u75B2\u76AE\u88AB\u907F\u9642\u5339\u5F3C\u5FC5\u6CCC\u73CC\u7562\u758B\u7B46\u82FE\u999D\u4E4F\u903C\u4E0B\u4F55\u53A6\u590F\u5EC8\u6630\u6CB3\u7455\u8377\u8766\u8CC0\u9050\u971E\u9C15\u58D1\u5B78\u8650\u8B14\u9DB4\u5BD2\u6068\u608D\u65F1\u6C57\u6F22\u6FA3\u701A\u7F55\u7FF0\u9591\u9592\u9650\u97D3\u5272\u8F44\u51FD\u542B\u54B8\u5563\u558A\u6ABB\u6DB5\u7DD8\u8266\u929C\u9677\u9E79\u5408\u54C8\u76D2\u86E4\u95A4\u95D4\u965C\u4EA2\u4F09\u59EE\u5AE6\u5DF7\u6052\u6297\u676D\u6841\u6C86\u6E2F\u7F38\u809B\u822A"], + ["faa1", "\uFA08\uFA09\u9805\u4EA5\u5055\u54B3\u5793\u595A\u5B69\u5BB3\u61C8\u6977\u6D77\u7023\u87F9\u89E3\u8A72\u8AE7\u9082\u99ED\u9AB8\u52BE\u6838\u5016\u5E78\u674F\u8347\u884C\u4EAB\u5411\u56AE\u73E6\u9115\u97FF\u9909\u9957\u9999\u5653\u589F\u865B\u8A31\u61B2\u6AF6\u737B\u8ED2\u6B47\u96AA\u9A57\u5955\u7200\u8D6B\u9769\u4FD4\u5CF4\u5F26\u61F8\u665B\u6CEB\u70AB\u7384\u73B9\u73FE\u7729\u774D\u7D43\u7D62\u7E23\u8237\u8852\uFA0A\u8CE2\u9249\u986F\u5B51\u7A74\u8840\u9801\u5ACC\u4FE0\u5354\u593E\u5CFD\u633E\u6D79\u72F9\u8105\u8107\u83A2\u92CF\u9830\u4EA8\u5144\u5211\u578B"], + ["fba1", "\u5F62\u6CC2\u6ECE\u7005\u7050\u70AF\u7192\u73E9\u7469\u834A\u87A2\u8861\u9008\u90A2\u93A3\u99A8\u516E\u5F57\u60E0\u6167\u66B3\u8559\u8E4A\u91AF\u978B\u4E4E\u4E92\u547C\u58D5\u58FA\u597D\u5CB5\u5F27\u6236\u6248\u660A\u6667\u6BEB\u6D69\u6DCF\u6E56\u6EF8\u6F94\u6FE0\u6FE9\u705D\u72D0\u7425\u745A\u74E0\u7693\u795C\u7CCA\u7E1E\u80E1\u82A6\u846B\u84BF\u864E\u865F\u8774\u8B77\u8C6A\u93AC\u9800\u9865\u60D1\u6216\u9177\u5A5A\u660F\u6DF7\u6E3E\u743F\u9B42\u5FFD\u60DA\u7B0F\u54C4\u5F18\u6C5E\u6CD3\u6D2A\u70D8\u7D05\u8679\u8A0C\u9D3B\u5316\u548C\u5B05\u6A3A\u706B\u7575"], + ["fca1", "\u798D\u79BE\u82B1\u83EF\u8A71\u8B41\u8CA8\u9774\uFA0B\u64F4\u652B\u78BA\u78BB\u7A6B\u4E38\u559A\u5950\u5BA6\u5E7B\u60A3\u63DB\u6B61\u6665\u6853\u6E19\u7165\u74B0\u7D08\u9084\u9A69\u9C25\u6D3B\u6ED1\u733E\u8C41\u95CA\u51F0\u5E4C\u5FA8\u604D\u60F6\u6130\u614C\u6643\u6644\u69A5\u6CC1\u6E5F\u6EC9\u6F62\u714C\u749C\u7687\u7BC1\u7C27\u8352\u8757\u9051\u968D\u9EC3\u532F\u56DE\u5EFB\u5F8A\u6062\u6094\u61F7\u6666\u6703\u6A9C\u6DEE\u6FAE\u7070\u736A\u7E6A\u81BE\u8334\u86D4\u8AA8\u8CC4\u5283\u7372\u5B96\u6A6B\u9404\u54EE\u5686\u5B5D\u6548\u6585\u66C9\u689F\u6D8D\u6DC6"], + ["fda1", "\u723B\u80B4\u9175\u9A4D\u4FAF\u5019\u539A\u540E\u543C\u5589\u55C5\u5E3F\u5F8C\u673D\u7166\u73DD\u9005\u52DB\u52F3\u5864\u58CE\u7104\u718F\u71FB\u85B0\u8A13\u6688\u85A8\u55A7\u6684\u714A\u8431\u5349\u5599\u6BC1\u5F59\u5FBD\u63EE\u6689\u7147\u8AF1\u8F1D\u9EBE\u4F11\u643A\u70CB\u7566\u8667\u6064\u8B4E\u9DF8\u5147\u51F6\u5308\u6D36\u80F8\u9ED1\u6615\u6B23\u7098\u75D5\u5403\u5C79\u7D07\u8A16\u6B20\u6B3D\u6B46\u5438\u6070\u6D3D\u7FD5\u8208\u50D6\u51DE\u559C\u566B\u56CD\u59EC\u5B09\u5E0C\u6199\u6198\u6231\u665E\u66E6\u7199\u71B9\u71BA\u72A7\u79A7\u7A00\u7FB2\u8A70"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/cp950.json +var require_cp950 = __commonJS({ + "node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module2) { + module2.exports = [ + ["0", "\0", 127], + ["a140", "\u3000\uFF0C\u3001\u3002\uFF0E\u2027\uFF1B\uFF1A\uFF1F\uFF01\uFE30\u2026\u2025\uFE50\uFE51\uFE52\xB7\uFE54\uFE55\uFE56\uFE57\uFF5C\u2013\uFE31\u2014\uFE33\u2574\uFE34\uFE4F\uFF08\uFF09\uFE35\uFE36\uFF5B\uFF5D\uFE37\uFE38\u3014\u3015\uFE39\uFE3A\u3010\u3011\uFE3B\uFE3C\u300A\u300B\uFE3D\uFE3E\u3008\u3009\uFE3F\uFE40\u300C\u300D\uFE41\uFE42\u300E\u300F\uFE43\uFE44\uFE59\uFE5A"], + ["a1a1", "\uFE5B\uFE5C\uFE5D\uFE5E\u2018\u2019\u201C\u201D\u301D\u301E\u2035\u2032\uFF03\uFF06\uFF0A\u203B\xA7\u3003\u25CB\u25CF\u25B3\u25B2\u25CE\u2606\u2605\u25C7\u25C6\u25A1\u25A0\u25BD\u25BC\u32A3\u2105\xAF\uFFE3\uFF3F\u02CD\uFE49\uFE4A\uFE4D\uFE4E\uFE4B\uFE4C\uFE5F\uFE60\uFE61\uFF0B\uFF0D\xD7\xF7\xB1\u221A\uFF1C\uFF1E\uFF1D\u2266\u2267\u2260\u221E\u2252\u2261\uFE62", 4, "\uFF5E\u2229\u222A\u22A5\u2220\u221F\u22BF\u33D2\u33D1\u222B\u222E\u2235\u2234\u2640\u2642\u2295\u2299\u2191\u2193\u2190\u2192\u2196\u2197\u2199\u2198\u2225\u2223\uFF0F"], + ["a240", "\uFF3C\u2215\uFE68\uFF04\uFFE5\u3012\uFFE0\uFFE1\uFF05\uFF20\u2103\u2109\uFE69\uFE6A\uFE6B\u33D5\u339C\u339D\u339E\u33CE\u33A1\u338E\u338F\u33C4\xB0\u5159\u515B\u515E\u515D\u5161\u5163\u55E7\u74E9\u7CCE\u2581", 7, "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u253C\u2534\u252C\u2524\u251C\u2594\u2500\u2502\u2595\u250C\u2510\u2514\u2518\u256D"], + ["a2a1", "\u256E\u2570\u256F\u2550\u255E\u256A\u2561\u25E2\u25E3\u25E5\u25E4\u2571\u2572\u2573\uFF10", 9, "\u2160", 9, "\u3021", 8, "\u5341\u5344\u5345\uFF21", 25, "\uFF41", 21], + ["a340", "\uFF57\uFF58\uFF59\uFF5A\u0391", 16, "\u03A3", 6, "\u03B1", 16, "\u03C3", 6, "\u3105", 10], + ["a3a1", "\u3110", 25, "\u02D9\u02C9\u02CA\u02C7\u02CB"], + ["a3e1", "\u20AC"], + ["a440", "\u4E00\u4E59\u4E01\u4E03\u4E43\u4E5D\u4E86\u4E8C\u4EBA\u513F\u5165\u516B\u51E0\u5200\u5201\u529B\u5315\u5341\u535C\u53C8\u4E09\u4E0B\u4E08\u4E0A\u4E2B\u4E38\u51E1\u4E45\u4E48\u4E5F\u4E5E\u4E8E\u4EA1\u5140\u5203\u52FA\u5343\u53C9\u53E3\u571F\u58EB\u5915\u5927\u5973\u5B50\u5B51\u5B53\u5BF8\u5C0F\u5C22\u5C38\u5C71\u5DDD\u5DE5\u5DF1\u5DF2\u5DF3\u5DFE\u5E72\u5EFE\u5F0B\u5F13\u624D"], + ["a4a1", "\u4E11\u4E10\u4E0D\u4E2D\u4E30\u4E39\u4E4B\u5C39\u4E88\u4E91\u4E95\u4E92\u4E94\u4EA2\u4EC1\u4EC0\u4EC3\u4EC6\u4EC7\u4ECD\u4ECA\u4ECB\u4EC4\u5143\u5141\u5167\u516D\u516E\u516C\u5197\u51F6\u5206\u5207\u5208\u52FB\u52FE\u52FF\u5316\u5339\u5348\u5347\u5345\u535E\u5384\u53CB\u53CA\u53CD\u58EC\u5929\u592B\u592A\u592D\u5B54\u5C11\u5C24\u5C3A\u5C6F\u5DF4\u5E7B\u5EFF\u5F14\u5F15\u5FC3\u6208\u6236\u624B\u624E\u652F\u6587\u6597\u65A4\u65B9\u65E5\u66F0\u6708\u6728\u6B20\u6B62\u6B79\u6BCB\u6BD4\u6BDB\u6C0F\u6C34\u706B\u722A\u7236\u723B\u7247\u7259\u725B\u72AC\u738B\u4E19"], + ["a540", "\u4E16\u4E15\u4E14\u4E18\u4E3B\u4E4D\u4E4F\u4E4E\u4EE5\u4ED8\u4ED4\u4ED5\u4ED6\u4ED7\u4EE3\u4EE4\u4ED9\u4EDE\u5145\u5144\u5189\u518A\u51AC\u51F9\u51FA\u51F8\u520A\u52A0\u529F\u5305\u5306\u5317\u531D\u4EDF\u534A\u5349\u5361\u5360\u536F\u536E\u53BB\u53EF\u53E4\u53F3\u53EC\u53EE\u53E9\u53E8\u53FC\u53F8\u53F5\u53EB\u53E6\u53EA\u53F2\u53F1\u53F0\u53E5\u53ED\u53FB\u56DB\u56DA\u5916"], + ["a5a1", "\u592E\u5931\u5974\u5976\u5B55\u5B83\u5C3C\u5DE8\u5DE7\u5DE6\u5E02\u5E03\u5E73\u5E7C\u5F01\u5F18\u5F17\u5FC5\u620A\u6253\u6254\u6252\u6251\u65A5\u65E6\u672E\u672C\u672A\u672B\u672D\u6B63\u6BCD\u6C11\u6C10\u6C38\u6C41\u6C40\u6C3E\u72AF\u7384\u7389\u74DC\u74E6\u7518\u751F\u7528\u7529\u7530\u7531\u7532\u7533\u758B\u767D\u76AE\u76BF\u76EE\u77DB\u77E2\u77F3\u793A\u79BE\u7A74\u7ACB\u4E1E\u4E1F\u4E52\u4E53\u4E69\u4E99\u4EA4\u4EA6\u4EA5\u4EFF\u4F09\u4F19\u4F0A\u4F15\u4F0D\u4F10\u4F11\u4F0F\u4EF2\u4EF6\u4EFB\u4EF0\u4EF3\u4EFD\u4F01\u4F0B\u5149\u5147\u5146\u5148\u5168"], + ["a640", "\u5171\u518D\u51B0\u5217\u5211\u5212\u520E\u5216\u52A3\u5308\u5321\u5320\u5370\u5371\u5409\u540F\u540C\u540A\u5410\u5401\u540B\u5404\u5411\u540D\u5408\u5403\u540E\u5406\u5412\u56E0\u56DE\u56DD\u5733\u5730\u5728\u572D\u572C\u572F\u5729\u5919\u591A\u5937\u5938\u5984\u5978\u5983\u597D\u5979\u5982\u5981\u5B57\u5B58\u5B87\u5B88\u5B85\u5B89\u5BFA\u5C16\u5C79\u5DDE\u5E06\u5E76\u5E74"], + ["a6a1", "\u5F0F\u5F1B\u5FD9\u5FD6\u620E\u620C\u620D\u6210\u6263\u625B\u6258\u6536\u65E9\u65E8\u65EC\u65ED\u66F2\u66F3\u6709\u673D\u6734\u6731\u6735\u6B21\u6B64\u6B7B\u6C16\u6C5D\u6C57\u6C59\u6C5F\u6C60\u6C50\u6C55\u6C61\u6C5B\u6C4D\u6C4E\u7070\u725F\u725D\u767E\u7AF9\u7C73\u7CF8\u7F36\u7F8A\u7FBD\u8001\u8003\u800C\u8012\u8033\u807F\u8089\u808B\u808C\u81E3\u81EA\u81F3\u81FC\u820C\u821B\u821F\u826E\u8272\u827E\u866B\u8840\u884C\u8863\u897F\u9621\u4E32\u4EA8\u4F4D\u4F4F\u4F47\u4F57\u4F5E\u4F34\u4F5B\u4F55\u4F30\u4F50\u4F51\u4F3D\u4F3A\u4F38\u4F43\u4F54\u4F3C\u4F46\u4F63"], + ["a740", "\u4F5C\u4F60\u4F2F\u4F4E\u4F36\u4F59\u4F5D\u4F48\u4F5A\u514C\u514B\u514D\u5175\u51B6\u51B7\u5225\u5224\u5229\u522A\u5228\u52AB\u52A9\u52AA\u52AC\u5323\u5373\u5375\u541D\u542D\u541E\u543E\u5426\u544E\u5427\u5446\u5443\u5433\u5448\u5442\u541B\u5429\u544A\u5439\u543B\u5438\u542E\u5435\u5436\u5420\u543C\u5440\u5431\u542B\u541F\u542C\u56EA\u56F0\u56E4\u56EB\u574A\u5751\u5740\u574D"], + ["a7a1", "\u5747\u574E\u573E\u5750\u574F\u573B\u58EF\u593E\u599D\u5992\u59A8\u599E\u59A3\u5999\u5996\u598D\u59A4\u5993\u598A\u59A5\u5B5D\u5B5C\u5B5A\u5B5B\u5B8C\u5B8B\u5B8F\u5C2C\u5C40\u5C41\u5C3F\u5C3E\u5C90\u5C91\u5C94\u5C8C\u5DEB\u5E0C\u5E8F\u5E87\u5E8A\u5EF7\u5F04\u5F1F\u5F64\u5F62\u5F77\u5F79\u5FD8\u5FCC\u5FD7\u5FCD\u5FF1\u5FEB\u5FF8\u5FEA\u6212\u6211\u6284\u6297\u6296\u6280\u6276\u6289\u626D\u628A\u627C\u627E\u6279\u6273\u6292\u626F\u6298\u626E\u6295\u6293\u6291\u6286\u6539\u653B\u6538\u65F1\u66F4\u675F\u674E\u674F\u6750\u6751\u675C\u6756\u675E\u6749\u6746\u6760"], + ["a840", "\u6753\u6757\u6B65\u6BCF\u6C42\u6C5E\u6C99\u6C81\u6C88\u6C89\u6C85\u6C9B\u6C6A\u6C7A\u6C90\u6C70\u6C8C\u6C68\u6C96\u6C92\u6C7D\u6C83\u6C72\u6C7E\u6C74\u6C86\u6C76\u6C8D\u6C94\u6C98\u6C82\u7076\u707C\u707D\u7078\u7262\u7261\u7260\u72C4\u72C2\u7396\u752C\u752B\u7537\u7538\u7682\u76EF\u77E3\u79C1\u79C0\u79BF\u7A76\u7CFB\u7F55\u8096\u8093\u809D\u8098\u809B\u809A\u80B2\u826F\u8292"], + ["a8a1", "\u828B\u828D\u898B\u89D2\u8A00\u8C37\u8C46\u8C55\u8C9D\u8D64\u8D70\u8DB3\u8EAB\u8ECA\u8F9B\u8FB0\u8FC2\u8FC6\u8FC5\u8FC4\u5DE1\u9091\u90A2\u90AA\u90A6\u90A3\u9149\u91C6\u91CC\u9632\u962E\u9631\u962A\u962C\u4E26\u4E56\u4E73\u4E8B\u4E9B\u4E9E\u4EAB\u4EAC\u4F6F\u4F9D\u4F8D\u4F73\u4F7F\u4F6C\u4F9B\u4F8B\u4F86\u4F83\u4F70\u4F75\u4F88\u4F69\u4F7B\u4F96\u4F7E\u4F8F\u4F91\u4F7A\u5154\u5152\u5155\u5169\u5177\u5176\u5178\u51BD\u51FD\u523B\u5238\u5237\u523A\u5230\u522E\u5236\u5241\u52BE\u52BB\u5352\u5354\u5353\u5351\u5366\u5377\u5378\u5379\u53D6\u53D4\u53D7\u5473\u5475"], + ["a940", "\u5496\u5478\u5495\u5480\u547B\u5477\u5484\u5492\u5486\u547C\u5490\u5471\u5476\u548C\u549A\u5462\u5468\u548B\u547D\u548E\u56FA\u5783\u5777\u576A\u5769\u5761\u5766\u5764\u577C\u591C\u5949\u5947\u5948\u5944\u5954\u59BE\u59BB\u59D4\u59B9\u59AE\u59D1\u59C6\u59D0\u59CD\u59CB\u59D3\u59CA\u59AF\u59B3\u59D2\u59C5\u5B5F\u5B64\u5B63\u5B97\u5B9A\u5B98\u5B9C\u5B99\u5B9B\u5C1A\u5C48\u5C45"], + ["a9a1", "\u5C46\u5CB7\u5CA1\u5CB8\u5CA9\u5CAB\u5CB1\u5CB3\u5E18\u5E1A\u5E16\u5E15\u5E1B\u5E11\u5E78\u5E9A\u5E97\u5E9C\u5E95\u5E96\u5EF6\u5F26\u5F27\u5F29\u5F80\u5F81\u5F7F\u5F7C\u5FDD\u5FE0\u5FFD\u5FF5\u5FFF\u600F\u6014\u602F\u6035\u6016\u602A\u6015\u6021\u6027\u6029\u602B\u601B\u6216\u6215\u623F\u623E\u6240\u627F\u62C9\u62CC\u62C4\u62BF\u62C2\u62B9\u62D2\u62DB\u62AB\u62D3\u62D4\u62CB\u62C8\u62A8\u62BD\u62BC\u62D0\u62D9\u62C7\u62CD\u62B5\u62DA\u62B1\u62D8\u62D6\u62D7\u62C6\u62AC\u62CE\u653E\u65A7\u65BC\u65FA\u6614\u6613\u660C\u6606\u6602\u660E\u6600\u660F\u6615\u660A"], + ["aa40", "\u6607\u670D\u670B\u676D\u678B\u6795\u6771\u679C\u6773\u6777\u6787\u679D\u6797\u676F\u6770\u677F\u6789\u677E\u6790\u6775\u679A\u6793\u677C\u676A\u6772\u6B23\u6B66\u6B67\u6B7F\u6C13\u6C1B\u6CE3\u6CE8\u6CF3\u6CB1\u6CCC\u6CE5\u6CB3\u6CBD\u6CBE\u6CBC\u6CE2\u6CAB\u6CD5\u6CD3\u6CB8\u6CC4\u6CB9\u6CC1\u6CAE\u6CD7\u6CC5\u6CF1\u6CBF\u6CBB\u6CE1\u6CDB\u6CCA\u6CAC\u6CEF\u6CDC\u6CD6\u6CE0"], + ["aaa1", "\u7095\u708E\u7092\u708A\u7099\u722C\u722D\u7238\u7248\u7267\u7269\u72C0\u72CE\u72D9\u72D7\u72D0\u73A9\u73A8\u739F\u73AB\u73A5\u753D\u759D\u7599\u759A\u7684\u76C2\u76F2\u76F4\u77E5\u77FD\u793E\u7940\u7941\u79C9\u79C8\u7A7A\u7A79\u7AFA\u7CFE\u7F54\u7F8C\u7F8B\u8005\u80BA\u80A5\u80A2\u80B1\u80A1\u80AB\u80A9\u80B4\u80AA\u80AF\u81E5\u81FE\u820D\u82B3\u829D\u8299\u82AD\u82BD\u829F\u82B9\u82B1\u82AC\u82A5\u82AF\u82B8\u82A3\u82B0\u82BE\u82B7\u864E\u8671\u521D\u8868\u8ECB\u8FCE\u8FD4\u8FD1\u90B5\u90B8\u90B1\u90B6\u91C7\u91D1\u9577\u9580\u961C\u9640\u963F\u963B\u9644"], + ["ab40", "\u9642\u96B9\u96E8\u9752\u975E\u4E9F\u4EAD\u4EAE\u4FE1\u4FB5\u4FAF\u4FBF\u4FE0\u4FD1\u4FCF\u4FDD\u4FC3\u4FB6\u4FD8\u4FDF\u4FCA\u4FD7\u4FAE\u4FD0\u4FC4\u4FC2\u4FDA\u4FCE\u4FDE\u4FB7\u5157\u5192\u5191\u51A0\u524E\u5243\u524A\u524D\u524C\u524B\u5247\u52C7\u52C9\u52C3\u52C1\u530D\u5357\u537B\u539A\u53DB\u54AC\u54C0\u54A8\u54CE\u54C9\u54B8\u54A6\u54B3\u54C7\u54C2\u54BD\u54AA\u54C1"], + ["aba1", "\u54C4\u54C8\u54AF\u54AB\u54B1\u54BB\u54A9\u54A7\u54BF\u56FF\u5782\u578B\u57A0\u57A3\u57A2\u57CE\u57AE\u5793\u5955\u5951\u594F\u594E\u5950\u59DC\u59D8\u59FF\u59E3\u59E8\u5A03\u59E5\u59EA\u59DA\u59E6\u5A01\u59FB\u5B69\u5BA3\u5BA6\u5BA4\u5BA2\u5BA5\u5C01\u5C4E\u5C4F\u5C4D\u5C4B\u5CD9\u5CD2\u5DF7\u5E1D\u5E25\u5E1F\u5E7D\u5EA0\u5EA6\u5EFA\u5F08\u5F2D\u5F65\u5F88\u5F85\u5F8A\u5F8B\u5F87\u5F8C\u5F89\u6012\u601D\u6020\u6025\u600E\u6028\u604D\u6070\u6068\u6062\u6046\u6043\u606C\u606B\u606A\u6064\u6241\u62DC\u6316\u6309\u62FC\u62ED\u6301\u62EE\u62FD\u6307\u62F1\u62F7"], + ["ac40", "\u62EF\u62EC\u62FE\u62F4\u6311\u6302\u653F\u6545\u65AB\u65BD\u65E2\u6625\u662D\u6620\u6627\u662F\u661F\u6628\u6631\u6624\u66F7\u67FF\u67D3\u67F1\u67D4\u67D0\u67EC\u67B6\u67AF\u67F5\u67E9\u67EF\u67C4\u67D1\u67B4\u67DA\u67E5\u67B8\u67CF\u67DE\u67F3\u67B0\u67D9\u67E2\u67DD\u67D2\u6B6A\u6B83\u6B86\u6BB5\u6BD2\u6BD7\u6C1F\u6CC9\u6D0B\u6D32\u6D2A\u6D41\u6D25\u6D0C\u6D31\u6D1E\u6D17"], + ["aca1", "\u6D3B\u6D3D\u6D3E\u6D36\u6D1B\u6CF5\u6D39\u6D27\u6D38\u6D29\u6D2E\u6D35\u6D0E\u6D2B\u70AB\u70BA\u70B3\u70AC\u70AF\u70AD\u70B8\u70AE\u70A4\u7230\u7272\u726F\u7274\u72E9\u72E0\u72E1\u73B7\u73CA\u73BB\u73B2\u73CD\u73C0\u73B3\u751A\u752D\u754F\u754C\u754E\u754B\u75AB\u75A4\u75A5\u75A2\u75A3\u7678\u7686\u7687\u7688\u76C8\u76C6\u76C3\u76C5\u7701\u76F9\u76F8\u7709\u770B\u76FE\u76FC\u7707\u77DC\u7802\u7814\u780C\u780D\u7946\u7949\u7948\u7947\u79B9\u79BA\u79D1\u79D2\u79CB\u7A7F\u7A81\u7AFF\u7AFD\u7C7D\u7D02\u7D05\u7D00\u7D09\u7D07\u7D04\u7D06\u7F38\u7F8E\u7FBF\u8004"], + ["ad40", "\u8010\u800D\u8011\u8036\u80D6\u80E5\u80DA\u80C3\u80C4\u80CC\u80E1\u80DB\u80CE\u80DE\u80E4\u80DD\u81F4\u8222\u82E7\u8303\u8305\u82E3\u82DB\u82E6\u8304\u82E5\u8302\u8309\u82D2\u82D7\u82F1\u8301\u82DC\u82D4\u82D1\u82DE\u82D3\u82DF\u82EF\u8306\u8650\u8679\u867B\u867A\u884D\u886B\u8981\u89D4\u8A08\u8A02\u8A03\u8C9E\u8CA0\u8D74\u8D73\u8DB4\u8ECD\u8ECC\u8FF0\u8FE6\u8FE2\u8FEA\u8FE5"], + ["ada1", "\u8FED\u8FEB\u8FE4\u8FE8\u90CA\u90CE\u90C1\u90C3\u914B\u914A\u91CD\u9582\u9650\u964B\u964C\u964D\u9762\u9769\u97CB\u97ED\u97F3\u9801\u98A8\u98DB\u98DF\u9996\u9999\u4E58\u4EB3\u500C\u500D\u5023\u4FEF\u5026\u5025\u4FF8\u5029\u5016\u5006\u503C\u501F\u501A\u5012\u5011\u4FFA\u5000\u5014\u5028\u4FF1\u5021\u500B\u5019\u5018\u4FF3\u4FEE\u502D\u502A\u4FFE\u502B\u5009\u517C\u51A4\u51A5\u51A2\u51CD\u51CC\u51C6\u51CB\u5256\u525C\u5254\u525B\u525D\u532A\u537F\u539F\u539D\u53DF\u54E8\u5510\u5501\u5537\u54FC\u54E5\u54F2\u5506\u54FA\u5514\u54E9\u54ED\u54E1\u5509\u54EE\u54EA"], + ["ae40", "\u54E6\u5527\u5507\u54FD\u550F\u5703\u5704\u57C2\u57D4\u57CB\u57C3\u5809\u590F\u5957\u5958\u595A\u5A11\u5A18\u5A1C\u5A1F\u5A1B\u5A13\u59EC\u5A20\u5A23\u5A29\u5A25\u5A0C\u5A09\u5B6B\u5C58\u5BB0\u5BB3\u5BB6\u5BB4\u5BAE\u5BB5\u5BB9\u5BB8\u5C04\u5C51\u5C55\u5C50\u5CED\u5CFD\u5CFB\u5CEA\u5CE8\u5CF0\u5CF6\u5D01\u5CF4\u5DEE\u5E2D\u5E2B\u5EAB\u5EAD\u5EA7\u5F31\u5F92\u5F91\u5F90\u6059"], + ["aea1", "\u6063\u6065\u6050\u6055\u606D\u6069\u606F\u6084\u609F\u609A\u608D\u6094\u608C\u6085\u6096\u6247\u62F3\u6308\u62FF\u634E\u633E\u632F\u6355\u6342\u6346\u634F\u6349\u633A\u6350\u633D\u632A\u632B\u6328\u634D\u634C\u6548\u6549\u6599\u65C1\u65C5\u6642\u6649\u664F\u6643\u6652\u664C\u6645\u6641\u66F8\u6714\u6715\u6717\u6821\u6838\u6848\u6846\u6853\u6839\u6842\u6854\u6829\u68B3\u6817\u684C\u6851\u683D\u67F4\u6850\u6840\u683C\u6843\u682A\u6845\u6813\u6818\u6841\u6B8A\u6B89\u6BB7\u6C23\u6C27\u6C28\u6C26\u6C24\u6CF0\u6D6A\u6D95\u6D88\u6D87\u6D66\u6D78\u6D77\u6D59\u6D93"], + ["af40", "\u6D6C\u6D89\u6D6E\u6D5A\u6D74\u6D69\u6D8C\u6D8A\u6D79\u6D85\u6D65\u6D94\u70CA\u70D8\u70E4\u70D9\u70C8\u70CF\u7239\u7279\u72FC\u72F9\u72FD\u72F8\u72F7\u7386\u73ED\u7409\u73EE\u73E0\u73EA\u73DE\u7554\u755D\u755C\u755A\u7559\u75BE\u75C5\u75C7\u75B2\u75B3\u75BD\u75BC\u75B9\u75C2\u75B8\u768B\u76B0\u76CA\u76CD\u76CE\u7729\u771F\u7720\u7728\u77E9\u7830\u7827\u7838\u781D\u7834\u7837"], + ["afa1", "\u7825\u782D\u7820\u781F\u7832\u7955\u7950\u7960\u795F\u7956\u795E\u795D\u7957\u795A\u79E4\u79E3\u79E7\u79DF\u79E6\u79E9\u79D8\u7A84\u7A88\u7AD9\u7B06\u7B11\u7C89\u7D21\u7D17\u7D0B\u7D0A\u7D20\u7D22\u7D14\u7D10\u7D15\u7D1A\u7D1C\u7D0D\u7D19\u7D1B\u7F3A\u7F5F\u7F94\u7FC5\u7FC1\u8006\u8018\u8015\u8019\u8017\u803D\u803F\u80F1\u8102\u80F0\u8105\u80ED\u80F4\u8106\u80F8\u80F3\u8108\u80FD\u810A\u80FC\u80EF\u81ED\u81EC\u8200\u8210\u822A\u822B\u8228\u822C\u82BB\u832B\u8352\u8354\u834A\u8338\u8350\u8349\u8335\u8334\u834F\u8332\u8339\u8336\u8317\u8340\u8331\u8328\u8343"], + ["b040", "\u8654\u868A\u86AA\u8693\u86A4\u86A9\u868C\u86A3\u869C\u8870\u8877\u8881\u8882\u887D\u8879\u8A18\u8A10\u8A0E\u8A0C\u8A15\u8A0A\u8A17\u8A13\u8A16\u8A0F\u8A11\u8C48\u8C7A\u8C79\u8CA1\u8CA2\u8D77\u8EAC\u8ED2\u8ED4\u8ECF\u8FB1\u9001\u9006\u8FF7\u9000\u8FFA\u8FF4\u9003\u8FFD\u9005\u8FF8\u9095\u90E1\u90DD\u90E2\u9152\u914D\u914C\u91D8\u91DD\u91D7\u91DC\u91D9\u9583\u9662\u9663\u9661"], + ["b0a1", "\u965B\u965D\u9664\u9658\u965E\u96BB\u98E2\u99AC\u9AA8\u9AD8\u9B25\u9B32\u9B3C\u4E7E\u507A\u507D\u505C\u5047\u5043\u504C\u505A\u5049\u5065\u5076\u504E\u5055\u5075\u5074\u5077\u504F\u500F\u506F\u506D\u515C\u5195\u51F0\u526A\u526F\u52D2\u52D9\u52D8\u52D5\u5310\u530F\u5319\u533F\u5340\u533E\u53C3\u66FC\u5546\u556A\u5566\u5544\u555E\u5561\u5543\u554A\u5531\u5556\u554F\u5555\u552F\u5564\u5538\u552E\u555C\u552C\u5563\u5533\u5541\u5557\u5708\u570B\u5709\u57DF\u5805\u580A\u5806\u57E0\u57E4\u57FA\u5802\u5835\u57F7\u57F9\u5920\u5962\u5A36\u5A41\u5A49\u5A66\u5A6A\u5A40"], + ["b140", "\u5A3C\u5A62\u5A5A\u5A46\u5A4A\u5B70\u5BC7\u5BC5\u5BC4\u5BC2\u5BBF\u5BC6\u5C09\u5C08\u5C07\u5C60\u5C5C\u5C5D\u5D07\u5D06\u5D0E\u5D1B\u5D16\u5D22\u5D11\u5D29\u5D14\u5D19\u5D24\u5D27\u5D17\u5DE2\u5E38\u5E36\u5E33\u5E37\u5EB7\u5EB8\u5EB6\u5EB5\u5EBE\u5F35\u5F37\u5F57\u5F6C\u5F69\u5F6B\u5F97\u5F99\u5F9E\u5F98\u5FA1\u5FA0\u5F9C\u607F\u60A3\u6089\u60A0\u60A8\u60CB\u60B4\u60E6\u60BD"], + ["b1a1", "\u60C5\u60BB\u60B5\u60DC\u60BC\u60D8\u60D5\u60C6\u60DF\u60B8\u60DA\u60C7\u621A\u621B\u6248\u63A0\u63A7\u6372\u6396\u63A2\u63A5\u6377\u6367\u6398\u63AA\u6371\u63A9\u6389\u6383\u639B\u636B\u63A8\u6384\u6388\u6399\u63A1\u63AC\u6392\u638F\u6380\u637B\u6369\u6368\u637A\u655D\u6556\u6551\u6559\u6557\u555F\u654F\u6558\u6555\u6554\u659C\u659B\u65AC\u65CF\u65CB\u65CC\u65CE\u665D\u665A\u6664\u6668\u6666\u665E\u66F9\u52D7\u671B\u6881\u68AF\u68A2\u6893\u68B5\u687F\u6876\u68B1\u68A7\u6897\u68B0\u6883\u68C4\u68AD\u6886\u6885\u6894\u689D\u68A8\u689F\u68A1\u6882\u6B32\u6BBA"], + ["b240", "\u6BEB\u6BEC\u6C2B\u6D8E\u6DBC\u6DF3\u6DD9\u6DB2\u6DE1\u6DCC\u6DE4\u6DFB\u6DFA\u6E05\u6DC7\u6DCB\u6DAF\u6DD1\u6DAE\u6DDE\u6DF9\u6DB8\u6DF7\u6DF5\u6DC5\u6DD2\u6E1A\u6DB5\u6DDA\u6DEB\u6DD8\u6DEA\u6DF1\u6DEE\u6DE8\u6DC6\u6DC4\u6DAA\u6DEC\u6DBF\u6DE6\u70F9\u7109\u710A\u70FD\u70EF\u723D\u727D\u7281\u731C\u731B\u7316\u7313\u7319\u7387\u7405\u740A\u7403\u7406\u73FE\u740D\u74E0\u74F6"], + ["b2a1", "\u74F7\u751C\u7522\u7565\u7566\u7562\u7570\u758F\u75D4\u75D5\u75B5\u75CA\u75CD\u768E\u76D4\u76D2\u76DB\u7737\u773E\u773C\u7736\u7738\u773A\u786B\u7843\u784E\u7965\u7968\u796D\u79FB\u7A92\u7A95\u7B20\u7B28\u7B1B\u7B2C\u7B26\u7B19\u7B1E\u7B2E\u7C92\u7C97\u7C95\u7D46\u7D43\u7D71\u7D2E\u7D39\u7D3C\u7D40\u7D30\u7D33\u7D44\u7D2F\u7D42\u7D32\u7D31\u7F3D\u7F9E\u7F9A\u7FCC\u7FCE\u7FD2\u801C\u804A\u8046\u812F\u8116\u8123\u812B\u8129\u8130\u8124\u8202\u8235\u8237\u8236\u8239\u838E\u839E\u8398\u8378\u83A2\u8396\u83BD\u83AB\u8392\u838A\u8393\u8389\u83A0\u8377\u837B\u837C"], + ["b340", "\u8386\u83A7\u8655\u5F6A\u86C7\u86C0\u86B6\u86C4\u86B5\u86C6\u86CB\u86B1\u86AF\u86C9\u8853\u889E\u8888\u88AB\u8892\u8896\u888D\u888B\u8993\u898F\u8A2A\u8A1D\u8A23\u8A25\u8A31\u8A2D\u8A1F\u8A1B\u8A22\u8C49\u8C5A\u8CA9\u8CAC\u8CAB\u8CA8\u8CAA\u8CA7\u8D67\u8D66\u8DBE\u8DBA\u8EDB\u8EDF\u9019\u900D\u901A\u9017\u9023\u901F\u901D\u9010\u9015\u901E\u9020\u900F\u9022\u9016\u901B\u9014"], + ["b3a1", "\u90E8\u90ED\u90FD\u9157\u91CE\u91F5\u91E6\u91E3\u91E7\u91ED\u91E9\u9589\u966A\u9675\u9673\u9678\u9670\u9674\u9676\u9677\u966C\u96C0\u96EA\u96E9\u7AE0\u7ADF\u9802\u9803\u9B5A\u9CE5\u9E75\u9E7F\u9EA5\u9EBB\u50A2\u508D\u5085\u5099\u5091\u5080\u5096\u5098\u509A\u6700\u51F1\u5272\u5274\u5275\u5269\u52DE\u52DD\u52DB\u535A\u53A5\u557B\u5580\u55A7\u557C\u558A\u559D\u5598\u5582\u559C\u55AA\u5594\u5587\u558B\u5583\u55B3\u55AE\u559F\u553E\u55B2\u559A\u55BB\u55AC\u55B1\u557E\u5589\u55AB\u5599\u570D\u582F\u582A\u5834\u5824\u5830\u5831\u5821\u581D\u5820\u58F9\u58FA\u5960"], + ["b440", "\u5A77\u5A9A\u5A7F\u5A92\u5A9B\u5AA7\u5B73\u5B71\u5BD2\u5BCC\u5BD3\u5BD0\u5C0A\u5C0B\u5C31\u5D4C\u5D50\u5D34\u5D47\u5DFD\u5E45\u5E3D\u5E40\u5E43\u5E7E\u5ECA\u5EC1\u5EC2\u5EC4\u5F3C\u5F6D\u5FA9\u5FAA\u5FA8\u60D1\u60E1\u60B2\u60B6\u60E0\u611C\u6123\u60FA\u6115\u60F0\u60FB\u60F4\u6168\u60F1\u610E\u60F6\u6109\u6100\u6112\u621F\u6249\u63A3\u638C\u63CF\u63C0\u63E9\u63C9\u63C6\u63CD"], + ["b4a1", "\u63D2\u63E3\u63D0\u63E1\u63D6\u63ED\u63EE\u6376\u63F4\u63EA\u63DB\u6452\u63DA\u63F9\u655E\u6566\u6562\u6563\u6591\u6590\u65AF\u666E\u6670\u6674\u6676\u666F\u6691\u667A\u667E\u6677\u66FE\u66FF\u671F\u671D\u68FA\u68D5\u68E0\u68D8\u68D7\u6905\u68DF\u68F5\u68EE\u68E7\u68F9\u68D2\u68F2\u68E3\u68CB\u68CD\u690D\u6912\u690E\u68C9\u68DA\u696E\u68FB\u6B3E\u6B3A\u6B3D\u6B98\u6B96\u6BBC\u6BEF\u6C2E\u6C2F\u6C2C\u6E2F\u6E38\u6E54\u6E21\u6E32\u6E67\u6E4A\u6E20\u6E25\u6E23\u6E1B\u6E5B\u6E58\u6E24\u6E56\u6E6E\u6E2D\u6E26\u6E6F\u6E34\u6E4D\u6E3A\u6E2C\u6E43\u6E1D\u6E3E\u6ECB"], + ["b540", "\u6E89\u6E19\u6E4E\u6E63\u6E44\u6E72\u6E69\u6E5F\u7119\u711A\u7126\u7130\u7121\u7136\u716E\u711C\u724C\u7284\u7280\u7336\u7325\u7334\u7329\u743A\u742A\u7433\u7422\u7425\u7435\u7436\u7434\u742F\u741B\u7426\u7428\u7525\u7526\u756B\u756A\u75E2\u75DB\u75E3\u75D9\u75D8\u75DE\u75E0\u767B\u767C\u7696\u7693\u76B4\u76DC\u774F\u77ED\u785D\u786C\u786F\u7A0D\u7A08\u7A0B\u7A05\u7A00\u7A98"], + ["b5a1", "\u7A97\u7A96\u7AE5\u7AE3\u7B49\u7B56\u7B46\u7B50\u7B52\u7B54\u7B4D\u7B4B\u7B4F\u7B51\u7C9F\u7CA5\u7D5E\u7D50\u7D68\u7D55\u7D2B\u7D6E\u7D72\u7D61\u7D66\u7D62\u7D70\u7D73\u5584\u7FD4\u7FD5\u800B\u8052\u8085\u8155\u8154\u814B\u8151\u814E\u8139\u8146\u813E\u814C\u8153\u8174\u8212\u821C\u83E9\u8403\u83F8\u840D\u83E0\u83C5\u840B\u83C1\u83EF\u83F1\u83F4\u8457\u840A\u83F0\u840C\u83CC\u83FD\u83F2\u83CA\u8438\u840E\u8404\u83DC\u8407\u83D4\u83DF\u865B\u86DF\u86D9\u86ED\u86D4\u86DB\u86E4\u86D0\u86DE\u8857\u88C1\u88C2\u88B1\u8983\u8996\u8A3B\u8A60\u8A55\u8A5E\u8A3C\u8A41"], + ["b640", "\u8A54\u8A5B\u8A50\u8A46\u8A34\u8A3A\u8A36\u8A56\u8C61\u8C82\u8CAF\u8CBC\u8CB3\u8CBD\u8CC1\u8CBB\u8CC0\u8CB4\u8CB7\u8CB6\u8CBF\u8CB8\u8D8A\u8D85\u8D81\u8DCE\u8DDD\u8DCB\u8DDA\u8DD1\u8DCC\u8DDB\u8DC6\u8EFB\u8EF8\u8EFC\u8F9C\u902E\u9035\u9031\u9038\u9032\u9036\u9102\u90F5\u9109\u90FE\u9163\u9165\u91CF\u9214\u9215\u9223\u9209\u921E\u920D\u9210\u9207\u9211\u9594\u958F\u958B\u9591"], + ["b6a1", "\u9593\u9592\u958E\u968A\u968E\u968B\u967D\u9685\u9686\u968D\u9672\u9684\u96C1\u96C5\u96C4\u96C6\u96C7\u96EF\u96F2\u97CC\u9805\u9806\u9808\u98E7\u98EA\u98EF\u98E9\u98F2\u98ED\u99AE\u99AD\u9EC3\u9ECD\u9ED1\u4E82\u50AD\u50B5\u50B2\u50B3\u50C5\u50BE\u50AC\u50B7\u50BB\u50AF\u50C7\u527F\u5277\u527D\u52DF\u52E6\u52E4\u52E2\u52E3\u532F\u55DF\u55E8\u55D3\u55E6\u55CE\u55DC\u55C7\u55D1\u55E3\u55E4\u55EF\u55DA\u55E1\u55C5\u55C6\u55E5\u55C9\u5712\u5713\u585E\u5851\u5858\u5857\u585A\u5854\u586B\u584C\u586D\u584A\u5862\u5852\u584B\u5967\u5AC1\u5AC9\u5ACC\u5ABE\u5ABD\u5ABC"], + ["b740", "\u5AB3\u5AC2\u5AB2\u5D69\u5D6F\u5E4C\u5E79\u5EC9\u5EC8\u5F12\u5F59\u5FAC\u5FAE\u611A\u610F\u6148\u611F\u60F3\u611B\u60F9\u6101\u6108\u614E\u614C\u6144\u614D\u613E\u6134\u6127\u610D\u6106\u6137\u6221\u6222\u6413\u643E\u641E\u642A\u642D\u643D\u642C\u640F\u641C\u6414\u640D\u6436\u6416\u6417\u6406\u656C\u659F\u65B0\u6697\u6689\u6687\u6688\u6696\u6684\u6698\u668D\u6703\u6994\u696D"], + ["b7a1", "\u695A\u6977\u6960\u6954\u6975\u6930\u6982\u694A\u6968\u696B\u695E\u6953\u6979\u6986\u695D\u6963\u695B\u6B47\u6B72\u6BC0\u6BBF\u6BD3\u6BFD\u6EA2\u6EAF\u6ED3\u6EB6\u6EC2\u6E90\u6E9D\u6EC7\u6EC5\u6EA5\u6E98\u6EBC\u6EBA\u6EAB\u6ED1\u6E96\u6E9C\u6EC4\u6ED4\u6EAA\u6EA7\u6EB4\u714E\u7159\u7169\u7164\u7149\u7167\u715C\u716C\u7166\u714C\u7165\u715E\u7146\u7168\u7156\u723A\u7252\u7337\u7345\u733F\u733E\u746F\u745A\u7455\u745F\u745E\u7441\u743F\u7459\u745B\u745C\u7576\u7578\u7600\u75F0\u7601\u75F2\u75F1\u75FA\u75FF\u75F4\u75F3\u76DE\u76DF\u775B\u776B\u7766\u775E\u7763"], + ["b840", "\u7779\u776A\u776C\u775C\u7765\u7768\u7762\u77EE\u788E\u78B0\u7897\u7898\u788C\u7889\u787C\u7891\u7893\u787F\u797A\u797F\u7981\u842C\u79BD\u7A1C\u7A1A\u7A20\u7A14\u7A1F\u7A1E\u7A9F\u7AA0\u7B77\u7BC0\u7B60\u7B6E\u7B67\u7CB1\u7CB3\u7CB5\u7D93\u7D79\u7D91\u7D81\u7D8F\u7D5B\u7F6E\u7F69\u7F6A\u7F72\u7FA9\u7FA8\u7FA4\u8056\u8058\u8086\u8084\u8171\u8170\u8178\u8165\u816E\u8173\u816B"], + ["b8a1", "\u8179\u817A\u8166\u8205\u8247\u8482\u8477\u843D\u8431\u8475\u8466\u846B\u8449\u846C\u845B\u843C\u8435\u8461\u8463\u8469\u846D\u8446\u865E\u865C\u865F\u86F9\u8713\u8708\u8707\u8700\u86FE\u86FB\u8702\u8703\u8706\u870A\u8859\u88DF\u88D4\u88D9\u88DC\u88D8\u88DD\u88E1\u88CA\u88D5\u88D2\u899C\u89E3\u8A6B\u8A72\u8A73\u8A66\u8A69\u8A70\u8A87\u8A7C\u8A63\u8AA0\u8A71\u8A85\u8A6D\u8A62\u8A6E\u8A6C\u8A79\u8A7B\u8A3E\u8A68\u8C62\u8C8A\u8C89\u8CCA\u8CC7\u8CC8\u8CC4\u8CB2\u8CC3\u8CC2\u8CC5\u8DE1\u8DDF\u8DE8\u8DEF\u8DF3\u8DFA\u8DEA\u8DE4\u8DE6\u8EB2\u8F03\u8F09\u8EFE\u8F0A"], + ["b940", "\u8F9F\u8FB2\u904B\u904A\u9053\u9042\u9054\u903C\u9055\u9050\u9047\u904F\u904E\u904D\u9051\u903E\u9041\u9112\u9117\u916C\u916A\u9169\u91C9\u9237\u9257\u9238\u923D\u9240\u923E\u925B\u924B\u9264\u9251\u9234\u9249\u924D\u9245\u9239\u923F\u925A\u9598\u9698\u9694\u9695\u96CD\u96CB\u96C9\u96CA\u96F7\u96FB\u96F9\u96F6\u9756\u9774\u9776\u9810\u9811\u9813\u980A\u9812\u980C\u98FC\u98F4"], + ["b9a1", "\u98FD\u98FE\u99B3\u99B1\u99B4\u9AE1\u9CE9\u9E82\u9F0E\u9F13\u9F20\u50E7\u50EE\u50E5\u50D6\u50ED\u50DA\u50D5\u50CF\u50D1\u50F1\u50CE\u50E9\u5162\u51F3\u5283\u5282\u5331\u53AD\u55FE\u5600\u561B\u5617\u55FD\u5614\u5606\u5609\u560D\u560E\u55F7\u5616\u561F\u5608\u5610\u55F6\u5718\u5716\u5875\u587E\u5883\u5893\u588A\u5879\u5885\u587D\u58FD\u5925\u5922\u5924\u596A\u5969\u5AE1\u5AE6\u5AE9\u5AD7\u5AD6\u5AD8\u5AE3\u5B75\u5BDE\u5BE7\u5BE1\u5BE5\u5BE6\u5BE8\u5BE2\u5BE4\u5BDF\u5C0D\u5C62\u5D84\u5D87\u5E5B\u5E63\u5E55\u5E57\u5E54\u5ED3\u5ED6\u5F0A\u5F46\u5F70\u5FB9\u6147"], + ["ba40", "\u613F\u614B\u6177\u6162\u6163\u615F\u615A\u6158\u6175\u622A\u6487\u6458\u6454\u64A4\u6478\u645F\u647A\u6451\u6467\u6434\u646D\u647B\u6572\u65A1\u65D7\u65D6\u66A2\u66A8\u669D\u699C\u69A8\u6995\u69C1\u69AE\u69D3\u69CB\u699B\u69B7\u69BB\u69AB\u69B4\u69D0\u69CD\u69AD\u69CC\u69A6\u69C3\u69A3\u6B49\u6B4C\u6C33\u6F33\u6F14\u6EFE\u6F13\u6EF4\u6F29\u6F3E\u6F20\u6F2C\u6F0F\u6F02\u6F22"], + ["baa1", "\u6EFF\u6EEF\u6F06\u6F31\u6F38\u6F32\u6F23\u6F15\u6F2B\u6F2F\u6F88\u6F2A\u6EEC\u6F01\u6EF2\u6ECC\u6EF7\u7194\u7199\u717D\u718A\u7184\u7192\u723E\u7292\u7296\u7344\u7350\u7464\u7463\u746A\u7470\u746D\u7504\u7591\u7627\u760D\u760B\u7609\u7613\u76E1\u76E3\u7784\u777D\u777F\u7761\u78C1\u789F\u78A7\u78B3\u78A9\u78A3\u798E\u798F\u798D\u7A2E\u7A31\u7AAA\u7AA9\u7AED\u7AEF\u7BA1\u7B95\u7B8B\u7B75\u7B97\u7B9D\u7B94\u7B8F\u7BB8\u7B87\u7B84\u7CB9\u7CBD\u7CBE\u7DBB\u7DB0\u7D9C\u7DBD\u7DBE\u7DA0\u7DCA\u7DB4\u7DB2\u7DB1\u7DBA\u7DA2\u7DBF\u7DB5\u7DB8\u7DAD\u7DD2\u7DC7\u7DAC"], + ["bb40", "\u7F70\u7FE0\u7FE1\u7FDF\u805E\u805A\u8087\u8150\u8180\u818F\u8188\u818A\u817F\u8182\u81E7\u81FA\u8207\u8214\u821E\u824B\u84C9\u84BF\u84C6\u84C4\u8499\u849E\u84B2\u849C\u84CB\u84B8\u84C0\u84D3\u8490\u84BC\u84D1\u84CA\u873F\u871C\u873B\u8722\u8725\u8734\u8718\u8755\u8737\u8729\u88F3\u8902\u88F4\u88F9\u88F8\u88FD\u88E8\u891A\u88EF\u8AA6\u8A8C\u8A9E\u8AA3\u8A8D\u8AA1\u8A93\u8AA4"], + ["bba1", "\u8AAA\u8AA5\u8AA8\u8A98\u8A91\u8A9A\u8AA7\u8C6A\u8C8D\u8C8C\u8CD3\u8CD1\u8CD2\u8D6B\u8D99\u8D95\u8DFC\u8F14\u8F12\u8F15\u8F13\u8FA3\u9060\u9058\u905C\u9063\u9059\u905E\u9062\u905D\u905B\u9119\u9118\u911E\u9175\u9178\u9177\u9174\u9278\u9280\u9285\u9298\u9296\u927B\u9293\u929C\u92A8\u927C\u9291\u95A1\u95A8\u95A9\u95A3\u95A5\u95A4\u9699\u969C\u969B\u96CC\u96D2\u9700\u977C\u9785\u97F6\u9817\u9818\u98AF\u98B1\u9903\u9905\u990C\u9909\u99C1\u9AAF\u9AB0\u9AE6\u9B41\u9B42\u9CF4\u9CF6\u9CF3\u9EBC\u9F3B\u9F4A\u5104\u5100\u50FB\u50F5\u50F9\u5102\u5108\u5109\u5105\u51DC"], + ["bc40", "\u5287\u5288\u5289\u528D\u528A\u52F0\u53B2\u562E\u563B\u5639\u5632\u563F\u5634\u5629\u5653\u564E\u5657\u5674\u5636\u562F\u5630\u5880\u589F\u589E\u58B3\u589C\u58AE\u58A9\u58A6\u596D\u5B09\u5AFB\u5B0B\u5AF5\u5B0C\u5B08\u5BEE\u5BEC\u5BE9\u5BEB\u5C64\u5C65\u5D9D\u5D94\u5E62\u5E5F\u5E61\u5EE2\u5EDA\u5EDF\u5EDD\u5EE3\u5EE0\u5F48\u5F71\u5FB7\u5FB5\u6176\u6167\u616E\u615D\u6155\u6182"], + ["bca1", "\u617C\u6170\u616B\u617E\u61A7\u6190\u61AB\u618E\u61AC\u619A\u61A4\u6194\u61AE\u622E\u6469\u646F\u6479\u649E\u64B2\u6488\u6490\u64B0\u64A5\u6493\u6495\u64A9\u6492\u64AE\u64AD\u64AB\u649A\u64AC\u6499\u64A2\u64B3\u6575\u6577\u6578\u66AE\u66AB\u66B4\u66B1\u6A23\u6A1F\u69E8\u6A01\u6A1E\u6A19\u69FD\u6A21\u6A13\u6A0A\u69F3\u6A02\u6A05\u69ED\u6A11\u6B50\u6B4E\u6BA4\u6BC5\u6BC6\u6F3F\u6F7C\u6F84\u6F51\u6F66\u6F54\u6F86\u6F6D\u6F5B\u6F78\u6F6E\u6F8E\u6F7A\u6F70\u6F64\u6F97\u6F58\u6ED5\u6F6F\u6F60\u6F5F\u719F\u71AC\u71B1\u71A8\u7256\u729B\u734E\u7357\u7469\u748B\u7483"], + ["bd40", "\u747E\u7480\u757F\u7620\u7629\u761F\u7624\u7626\u7621\u7622\u769A\u76BA\u76E4\u778E\u7787\u778C\u7791\u778B\u78CB\u78C5\u78BA\u78CA\u78BE\u78D5\u78BC\u78D0\u7A3F\u7A3C\u7A40\u7A3D\u7A37\u7A3B\u7AAF\u7AAE\u7BAD\u7BB1\u7BC4\u7BB4\u7BC6\u7BC7\u7BC1\u7BA0\u7BCC\u7CCA\u7DE0\u7DF4\u7DEF\u7DFB\u7DD8\u7DEC\u7DDD\u7DE8\u7DE3\u7DDA\u7DDE\u7DE9\u7D9E\u7DD9\u7DF2\u7DF9\u7F75\u7F77\u7FAF"], + ["bda1", "\u7FE9\u8026\u819B\u819C\u819D\u81A0\u819A\u8198\u8517\u853D\u851A\u84EE\u852C\u852D\u8513\u8511\u8523\u8521\u8514\u84EC\u8525\u84FF\u8506\u8782\u8774\u8776\u8760\u8766\u8778\u8768\u8759\u8757\u874C\u8753\u885B\u885D\u8910\u8907\u8912\u8913\u8915\u890A\u8ABC\u8AD2\u8AC7\u8AC4\u8A95\u8ACB\u8AF8\u8AB2\u8AC9\u8AC2\u8ABF\u8AB0\u8AD6\u8ACD\u8AB6\u8AB9\u8ADB\u8C4C\u8C4E\u8C6C\u8CE0\u8CDE\u8CE6\u8CE4\u8CEC\u8CED\u8CE2\u8CE3\u8CDC\u8CEA\u8CE1\u8D6D\u8D9F\u8DA3\u8E2B\u8E10\u8E1D\u8E22\u8E0F\u8E29\u8E1F\u8E21\u8E1E\u8EBA\u8F1D\u8F1B\u8F1F\u8F29\u8F26\u8F2A\u8F1C\u8F1E"], + ["be40", "\u8F25\u9069\u906E\u9068\u906D\u9077\u9130\u912D\u9127\u9131\u9187\u9189\u918B\u9183\u92C5\u92BB\u92B7\u92EA\u92AC\u92E4\u92C1\u92B3\u92BC\u92D2\u92C7\u92F0\u92B2\u95AD\u95B1\u9704\u9706\u9707\u9709\u9760\u978D\u978B\u978F\u9821\u982B\u981C\u98B3\u990A\u9913\u9912\u9918\u99DD\u99D0\u99DF\u99DB\u99D1\u99D5\u99D2\u99D9\u9AB7\u9AEE\u9AEF\u9B27\u9B45\u9B44\u9B77\u9B6F\u9D06\u9D09"], + ["bea1", "\u9D03\u9EA9\u9EBE\u9ECE\u58A8\u9F52\u5112\u5118\u5114\u5110\u5115\u5180\u51AA\u51DD\u5291\u5293\u52F3\u5659\u566B\u5679\u5669\u5664\u5678\u566A\u5668\u5665\u5671\u566F\u566C\u5662\u5676\u58C1\u58BE\u58C7\u58C5\u596E\u5B1D\u5B34\u5B78\u5BF0\u5C0E\u5F4A\u61B2\u6191\u61A9\u618A\u61CD\u61B6\u61BE\u61CA\u61C8\u6230\u64C5\u64C1\u64CB\u64BB\u64BC\u64DA\u64C4\u64C7\u64C2\u64CD\u64BF\u64D2\u64D4\u64BE\u6574\u66C6\u66C9\u66B9\u66C4\u66C7\u66B8\u6A3D\u6A38\u6A3A\u6A59\u6A6B\u6A58\u6A39\u6A44\u6A62\u6A61\u6A4B\u6A47\u6A35\u6A5F\u6A48\u6B59\u6B77\u6C05\u6FC2\u6FB1\u6FA1"], + ["bf40", "\u6FC3\u6FA4\u6FC1\u6FA7\u6FB3\u6FC0\u6FB9\u6FB6\u6FA6\u6FA0\u6FB4\u71BE\u71C9\u71D0\u71D2\u71C8\u71D5\u71B9\u71CE\u71D9\u71DC\u71C3\u71C4\u7368\u749C\u74A3\u7498\u749F\u749E\u74E2\u750C\u750D\u7634\u7638\u763A\u76E7\u76E5\u77A0\u779E\u779F\u77A5\u78E8\u78DA\u78EC\u78E7\u79A6\u7A4D\u7A4E\u7A46\u7A4C\u7A4B\u7ABA\u7BD9\u7C11\u7BC9\u7BE4\u7BDB\u7BE1\u7BE9\u7BE6\u7CD5\u7CD6\u7E0A"], + ["bfa1", "\u7E11\u7E08\u7E1B\u7E23\u7E1E\u7E1D\u7E09\u7E10\u7F79\u7FB2\u7FF0\u7FF1\u7FEE\u8028\u81B3\u81A9\u81A8\u81FB\u8208\u8258\u8259\u854A\u8559\u8548\u8568\u8569\u8543\u8549\u856D\u856A\u855E\u8783\u879F\u879E\u87A2\u878D\u8861\u892A\u8932\u8925\u892B\u8921\u89AA\u89A6\u8AE6\u8AFA\u8AEB\u8AF1\u8B00\u8ADC\u8AE7\u8AEE\u8AFE\u8B01\u8B02\u8AF7\u8AED\u8AF3\u8AF6\u8AFC\u8C6B\u8C6D\u8C93\u8CF4\u8E44\u8E31\u8E34\u8E42\u8E39\u8E35\u8F3B\u8F2F\u8F38\u8F33\u8FA8\u8FA6\u9075\u9074\u9078\u9072\u907C\u907A\u9134\u9192\u9320\u9336\u92F8\u9333\u932F\u9322\u92FC\u932B\u9304\u931A"], + ["c040", "\u9310\u9326\u9321\u9315\u932E\u9319\u95BB\u96A7\u96A8\u96AA\u96D5\u970E\u9711\u9716\u970D\u9713\u970F\u975B\u975C\u9766\u9798\u9830\u9838\u983B\u9837\u982D\u9839\u9824\u9910\u9928\u991E\u991B\u9921\u991A\u99ED\u99E2\u99F1\u9AB8\u9ABC\u9AFB\u9AED\u9B28\u9B91\u9D15\u9D23\u9D26\u9D28\u9D12\u9D1B\u9ED8\u9ED4\u9F8D\u9F9C\u512A\u511F\u5121\u5132\u52F5\u568E\u5680\u5690\u5685\u5687"], + ["c0a1", "\u568F\u58D5\u58D3\u58D1\u58CE\u5B30\u5B2A\u5B24\u5B7A\u5C37\u5C68\u5DBC\u5DBA\u5DBD\u5DB8\u5E6B\u5F4C\u5FBD\u61C9\u61C2\u61C7\u61E6\u61CB\u6232\u6234\u64CE\u64CA\u64D8\u64E0\u64F0\u64E6\u64EC\u64F1\u64E2\u64ED\u6582\u6583\u66D9\u66D6\u6A80\u6A94\u6A84\u6AA2\u6A9C\u6ADB\u6AA3\u6A7E\u6A97\u6A90\u6AA0\u6B5C\u6BAE\u6BDA\u6C08\u6FD8\u6FF1\u6FDF\u6FE0\u6FDB\u6FE4\u6FEB\u6FEF\u6F80\u6FEC\u6FE1\u6FE9\u6FD5\u6FEE\u6FF0\u71E7\u71DF\u71EE\u71E6\u71E5\u71ED\u71EC\u71F4\u71E0\u7235\u7246\u7370\u7372\u74A9\u74B0\u74A6\u74A8\u7646\u7642\u764C\u76EA\u77B3\u77AA\u77B0\u77AC"], + ["c140", "\u77A7\u77AD\u77EF\u78F7\u78FA\u78F4\u78EF\u7901\u79A7\u79AA\u7A57\u7ABF\u7C07\u7C0D\u7BFE\u7BF7\u7C0C\u7BE0\u7CE0\u7CDC\u7CDE\u7CE2\u7CDF\u7CD9\u7CDD\u7E2E\u7E3E\u7E46\u7E37\u7E32\u7E43\u7E2B\u7E3D\u7E31\u7E45\u7E41\u7E34\u7E39\u7E48\u7E35\u7E3F\u7E2F\u7F44\u7FF3\u7FFC\u8071\u8072\u8070\u806F\u8073\u81C6\u81C3\u81BA\u81C2\u81C0\u81BF\u81BD\u81C9\u81BE\u81E8\u8209\u8271\u85AA"], + ["c1a1", "\u8584\u857E\u859C\u8591\u8594\u85AF\u859B\u8587\u85A8\u858A\u8667\u87C0\u87D1\u87B3\u87D2\u87C6\u87AB\u87BB\u87BA\u87C8\u87CB\u893B\u8936\u8944\u8938\u893D\u89AC\u8B0E\u8B17\u8B19\u8B1B\u8B0A\u8B20\u8B1D\u8B04\u8B10\u8C41\u8C3F\u8C73\u8CFA\u8CFD\u8CFC\u8CF8\u8CFB\u8DA8\u8E49\u8E4B\u8E48\u8E4A\u8F44\u8F3E\u8F42\u8F45\u8F3F\u907F\u907D\u9084\u9081\u9082\u9080\u9139\u91A3\u919E\u919C\u934D\u9382\u9328\u9375\u934A\u9365\u934B\u9318\u937E\u936C\u935B\u9370\u935A\u9354\u95CA\u95CB\u95CC\u95C8\u95C6\u96B1\u96B8\u96D6\u971C\u971E\u97A0\u97D3\u9846\u98B6\u9935\u9A01"], + ["c240", "\u99FF\u9BAE\u9BAB\u9BAA\u9BAD\u9D3B\u9D3F\u9E8B\u9ECF\u9EDE\u9EDC\u9EDD\u9EDB\u9F3E\u9F4B\u53E2\u5695\u56AE\u58D9\u58D8\u5B38\u5F5D\u61E3\u6233\u64F4\u64F2\u64FE\u6506\u64FA\u64FB\u64F7\u65B7\u66DC\u6726\u6AB3\u6AAC\u6AC3\u6ABB\u6AB8\u6AC2\u6AAE\u6AAF\u6B5F\u6B78\u6BAF\u7009\u700B\u6FFE\u7006\u6FFA\u7011\u700F\u71FB\u71FC\u71FE\u71F8\u7377\u7375\u74A7\u74BF\u7515\u7656\u7658"], + ["c2a1", "\u7652\u77BD\u77BF\u77BB\u77BC\u790E\u79AE\u7A61\u7A62\u7A60\u7AC4\u7AC5\u7C2B\u7C27\u7C2A\u7C1E\u7C23\u7C21\u7CE7\u7E54\u7E55\u7E5E\u7E5A\u7E61\u7E52\u7E59\u7F48\u7FF9\u7FFB\u8077\u8076\u81CD\u81CF\u820A\u85CF\u85A9\u85CD\u85D0\u85C9\u85B0\u85BA\u85B9\u85A6\u87EF\u87EC\u87F2\u87E0\u8986\u89B2\u89F4\u8B28\u8B39\u8B2C\u8B2B\u8C50\u8D05\u8E59\u8E63\u8E66\u8E64\u8E5F\u8E55\u8EC0\u8F49\u8F4D\u9087\u9083\u9088\u91AB\u91AC\u91D0\u9394\u938A\u9396\u93A2\u93B3\u93AE\u93AC\u93B0\u9398\u939A\u9397\u95D4\u95D6\u95D0\u95D5\u96E2\u96DC\u96D9\u96DB\u96DE\u9724\u97A3\u97A6"], + ["c340", "\u97AD\u97F9\u984D\u984F\u984C\u984E\u9853\u98BA\u993E\u993F\u993D\u992E\u99A5\u9A0E\u9AC1\u9B03\u9B06\u9B4F\u9B4E\u9B4D\u9BCA\u9BC9\u9BFD\u9BC8\u9BC0\u9D51\u9D5D\u9D60\u9EE0\u9F15\u9F2C\u5133\u56A5\u58DE\u58DF\u58E2\u5BF5\u9F90\u5EEC\u61F2\u61F7\u61F6\u61F5\u6500\u650F\u66E0\u66DD\u6AE5\u6ADD\u6ADA\u6AD3\u701B\u701F\u7028\u701A\u701D\u7015\u7018\u7206\u720D\u7258\u72A2\u7378"], + ["c3a1", "\u737A\u74BD\u74CA\u74E3\u7587\u7586\u765F\u7661\u77C7\u7919\u79B1\u7A6B\u7A69\u7C3E\u7C3F\u7C38\u7C3D\u7C37\u7C40\u7E6B\u7E6D\u7E79\u7E69\u7E6A\u7F85\u7E73\u7FB6\u7FB9\u7FB8\u81D8\u85E9\u85DD\u85EA\u85D5\u85E4\u85E5\u85F7\u87FB\u8805\u880D\u87F9\u87FE\u8960\u895F\u8956\u895E\u8B41\u8B5C\u8B58\u8B49\u8B5A\u8B4E\u8B4F\u8B46\u8B59\u8D08\u8D0A\u8E7C\u8E72\u8E87\u8E76\u8E6C\u8E7A\u8E74\u8F54\u8F4E\u8FAD\u908A\u908B\u91B1\u91AE\u93E1\u93D1\u93DF\u93C3\u93C8\u93DC\u93DD\u93D6\u93E2\u93CD\u93D8\u93E4\u93D7\u93E8\u95DC\u96B4\u96E3\u972A\u9727\u9761\u97DC\u97FB\u985E"], + ["c440", "\u9858\u985B\u98BC\u9945\u9949\u9A16\u9A19\u9B0D\u9BE8\u9BE7\u9BD6\u9BDB\u9D89\u9D61\u9D72\u9D6A\u9D6C\u9E92\u9E97\u9E93\u9EB4\u52F8\u56A8\u56B7\u56B6\u56B4\u56BC\u58E4\u5B40\u5B43\u5B7D\u5BF6\u5DC9\u61F8\u61FA\u6518\u6514\u6519\u66E6\u6727\u6AEC\u703E\u7030\u7032\u7210\u737B\u74CF\u7662\u7665\u7926\u792A\u792C\u792B\u7AC7\u7AF6\u7C4C\u7C43\u7C4D\u7CEF\u7CF0\u8FAE\u7E7D\u7E7C"], + ["c4a1", "\u7E82\u7F4C\u8000\u81DA\u8266\u85FB\u85F9\u8611\u85FA\u8606\u860B\u8607\u860A\u8814\u8815\u8964\u89BA\u89F8\u8B70\u8B6C\u8B66\u8B6F\u8B5F\u8B6B\u8D0F\u8D0D\u8E89\u8E81\u8E85\u8E82\u91B4\u91CB\u9418\u9403\u93FD\u95E1\u9730\u98C4\u9952\u9951\u99A8\u9A2B\u9A30\u9A37\u9A35\u9C13\u9C0D\u9E79\u9EB5\u9EE8\u9F2F\u9F5F\u9F63\u9F61\u5137\u5138\u56C1\u56C0\u56C2\u5914\u5C6C\u5DCD\u61FC\u61FE\u651D\u651C\u6595\u66E9\u6AFB\u6B04\u6AFA\u6BB2\u704C\u721B\u72A7\u74D6\u74D4\u7669\u77D3\u7C50\u7E8F\u7E8C\u7FBC\u8617\u862D\u861A\u8823\u8822\u8821\u881F\u896A\u896C\u89BD\u8B74"], + ["c540", "\u8B77\u8B7D\u8D13\u8E8A\u8E8D\u8E8B\u8F5F\u8FAF\u91BA\u942E\u9433\u9435\u943A\u9438\u9432\u942B\u95E2\u9738\u9739\u9732\u97FF\u9867\u9865\u9957\u9A45\u9A43\u9A40\u9A3E\u9ACF\u9B54\u9B51\u9C2D\u9C25\u9DAF\u9DB4\u9DC2\u9DB8\u9E9D\u9EEF\u9F19\u9F5C\u9F66\u9F67\u513C\u513B\u56C8\u56CA\u56C9\u5B7F\u5DD4\u5DD2\u5F4E\u61FF\u6524\u6B0A\u6B61\u7051\u7058\u7380\u74E4\u758A\u766E\u766C"], + ["c5a1", "\u79B3\u7C60\u7C5F\u807E\u807D\u81DF\u8972\u896F\u89FC\u8B80\u8D16\u8D17\u8E91\u8E93\u8F61\u9148\u9444\u9451\u9452\u973D\u973E\u97C3\u97C1\u986B\u9955\u9A55\u9A4D\u9AD2\u9B1A\u9C49\u9C31\u9C3E\u9C3B\u9DD3\u9DD7\u9F34\u9F6C\u9F6A\u9F94\u56CC\u5DD6\u6200\u6523\u652B\u652A\u66EC\u6B10\u74DA\u7ACA\u7C64\u7C63\u7C65\u7E93\u7E96\u7E94\u81E2\u8638\u863F\u8831\u8B8A\u9090\u908F\u9463\u9460\u9464\u9768\u986F\u995C\u9A5A\u9A5B\u9A57\u9AD3\u9AD4\u9AD1\u9C54\u9C57\u9C56\u9DE5\u9E9F\u9EF4\u56D1\u58E9\u652C\u705E\u7671\u7672\u77D7\u7F50\u7F88\u8836\u8839\u8862\u8B93\u8B92"], + ["c640", "\u8B96\u8277\u8D1B\u91C0\u946A\u9742\u9748\u9744\u97C6\u9870\u9A5F\u9B22\u9B58\u9C5F\u9DF9\u9DFA\u9E7C\u9E7D\u9F07\u9F77\u9F72\u5EF3\u6B16\u7063\u7C6C\u7C6E\u883B\u89C0\u8EA1\u91C1\u9472\u9470\u9871\u995E\u9AD6\u9B23\u9ECC\u7064\u77DA\u8B9A\u9477\u97C9\u9A62\u9A65\u7E9C\u8B9C\u8EAA\u91C5\u947D\u947E\u947C\u9C77\u9C78\u9EF7\u8C54\u947F\u9E1A\u7228\u9A6A\u9B31\u9E1B\u9E1E\u7C72"], + ["c940", "\u4E42\u4E5C\u51F5\u531A\u5382\u4E07\u4E0C\u4E47\u4E8D\u56D7\uFA0C\u5C6E\u5F73\u4E0F\u5187\u4E0E\u4E2E\u4E93\u4EC2\u4EC9\u4EC8\u5198\u52FC\u536C\u53B9\u5720\u5903\u592C\u5C10\u5DFF\u65E1\u6BB3\u6BCC\u6C14\u723F\u4E31\u4E3C\u4EE8\u4EDC\u4EE9\u4EE1\u4EDD\u4EDA\u520C\u531C\u534C\u5722\u5723\u5917\u592F\u5B81\u5B84\u5C12\u5C3B\u5C74\u5C73\u5E04\u5E80\u5E82\u5FC9\u6209\u6250\u6C15"], + ["c9a1", "\u6C36\u6C43\u6C3F\u6C3B\u72AE\u72B0\u738A\u79B8\u808A\u961E\u4F0E\u4F18\u4F2C\u4EF5\u4F14\u4EF1\u4F00\u4EF7\u4F08\u4F1D\u4F02\u4F05\u4F22\u4F13\u4F04\u4EF4\u4F12\u51B1\u5213\u5209\u5210\u52A6\u5322\u531F\u534D\u538A\u5407\u56E1\u56DF\u572E\u572A\u5734\u593C\u5980\u597C\u5985\u597B\u597E\u5977\u597F\u5B56\u5C15\u5C25\u5C7C\u5C7A\u5C7B\u5C7E\u5DDF\u5E75\u5E84\u5F02\u5F1A\u5F74\u5FD5\u5FD4\u5FCF\u625C\u625E\u6264\u6261\u6266\u6262\u6259\u6260\u625A\u6265\u65EF\u65EE\u673E\u6739\u6738\u673B\u673A\u673F\u673C\u6733\u6C18\u6C46\u6C52\u6C5C\u6C4F\u6C4A\u6C54\u6C4B"], + ["ca40", "\u6C4C\u7071\u725E\u72B4\u72B5\u738E\u752A\u767F\u7A75\u7F51\u8278\u827C\u8280\u827D\u827F\u864D\u897E\u9099\u9097\u9098\u909B\u9094\u9622\u9624\u9620\u9623\u4F56\u4F3B\u4F62\u4F49\u4F53\u4F64\u4F3E\u4F67\u4F52\u4F5F\u4F41\u4F58\u4F2D\u4F33\u4F3F\u4F61\u518F\u51B9\u521C\u521E\u5221\u52AD\u52AE\u5309\u5363\u5372\u538E\u538F\u5430\u5437\u542A\u5454\u5445\u5419\u541C\u5425\u5418"], + ["caa1", "\u543D\u544F\u5441\u5428\u5424\u5447\u56EE\u56E7\u56E5\u5741\u5745\u574C\u5749\u574B\u5752\u5906\u5940\u59A6\u5998\u59A0\u5997\u598E\u59A2\u5990\u598F\u59A7\u59A1\u5B8E\u5B92\u5C28\u5C2A\u5C8D\u5C8F\u5C88\u5C8B\u5C89\u5C92\u5C8A\u5C86\u5C93\u5C95\u5DE0\u5E0A\u5E0E\u5E8B\u5E89\u5E8C\u5E88\u5E8D\u5F05\u5F1D\u5F78\u5F76\u5FD2\u5FD1\u5FD0\u5FED\u5FE8\u5FEE\u5FF3\u5FE1\u5FE4\u5FE3\u5FFA\u5FEF\u5FF7\u5FFB\u6000\u5FF4\u623A\u6283\u628C\u628E\u628F\u6294\u6287\u6271\u627B\u627A\u6270\u6281\u6288\u6277\u627D\u6272\u6274\u6537\u65F0\u65F4\u65F3\u65F2\u65F5\u6745\u6747"], + ["cb40", "\u6759\u6755\u674C\u6748\u675D\u674D\u675A\u674B\u6BD0\u6C19\u6C1A\u6C78\u6C67\u6C6B\u6C84\u6C8B\u6C8F\u6C71\u6C6F\u6C69\u6C9A\u6C6D\u6C87\u6C95\u6C9C\u6C66\u6C73\u6C65\u6C7B\u6C8E\u7074\u707A\u7263\u72BF\u72BD\u72C3\u72C6\u72C1\u72BA\u72C5\u7395\u7397\u7393\u7394\u7392\u753A\u7539\u7594\u7595\u7681\u793D\u8034\u8095\u8099\u8090\u8092\u809C\u8290\u828F\u8285\u828E\u8291\u8293"], + ["cba1", "\u828A\u8283\u8284\u8C78\u8FC9\u8FBF\u909F\u90A1\u90A5\u909E\u90A7\u90A0\u9630\u9628\u962F\u962D\u4E33\u4F98\u4F7C\u4F85\u4F7D\u4F80\u4F87\u4F76\u4F74\u4F89\u4F84\u4F77\u4F4C\u4F97\u4F6A\u4F9A\u4F79\u4F81\u4F78\u4F90\u4F9C\u4F94\u4F9E\u4F92\u4F82\u4F95\u4F6B\u4F6E\u519E\u51BC\u51BE\u5235\u5232\u5233\u5246\u5231\u52BC\u530A\u530B\u533C\u5392\u5394\u5487\u547F\u5481\u5491\u5482\u5488\u546B\u547A\u547E\u5465\u546C\u5474\u5466\u548D\u546F\u5461\u5460\u5498\u5463\u5467\u5464\u56F7\u56F9\u576F\u5772\u576D\u576B\u5771\u5770\u5776\u5780\u5775\u577B\u5773\u5774\u5762"], + ["cc40", "\u5768\u577D\u590C\u5945\u59B5\u59BA\u59CF\u59CE\u59B2\u59CC\u59C1\u59B6\u59BC\u59C3\u59D6\u59B1\u59BD\u59C0\u59C8\u59B4\u59C7\u5B62\u5B65\u5B93\u5B95\u5C44\u5C47\u5CAE\u5CA4\u5CA0\u5CB5\u5CAF\u5CA8\u5CAC\u5C9F\u5CA3\u5CAD\u5CA2\u5CAA\u5CA7\u5C9D\u5CA5\u5CB6\u5CB0\u5CA6\u5E17\u5E14\u5E19\u5F28\u5F22\u5F23\u5F24\u5F54\u5F82\u5F7E\u5F7D\u5FDE\u5FE5\u602D\u6026\u6019\u6032\u600B"], + ["cca1", "\u6034\u600A\u6017\u6033\u601A\u601E\u602C\u6022\u600D\u6010\u602E\u6013\u6011\u600C\u6009\u601C\u6214\u623D\u62AD\u62B4\u62D1\u62BE\u62AA\u62B6\u62CA\u62AE\u62B3\u62AF\u62BB\u62A9\u62B0\u62B8\u653D\u65A8\u65BB\u6609\u65FC\u6604\u6612\u6608\u65FB\u6603\u660B\u660D\u6605\u65FD\u6611\u6610\u66F6\u670A\u6785\u676C\u678E\u6792\u6776\u677B\u6798\u6786\u6784\u6774\u678D\u678C\u677A\u679F\u6791\u6799\u6783\u677D\u6781\u6778\u6779\u6794\u6B25\u6B80\u6B7E\u6BDE\u6C1D\u6C93\u6CEC\u6CEB\u6CEE\u6CD9\u6CB6\u6CD4\u6CAD\u6CE7\u6CB7\u6CD0\u6CC2\u6CBA\u6CC3\u6CC6\u6CED\u6CF2"], + ["cd40", "\u6CD2\u6CDD\u6CB4\u6C8A\u6C9D\u6C80\u6CDE\u6CC0\u6D30\u6CCD\u6CC7\u6CB0\u6CF9\u6CCF\u6CE9\u6CD1\u7094\u7098\u7085\u7093\u7086\u7084\u7091\u7096\u7082\u709A\u7083\u726A\u72D6\u72CB\u72D8\u72C9\u72DC\u72D2\u72D4\u72DA\u72CC\u72D1\u73A4\u73A1\u73AD\u73A6\u73A2\u73A0\u73AC\u739D\u74DD\u74E8\u753F\u7540\u753E\u758C\u7598\u76AF\u76F3\u76F1\u76F0\u76F5\u77F8\u77FC\u77F9\u77FB\u77FA"], + ["cda1", "\u77F7\u7942\u793F\u79C5\u7A78\u7A7B\u7AFB\u7C75\u7CFD\u8035\u808F\u80AE\u80A3\u80B8\u80B5\u80AD\u8220\u82A0\u82C0\u82AB\u829A\u8298\u829B\u82B5\u82A7\u82AE\u82BC\u829E\u82BA\u82B4\u82A8\u82A1\u82A9\u82C2\u82A4\u82C3\u82B6\u82A2\u8670\u866F\u866D\u866E\u8C56\u8FD2\u8FCB\u8FD3\u8FCD\u8FD6\u8FD5\u8FD7\u90B2\u90B4\u90AF\u90B3\u90B0\u9639\u963D\u963C\u963A\u9643\u4FCD\u4FC5\u4FD3\u4FB2\u4FC9\u4FCB\u4FC1\u4FD4\u4FDC\u4FD9\u4FBB\u4FB3\u4FDB\u4FC7\u4FD6\u4FBA\u4FC0\u4FB9\u4FEC\u5244\u5249\u52C0\u52C2\u533D\u537C\u5397\u5396\u5399\u5398\u54BA\u54A1\u54AD\u54A5\u54CF"], + ["ce40", "\u54C3\u830D\u54B7\u54AE\u54D6\u54B6\u54C5\u54C6\u54A0\u5470\u54BC\u54A2\u54BE\u5472\u54DE\u54B0\u57B5\u579E\u579F\u57A4\u578C\u5797\u579D\u579B\u5794\u5798\u578F\u5799\u57A5\u579A\u5795\u58F4\u590D\u5953\u59E1\u59DE\u59EE\u5A00\u59F1\u59DD\u59FA\u59FD\u59FC\u59F6\u59E4\u59F2\u59F7\u59DB\u59E9\u59F3\u59F5\u59E0\u59FE\u59F4\u59ED\u5BA8\u5C4C\u5CD0\u5CD8\u5CCC\u5CD7\u5CCB\u5CDB"], + ["cea1", "\u5CDE\u5CDA\u5CC9\u5CC7\u5CCA\u5CD6\u5CD3\u5CD4\u5CCF\u5CC8\u5CC6\u5CCE\u5CDF\u5CF8\u5DF9\u5E21\u5E22\u5E23\u5E20\u5E24\u5EB0\u5EA4\u5EA2\u5E9B\u5EA3\u5EA5\u5F07\u5F2E\u5F56\u5F86\u6037\u6039\u6054\u6072\u605E\u6045\u6053\u6047\u6049\u605B\u604C\u6040\u6042\u605F\u6024\u6044\u6058\u6066\u606E\u6242\u6243\u62CF\u630D\u630B\u62F5\u630E\u6303\u62EB\u62F9\u630F\u630C\u62F8\u62F6\u6300\u6313\u6314\u62FA\u6315\u62FB\u62F0\u6541\u6543\u65AA\u65BF\u6636\u6621\u6632\u6635\u661C\u6626\u6622\u6633\u662B\u663A\u661D\u6634\u6639\u662E\u670F\u6710\u67C1\u67F2\u67C8\u67BA"], + ["cf40", "\u67DC\u67BB\u67F8\u67D8\u67C0\u67B7\u67C5\u67EB\u67E4\u67DF\u67B5\u67CD\u67B3\u67F7\u67F6\u67EE\u67E3\u67C2\u67B9\u67CE\u67E7\u67F0\u67B2\u67FC\u67C6\u67ED\u67CC\u67AE\u67E6\u67DB\u67FA\u67C9\u67CA\u67C3\u67EA\u67CB\u6B28\u6B82\u6B84\u6BB6\u6BD6\u6BD8\u6BE0\u6C20\u6C21\u6D28\u6D34\u6D2D\u6D1F\u6D3C\u6D3F\u6D12\u6D0A\u6CDA\u6D33\u6D04\u6D19\u6D3A\u6D1A\u6D11\u6D00\u6D1D\u6D42"], + ["cfa1", "\u6D01\u6D18\u6D37\u6D03\u6D0F\u6D40\u6D07\u6D20\u6D2C\u6D08\u6D22\u6D09\u6D10\u70B7\u709F\u70BE\u70B1\u70B0\u70A1\u70B4\u70B5\u70A9\u7241\u7249\u724A\u726C\u7270\u7273\u726E\u72CA\u72E4\u72E8\u72EB\u72DF\u72EA\u72E6\u72E3\u7385\u73CC\u73C2\u73C8\u73C5\u73B9\u73B6\u73B5\u73B4\u73EB\u73BF\u73C7\u73BE\u73C3\u73C6\u73B8\u73CB\u74EC\u74EE\u752E\u7547\u7548\u75A7\u75AA\u7679\u76C4\u7708\u7703\u7704\u7705\u770A\u76F7\u76FB\u76FA\u77E7\u77E8\u7806\u7811\u7812\u7805\u7810\u780F\u780E\u7809\u7803\u7813\u794A\u794C\u794B\u7945\u7944\u79D5\u79CD\u79CF\u79D6\u79CE\u7A80"], + ["d040", "\u7A7E\u7AD1\u7B00\u7B01\u7C7A\u7C78\u7C79\u7C7F\u7C80\u7C81\u7D03\u7D08\u7D01\u7F58\u7F91\u7F8D\u7FBE\u8007\u800E\u800F\u8014\u8037\u80D8\u80C7\u80E0\u80D1\u80C8\u80C2\u80D0\u80C5\u80E3\u80D9\u80DC\u80CA\u80D5\u80C9\u80CF\u80D7\u80E6\u80CD\u81FF\u8221\u8294\u82D9\u82FE\u82F9\u8307\u82E8\u8300\u82D5\u833A\u82EB\u82D6\u82F4\u82EC\u82E1\u82F2\u82F5\u830C\u82FB\u82F6\u82F0\u82EA"], + ["d0a1", "\u82E4\u82E0\u82FA\u82F3\u82ED\u8677\u8674\u867C\u8673\u8841\u884E\u8867\u886A\u8869\u89D3\u8A04\u8A07\u8D72\u8FE3\u8FE1\u8FEE\u8FE0\u90F1\u90BD\u90BF\u90D5\u90C5\u90BE\u90C7\u90CB\u90C8\u91D4\u91D3\u9654\u964F\u9651\u9653\u964A\u964E\u501E\u5005\u5007\u5013\u5022\u5030\u501B\u4FF5\u4FF4\u5033\u5037\u502C\u4FF6\u4FF7\u5017\u501C\u5020\u5027\u5035\u502F\u5031\u500E\u515A\u5194\u5193\u51CA\u51C4\u51C5\u51C8\u51CE\u5261\u525A\u5252\u525E\u525F\u5255\u5262\u52CD\u530E\u539E\u5526\u54E2\u5517\u5512\u54E7\u54F3\u54E4\u551A\u54FF\u5504\u5508\u54EB\u5511\u5505\u54F1"], + ["d140", "\u550A\u54FB\u54F7\u54F8\u54E0\u550E\u5503\u550B\u5701\u5702\u57CC\u5832\u57D5\u57D2\u57BA\u57C6\u57BD\u57BC\u57B8\u57B6\u57BF\u57C7\u57D0\u57B9\u57C1\u590E\u594A\u5A19\u5A16\u5A2D\u5A2E\u5A15\u5A0F\u5A17\u5A0A\u5A1E\u5A33\u5B6C\u5BA7\u5BAD\u5BAC\u5C03\u5C56\u5C54\u5CEC\u5CFF\u5CEE\u5CF1\u5CF7\u5D00\u5CF9\u5E29\u5E28\u5EA8\u5EAE\u5EAA\u5EAC\u5F33\u5F30\u5F67\u605D\u605A\u6067"], + ["d1a1", "\u6041\u60A2\u6088\u6080\u6092\u6081\u609D\u6083\u6095\u609B\u6097\u6087\u609C\u608E\u6219\u6246\u62F2\u6310\u6356\u632C\u6344\u6345\u6336\u6343\u63E4\u6339\u634B\u634A\u633C\u6329\u6341\u6334\u6358\u6354\u6359\u632D\u6347\u6333\u635A\u6351\u6338\u6357\u6340\u6348\u654A\u6546\u65C6\u65C3\u65C4\u65C2\u664A\u665F\u6647\u6651\u6712\u6713\u681F\u681A\u6849\u6832\u6833\u683B\u684B\u684F\u6816\u6831\u681C\u6835\u682B\u682D\u682F\u684E\u6844\u6834\u681D\u6812\u6814\u6826\u6828\u682E\u684D\u683A\u6825\u6820\u6B2C\u6B2F\u6B2D\u6B31\u6B34\u6B6D\u8082\u6B88\u6BE6\u6BE4"], + ["d240", "\u6BE8\u6BE3\u6BE2\u6BE7\u6C25\u6D7A\u6D63\u6D64\u6D76\u6D0D\u6D61\u6D92\u6D58\u6D62\u6D6D\u6D6F\u6D91\u6D8D\u6DEF\u6D7F\u6D86\u6D5E\u6D67\u6D60\u6D97\u6D70\u6D7C\u6D5F\u6D82\u6D98\u6D2F\u6D68\u6D8B\u6D7E\u6D80\u6D84\u6D16\u6D83\u6D7B\u6D7D\u6D75\u6D90\u70DC\u70D3\u70D1\u70DD\u70CB\u7F39\u70E2\u70D7\u70D2\u70DE\u70E0\u70D4\u70CD\u70C5\u70C6\u70C7\u70DA\u70CE\u70E1\u7242\u7278"], + ["d2a1", "\u7277\u7276\u7300\u72FA\u72F4\u72FE\u72F6\u72F3\u72FB\u7301\u73D3\u73D9\u73E5\u73D6\u73BC\u73E7\u73E3\u73E9\u73DC\u73D2\u73DB\u73D4\u73DD\u73DA\u73D7\u73D8\u73E8\u74DE\u74DF\u74F4\u74F5\u7521\u755B\u755F\u75B0\u75C1\u75BB\u75C4\u75C0\u75BF\u75B6\u75BA\u768A\u76C9\u771D\u771B\u7710\u7713\u7712\u7723\u7711\u7715\u7719\u771A\u7722\u7727\u7823\u782C\u7822\u7835\u782F\u7828\u782E\u782B\u7821\u7829\u7833\u782A\u7831\u7954\u795B\u794F\u795C\u7953\u7952\u7951\u79EB\u79EC\u79E0\u79EE\u79ED\u79EA\u79DC\u79DE\u79DD\u7A86\u7A89\u7A85\u7A8B\u7A8C\u7A8A\u7A87\u7AD8\u7B10"], + ["d340", "\u7B04\u7B13\u7B05\u7B0F\u7B08\u7B0A\u7B0E\u7B09\u7B12\u7C84\u7C91\u7C8A\u7C8C\u7C88\u7C8D\u7C85\u7D1E\u7D1D\u7D11\u7D0E\u7D18\u7D16\u7D13\u7D1F\u7D12\u7D0F\u7D0C\u7F5C\u7F61\u7F5E\u7F60\u7F5D\u7F5B\u7F96\u7F92\u7FC3\u7FC2\u7FC0\u8016\u803E\u8039\u80FA\u80F2\u80F9\u80F5\u8101\u80FB\u8100\u8201\u822F\u8225\u8333\u832D\u8344\u8319\u8351\u8325\u8356\u833F\u8341\u8326\u831C\u8322"], + ["d3a1", "\u8342\u834E\u831B\u832A\u8308\u833C\u834D\u8316\u8324\u8320\u8337\u832F\u8329\u8347\u8345\u834C\u8353\u831E\u832C\u834B\u8327\u8348\u8653\u8652\u86A2\u86A8\u8696\u868D\u8691\u869E\u8687\u8697\u8686\u868B\u869A\u8685\u86A5\u8699\u86A1\u86A7\u8695\u8698\u868E\u869D\u8690\u8694\u8843\u8844\u886D\u8875\u8876\u8872\u8880\u8871\u887F\u886F\u8883\u887E\u8874\u887C\u8A12\u8C47\u8C57\u8C7B\u8CA4\u8CA3\u8D76\u8D78\u8DB5\u8DB7\u8DB6\u8ED1\u8ED3\u8FFE\u8FF5\u9002\u8FFF\u8FFB\u9004\u8FFC\u8FF6\u90D6\u90E0\u90D9\u90DA\u90E3\u90DF\u90E5\u90D8\u90DB\u90D7\u90DC\u90E4\u9150"], + ["d440", "\u914E\u914F\u91D5\u91E2\u91DA\u965C\u965F\u96BC\u98E3\u9ADF\u9B2F\u4E7F\u5070\u506A\u5061\u505E\u5060\u5053\u504B\u505D\u5072\u5048\u504D\u5041\u505B\u504A\u5062\u5015\u5045\u505F\u5069\u506B\u5063\u5064\u5046\u5040\u506E\u5073\u5057\u5051\u51D0\u526B\u526D\u526C\u526E\u52D6\u52D3\u532D\u539C\u5575\u5576\u553C\u554D\u5550\u5534\u552A\u5551\u5562\u5536\u5535\u5530\u5552\u5545"], + ["d4a1", "\u550C\u5532\u5565\u554E\u5539\u5548\u552D\u553B\u5540\u554B\u570A\u5707\u57FB\u5814\u57E2\u57F6\u57DC\u57F4\u5800\u57ED\u57FD\u5808\u57F8\u580B\u57F3\u57CF\u5807\u57EE\u57E3\u57F2\u57E5\u57EC\u57E1\u580E\u57FC\u5810\u57E7\u5801\u580C\u57F1\u57E9\u57F0\u580D\u5804\u595C\u5A60\u5A58\u5A55\u5A67\u5A5E\u5A38\u5A35\u5A6D\u5A50\u5A5F\u5A65\u5A6C\u5A53\u5A64\u5A57\u5A43\u5A5D\u5A52\u5A44\u5A5B\u5A48\u5A8E\u5A3E\u5A4D\u5A39\u5A4C\u5A70\u5A69\u5A47\u5A51\u5A56\u5A42\u5A5C\u5B72\u5B6E\u5BC1\u5BC0\u5C59\u5D1E\u5D0B\u5D1D\u5D1A\u5D20\u5D0C\u5D28\u5D0D\u5D26\u5D25\u5D0F"], + ["d540", "\u5D30\u5D12\u5D23\u5D1F\u5D2E\u5E3E\u5E34\u5EB1\u5EB4\u5EB9\u5EB2\u5EB3\u5F36\u5F38\u5F9B\u5F96\u5F9F\u608A\u6090\u6086\u60BE\u60B0\u60BA\u60D3\u60D4\u60CF\u60E4\u60D9\u60DD\u60C8\u60B1\u60DB\u60B7\u60CA\u60BF\u60C3\u60CD\u60C0\u6332\u6365\u638A\u6382\u637D\u63BD\u639E\u63AD\u639D\u6397\u63AB\u638E\u636F\u6387\u6390\u636E\u63AF\u6375\u639C\u636D\u63AE\u637C\u63A4\u633B\u639F"], + ["d5a1", "\u6378\u6385\u6381\u6391\u638D\u6370\u6553\u65CD\u6665\u6661\u665B\u6659\u665C\u6662\u6718\u6879\u6887\u6890\u689C\u686D\u686E\u68AE\u68AB\u6956\u686F\u68A3\u68AC\u68A9\u6875\u6874\u68B2\u688F\u6877\u6892\u687C\u686B\u6872\u68AA\u6880\u6871\u687E\u689B\u6896\u688B\u68A0\u6889\u68A4\u6878\u687B\u6891\u688C\u688A\u687D\u6B36\u6B33\u6B37\u6B38\u6B91\u6B8F\u6B8D\u6B8E\u6B8C\u6C2A\u6DC0\u6DAB\u6DB4\u6DB3\u6E74\u6DAC\u6DE9\u6DE2\u6DB7\u6DF6\u6DD4\u6E00\u6DC8\u6DE0\u6DDF\u6DD6\u6DBE\u6DE5\u6DDC\u6DDD\u6DDB\u6DF4\u6DCA\u6DBD\u6DED\u6DF0\u6DBA\u6DD5\u6DC2\u6DCF\u6DC9"], + ["d640", "\u6DD0\u6DF2\u6DD3\u6DFD\u6DD7\u6DCD\u6DE3\u6DBB\u70FA\u710D\u70F7\u7117\u70F4\u710C\u70F0\u7104\u70F3\u7110\u70FC\u70FF\u7106\u7113\u7100\u70F8\u70F6\u710B\u7102\u710E\u727E\u727B\u727C\u727F\u731D\u7317\u7307\u7311\u7318\u730A\u7308\u72FF\u730F\u731E\u7388\u73F6\u73F8\u73F5\u7404\u7401\u73FD\u7407\u7400\u73FA\u73FC\u73FF\u740C\u740B\u73F4\u7408\u7564\u7563\u75CE\u75D2\u75CF"], + ["d6a1", "\u75CB\u75CC\u75D1\u75D0\u768F\u7689\u76D3\u7739\u772F\u772D\u7731\u7732\u7734\u7733\u773D\u7725\u773B\u7735\u7848\u7852\u7849\u784D\u784A\u784C\u7826\u7845\u7850\u7964\u7967\u7969\u796A\u7963\u796B\u7961\u79BB\u79FA\u79F8\u79F6\u79F7\u7A8F\u7A94\u7A90\u7B35\u7B47\u7B34\u7B25\u7B30\u7B22\u7B24\u7B33\u7B18\u7B2A\u7B1D\u7B31\u7B2B\u7B2D\u7B2F\u7B32\u7B38\u7B1A\u7B23\u7C94\u7C98\u7C96\u7CA3\u7D35\u7D3D\u7D38\u7D36\u7D3A\u7D45\u7D2C\u7D29\u7D41\u7D47\u7D3E\u7D3F\u7D4A\u7D3B\u7D28\u7F63\u7F95\u7F9C\u7F9D\u7F9B\u7FCA\u7FCB\u7FCD\u7FD0\u7FD1\u7FC7\u7FCF\u7FC9\u801F"], + ["d740", "\u801E\u801B\u8047\u8043\u8048\u8118\u8125\u8119\u811B\u812D\u811F\u812C\u811E\u8121\u8115\u8127\u811D\u8122\u8211\u8238\u8233\u823A\u8234\u8232\u8274\u8390\u83A3\u83A8\u838D\u837A\u8373\u83A4\u8374\u838F\u8381\u8395\u8399\u8375\u8394\u83A9\u837D\u8383\u838C\u839D\u839B\u83AA\u838B\u837E\u83A5\u83AF\u8388\u8397\u83B0\u837F\u83A6\u8387\u83AE\u8376\u839A\u8659\u8656\u86BF\u86B7"], + ["d7a1", "\u86C2\u86C1\u86C5\u86BA\u86B0\u86C8\u86B9\u86B3\u86B8\u86CC\u86B4\u86BB\u86BC\u86C3\u86BD\u86BE\u8852\u8889\u8895\u88A8\u88A2\u88AA\u889A\u8891\u88A1\u889F\u8898\u88A7\u8899\u889B\u8897\u88A4\u88AC\u888C\u8893\u888E\u8982\u89D6\u89D9\u89D5\u8A30\u8A27\u8A2C\u8A1E\u8C39\u8C3B\u8C5C\u8C5D\u8C7D\u8CA5\u8D7D\u8D7B\u8D79\u8DBC\u8DC2\u8DB9\u8DBF\u8DC1\u8ED8\u8EDE\u8EDD\u8EDC\u8ED7\u8EE0\u8EE1\u9024\u900B\u9011\u901C\u900C\u9021\u90EF\u90EA\u90F0\u90F4\u90F2\u90F3\u90D4\u90EB\u90EC\u90E9\u9156\u9158\u915A\u9153\u9155\u91EC\u91F4\u91F1\u91F3\u91F8\u91E4\u91F9\u91EA"], + ["d840", "\u91EB\u91F7\u91E8\u91EE\u957A\u9586\u9588\u967C\u966D\u966B\u9671\u966F\u96BF\u976A\u9804\u98E5\u9997\u509B\u5095\u5094\u509E\u508B\u50A3\u5083\u508C\u508E\u509D\u5068\u509C\u5092\u5082\u5087\u515F\u51D4\u5312\u5311\u53A4\u53A7\u5591\u55A8\u55A5\u55AD\u5577\u5645\u55A2\u5593\u5588\u558F\u55B5\u5581\u55A3\u5592\u55A4\u557D\u558C\u55A6\u557F\u5595\u55A1\u558E\u570C\u5829\u5837"], + ["d8a1", "\u5819\u581E\u5827\u5823\u5828\u57F5\u5848\u5825\u581C\u581B\u5833\u583F\u5836\u582E\u5839\u5838\u582D\u582C\u583B\u5961\u5AAF\u5A94\u5A9F\u5A7A\u5AA2\u5A9E\u5A78\u5AA6\u5A7C\u5AA5\u5AAC\u5A95\u5AAE\u5A37\u5A84\u5A8A\u5A97\u5A83\u5A8B\u5AA9\u5A7B\u5A7D\u5A8C\u5A9C\u5A8F\u5A93\u5A9D\u5BEA\u5BCD\u5BCB\u5BD4\u5BD1\u5BCA\u5BCE\u5C0C\u5C30\u5D37\u5D43\u5D6B\u5D41\u5D4B\u5D3F\u5D35\u5D51\u5D4E\u5D55\u5D33\u5D3A\u5D52\u5D3D\u5D31\u5D59\u5D42\u5D39\u5D49\u5D38\u5D3C\u5D32\u5D36\u5D40\u5D45\u5E44\u5E41\u5F58\u5FA6\u5FA5\u5FAB\u60C9\u60B9\u60CC\u60E2\u60CE\u60C4\u6114"], + ["d940", "\u60F2\u610A\u6116\u6105\u60F5\u6113\u60F8\u60FC\u60FE\u60C1\u6103\u6118\u611D\u6110\u60FF\u6104\u610B\u624A\u6394\u63B1\u63B0\u63CE\u63E5\u63E8\u63EF\u63C3\u649D\u63F3\u63CA\u63E0\u63F6\u63D5\u63F2\u63F5\u6461\u63DF\u63BE\u63DD\u63DC\u63C4\u63D8\u63D3\u63C2\u63C7\u63CC\u63CB\u63C8\u63F0\u63D7\u63D9\u6532\u6567\u656A\u6564\u655C\u6568\u6565\u658C\u659D\u659E\u65AE\u65D0\u65D2"], + ["d9a1", "\u667C\u666C\u667B\u6680\u6671\u6679\u666A\u6672\u6701\u690C\u68D3\u6904\u68DC\u692A\u68EC\u68EA\u68F1\u690F\u68D6\u68F7\u68EB\u68E4\u68F6\u6913\u6910\u68F3\u68E1\u6907\u68CC\u6908\u6970\u68B4\u6911\u68EF\u68C6\u6914\u68F8\u68D0\u68FD\u68FC\u68E8\u690B\u690A\u6917\u68CE\u68C8\u68DD\u68DE\u68E6\u68F4\u68D1\u6906\u68D4\u68E9\u6915\u6925\u68C7\u6B39\u6B3B\u6B3F\u6B3C\u6B94\u6B97\u6B99\u6B95\u6BBD\u6BF0\u6BF2\u6BF3\u6C30\u6DFC\u6E46\u6E47\u6E1F\u6E49\u6E88\u6E3C\u6E3D\u6E45\u6E62\u6E2B\u6E3F\u6E41\u6E5D\u6E73\u6E1C\u6E33\u6E4B\u6E40\u6E51\u6E3B\u6E03\u6E2E\u6E5E"], + ["da40", "\u6E68\u6E5C\u6E61\u6E31\u6E28\u6E60\u6E71\u6E6B\u6E39\u6E22\u6E30\u6E53\u6E65\u6E27\u6E78\u6E64\u6E77\u6E55\u6E79\u6E52\u6E66\u6E35\u6E36\u6E5A\u7120\u711E\u712F\u70FB\u712E\u7131\u7123\u7125\u7122\u7132\u711F\u7128\u713A\u711B\u724B\u725A\u7288\u7289\u7286\u7285\u728B\u7312\u730B\u7330\u7322\u7331\u7333\u7327\u7332\u732D\u7326\u7323\u7335\u730C\u742E\u742C\u7430\u742B\u7416"], + ["daa1", "\u741A\u7421\u742D\u7431\u7424\u7423\u741D\u7429\u7420\u7432\u74FB\u752F\u756F\u756C\u75E7\u75DA\u75E1\u75E6\u75DD\u75DF\u75E4\u75D7\u7695\u7692\u76DA\u7746\u7747\u7744\u774D\u7745\u774A\u774E\u774B\u774C\u77DE\u77EC\u7860\u7864\u7865\u785C\u786D\u7871\u786A\u786E\u7870\u7869\u7868\u785E\u7862\u7974\u7973\u7972\u7970\u7A02\u7A0A\u7A03\u7A0C\u7A04\u7A99\u7AE6\u7AE4\u7B4A\u7B3B\u7B44\u7B48\u7B4C\u7B4E\u7B40\u7B58\u7B45\u7CA2\u7C9E\u7CA8\u7CA1\u7D58\u7D6F\u7D63\u7D53\u7D56\u7D67\u7D6A\u7D4F\u7D6D\u7D5C\u7D6B\u7D52\u7D54\u7D69\u7D51\u7D5F\u7D4E\u7F3E\u7F3F\u7F65"], + ["db40", "\u7F66\u7FA2\u7FA0\u7FA1\u7FD7\u8051\u804F\u8050\u80FE\u80D4\u8143\u814A\u8152\u814F\u8147\u813D\u814D\u813A\u81E6\u81EE\u81F7\u81F8\u81F9\u8204\u823C\u823D\u823F\u8275\u833B\u83CF\u83F9\u8423\u83C0\u83E8\u8412\u83E7\u83E4\u83FC\u83F6\u8410\u83C6\u83C8\u83EB\u83E3\u83BF\u8401\u83DD\u83E5\u83D8\u83FF\u83E1\u83CB\u83CE\u83D6\u83F5\u83C9\u8409\u840F\u83DE\u8411\u8406\u83C2\u83F3"], + ["dba1", "\u83D5\u83FA\u83C7\u83D1\u83EA\u8413\u83C3\u83EC\u83EE\u83C4\u83FB\u83D7\u83E2\u841B\u83DB\u83FE\u86D8\u86E2\u86E6\u86D3\u86E3\u86DA\u86EA\u86DD\u86EB\u86DC\u86EC\u86E9\u86D7\u86E8\u86D1\u8848\u8856\u8855\u88BA\u88D7\u88B9\u88B8\u88C0\u88BE\u88B6\u88BC\u88B7\u88BD\u88B2\u8901\u88C9\u8995\u8998\u8997\u89DD\u89DA\u89DB\u8A4E\u8A4D\u8A39\u8A59\u8A40\u8A57\u8A58\u8A44\u8A45\u8A52\u8A48\u8A51\u8A4A\u8A4C\u8A4F\u8C5F\u8C81\u8C80\u8CBA\u8CBE\u8CB0\u8CB9\u8CB5\u8D84\u8D80\u8D89\u8DD8\u8DD3\u8DCD\u8DC7\u8DD6\u8DDC\u8DCF\u8DD5\u8DD9\u8DC8\u8DD7\u8DC5\u8EEF\u8EF7\u8EFA"], + ["dc40", "\u8EF9\u8EE6\u8EEE\u8EE5\u8EF5\u8EE7\u8EE8\u8EF6\u8EEB\u8EF1\u8EEC\u8EF4\u8EE9\u902D\u9034\u902F\u9106\u912C\u9104\u90FF\u90FC\u9108\u90F9\u90FB\u9101\u9100\u9107\u9105\u9103\u9161\u9164\u915F\u9162\u9160\u9201\u920A\u9225\u9203\u921A\u9226\u920F\u920C\u9200\u9212\u91FF\u91FD\u9206\u9204\u9227\u9202\u921C\u9224\u9219\u9217\u9205\u9216\u957B\u958D\u958C\u9590\u9687\u967E\u9688"], + ["dca1", "\u9689\u9683\u9680\u96C2\u96C8\u96C3\u96F1\u96F0\u976C\u9770\u976E\u9807\u98A9\u98EB\u9CE6\u9EF9\u4E83\u4E84\u4EB6\u50BD\u50BF\u50C6\u50AE\u50C4\u50CA\u50B4\u50C8\u50C2\u50B0\u50C1\u50BA\u50B1\u50CB\u50C9\u50B6\u50B8\u51D7\u527A\u5278\u527B\u527C\u55C3\u55DB\u55CC\u55D0\u55CB\u55CA\u55DD\u55C0\u55D4\u55C4\u55E9\u55BF\u55D2\u558D\u55CF\u55D5\u55E2\u55D6\u55C8\u55F2\u55CD\u55D9\u55C2\u5714\u5853\u5868\u5864\u584F\u584D\u5849\u586F\u5855\u584E\u585D\u5859\u5865\u585B\u583D\u5863\u5871\u58FC\u5AC7\u5AC4\u5ACB\u5ABA\u5AB8\u5AB1\u5AB5\u5AB0\u5ABF\u5AC8\u5ABB\u5AC6"], + ["dd40", "\u5AB7\u5AC0\u5ACA\u5AB4\u5AB6\u5ACD\u5AB9\u5A90\u5BD6\u5BD8\u5BD9\u5C1F\u5C33\u5D71\u5D63\u5D4A\u5D65\u5D72\u5D6C\u5D5E\u5D68\u5D67\u5D62\u5DF0\u5E4F\u5E4E\u5E4A\u5E4D\u5E4B\u5EC5\u5ECC\u5EC6\u5ECB\u5EC7\u5F40\u5FAF\u5FAD\u60F7\u6149\u614A\u612B\u6145\u6136\u6132\u612E\u6146\u612F\u614F\u6129\u6140\u6220\u9168\u6223\u6225\u6224\u63C5\u63F1\u63EB\u6410\u6412\u6409\u6420\u6424"], + ["dda1", "\u6433\u6443\u641F\u6415\u6418\u6439\u6437\u6422\u6423\u640C\u6426\u6430\u6428\u6441\u6435\u642F\u640A\u641A\u6440\u6425\u6427\u640B\u63E7\u641B\u642E\u6421\u640E\u656F\u6592\u65D3\u6686\u668C\u6695\u6690\u668B\u668A\u6699\u6694\u6678\u6720\u6966\u695F\u6938\u694E\u6962\u6971\u693F\u6945\u696A\u6939\u6942\u6957\u6959\u697A\u6948\u6949\u6935\u696C\u6933\u693D\u6965\u68F0\u6978\u6934\u6969\u6940\u696F\u6944\u6976\u6958\u6941\u6974\u694C\u693B\u694B\u6937\u695C\u694F\u6951\u6932\u6952\u692F\u697B\u693C\u6B46\u6B45\u6B43\u6B42\u6B48\u6B41\u6B9B\uFA0D\u6BFB\u6BFC"], + ["de40", "\u6BF9\u6BF7\u6BF8\u6E9B\u6ED6\u6EC8\u6E8F\u6EC0\u6E9F\u6E93\u6E94\u6EA0\u6EB1\u6EB9\u6EC6\u6ED2\u6EBD\u6EC1\u6E9E\u6EC9\u6EB7\u6EB0\u6ECD\u6EA6\u6ECF\u6EB2\u6EBE\u6EC3\u6EDC\u6ED8\u6E99\u6E92\u6E8E\u6E8D\u6EA4\u6EA1\u6EBF\u6EB3\u6ED0\u6ECA\u6E97\u6EAE\u6EA3\u7147\u7154\u7152\u7163\u7160\u7141\u715D\u7162\u7172\u7178\u716A\u7161\u7142\u7158\u7143\u714B\u7170\u715F\u7150\u7153"], + ["dea1", "\u7144\u714D\u715A\u724F\u728D\u728C\u7291\u7290\u728E\u733C\u7342\u733B\u733A\u7340\u734A\u7349\u7444\u744A\u744B\u7452\u7451\u7457\u7440\u744F\u7450\u744E\u7442\u7446\u744D\u7454\u74E1\u74FF\u74FE\u74FD\u751D\u7579\u7577\u6983\u75EF\u760F\u7603\u75F7\u75FE\u75FC\u75F9\u75F8\u7610\u75FB\u75F6\u75ED\u75F5\u75FD\u7699\u76B5\u76DD\u7755\u775F\u7760\u7752\u7756\u775A\u7769\u7767\u7754\u7759\u776D\u77E0\u7887\u789A\u7894\u788F\u7884\u7895\u7885\u7886\u78A1\u7883\u7879\u7899\u7880\u7896\u787B\u797C\u7982\u797D\u7979\u7A11\u7A18\u7A19\u7A12\u7A17\u7A15\u7A22\u7A13"], + ["df40", "\u7A1B\u7A10\u7AA3\u7AA2\u7A9E\u7AEB\u7B66\u7B64\u7B6D\u7B74\u7B69\u7B72\u7B65\u7B73\u7B71\u7B70\u7B61\u7B78\u7B76\u7B63\u7CB2\u7CB4\u7CAF\u7D88\u7D86\u7D80\u7D8D\u7D7F\u7D85\u7D7A\u7D8E\u7D7B\u7D83\u7D7C\u7D8C\u7D94\u7D84\u7D7D\u7D92\u7F6D\u7F6B\u7F67\u7F68\u7F6C\u7FA6\u7FA5\u7FA7\u7FDB\u7FDC\u8021\u8164\u8160\u8177\u815C\u8169\u815B\u8162\u8172\u6721\u815E\u8176\u8167\u816F"], + ["dfa1", "\u8144\u8161\u821D\u8249\u8244\u8240\u8242\u8245\u84F1\u843F\u8456\u8476\u8479\u848F\u848D\u8465\u8451\u8440\u8486\u8467\u8430\u844D\u847D\u845A\u8459\u8474\u8473\u845D\u8507\u845E\u8437\u843A\u8434\u847A\u8443\u8478\u8432\u8445\u8429\u83D9\u844B\u842F\u8442\u842D\u845F\u8470\u8439\u844E\u844C\u8452\u846F\u84C5\u848E\u843B\u8447\u8436\u8433\u8468\u847E\u8444\u842B\u8460\u8454\u846E\u8450\u870B\u8704\u86F7\u870C\u86FA\u86D6\u86F5\u874D\u86F8\u870E\u8709\u8701\u86F6\u870D\u8705\u88D6\u88CB\u88CD\u88CE\u88DE\u88DB\u88DA\u88CC\u88D0\u8985\u899B\u89DF\u89E5\u89E4"], + ["e040", "\u89E1\u89E0\u89E2\u89DC\u89E6\u8A76\u8A86\u8A7F\u8A61\u8A3F\u8A77\u8A82\u8A84\u8A75\u8A83\u8A81\u8A74\u8A7A\u8C3C\u8C4B\u8C4A\u8C65\u8C64\u8C66\u8C86\u8C84\u8C85\u8CCC\u8D68\u8D69\u8D91\u8D8C\u8D8E\u8D8F\u8D8D\u8D93\u8D94\u8D90\u8D92\u8DF0\u8DE0\u8DEC\u8DF1\u8DEE\u8DD0\u8DE9\u8DE3\u8DE2\u8DE7\u8DF2\u8DEB\u8DF4\u8F06\u8EFF\u8F01\u8F00\u8F05\u8F07\u8F08\u8F02\u8F0B\u9052\u903F"], + ["e0a1", "\u9044\u9049\u903D\u9110\u910D\u910F\u9111\u9116\u9114\u910B\u910E\u916E\u916F\u9248\u9252\u9230\u923A\u9266\u9233\u9265\u925E\u9283\u922E\u924A\u9246\u926D\u926C\u924F\u9260\u9267\u926F\u9236\u9261\u9270\u9231\u9254\u9263\u9250\u9272\u924E\u9253\u924C\u9256\u9232\u959F\u959C\u959E\u959B\u9692\u9693\u9691\u9697\u96CE\u96FA\u96FD\u96F8\u96F5\u9773\u9777\u9778\u9772\u980F\u980D\u980E\u98AC\u98F6\u98F9\u99AF\u99B2\u99B0\u99B5\u9AAD\u9AAB\u9B5B\u9CEA\u9CED\u9CE7\u9E80\u9EFD\u50E6\u50D4\u50D7\u50E8\u50F3\u50DB\u50EA\u50DD\u50E4\u50D3\u50EC\u50F0\u50EF\u50E3\u50E0"], + ["e140", "\u51D8\u5280\u5281\u52E9\u52EB\u5330\u53AC\u5627\u5615\u560C\u5612\u55FC\u560F\u561C\u5601\u5613\u5602\u55FA\u561D\u5604\u55FF\u55F9\u5889\u587C\u5890\u5898\u5886\u5881\u587F\u5874\u588B\u587A\u5887\u5891\u588E\u5876\u5882\u5888\u587B\u5894\u588F\u58FE\u596B\u5ADC\u5AEE\u5AE5\u5AD5\u5AEA\u5ADA\u5AED\u5AEB\u5AF3\u5AE2\u5AE0\u5ADB\u5AEC\u5ADE\u5ADD\u5AD9\u5AE8\u5ADF\u5B77\u5BE0"], + ["e1a1", "\u5BE3\u5C63\u5D82\u5D80\u5D7D\u5D86\u5D7A\u5D81\u5D77\u5D8A\u5D89\u5D88\u5D7E\u5D7C\u5D8D\u5D79\u5D7F\u5E58\u5E59\u5E53\u5ED8\u5ED1\u5ED7\u5ECE\u5EDC\u5ED5\u5ED9\u5ED2\u5ED4\u5F44\u5F43\u5F6F\u5FB6\u612C\u6128\u6141\u615E\u6171\u6173\u6152\u6153\u6172\u616C\u6180\u6174\u6154\u617A\u615B\u6165\u613B\u616A\u6161\u6156\u6229\u6227\u622B\u642B\u644D\u645B\u645D\u6474\u6476\u6472\u6473\u647D\u6475\u6466\u64A6\u644E\u6482\u645E\u645C\u644B\u6453\u6460\u6450\u647F\u643F\u646C\u646B\u6459\u6465\u6477\u6573\u65A0\u66A1\u66A0\u669F\u6705\u6704\u6722\u69B1\u69B6\u69C9"], + ["e240", "\u69A0\u69CE\u6996\u69B0\u69AC\u69BC\u6991\u6999\u698E\u69A7\u698D\u69A9\u69BE\u69AF\u69BF\u69C4\u69BD\u69A4\u69D4\u69B9\u69CA\u699A\u69CF\u69B3\u6993\u69AA\u69A1\u699E\u69D9\u6997\u6990\u69C2\u69B5\u69A5\u69C6\u6B4A\u6B4D\u6B4B\u6B9E\u6B9F\u6BA0\u6BC3\u6BC4\u6BFE\u6ECE\u6EF5\u6EF1\u6F03\u6F25\u6EF8\u6F37\u6EFB\u6F2E\u6F09\u6F4E\u6F19\u6F1A\u6F27\u6F18\u6F3B\u6F12\u6EED\u6F0A"], + ["e2a1", "\u6F36\u6F73\u6EF9\u6EEE\u6F2D\u6F40\u6F30\u6F3C\u6F35\u6EEB\u6F07\u6F0E\u6F43\u6F05\u6EFD\u6EF6\u6F39\u6F1C\u6EFC\u6F3A\u6F1F\u6F0D\u6F1E\u6F08\u6F21\u7187\u7190\u7189\u7180\u7185\u7182\u718F\u717B\u7186\u7181\u7197\u7244\u7253\u7297\u7295\u7293\u7343\u734D\u7351\u734C\u7462\u7473\u7471\u7475\u7472\u7467\u746E\u7500\u7502\u7503\u757D\u7590\u7616\u7608\u760C\u7615\u7611\u760A\u7614\u76B8\u7781\u777C\u7785\u7782\u776E\u7780\u776F\u777E\u7783\u78B2\u78AA\u78B4\u78AD\u78A8\u787E\u78AB\u789E\u78A5\u78A0\u78AC\u78A2\u78A4\u7998\u798A\u798B\u7996\u7995\u7994\u7993"], + ["e340", "\u7997\u7988\u7992\u7990\u7A2B\u7A4A\u7A30\u7A2F\u7A28\u7A26\u7AA8\u7AAB\u7AAC\u7AEE\u7B88\u7B9C\u7B8A\u7B91\u7B90\u7B96\u7B8D\u7B8C\u7B9B\u7B8E\u7B85\u7B98\u5284\u7B99\u7BA4\u7B82\u7CBB\u7CBF\u7CBC\u7CBA\u7DA7\u7DB7\u7DC2\u7DA3\u7DAA\u7DC1\u7DC0\u7DC5\u7D9D\u7DCE\u7DC4\u7DC6\u7DCB\u7DCC\u7DAF\u7DB9\u7D96\u7DBC\u7D9F\u7DA6\u7DAE\u7DA9\u7DA1\u7DC9\u7F73\u7FE2\u7FE3\u7FE5\u7FDE"], + ["e3a1", "\u8024\u805D\u805C\u8189\u8186\u8183\u8187\u818D\u818C\u818B\u8215\u8497\u84A4\u84A1\u849F\u84BA\u84CE\u84C2\u84AC\u84AE\u84AB\u84B9\u84B4\u84C1\u84CD\u84AA\u849A\u84B1\u84D0\u849D\u84A7\u84BB\u84A2\u8494\u84C7\u84CC\u849B\u84A9\u84AF\u84A8\u84D6\u8498\u84B6\u84CF\u84A0\u84D7\u84D4\u84D2\u84DB\u84B0\u8491\u8661\u8733\u8723\u8728\u876B\u8740\u872E\u871E\u8721\u8719\u871B\u8743\u872C\u8741\u873E\u8746\u8720\u8732\u872A\u872D\u873C\u8712\u873A\u8731\u8735\u8742\u8726\u8727\u8738\u8724\u871A\u8730\u8711\u88F7\u88E7\u88F1\u88F2\u88FA\u88FE\u88EE\u88FC\u88F6\u88FB"], + ["e440", "\u88F0\u88EC\u88EB\u899D\u89A1\u899F\u899E\u89E9\u89EB\u89E8\u8AAB\u8A99\u8A8B\u8A92\u8A8F\u8A96\u8C3D\u8C68\u8C69\u8CD5\u8CCF\u8CD7\u8D96\u8E09\u8E02\u8DFF\u8E0D\u8DFD\u8E0A\u8E03\u8E07\u8E06\u8E05\u8DFE\u8E00\u8E04\u8F10\u8F11\u8F0E\u8F0D\u9123\u911C\u9120\u9122\u911F\u911D\u911A\u9124\u9121\u911B\u917A\u9172\u9179\u9173\u92A5\u92A4\u9276\u929B\u927A\u92A0\u9294\u92AA\u928D"], + ["e4a1", "\u92A6\u929A\u92AB\u9279\u9297\u927F\u92A3\u92EE\u928E\u9282\u9295\u92A2\u927D\u9288\u92A1\u928A\u9286\u928C\u9299\u92A7\u927E\u9287\u92A9\u929D\u928B\u922D\u969E\u96A1\u96FF\u9758\u977D\u977A\u977E\u9783\u9780\u9782\u977B\u9784\u9781\u977F\u97CE\u97CD\u9816\u98AD\u98AE\u9902\u9900\u9907\u999D\u999C\u99C3\u99B9\u99BB\u99BA\u99C2\u99BD\u99C7\u9AB1\u9AE3\u9AE7\u9B3E\u9B3F\u9B60\u9B61\u9B5F\u9CF1\u9CF2\u9CF5\u9EA7\u50FF\u5103\u5130\u50F8\u5106\u5107\u50F6\u50FE\u510B\u510C\u50FD\u510A\u528B\u528C\u52F1\u52EF\u5648\u5642\u564C\u5635\u5641\u564A\u5649\u5646\u5658"], + ["e540", "\u565A\u5640\u5633\u563D\u562C\u563E\u5638\u562A\u563A\u571A\u58AB\u589D\u58B1\u58A0\u58A3\u58AF\u58AC\u58A5\u58A1\u58FF\u5AFF\u5AF4\u5AFD\u5AF7\u5AF6\u5B03\u5AF8\u5B02\u5AF9\u5B01\u5B07\u5B05\u5B0F\u5C67\u5D99\u5D97\u5D9F\u5D92\u5DA2\u5D93\u5D95\u5DA0\u5D9C\u5DA1\u5D9A\u5D9E\u5E69\u5E5D\u5E60\u5E5C\u7DF3\u5EDB\u5EDE\u5EE1\u5F49\u5FB2\u618B\u6183\u6179\u61B1\u61B0\u61A2\u6189"], + ["e5a1", "\u619B\u6193\u61AF\u61AD\u619F\u6192\u61AA\u61A1\u618D\u6166\u61B3\u622D\u646E\u6470\u6496\u64A0\u6485\u6497\u649C\u648F\u648B\u648A\u648C\u64A3\u649F\u6468\u64B1\u6498\u6576\u657A\u6579\u657B\u65B2\u65B3\u66B5\u66B0\u66A9\u66B2\u66B7\u66AA\u66AF\u6A00\u6A06\u6A17\u69E5\u69F8\u6A15\u69F1\u69E4\u6A20\u69FF\u69EC\u69E2\u6A1B\u6A1D\u69FE\u6A27\u69F2\u69EE\u6A14\u69F7\u69E7\u6A40\u6A08\u69E6\u69FB\u6A0D\u69FC\u69EB\u6A09\u6A04\u6A18\u6A25\u6A0F\u69F6\u6A26\u6A07\u69F4\u6A16\u6B51\u6BA5\u6BA3\u6BA2\u6BA6\u6C01\u6C00\u6BFF\u6C02\u6F41\u6F26\u6F7E\u6F87\u6FC6\u6F92"], + ["e640", "\u6F8D\u6F89\u6F8C\u6F62\u6F4F\u6F85\u6F5A\u6F96\u6F76\u6F6C\u6F82\u6F55\u6F72\u6F52\u6F50\u6F57\u6F94\u6F93\u6F5D\u6F00\u6F61\u6F6B\u6F7D\u6F67\u6F90\u6F53\u6F8B\u6F69\u6F7F\u6F95\u6F63\u6F77\u6F6A\u6F7B\u71B2\u71AF\u719B\u71B0\u71A0\u719A\u71A9\u71B5\u719D\u71A5\u719E\u71A4\u71A1\u71AA\u719C\u71A7\u71B3\u7298\u729A\u7358\u7352\u735E\u735F\u7360\u735D\u735B\u7361\u735A\u7359"], + ["e6a1", "\u7362\u7487\u7489\u748A\u7486\u7481\u747D\u7485\u7488\u747C\u7479\u7508\u7507\u757E\u7625\u761E\u7619\u761D\u761C\u7623\u761A\u7628\u761B\u769C\u769D\u769E\u769B\u778D\u778F\u7789\u7788\u78CD\u78BB\u78CF\u78CC\u78D1\u78CE\u78D4\u78C8\u78C3\u78C4\u78C9\u799A\u79A1\u79A0\u799C\u79A2\u799B\u6B76\u7A39\u7AB2\u7AB4\u7AB3\u7BB7\u7BCB\u7BBE\u7BAC\u7BCE\u7BAF\u7BB9\u7BCA\u7BB5\u7CC5\u7CC8\u7CCC\u7CCB\u7DF7\u7DDB\u7DEA\u7DE7\u7DD7\u7DE1\u7E03\u7DFA\u7DE6\u7DF6\u7DF1\u7DF0\u7DEE\u7DDF\u7F76\u7FAC\u7FB0\u7FAD\u7FED\u7FEB\u7FEA\u7FEC\u7FE6\u7FE8\u8064\u8067\u81A3\u819F"], + ["e740", "\u819E\u8195\u81A2\u8199\u8197\u8216\u824F\u8253\u8252\u8250\u824E\u8251\u8524\u853B\u850F\u8500\u8529\u850E\u8509\u850D\u851F\u850A\u8527\u851C\u84FB\u852B\u84FA\u8508\u850C\u84F4\u852A\u84F2\u8515\u84F7\u84EB\u84F3\u84FC\u8512\u84EA\u84E9\u8516\u84FE\u8528\u851D\u852E\u8502\u84FD\u851E\u84F6\u8531\u8526\u84E7\u84E8\u84F0\u84EF\u84F9\u8518\u8520\u8530\u850B\u8519\u852F\u8662"], + ["e7a1", "\u8756\u8763\u8764\u8777\u87E1\u8773\u8758\u8754\u875B\u8752\u8761\u875A\u8751\u875E\u876D\u876A\u8750\u874E\u875F\u875D\u876F\u876C\u877A\u876E\u875C\u8765\u874F\u877B\u8775\u8762\u8767\u8769\u885A\u8905\u890C\u8914\u890B\u8917\u8918\u8919\u8906\u8916\u8911\u890E\u8909\u89A2\u89A4\u89A3\u89ED\u89F0\u89EC\u8ACF\u8AC6\u8AB8\u8AD3\u8AD1\u8AD4\u8AD5\u8ABB\u8AD7\u8ABE\u8AC0\u8AC5\u8AD8\u8AC3\u8ABA\u8ABD\u8AD9\u8C3E\u8C4D\u8C8F\u8CE5\u8CDF\u8CD9\u8CE8\u8CDA\u8CDD\u8CE7\u8DA0\u8D9C\u8DA1\u8D9B\u8E20\u8E23\u8E25\u8E24\u8E2E\u8E15\u8E1B\u8E16\u8E11\u8E19\u8E26\u8E27"], + ["e840", "\u8E14\u8E12\u8E18\u8E13\u8E1C\u8E17\u8E1A\u8F2C\u8F24\u8F18\u8F1A\u8F20\u8F23\u8F16\u8F17\u9073\u9070\u906F\u9067\u906B\u912F\u912B\u9129\u912A\u9132\u9126\u912E\u9185\u9186\u918A\u9181\u9182\u9184\u9180\u92D0\u92C3\u92C4\u92C0\u92D9\u92B6\u92CF\u92F1\u92DF\u92D8\u92E9\u92D7\u92DD\u92CC\u92EF\u92C2\u92E8\u92CA\u92C8\u92CE\u92E6\u92CD\u92D5\u92C9\u92E0\u92DE\u92E7\u92D1\u92D3"], + ["e8a1", "\u92B5\u92E1\u92C6\u92B4\u957C\u95AC\u95AB\u95AE\u95B0\u96A4\u96A2\u96D3\u9705\u9708\u9702\u975A\u978A\u978E\u9788\u97D0\u97CF\u981E\u981D\u9826\u9829\u9828\u9820\u981B\u9827\u98B2\u9908\u98FA\u9911\u9914\u9916\u9917\u9915\u99DC\u99CD\u99CF\u99D3\u99D4\u99CE\u99C9\u99D6\u99D8\u99CB\u99D7\u99CC\u9AB3\u9AEC\u9AEB\u9AF3\u9AF2\u9AF1\u9B46\u9B43\u9B67\u9B74\u9B71\u9B66\u9B76\u9B75\u9B70\u9B68\u9B64\u9B6C\u9CFC\u9CFA\u9CFD\u9CFF\u9CF7\u9D07\u9D00\u9CF9\u9CFB\u9D08\u9D05\u9D04\u9E83\u9ED3\u9F0F\u9F10\u511C\u5113\u5117\u511A\u5111\u51DE\u5334\u53E1\u5670\u5660\u566E"], + ["e940", "\u5673\u5666\u5663\u566D\u5672\u565E\u5677\u571C\u571B\u58C8\u58BD\u58C9\u58BF\u58BA\u58C2\u58BC\u58C6\u5B17\u5B19\u5B1B\u5B21\u5B14\u5B13\u5B10\u5B16\u5B28\u5B1A\u5B20\u5B1E\u5BEF\u5DAC\u5DB1\u5DA9\u5DA7\u5DB5\u5DB0\u5DAE\u5DAA\u5DA8\u5DB2\u5DAD\u5DAF\u5DB4\u5E67\u5E68\u5E66\u5E6F\u5EE9\u5EE7\u5EE6\u5EE8\u5EE5\u5F4B\u5FBC\u619D\u61A8\u6196\u61C5\u61B4\u61C6\u61C1\u61CC\u61BA"], + ["e9a1", "\u61BF\u61B8\u618C\u64D7\u64D6\u64D0\u64CF\u64C9\u64BD\u6489\u64C3\u64DB\u64F3\u64D9\u6533\u657F\u657C\u65A2\u66C8\u66BE\u66C0\u66CA\u66CB\u66CF\u66BD\u66BB\u66BA\u66CC\u6723\u6A34\u6A66\u6A49\u6A67\u6A32\u6A68\u6A3E\u6A5D\u6A6D\u6A76\u6A5B\u6A51\u6A28\u6A5A\u6A3B\u6A3F\u6A41\u6A6A\u6A64\u6A50\u6A4F\u6A54\u6A6F\u6A69\u6A60\u6A3C\u6A5E\u6A56\u6A55\u6A4D\u6A4E\u6A46\u6B55\u6B54\u6B56\u6BA7\u6BAA\u6BAB\u6BC8\u6BC7\u6C04\u6C03\u6C06\u6FAD\u6FCB\u6FA3\u6FC7\u6FBC\u6FCE\u6FC8\u6F5E\u6FC4\u6FBD\u6F9E\u6FCA\u6FA8\u7004\u6FA5\u6FAE\u6FBA\u6FAC\u6FAA\u6FCF\u6FBF\u6FB8"], + ["ea40", "\u6FA2\u6FC9\u6FAB\u6FCD\u6FAF\u6FB2\u6FB0\u71C5\u71C2\u71BF\u71B8\u71D6\u71C0\u71C1\u71CB\u71D4\u71CA\u71C7\u71CF\u71BD\u71D8\u71BC\u71C6\u71DA\u71DB\u729D\u729E\u7369\u7366\u7367\u736C\u7365\u736B\u736A\u747F\u749A\u74A0\u7494\u7492\u7495\u74A1\u750B\u7580\u762F\u762D\u7631\u763D\u7633\u763C\u7635\u7632\u7630\u76BB\u76E6\u779A\u779D\u77A1\u779C\u779B\u77A2\u77A3\u7795\u7799"], + ["eaa1", "\u7797\u78DD\u78E9\u78E5\u78EA\u78DE\u78E3\u78DB\u78E1\u78E2\u78ED\u78DF\u78E0\u79A4\u7A44\u7A48\u7A47\u7AB6\u7AB8\u7AB5\u7AB1\u7AB7\u7BDE\u7BE3\u7BE7\u7BDD\u7BD5\u7BE5\u7BDA\u7BE8\u7BF9\u7BD4\u7BEA\u7BE2\u7BDC\u7BEB\u7BD8\u7BDF\u7CD2\u7CD4\u7CD7\u7CD0\u7CD1\u7E12\u7E21\u7E17\u7E0C\u7E1F\u7E20\u7E13\u7E0E\u7E1C\u7E15\u7E1A\u7E22\u7E0B\u7E0F\u7E16\u7E0D\u7E14\u7E25\u7E24\u7F43\u7F7B\u7F7C\u7F7A\u7FB1\u7FEF\u802A\u8029\u806C\u81B1\u81A6\u81AE\u81B9\u81B5\u81AB\u81B0\u81AC\u81B4\u81B2\u81B7\u81A7\u81F2\u8255\u8256\u8257\u8556\u8545\u856B\u854D\u8553\u8561\u8558"], + ["eb40", "\u8540\u8546\u8564\u8541\u8562\u8544\u8551\u8547\u8563\u853E\u855B\u8571\u854E\u856E\u8575\u8555\u8567\u8560\u858C\u8566\u855D\u8554\u8565\u856C\u8663\u8665\u8664\u879B\u878F\u8797\u8793\u8792\u8788\u8781\u8796\u8798\u8779\u8787\u87A3\u8785\u8790\u8791\u879D\u8784\u8794\u879C\u879A\u8789\u891E\u8926\u8930\u892D\u892E\u8927\u8931\u8922\u8929\u8923\u892F\u892C\u891F\u89F1\u8AE0"], + ["eba1", "\u8AE2\u8AF2\u8AF4\u8AF5\u8ADD\u8B14\u8AE4\u8ADF\u8AF0\u8AC8\u8ADE\u8AE1\u8AE8\u8AFF\u8AEF\u8AFB\u8C91\u8C92\u8C90\u8CF5\u8CEE\u8CF1\u8CF0\u8CF3\u8D6C\u8D6E\u8DA5\u8DA7\u8E33\u8E3E\u8E38\u8E40\u8E45\u8E36\u8E3C\u8E3D\u8E41\u8E30\u8E3F\u8EBD\u8F36\u8F2E\u8F35\u8F32\u8F39\u8F37\u8F34\u9076\u9079\u907B\u9086\u90FA\u9133\u9135\u9136\u9193\u9190\u9191\u918D\u918F\u9327\u931E\u9308\u931F\u9306\u930F\u937A\u9338\u933C\u931B\u9323\u9312\u9301\u9346\u932D\u930E\u930D\u92CB\u931D\u92FA\u9325\u9313\u92F9\u92F7\u9334\u9302\u9324\u92FF\u9329\u9339\u9335\u932A\u9314\u930C"], + ["ec40", "\u930B\u92FE\u9309\u9300\u92FB\u9316\u95BC\u95CD\u95BE\u95B9\u95BA\u95B6\u95BF\u95B5\u95BD\u96A9\u96D4\u970B\u9712\u9710\u9799\u9797\u9794\u97F0\u97F8\u9835\u982F\u9832\u9924\u991F\u9927\u9929\u999E\u99EE\u99EC\u99E5\u99E4\u99F0\u99E3\u99EA\u99E9\u99E7\u9AB9\u9ABF\u9AB4\u9ABB\u9AF6\u9AFA\u9AF9\u9AF7\u9B33\u9B80\u9B85\u9B87\u9B7C\u9B7E\u9B7B\u9B82\u9B93\u9B92\u9B90\u9B7A\u9B95"], + ["eca1", "\u9B7D\u9B88\u9D25\u9D17\u9D20\u9D1E\u9D14\u9D29\u9D1D\u9D18\u9D22\u9D10\u9D19\u9D1F\u9E88\u9E86\u9E87\u9EAE\u9EAD\u9ED5\u9ED6\u9EFA\u9F12\u9F3D\u5126\u5125\u5122\u5124\u5120\u5129\u52F4\u5693\u568C\u568D\u5686\u5684\u5683\u567E\u5682\u567F\u5681\u58D6\u58D4\u58CF\u58D2\u5B2D\u5B25\u5B32\u5B23\u5B2C\u5B27\u5B26\u5B2F\u5B2E\u5B7B\u5BF1\u5BF2\u5DB7\u5E6C\u5E6A\u5FBE\u5FBB\u61C3\u61B5\u61BC\u61E7\u61E0\u61E5\u61E4\u61E8\u61DE\u64EF\u64E9\u64E3\u64EB\u64E4\u64E8\u6581\u6580\u65B6\u65DA\u66D2\u6A8D\u6A96\u6A81\u6AA5\u6A89\u6A9F\u6A9B\u6AA1\u6A9E\u6A87\u6A93\u6A8E"], + ["ed40", "\u6A95\u6A83\u6AA8\u6AA4\u6A91\u6A7F\u6AA6\u6A9A\u6A85\u6A8C\u6A92\u6B5B\u6BAD\u6C09\u6FCC\u6FA9\u6FF4\u6FD4\u6FE3\u6FDC\u6FED\u6FE7\u6FE6\u6FDE\u6FF2\u6FDD\u6FE2\u6FE8\u71E1\u71F1\u71E8\u71F2\u71E4\u71F0\u71E2\u7373\u736E\u736F\u7497\u74B2\u74AB\u7490\u74AA\u74AD\u74B1\u74A5\u74AF\u7510\u7511\u7512\u750F\u7584\u7643\u7648\u7649\u7647\u76A4\u76E9\u77B5\u77AB\u77B2\u77B7\u77B6"], + ["eda1", "\u77B4\u77B1\u77A8\u77F0\u78F3\u78FD\u7902\u78FB\u78FC\u78F2\u7905\u78F9\u78FE\u7904\u79AB\u79A8\u7A5C\u7A5B\u7A56\u7A58\u7A54\u7A5A\u7ABE\u7AC0\u7AC1\u7C05\u7C0F\u7BF2\u7C00\u7BFF\u7BFB\u7C0E\u7BF4\u7C0B\u7BF3\u7C02\u7C09\u7C03\u7C01\u7BF8\u7BFD\u7C06\u7BF0\u7BF1\u7C10\u7C0A\u7CE8\u7E2D\u7E3C\u7E42\u7E33\u9848\u7E38\u7E2A\u7E49\u7E40\u7E47\u7E29\u7E4C\u7E30\u7E3B\u7E36\u7E44\u7E3A\u7F45\u7F7F\u7F7E\u7F7D\u7FF4\u7FF2\u802C\u81BB\u81C4\u81CC\u81CA\u81C5\u81C7\u81BC\u81E9\u825B\u825A\u825C\u8583\u8580\u858F\u85A7\u8595\u85A0\u858B\u85A3\u857B\u85A4\u859A\u859E"], + ["ee40", "\u8577\u857C\u8589\u85A1\u857A\u8578\u8557\u858E\u8596\u8586\u858D\u8599\u859D\u8581\u85A2\u8582\u8588\u8585\u8579\u8576\u8598\u8590\u859F\u8668\u87BE\u87AA\u87AD\u87C5\u87B0\u87AC\u87B9\u87B5\u87BC\u87AE\u87C9\u87C3\u87C2\u87CC\u87B7\u87AF\u87C4\u87CA\u87B4\u87B6\u87BF\u87B8\u87BD\u87DE\u87B2\u8935\u8933\u893C\u893E\u8941\u8952\u8937\u8942\u89AD\u89AF\u89AE\u89F2\u89F3\u8B1E"], + ["eea1", "\u8B18\u8B16\u8B11\u8B05\u8B0B\u8B22\u8B0F\u8B12\u8B15\u8B07\u8B0D\u8B08\u8B06\u8B1C\u8B13\u8B1A\u8C4F\u8C70\u8C72\u8C71\u8C6F\u8C95\u8C94\u8CF9\u8D6F\u8E4E\u8E4D\u8E53\u8E50\u8E4C\u8E47\u8F43\u8F40\u9085\u907E\u9138\u919A\u91A2\u919B\u9199\u919F\u91A1\u919D\u91A0\u93A1\u9383\u93AF\u9364\u9356\u9347\u937C\u9358\u935C\u9376\u9349\u9350\u9351\u9360\u936D\u938F\u934C\u936A\u9379\u9357\u9355\u9352\u934F\u9371\u9377\u937B\u9361\u935E\u9363\u9367\u9380\u934E\u9359\u95C7\u95C0\u95C9\u95C3\u95C5\u95B7\u96AE\u96B0\u96AC\u9720\u971F\u9718\u971D\u9719\u979A\u97A1\u979C"], + ["ef40", "\u979E\u979D\u97D5\u97D4\u97F1\u9841\u9844\u984A\u9849\u9845\u9843\u9925\u992B\u992C\u992A\u9933\u9932\u992F\u992D\u9931\u9930\u9998\u99A3\u99A1\u9A02\u99FA\u99F4\u99F7\u99F9\u99F8\u99F6\u99FB\u99FD\u99FE\u99FC\u9A03\u9ABE\u9AFE\u9AFD\u9B01\u9AFC\u9B48\u9B9A\u9BA8\u9B9E\u9B9B\u9BA6\u9BA1\u9BA5\u9BA4\u9B86\u9BA2\u9BA0\u9BAF\u9D33\u9D41\u9D67\u9D36\u9D2E\u9D2F\u9D31\u9D38\u9D30"], + ["efa1", "\u9D45\u9D42\u9D43\u9D3E\u9D37\u9D40\u9D3D\u7FF5\u9D2D\u9E8A\u9E89\u9E8D\u9EB0\u9EC8\u9EDA\u9EFB\u9EFF\u9F24\u9F23\u9F22\u9F54\u9FA0\u5131\u512D\u512E\u5698\u569C\u5697\u569A\u569D\u5699\u5970\u5B3C\u5C69\u5C6A\u5DC0\u5E6D\u5E6E\u61D8\u61DF\u61ED\u61EE\u61F1\u61EA\u61F0\u61EB\u61D6\u61E9\u64FF\u6504\u64FD\u64F8\u6501\u6503\u64FC\u6594\u65DB\u66DA\u66DB\u66D8\u6AC5\u6AB9\u6ABD\u6AE1\u6AC6\u6ABA\u6AB6\u6AB7\u6AC7\u6AB4\u6AAD\u6B5E\u6BC9\u6C0B\u7007\u700C\u700D\u7001\u7005\u7014\u700E\u6FFF\u7000\u6FFB\u7026\u6FFC\u6FF7\u700A\u7201\u71FF\u71F9\u7203\u71FD\u7376"], + ["f040", "\u74B8\u74C0\u74B5\u74C1\u74BE\u74B6\u74BB\u74C2\u7514\u7513\u765C\u7664\u7659\u7650\u7653\u7657\u765A\u76A6\u76BD\u76EC\u77C2\u77BA\u78FF\u790C\u7913\u7914\u7909\u7910\u7912\u7911\u79AD\u79AC\u7A5F\u7C1C\u7C29\u7C19\u7C20\u7C1F\u7C2D\u7C1D\u7C26\u7C28\u7C22\u7C25\u7C30\u7E5C\u7E50\u7E56\u7E63\u7E58\u7E62\u7E5F\u7E51\u7E60\u7E57\u7E53\u7FB5\u7FB3\u7FF7\u7FF8\u8075\u81D1\u81D2"], + ["f0a1", "\u81D0\u825F\u825E\u85B4\u85C6\u85C0\u85C3\u85C2\u85B3\u85B5\u85BD\u85C7\u85C4\u85BF\u85CB\u85CE\u85C8\u85C5\u85B1\u85B6\u85D2\u8624\u85B8\u85B7\u85BE\u8669\u87E7\u87E6\u87E2\u87DB\u87EB\u87EA\u87E5\u87DF\u87F3\u87E4\u87D4\u87DC\u87D3\u87ED\u87D8\u87E3\u87A4\u87D7\u87D9\u8801\u87F4\u87E8\u87DD\u8953\u894B\u894F\u894C\u8946\u8950\u8951\u8949\u8B2A\u8B27\u8B23\u8B33\u8B30\u8B35\u8B47\u8B2F\u8B3C\u8B3E\u8B31\u8B25\u8B37\u8B26\u8B36\u8B2E\u8B24\u8B3B\u8B3D\u8B3A\u8C42\u8C75\u8C99\u8C98\u8C97\u8CFE\u8D04\u8D02\u8D00\u8E5C\u8E62\u8E60\u8E57\u8E56\u8E5E\u8E65\u8E67"], + ["f140", "\u8E5B\u8E5A\u8E61\u8E5D\u8E69\u8E54\u8F46\u8F47\u8F48\u8F4B\u9128\u913A\u913B\u913E\u91A8\u91A5\u91A7\u91AF\u91AA\u93B5\u938C\u9392\u93B7\u939B\u939D\u9389\u93A7\u938E\u93AA\u939E\u93A6\u9395\u9388\u9399\u939F\u938D\u93B1\u9391\u93B2\u93A4\u93A8\u93B4\u93A3\u93A5\u95D2\u95D3\u95D1\u96B3\u96D7\u96DA\u5DC2\u96DF\u96D8\u96DD\u9723\u9722\u9725\u97AC\u97AE\u97A8\u97AB\u97A4\u97AA"], + ["f1a1", "\u97A2\u97A5\u97D7\u97D9\u97D6\u97D8\u97FA\u9850\u9851\u9852\u98B8\u9941\u993C\u993A\u9A0F\u9A0B\u9A09\u9A0D\u9A04\u9A11\u9A0A\u9A05\u9A07\u9A06\u9AC0\u9ADC\u9B08\u9B04\u9B05\u9B29\u9B35\u9B4A\u9B4C\u9B4B\u9BC7\u9BC6\u9BC3\u9BBF\u9BC1\u9BB5\u9BB8\u9BD3\u9BB6\u9BC4\u9BB9\u9BBD\u9D5C\u9D53\u9D4F\u9D4A\u9D5B\u9D4B\u9D59\u9D56\u9D4C\u9D57\u9D52\u9D54\u9D5F\u9D58\u9D5A\u9E8E\u9E8C\u9EDF\u9F01\u9F00\u9F16\u9F25\u9F2B\u9F2A\u9F29\u9F28\u9F4C\u9F55\u5134\u5135\u5296\u52F7\u53B4\u56AB\u56AD\u56A6\u56A7\u56AA\u56AC\u58DA\u58DD\u58DB\u5912\u5B3D\u5B3E\u5B3F\u5DC3\u5E70"], + ["f240", "\u5FBF\u61FB\u6507\u6510\u650D\u6509\u650C\u650E\u6584\u65DE\u65DD\u66DE\u6AE7\u6AE0\u6ACC\u6AD1\u6AD9\u6ACB\u6ADF\u6ADC\u6AD0\u6AEB\u6ACF\u6ACD\u6ADE\u6B60\u6BB0\u6C0C\u7019\u7027\u7020\u7016\u702B\u7021\u7022\u7023\u7029\u7017\u7024\u701C\u702A\u720C\u720A\u7207\u7202\u7205\u72A5\u72A6\u72A4\u72A3\u72A1\u74CB\u74C5\u74B7\u74C3\u7516\u7660\u77C9\u77CA\u77C4\u77F1\u791D\u791B"], + ["f2a1", "\u7921\u791C\u7917\u791E\u79B0\u7A67\u7A68\u7C33\u7C3C\u7C39\u7C2C\u7C3B\u7CEC\u7CEA\u7E76\u7E75\u7E78\u7E70\u7E77\u7E6F\u7E7A\u7E72\u7E74\u7E68\u7F4B\u7F4A\u7F83\u7F86\u7FB7\u7FFD\u7FFE\u8078\u81D7\u81D5\u8264\u8261\u8263\u85EB\u85F1\u85ED\u85D9\u85E1\u85E8\u85DA\u85D7\u85EC\u85F2\u85F8\u85D8\u85DF\u85E3\u85DC\u85D1\u85F0\u85E6\u85EF\u85DE\u85E2\u8800\u87FA\u8803\u87F6\u87F7\u8809\u880C\u880B\u8806\u87FC\u8808\u87FF\u880A\u8802\u8962\u895A\u895B\u8957\u8961\u895C\u8958\u895D\u8959\u8988\u89B7\u89B6\u89F6\u8B50\u8B48\u8B4A\u8B40\u8B53\u8B56\u8B54\u8B4B\u8B55"], + ["f340", "\u8B51\u8B42\u8B52\u8B57\u8C43\u8C77\u8C76\u8C9A\u8D06\u8D07\u8D09\u8DAC\u8DAA\u8DAD\u8DAB\u8E6D\u8E78\u8E73\u8E6A\u8E6F\u8E7B\u8EC2\u8F52\u8F51\u8F4F\u8F50\u8F53\u8FB4\u9140\u913F\u91B0\u91AD\u93DE\u93C7\u93CF\u93C2\u93DA\u93D0\u93F9\u93EC\u93CC\u93D9\u93A9\u93E6\u93CA\u93D4\u93EE\u93E3\u93D5\u93C4\u93CE\u93C0\u93D2\u93E7\u957D\u95DA\u95DB\u96E1\u9729\u972B\u972C\u9728\u9726"], + ["f3a1", "\u97B3\u97B7\u97B6\u97DD\u97DE\u97DF\u985C\u9859\u985D\u9857\u98BF\u98BD\u98BB\u98BE\u9948\u9947\u9943\u99A6\u99A7\u9A1A\u9A15\u9A25\u9A1D\u9A24\u9A1B\u9A22\u9A20\u9A27\u9A23\u9A1E\u9A1C\u9A14\u9AC2\u9B0B\u9B0A\u9B0E\u9B0C\u9B37\u9BEA\u9BEB\u9BE0\u9BDE\u9BE4\u9BE6\u9BE2\u9BF0\u9BD4\u9BD7\u9BEC\u9BDC\u9BD9\u9BE5\u9BD5\u9BE1\u9BDA\u9D77\u9D81\u9D8A\u9D84\u9D88\u9D71\u9D80\u9D78\u9D86\u9D8B\u9D8C\u9D7D\u9D6B\u9D74\u9D75\u9D70\u9D69\u9D85\u9D73\u9D7B\u9D82\u9D6F\u9D79\u9D7F\u9D87\u9D68\u9E94\u9E91\u9EC0\u9EFC\u9F2D\u9F40\u9F41\u9F4D\u9F56\u9F57\u9F58\u5337\u56B2"], + ["f440", "\u56B5\u56B3\u58E3\u5B45\u5DC6\u5DC7\u5EEE\u5EEF\u5FC0\u5FC1\u61F9\u6517\u6516\u6515\u6513\u65DF\u66E8\u66E3\u66E4\u6AF3\u6AF0\u6AEA\u6AE8\u6AF9\u6AF1\u6AEE\u6AEF\u703C\u7035\u702F\u7037\u7034\u7031\u7042\u7038\u703F\u703A\u7039\u7040\u703B\u7033\u7041\u7213\u7214\u72A8\u737D\u737C\u74BA\u76AB\u76AA\u76BE\u76ED\u77CC\u77CE\u77CF\u77CD\u77F2\u7925\u7923\u7927\u7928\u7924\u7929"], + ["f4a1", "\u79B2\u7A6E\u7A6C\u7A6D\u7AF7\u7C49\u7C48\u7C4A\u7C47\u7C45\u7CEE\u7E7B\u7E7E\u7E81\u7E80\u7FBA\u7FFF\u8079\u81DB\u81D9\u820B\u8268\u8269\u8622\u85FF\u8601\u85FE\u861B\u8600\u85F6\u8604\u8609\u8605\u860C\u85FD\u8819\u8810\u8811\u8817\u8813\u8816\u8963\u8966\u89B9\u89F7\u8B60\u8B6A\u8B5D\u8B68\u8B63\u8B65\u8B67\u8B6D\u8DAE\u8E86\u8E88\u8E84\u8F59\u8F56\u8F57\u8F55\u8F58\u8F5A\u908D\u9143\u9141\u91B7\u91B5\u91B2\u91B3\u940B\u9413\u93FB\u9420\u940F\u9414\u93FE\u9415\u9410\u9428\u9419\u940D\u93F5\u9400\u93F7\u9407\u940E\u9416\u9412\u93FA\u9409\u93F8\u940A\u93FF"], + ["f540", "\u93FC\u940C\u93F6\u9411\u9406\u95DE\u95E0\u95DF\u972E\u972F\u97B9\u97BB\u97FD\u97FE\u9860\u9862\u9863\u985F\u98C1\u98C2\u9950\u994E\u9959\u994C\u994B\u9953\u9A32\u9A34\u9A31\u9A2C\u9A2A\u9A36\u9A29\u9A2E\u9A38\u9A2D\u9AC7\u9ACA\u9AC6\u9B10\u9B12\u9B11\u9C0B\u9C08\u9BF7\u9C05\u9C12\u9BF8\u9C40\u9C07\u9C0E\u9C06\u9C17\u9C14\u9C09\u9D9F\u9D99\u9DA4\u9D9D\u9D92\u9D98\u9D90\u9D9B"], + ["f5a1", "\u9DA0\u9D94\u9D9C\u9DAA\u9D97\u9DA1\u9D9A\u9DA2\u9DA8\u9D9E\u9DA3\u9DBF\u9DA9\u9D96\u9DA6\u9DA7\u9E99\u9E9B\u9E9A\u9EE5\u9EE4\u9EE7\u9EE6\u9F30\u9F2E\u9F5B\u9F60\u9F5E\u9F5D\u9F59\u9F91\u513A\u5139\u5298\u5297\u56C3\u56BD\u56BE\u5B48\u5B47\u5DCB\u5DCF\u5EF1\u61FD\u651B\u6B02\u6AFC\u6B03\u6AF8\u6B00\u7043\u7044\u704A\u7048\u7049\u7045\u7046\u721D\u721A\u7219\u737E\u7517\u766A\u77D0\u792D\u7931\u792F\u7C54\u7C53\u7CF2\u7E8A\u7E87\u7E88\u7E8B\u7E86\u7E8D\u7F4D\u7FBB\u8030\u81DD\u8618\u862A\u8626\u861F\u8623\u861C\u8619\u8627\u862E\u8621\u8620\u8629\u861E\u8625"], + ["f640", "\u8829\u881D\u881B\u8820\u8824\u881C\u882B\u884A\u896D\u8969\u896E\u896B\u89FA\u8B79\u8B78\u8B45\u8B7A\u8B7B\u8D10\u8D14\u8DAF\u8E8E\u8E8C\u8F5E\u8F5B\u8F5D\u9146\u9144\u9145\u91B9\u943F\u943B\u9436\u9429\u943D\u943C\u9430\u9439\u942A\u9437\u942C\u9440\u9431\u95E5\u95E4\u95E3\u9735\u973A\u97BF\u97E1\u9864\u98C9\u98C6\u98C0\u9958\u9956\u9A39\u9A3D\u9A46\u9A44\u9A42\u9A41\u9A3A"], + ["f6a1", "\u9A3F\u9ACD\u9B15\u9B17\u9B18\u9B16\u9B3A\u9B52\u9C2B\u9C1D\u9C1C\u9C2C\u9C23\u9C28\u9C29\u9C24\u9C21\u9DB7\u9DB6\u9DBC\u9DC1\u9DC7\u9DCA\u9DCF\u9DBE\u9DC5\u9DC3\u9DBB\u9DB5\u9DCE\u9DB9\u9DBA\u9DAC\u9DC8\u9DB1\u9DAD\u9DCC\u9DB3\u9DCD\u9DB2\u9E7A\u9E9C\u9EEB\u9EEE\u9EED\u9F1B\u9F18\u9F1A\u9F31\u9F4E\u9F65\u9F64\u9F92\u4EB9\u56C6\u56C5\u56CB\u5971\u5B4B\u5B4C\u5DD5\u5DD1\u5EF2\u6521\u6520\u6526\u6522\u6B0B\u6B08\u6B09\u6C0D\u7055\u7056\u7057\u7052\u721E\u721F\u72A9\u737F\u74D8\u74D5\u74D9\u74D7\u766D\u76AD\u7935\u79B4\u7A70\u7A71\u7C57\u7C5C\u7C59\u7C5B\u7C5A"], + ["f740", "\u7CF4\u7CF1\u7E91\u7F4F\u7F87\u81DE\u826B\u8634\u8635\u8633\u862C\u8632\u8636\u882C\u8828\u8826\u882A\u8825\u8971\u89BF\u89BE\u89FB\u8B7E\u8B84\u8B82\u8B86\u8B85\u8B7F\u8D15\u8E95\u8E94\u8E9A\u8E92\u8E90\u8E96\u8E97\u8F60\u8F62\u9147\u944C\u9450\u944A\u944B\u944F\u9447\u9445\u9448\u9449\u9446\u973F\u97E3\u986A\u9869\u98CB\u9954\u995B\u9A4E\u9A53\u9A54\u9A4C\u9A4F\u9A48\u9A4A"], + ["f7a1", "\u9A49\u9A52\u9A50\u9AD0\u9B19\u9B2B\u9B3B\u9B56\u9B55\u9C46\u9C48\u9C3F\u9C44\u9C39\u9C33\u9C41\u9C3C\u9C37\u9C34\u9C32\u9C3D\u9C36\u9DDB\u9DD2\u9DDE\u9DDA\u9DCB\u9DD0\u9DDC\u9DD1\u9DDF\u9DE9\u9DD9\u9DD8\u9DD6\u9DF5\u9DD5\u9DDD\u9EB6\u9EF0\u9F35\u9F33\u9F32\u9F42\u9F6B\u9F95\u9FA2\u513D\u5299\u58E8\u58E7\u5972\u5B4D\u5DD8\u882F\u5F4F\u6201\u6203\u6204\u6529\u6525\u6596\u66EB\u6B11\u6B12\u6B0F\u6BCA\u705B\u705A\u7222\u7382\u7381\u7383\u7670\u77D4\u7C67\u7C66\u7E95\u826C\u863A\u8640\u8639\u863C\u8631\u863B\u863E\u8830\u8832\u882E\u8833\u8976\u8974\u8973\u89FE"], + ["f840", "\u8B8C\u8B8E\u8B8B\u8B88\u8C45\u8D19\u8E98\u8F64\u8F63\u91BC\u9462\u9455\u945D\u9457\u945E\u97C4\u97C5\u9800\u9A56\u9A59\u9B1E\u9B1F\u9B20\u9C52\u9C58\u9C50\u9C4A\u9C4D\u9C4B\u9C55\u9C59\u9C4C\u9C4E\u9DFB\u9DF7\u9DEF\u9DE3\u9DEB\u9DF8\u9DE4\u9DF6\u9DE1\u9DEE\u9DE6\u9DF2\u9DF0\u9DE2\u9DEC\u9DF4\u9DF3\u9DE8\u9DED\u9EC2\u9ED0\u9EF2\u9EF3\u9F06\u9F1C\u9F38\u9F37\u9F36\u9F43\u9F4F"], + ["f8a1", "\u9F71\u9F70\u9F6E\u9F6F\u56D3\u56CD\u5B4E\u5C6D\u652D\u66ED\u66EE\u6B13\u705F\u7061\u705D\u7060\u7223\u74DB\u74E5\u77D5\u7938\u79B7\u79B6\u7C6A\u7E97\u7F89\u826D\u8643\u8838\u8837\u8835\u884B\u8B94\u8B95\u8E9E\u8E9F\u8EA0\u8E9D\u91BE\u91BD\u91C2\u946B\u9468\u9469\u96E5\u9746\u9743\u9747\u97C7\u97E5\u9A5E\u9AD5\u9B59\u9C63\u9C67\u9C66\u9C62\u9C5E\u9C60\u9E02\u9DFE\u9E07\u9E03\u9E06\u9E05\u9E00\u9E01\u9E09\u9DFF\u9DFD\u9E04\u9EA0\u9F1E\u9F46\u9F74\u9F75\u9F76\u56D4\u652E\u65B8\u6B18\u6B19\u6B17\u6B1A\u7062\u7226\u72AA\u77D8\u77D9\u7939\u7C69\u7C6B\u7CF6\u7E9A"], + ["f940", "\u7E98\u7E9B\u7E99\u81E0\u81E1\u8646\u8647\u8648\u8979\u897A\u897C\u897B\u89FF\u8B98\u8B99\u8EA5\u8EA4\u8EA3\u946E\u946D\u946F\u9471\u9473\u9749\u9872\u995F\u9C68\u9C6E\u9C6D\u9E0B\u9E0D\u9E10\u9E0F\u9E12\u9E11\u9EA1\u9EF5\u9F09\u9F47\u9F78\u9F7B\u9F7A\u9F79\u571E\u7066\u7C6F\u883C\u8DB2\u8EA6\u91C3\u9474\u9478\u9476\u9475\u9A60\u9C74\u9C73\u9C71\u9C75\u9E14\u9E13\u9EF6\u9F0A"], + ["f9a1", "\u9FA4\u7068\u7065\u7CF7\u866A\u883E\u883D\u883F\u8B9E\u8C9C\u8EA9\u8EC9\u974B\u9873\u9874\u98CC\u9961\u99AB\u9A64\u9A66\u9A67\u9B24\u9E15\u9E17\u9F48\u6207\u6B1E\u7227\u864C\u8EA8\u9482\u9480\u9481\u9A69\u9A68\u9B2E\u9E19\u7229\u864B\u8B9F\u9483\u9C79\u9EB7\u7675\u9A6B\u9C7A\u9E1D\u7069\u706A\u9EA4\u9F7E\u9F49\u9F98\u7881\u92B9\u88CF\u58BB\u6052\u7CA7\u5AFA\u2554\u2566\u2557\u2560\u256C\u2563\u255A\u2569\u255D\u2552\u2564\u2555\u255E\u256A\u2561\u2558\u2567\u255B\u2553\u2565\u2556\u255F\u256B\u2562\u2559\u2568\u255C\u2551\u2550\u256D\u256E\u2570\u256F\u2593"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/tables/big5-added.json +var require_big5_added = __commonJS({ + "node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module2) { + module2.exports = [ + ["8740", "\u43F0\u4C32\u4603\u45A6\u4578\u{27267}\u4D77\u45B3\u{27CB1}\u4CE2\u{27CC5}\u3B95\u4736\u4744\u4C47\u4C40\u{242BF}\u{23617}\u{27352}\u{26E8B}\u{270D2}\u4C57\u{2A351}\u474F\u45DA\u4C85\u{27C6C}\u4D07\u4AA4\u46A1\u{26B23}\u7225\u{25A54}\u{21A63}\u{23E06}\u{23F61}\u664D\u56FB"], + ["8767", "\u7D95\u591D\u{28BB9}\u3DF4\u9734\u{27BEF}\u5BDB\u{21D5E}\u5AA4\u3625\u{29EB0}\u5AD1\u5BB7\u5CFC\u676E\u8593\u{29945}\u7461\u749D\u3875\u{21D53}\u{2369E}\u{26021}\u3EEC"], + ["87a1", "\u{258DE}\u3AF5\u7AFC\u9F97\u{24161}\u{2890D}\u{231EA}\u{20A8A}\u{2325E}\u430A\u8484\u9F96\u942F\u4930\u8613\u5896\u974A\u9218\u79D0\u7A32\u6660\u6A29\u889D\u744C\u7BC5\u6782\u7A2C\u524F\u9046\u34E6\u73C4\u{25DB9}\u74C6\u9FC7\u57B3\u492F\u544C\u4131\u{2368E}\u5818\u7A72\u{27B65}\u8B8F\u46AE\u{26E88}\u4181\u{25D99}\u7BAE\u{224BC}\u9FC8\u{224C1}\u{224C9}\u{224CC}\u9FC9\u8504\u{235BB}\u40B4\u9FCA\u44E1\u{2ADFF}\u62C1\u706E\u9FCB"], + ["8840", "\u31C0", 4, "\u{2010C}\u31C5\u{200D1}\u{200CD}\u31C6\u31C7\u{200CB}\u{21FE8}\u31C8\u{200CA}\u31C9\u31CA\u31CB\u31CC\u{2010E}\u31CD\u31CE\u0100\xC1\u01CD\xC0\u0112\xC9\u011A\xC8\u014C\xD3\u01D1\xD2\u0FFF\xCA\u0304\u1EBE\u0FFF\xCA\u030C\u1EC0\xCA\u0101\xE1\u01CE\xE0\u0251\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA"], + ["88a1", "\u01DC\xFC\u0FFF\xEA\u0304\u1EBF\u0FFF\xEA\u030C\u1EC1\xEA\u0261\u23DA\u23DB"], + ["8940", "\u{2A3A9}\u{21145}"], + ["8943", "\u650A"], + ["8946", "\u4E3D\u6EDD\u9D4E\u91DF"], + ["894c", "\u{27735}\u6491\u4F1A\u4F28\u4FA8\u5156\u5174\u519C\u51E4\u52A1\u52A8\u533B\u534E\u53D1\u53D8\u56E2\u58F0\u5904\u5907\u5932\u5934\u5B66\u5B9E\u5B9F\u5C9A\u5E86\u603B\u6589\u67FE\u6804\u6865\u6D4E\u70BC\u7535\u7EA4\u7EAC\u7EBA\u7EC7\u7ECF\u7EDF\u7F06\u7F37\u827A\u82CF\u836F\u89C6\u8BBE\u8BE2\u8F66\u8F67\u8F6E"], + ["89a1", "\u7411\u7CFC\u7DCD\u6946\u7AC9\u5227"], + ["89ab", "\u918C\u78B8\u915E\u80BC"], + ["89b0", "\u8D0B\u80F6\u{209E7}"], + ["89b5", "\u809F\u9EC7\u4CCD\u9DC9\u9E0C\u4C3E\u{29DF6}\u{2700E}\u9E0A\u{2A133}\u35C1"], + ["89c1", "\u6E9A\u823E\u7519"], + ["89c5", "\u4911\u9A6C\u9A8F\u9F99\u7987\u{2846C}\u{21DCA}\u{205D0}\u{22AE6}\u4E24\u4E81\u4E80\u4E87\u4EBF\u4EEB\u4F37\u344C\u4FBD\u3E48\u5003\u5088\u347D\u3493\u34A5\u5186\u5905\u51DB\u51FC\u5205\u4E89\u5279\u5290\u5327\u35C7\u53A9\u3551\u53B0\u3553\u53C2\u5423\u356D\u3572\u3681\u5493\u54A3\u54B4\u54B9\u54D0\u54EF\u5518\u5523\u5528\u3598\u553F\u35A5\u35BF\u55D7\u35C5"], + ["8a40", "\u{27D84}\u5525"], + ["8a43", "\u{20C42}\u{20D15}\u{2512B}\u5590\u{22CC6}\u39EC\u{20341}\u8E46\u{24DB8}\u{294E5}\u4053\u{280BE}\u777A\u{22C38}\u3A34\u47D5\u{2815D}\u{269F2}\u{24DEA}\u64DD\u{20D7C}\u{20FB4}\u{20CD5}\u{210F4}\u648D\u8E7E\u{20E96}\u{20C0B}\u{20F64}\u{22CA9}\u{28256}\u{244D3}"], + ["8a64", "\u{20D46}\u{29A4D}\u{280E9}\u47F4\u{24EA7}\u{22CC2}\u9AB2\u3A67\u{295F4}\u3FED\u3506\u{252C7}\u{297D4}\u{278C8}\u{22D44}\u9D6E\u9815"], + ["8a76", "\u43D9\u{260A5}\u64B4\u54E3\u{22D4C}\u{22BCA}\u{21077}\u39FB\u{2106F}"], + ["8aa1", "\u{266DA}\u{26716}\u{279A0}\u64EA\u{25052}\u{20C43}\u8E68\u{221A1}\u{28B4C}\u{20731}"], + ["8aac", "\u480B\u{201A9}\u3FFA\u5873\u{22D8D}"], + ["8ab2", "\u{245C8}\u{204FC}\u{26097}\u{20F4C}\u{20D96}\u5579\u40BB\u43BA"], + ["8abb", "\u4AB4\u{22A66}\u{2109D}\u81AA\u98F5\u{20D9C}\u6379\u39FE\u{22775}\u8DC0\u56A1\u647C\u3E43"], + ["8ac9", "\u{2A601}\u{20E09}\u{22ACF}\u{22CC9}"], + ["8ace", "\u{210C8}\u{239C2}\u3992\u3A06\u{2829B}\u3578\u{25E49}\u{220C7}\u5652\u{20F31}\u{22CB2}\u{29720}\u34BC\u6C3D\u{24E3B}"], + ["8adf", "\u{27574}\u{22E8B}\u{22208}\u{2A65B}\u{28CCD}\u{20E7A}\u{20C34}\u{2681C}\u7F93\u{210CF}\u{22803}\u{22939}\u35FB\u{251E3}\u{20E8C}\u{20F8D}\u{20EAA}\u3F93\u{20F30}\u{20D47}\u{2114F}\u{20E4C}"], + ["8af6", "\u{20EAB}\u{20BA9}\u{20D48}\u{210C0}\u{2113D}\u3FF9\u{22696}\u6432\u{20FAD}"], + ["8b40", "\u{233F4}\u{27639}\u{22BCE}\u{20D7E}\u{20D7F}\u{22C51}\u{22C55}\u3A18\u{20E98}\u{210C7}\u{20F2E}\u{2A632}\u{26B50}\u{28CD2}\u{28D99}\u{28CCA}\u95AA\u54CC\u82C4\u55B9"], + ["8b55", "\u{29EC3}\u9C26\u9AB6\u{2775E}\u{22DEE}\u7140\u816D\u80EC\u5C1C\u{26572}\u8134\u3797\u535F\u{280BD}\u91B6\u{20EFA}\u{20E0F}\u{20E77}\u{20EFB}\u35DD\u{24DEB}\u3609\u{20CD6}\u56AF\u{227B5}\u{210C9}\u{20E10}\u{20E78}\u{21078}\u{21148}\u{28207}\u{21455}\u{20E79}\u{24E50}\u{22DA4}\u5A54\u{2101D}\u{2101E}\u{210F5}\u{210F6}\u579C\u{20E11}"], + ["8ba1", "\u{27694}\u{282CD}\u{20FB5}\u{20E7B}\u{2517E}\u3703\u{20FB6}\u{21180}\u{252D8}\u{2A2BD}\u{249DA}\u{2183A}\u{24177}\u{2827C}\u5899\u5268\u361A\u{2573D}\u7BB2\u5B68\u4800\u4B2C\u9F27\u49E7\u9C1F\u9B8D\u{25B74}\u{2313D}\u55FB\u35F2\u5689\u4E28\u5902\u{21BC1}\u{2F878}\u9751\u{20086}\u4E5B\u4EBB\u353E\u5C23\u5F51\u5FC4\u38FA\u624C\u6535\u6B7A\u6C35\u6C3A\u706C\u722B\u4E2C\u72AD\u{248E9}\u7F52\u793B\u7CF9\u7F53\u{2626A}\u34C1"], + ["8bde", "\u{2634B}\u8002\u8080\u{26612}\u{26951}\u535D\u8864\u89C1\u{278B2}\u8BA0\u8D1D\u9485\u9578\u957F\u95E8\u{28E0F}\u97E6\u9875\u98CE\u98DE\u9963\u{29810}\u9C7C\u9E1F\u9EC4\u6B6F\uF907\u4E37\u{20087}\u961D\u6237\u94A2"], + ["8c40", "\u503B\u6DFE\u{29C73}\u9FA6\u3DC9\u888F\u{2414E}\u7077\u5CF5\u4B20\u{251CD}\u3559\u{25D30}\u6122\u{28A32}\u8FA7\u91F6\u7191\u6719\u73BA\u{23281}\u{2A107}\u3C8B\u{21980}\u4B10\u78E4\u7402\u51AE\u{2870F}\u4009\u6A63\u{2A2BA}\u4223\u860F\u{20A6F}\u7A2A\u{29947}\u{28AEA}\u9755\u704D\u5324\u{2207E}\u93F4\u76D9\u{289E3}\u9FA7\u77DD\u4EA3\u4FF0\u50BC\u4E2F\u4F17\u9FA8\u5434\u7D8B\u5892\u58D0\u{21DB6}\u5E92\u5E99\u5FC2\u{22712}\u658B"], + ["8ca1", "\u{233F9}\u6919\u6A43\u{23C63}\u6CFF"], + ["8ca7", "\u7200\u{24505}\u738C\u3EDB\u{24A13}\u5B15\u74B9\u8B83\u{25CA4}\u{25695}\u7A93\u7BEC\u7CC3\u7E6C\u82F8\u8597\u9FA9\u8890\u9FAA\u8EB9\u9FAB\u8FCF\u855F\u99E0\u9221\u9FAC\u{28DB9}\u{2143F}\u4071\u42A2\u5A1A"], + ["8cc9", "\u9868\u676B\u4276\u573D"], + ["8cce", "\u85D6\u{2497B}\u82BF\u{2710D}\u4C81\u{26D74}\u5D7B\u{26B15}\u{26FBE}\u9FAD\u9FAE\u5B96\u9FAF\u66E7\u7E5B\u6E57\u79CA\u3D88\u44C3\u{23256}\u{22796}\u439A\u4536"], + ["8ce6", "\u5CD5\u{23B1A}\u8AF9\u5C78\u3D12\u{23551}\u5D78\u9FB2\u7157\u4558\u{240EC}\u{21E23}\u4C77\u3978\u344A\u{201A4}\u{26C41}\u8ACC\u4FB4\u{20239}\u59BF\u816C\u9856\u{298FA}\u5F3B"], + ["8d40", "\u{20B9F}"], + ["8d42", "\u{221C1}\u{2896D}\u4102\u46BB\u{29079}\u3F07\u9FB3\u{2A1B5}\u40F8\u37D6\u46F7\u{26C46}\u417C\u{286B2}\u{273FF}\u456D\u38D4\u{2549A}\u4561\u451B\u4D89\u4C7B\u4D76\u45EA\u3FC8\u{24B0F}\u3661\u44DE\u44BD\u41ED\u5D3E\u5D48\u5D56\u3DFC\u380F\u5DA4\u5DB9\u3820\u3838\u5E42\u5EBD\u5F25\u5F83\u3908\u3914\u393F\u394D\u60D7\u613D\u5CE5\u3989\u61B7\u61B9\u61CF\u39B8\u622C\u6290\u62E5\u6318\u39F8\u56B1"], + ["8da1", "\u3A03\u63E2\u63FB\u6407\u645A\u3A4B\u64C0\u5D15\u5621\u9F9F\u3A97\u6586\u3ABD\u65FF\u6653\u3AF2\u6692\u3B22\u6716\u3B42\u67A4\u6800\u3B58\u684A\u6884\u3B72\u3B71\u3B7B\u6909\u6943\u725C\u6964\u699F\u6985\u3BBC\u69D6\u3BDD\u6A65\u6A74\u6A71\u6A82\u3BEC\u6A99\u3BF2\u6AAB\u6AB5\u6AD4\u6AF6\u6B81\u6BC1\u6BEA\u6C75\u6CAA\u3CCB\u6D02\u6D06\u6D26\u6D81\u3CEF\u6DA4\u6DB1\u6E15\u6E18\u6E29\u6E86\u{289C0}\u6EBB\u6EE2\u6EDA\u9F7F\u6EE8\u6EE9\u6F24\u6F34\u3D46\u{23F41}\u6F81\u6FBE\u3D6A\u3D75\u71B7\u5C99\u3D8A\u702C\u3D91\u7050\u7054\u706F\u707F\u7089\u{20325}\u43C1\u35F1\u{20ED8}"], + ["8e40", "\u{23ED7}\u57BE\u{26ED3}\u713E\u{257E0}\u364E\u69A2\u{28BE9}\u5B74\u7A49\u{258E1}\u{294D9}\u7A65\u7A7D\u{259AC}\u7ABB\u7AB0\u7AC2\u7AC3\u71D1\u{2648D}\u41CA\u7ADA\u7ADD\u7AEA\u41EF\u54B2\u{25C01}\u7B0B\u7B55\u7B29\u{2530E}\u{25CFE}\u7BA2\u7B6F\u839C\u{25BB4}\u{26C7F}\u7BD0\u8421\u7B92\u7BB8\u{25D20}\u3DAD\u{25C65}\u8492\u7BFA\u7C06\u7C35\u{25CC1}\u7C44\u7C83\u{24882}\u7CA6\u667D\u{24578}\u7CC9\u7CC7\u7CE6\u7C74\u7CF3\u7CF5\u7CCE"], + ["8ea1", "\u7E67\u451D\u{26E44}\u7D5D\u{26ED6}\u748D\u7D89\u7DAB\u7135\u7DB3\u7DD2\u{24057}\u{26029}\u7DE4\u3D13\u7DF5\u{217F9}\u7DE5\u{2836D}\u7E1D\u{26121}\u{2615A}\u7E6E\u7E92\u432B\u946C\u7E27\u7F40\u7F41\u7F47\u7936\u{262D0}\u99E1\u7F97\u{26351}\u7FA3\u{21661}\u{20068}\u455C\u{23766}\u4503\u{2833A}\u7FFA\u{26489}\u8005\u8008\u801D\u8028\u802F\u{2A087}\u{26CC3}\u803B\u803C\u8061\u{22714}\u4989\u{26626}\u{23DE3}\u{266E8}\u6725\u80A7\u{28A48}\u8107\u811A\u58B0\u{226F6}\u6C7F\u{26498}\u{24FB8}\u64E7\u{2148A}\u8218\u{2185E}\u6A53\u{24A65}\u{24A95}\u447A\u8229\u{20B0D}\u{26A52}\u{23D7E}\u4FF9\u{214FD}\u84E2\u8362\u{26B0A}\u{249A7}\u{23530}\u{21773}\u{23DF8}\u82AA\u691B\u{2F994}\u41DB"], + ["8f40", "\u854B\u82D0\u831A\u{20E16}\u{217B4}\u36C1\u{2317D}\u{2355A}\u827B\u82E2\u8318\u{23E8B}\u{26DA3}\u{26B05}\u{26B97}\u{235CE}\u3DBF\u831D\u55EC\u8385\u450B\u{26DA5}\u83AC\u83C1\u83D3\u347E\u{26ED4}\u6A57\u855A\u3496\u{26E42}\u{22EEF}\u8458\u{25BE4}\u8471\u3DD3\u44E4\u6AA7\u844A\u{23CB5}\u7958\u84A8\u{26B96}\u{26E77}\u{26E43}\u84DE\u840F\u8391\u44A0\u8493\u84E4\u{25C91}\u4240\u{25CC0}\u4543\u8534\u5AF2\u{26E99}\u4527\u8573\u4516\u67BF\u8616"], + ["8fa1", "\u{28625}\u{2863B}\u85C1\u{27088}\u8602\u{21582}\u{270CD}\u{2F9B2}\u456A\u8628\u3648\u{218A2}\u53F7\u{2739A}\u867E\u8771\u{2A0F8}\u87EE\u{22C27}\u87B1\u87DA\u880F\u5661\u866C\u6856\u460F\u8845\u8846\u{275E0}\u{23DB9}\u{275E4}\u885E\u889C\u465B\u88B4\u88B5\u63C1\u88C5\u7777\u{2770F}\u8987\u898A\u89A6\u89A9\u89A7\u89BC\u{28A25}\u89E7\u{27924}\u{27ABD}\u8A9C\u7793\u91FE\u8A90\u{27A59}\u7AE9\u{27B3A}\u{23F8F}\u4713\u{27B38}\u717C\u8B0C\u8B1F\u{25430}\u{25565}\u8B3F\u8B4C\u8B4D\u8AA9\u{24A7A}\u8B90\u8B9B\u8AAF\u{216DF}\u4615\u884F\u8C9B\u{27D54}\u{27D8F}\u{2F9D4}\u3725\u{27D53}\u8CD6\u{27D98}\u{27DBD}\u8D12\u8D03\u{21910}\u8CDB\u705C\u8D11\u{24CC9}\u3ED0\u8D77"], + ["9040", "\u8DA9\u{28002}\u{21014}\u{2498A}\u3B7C\u{281BC}\u{2710C}\u7AE7\u8EAD\u8EB6\u8EC3\u92D4\u8F19\u8F2D\u{28365}\u{28412}\u8FA5\u9303\u{2A29F}\u{20A50}\u8FB3\u492A\u{289DE}\u{2853D}\u{23DBB}\u5EF8\u{23262}\u8FF9\u{2A014}\u{286BC}\u{28501}\u{22325}\u3980\u{26ED7}\u9037\u{2853C}\u{27ABE}\u9061\u{2856C}\u{2860B}\u90A8\u{28713}\u90C4\u{286E6}\u90AE\u90FD\u9167\u3AF0\u91A9\u91C4\u7CAC\u{28933}\u{21E89}\u920E\u6C9F\u9241\u9262\u{255B9}\u92B9\u{28AC6}\u{23C9B}\u{28B0C}\u{255DB}"], + ["90a1", "\u{20D31}\u932C\u936B\u{28AE1}\u{28BEB}\u708F\u5AC3\u{28AE2}\u{28AE5}\u4965\u9244\u{28BEC}\u{28C39}\u{28BFF}\u9373\u945B\u8EBC\u9585\u95A6\u9426\u95A0\u6FF6\u42B9\u{2267A}\u{286D8}\u{2127C}\u{23E2E}\u49DF\u6C1C\u967B\u9696\u416C\u96A3\u{26ED5}\u61DA\u96B6\u78F5\u{28AE0}\u96BD\u53CC\u49A1\u{26CB8}\u{20274}\u{26410}\u{290AF}\u{290E5}\u{24AD1}\u{21915}\u{2330A}\u9731\u8642\u9736\u4A0F\u453D\u4585\u{24AE9}\u7075\u5B41\u971B\u975C\u{291D5}\u9757\u5B4A\u{291EB}\u975F\u9425\u50D0\u{230B7}\u{230BC}\u9789\u979F\u97B1\u97BE\u97C0\u97D2\u97E0\u{2546C}\u97EE\u741C\u{29433}\u97FF\u97F5\u{2941D}\u{2797A}\u4AD1\u9834\u9833\u984B\u9866\u3B0E\u{27175}\u3D51\u{20630}\u{2415C}"], + ["9140", "\u{25706}\u98CA\u98B7\u98C8\u98C7\u4AFF\u{26D27}\u{216D3}\u55B0\u98E1\u98E6\u98EC\u9378\u9939\u{24A29}\u4B72\u{29857}\u{29905}\u99F5\u9A0C\u9A3B\u9A10\u9A58\u{25725}\u36C4\u{290B1}\u{29BD5}\u9AE0\u9AE2\u{29B05}\u9AF4\u4C0E\u9B14\u9B2D\u{28600}\u5034\u9B34\u{269A8}\u38C3\u{2307D}\u9B50\u9B40\u{29D3E}\u5A45\u{21863}\u9B8E\u{2424B}\u9C02\u9BFF\u9C0C\u{29E68}\u9DD4\u{29FB7}\u{2A192}\u{2A1AB}\u{2A0E1}\u{2A123}\u{2A1DF}\u9D7E\u9D83\u{2A134}\u9E0E\u6888"], + ["91a1", "\u9DC4\u{2215B}\u{2A193}\u{2A220}\u{2193B}\u{2A233}\u9D39\u{2A0B9}\u{2A2B4}\u9E90\u9E95\u9E9E\u9EA2\u4D34\u9EAA\u9EAF\u{24364}\u9EC1\u3B60\u39E5\u3D1D\u4F32\u37BE\u{28C2B}\u9F02\u9F08\u4B96\u9424\u{26DA2}\u9F17\u9F16\u9F39\u569F\u568A\u9F45\u99B8\u{2908B}\u97F2\u847F\u9F62\u9F69\u7ADC\u9F8E\u7216\u4BBE\u{24975}\u{249BB}\u7177\u{249F8}\u{24348}\u{24A51}\u739E\u{28BDA}\u{218FA}\u799F\u{2897E}\u{28E36}\u9369\u93F3\u{28A44}\u92EC\u9381\u93CB\u{2896C}\u{244B9}\u7217\u3EEB\u7772\u7A43\u70D0\u{24473}\u{243F8}\u717E\u{217EF}\u70A3\u{218BE}\u{23599}\u3EC7\u{21885}\u{2542F}\u{217F8}\u3722\u{216FB}\u{21839}\u36E1\u{21774}\u{218D1}\u{25F4B}\u3723\u{216C0}\u575B\u{24A25}\u{213FE}\u{212A8}"], + ["9240", "\u{213C6}\u{214B6}\u8503\u{236A6}\u8503\u8455\u{24994}\u{27165}\u{23E31}\u{2555C}\u{23EFB}\u{27052}\u44F4\u{236EE}\u{2999D}\u{26F26}\u67F9\u3733\u3C15\u3DE7\u586C\u{21922}\u6810\u4057\u{2373F}\u{240E1}\u{2408B}\u{2410F}\u{26C21}\u54CB\u569E\u{266B1}\u5692\u{20FDF}\u{20BA8}\u{20E0D}\u93C6\u{28B13}\u939C\u4EF8\u512B\u3819\u{24436}\u4EBC\u{20465}\u{2037F}\u4F4B\u4F8A\u{25651}\u5A68\u{201AB}\u{203CB}\u3999\u{2030A}\u{20414}\u3435\u4F29\u{202C0}\u{28EB3}\u{20275}\u8ADA\u{2020C}\u4E98"], + ["92a1", "\u50CD\u510D\u4FA2\u4F03\u{24A0E}\u{23E8A}\u4F42\u502E\u506C\u5081\u4FCC\u4FE5\u5058\u50FC\u5159\u515B\u515D\u515E\u6E76\u{23595}\u{23E39}\u{23EBF}\u6D72\u{21884}\u{23E89}\u51A8\u51C3\u{205E0}\u44DD\u{204A3}\u{20492}\u{20491}\u8D7A\u{28A9C}\u{2070E}\u5259\u52A4\u{20873}\u52E1\u936E\u467A\u718C\u{2438C}\u{20C20}\u{249AC}\u{210E4}\u69D1\u{20E1D}\u7479\u3EDE\u7499\u7414\u7456\u7398\u4B8E\u{24ABC}\u{2408D}\u53D0\u3584\u720F\u{240C9}\u55B4\u{20345}\u54CD\u{20BC6}\u571D\u925D\u96F4\u9366\u57DD\u578D\u577F\u363E\u58CB\u5A99\u{28A46}\u{216FA}\u{2176F}\u{21710}\u5A2C\u59B8\u928F\u5A7E\u5ACF\u5A12\u{25946}\u{219F3}\u{21861}\u{24295}\u36F5\u6D05\u7443\u5A21\u{25E83}"], + ["9340", "\u5A81\u{28BD7}\u{20413}\u93E0\u748C\u{21303}\u7105\u4972\u9408\u{289FB}\u93BD\u37A0\u5C1E\u5C9E\u5E5E\u5E48\u{21996}\u{2197C}\u{23AEE}\u5ECD\u5B4F\u{21903}\u{21904}\u3701\u{218A0}\u36DD\u{216FE}\u36D3\u812A\u{28A47}\u{21DBA}\u{23472}\u{289A8}\u5F0C\u5F0E\u{21927}\u{217AB}\u5A6B\u{2173B}\u5B44\u8614\u{275FD}\u8860\u607E\u{22860}\u{2262B}\u5FDB\u3EB8\u{225AF}\u{225BE}\u{29088}\u{26F73}\u61C0\u{2003E}\u{20046}\u{2261B}\u6199\u6198\u6075\u{22C9B}\u{22D07}\u{246D4}\u{2914D}"], + ["93a1", "\u6471\u{24665}\u{22B6A}\u3A29\u{22B22}\u{23450}\u{298EA}\u{22E78}\u6337\u{2A45B}\u64B6\u6331\u63D1\u{249E3}\u{22D67}\u62A4\u{22CA1}\u643B\u656B\u6972\u3BF4\u{2308E}\u{232AD}\u{24989}\u{232AB}\u550D\u{232E0}\u{218D9}\u{2943F}\u66CE\u{23289}\u{231B3}\u3AE0\u4190\u{25584}\u{28B22}\u{2558F}\u{216FC}\u{2555B}\u{25425}\u78EE\u{23103}\u{2182A}\u{23234}\u3464\u{2320F}\u{23182}\u{242C9}\u668E\u{26D24}\u666B\u4B93\u6630\u{27870}\u{21DEB}\u6663\u{232D2}\u{232E1}\u661E\u{25872}\u38D1\u{2383A}\u{237BC}\u3B99\u{237A2}\u{233FE}\u74D0\u3B96\u678F\u{2462A}\u68B6\u681E\u3BC4\u6ABE\u3863\u{237D5}\u{24487}\u6A33\u6A52\u6AC9\u6B05\u{21912}\u6511\u6898\u6A4C\u3BD7\u6A7A\u6B57\u{23FC0}\u{23C9A}\u93A0\u92F2\u{28BEA}\u{28ACB}"], + ["9440", "\u9289\u{2801E}\u{289DC}\u9467\u6DA5\u6F0B\u{249EC}\u6D67\u{23F7F}\u3D8F\u6E04\u{2403C}\u5A3D\u6E0A\u5847\u6D24\u7842\u713B\u{2431A}\u{24276}\u70F1\u7250\u7287\u7294\u{2478F}\u{24725}\u5179\u{24AA4}\u{205EB}\u747A\u{23EF8}\u{2365F}\u{24A4A}\u{24917}\u{25FE1}\u3F06\u3EB1\u{24ADF}\u{28C23}\u{23F35}\u60A7\u3EF3\u74CC\u743C\u9387\u7437\u449F\u{26DEA}\u4551\u7583\u3F63\u{24CD9}\u{24D06}\u3F58\u7555\u7673\u{2A5C6}\u3B19\u7468\u{28ACC}\u{249AB}\u{2498E}\u3AFB"], + ["94a1", "\u3DCD\u{24A4E}\u3EFF\u{249C5}\u{248F3}\u91FA\u5732\u9342\u{28AE3}\u{21864}\u50DF\u{25221}\u{251E7}\u7778\u{23232}\u770E\u770F\u777B\u{24697}\u{23781}\u3A5E\u{248F0}\u7438\u749B\u3EBF\u{24ABA}\u{24AC7}\u40C8\u{24A96}\u{261AE}\u9307\u{25581}\u781E\u788D\u7888\u78D2\u73D0\u7959\u{27741}\u{256E3}\u410E\u799B\u8496\u79A5\u6A2D\u{23EFA}\u7A3A\u79F4\u416E\u{216E6}\u4132\u9235\u79F1\u{20D4C}\u{2498C}\u{20299}\u{23DBA}\u{2176E}\u3597\u556B\u3570\u36AA\u{201D4}\u{20C0D}\u7AE2\u5A59\u{226F5}\u{25AAF}\u{25A9C}\u5A0D\u{2025B}\u78F0\u5A2A\u{25BC6}\u7AFE\u41F9\u7C5D\u7C6D\u4211\u{25BB3}\u{25EBC}\u{25EA6}\u7CCD\u{249F9}\u{217B0}\u7C8E\u7C7C\u7CAE\u6AB2\u7DDC\u7E07\u7DD3\u7F4E\u{26261}"], + ["9540", "\u{2615C}\u{27B48}\u7D97\u{25E82}\u426A\u{26B75}\u{20916}\u67D6\u{2004E}\u{235CF}\u57C4\u{26412}\u{263F8}\u{24962}\u7FDD\u7B27\u{2082C}\u{25AE9}\u{25D43}\u7B0C\u{25E0E}\u99E6\u8645\u9A63\u6A1C\u{2343F}\u39E2\u{249F7}\u{265AD}\u9A1F\u{265A0}\u8480\u{27127}\u{26CD1}\u44EA\u8137\u4402\u80C6\u8109\u8142\u{267B4}\u98C3\u{26A42}\u8262\u8265\u{26A51}\u8453\u{26DA7}\u8610\u{2721B}\u5A86\u417F\u{21840}\u5B2B\u{218A1}\u5AE4\u{218D8}\u86A0\u{2F9BC}\u{23D8F}\u882D\u{27422}\u5A02"], + ["95a1", "\u886E\u4F45\u8887\u88BF\u88E6\u8965\u894D\u{25683}\u8954\u{27785}\u{27784}\u{28BF5}\u{28BD9}\u{28B9C}\u{289F9}\u3EAD\u84A3\u46F5\u46CF\u37F2\u8A3D\u8A1C\u{29448}\u5F4D\u922B\u{24284}\u65D4\u7129\u70C4\u{21845}\u9D6D\u8C9F\u8CE9\u{27DDC}\u599A\u77C3\u59F0\u436E\u36D4\u8E2A\u8EA7\u{24C09}\u8F30\u8F4A\u42F4\u6C58\u6FBB\u{22321}\u489B\u6F79\u6E8B\u{217DA}\u9BE9\u36B5\u{2492F}\u90BB\u9097\u5571\u4906\u91BB\u9404\u{28A4B}\u4062\u{28AFC}\u9427\u{28C1D}\u{28C3B}\u84E5\u8A2B\u9599\u95A7\u9597\u9596\u{28D34}\u7445\u3EC2\u{248FF}\u{24A42}\u{243EA}\u3EE7\u{23225}\u968F\u{28EE7}\u{28E66}\u{28E65}\u3ECC\u{249ED}\u{24A78}\u{23FEE}\u7412\u746B\u3EFC\u9741\u{290B0}"], + ["9640", "\u6847\u4A1D\u{29093}\u{257DF}\u975D\u9368\u{28989}\u{28C26}\u{28B2F}\u{263BE}\u92BA\u5B11\u8B69\u493C\u73F9\u{2421B}\u979B\u9771\u9938\u{20F26}\u5DC1\u{28BC5}\u{24AB2}\u981F\u{294DA}\u92F6\u{295D7}\u91E5\u44C0\u{28B50}\u{24A67}\u{28B64}\u98DC\u{28A45}\u3F00\u922A\u4925\u8414\u993B\u994D\u{27B06}\u3DFD\u999B\u4B6F\u99AA\u9A5C\u{28B65}\u{258C8}\u6A8F\u9A21\u5AFE\u9A2F\u{298F1}\u4B90\u{29948}\u99BC\u4BBD\u4B97\u937D\u5872\u{21302}\u5822\u{249B8}"], + ["96a1", "\u{214E8}\u7844\u{2271F}\u{23DB8}\u68C5\u3D7D\u9458\u3927\u6150\u{22781}\u{2296B}\u6107\u9C4F\u9C53\u9C7B\u9C35\u9C10\u9B7F\u9BCF\u{29E2D}\u9B9F\u{2A1F5}\u{2A0FE}\u9D21\u4CAE\u{24104}\u9E18\u4CB0\u9D0C\u{2A1B4}\u{2A0ED}\u{2A0F3}\u{2992F}\u9DA5\u84BD\u{26E12}\u{26FDF}\u{26B82}\u85FC\u4533\u{26DA4}\u{26E84}\u{26DF0}\u8420\u85EE\u{26E00}\u{237D7}\u{26064}\u79E2\u{2359C}\u{23640}\u492D\u{249DE}\u3D62\u93DB\u92BE\u9348\u{202BF}\u78B9\u9277\u944D\u4FE4\u3440\u9064\u{2555D}\u783D\u7854\u78B6\u784B\u{21757}\u{231C9}\u{24941}\u369A\u4F72\u6FDA\u6FD9\u701E\u701E\u5414\u{241B5}\u57BB\u58F3\u578A\u9D16\u57D7\u7134\u34AF\u{241AC}\u71EB\u{26C40}\u{24F97}\u5B28\u{217B5}\u{28A49}"], + ["9740", "\u610C\u5ACE\u5A0B\u42BC\u{24488}\u372C\u4B7B\u{289FC}\u93BB\u93B8\u{218D6}\u{20F1D}\u8472\u{26CC0}\u{21413}\u{242FA}\u{22C26}\u{243C1}\u5994\u{23DB7}\u{26741}\u7DA8\u{2615B}\u{260A4}\u{249B9}\u{2498B}\u{289FA}\u92E5\u73E2\u3EE9\u74B4\u{28B63}\u{2189F}\u3EE1\u{24AB3}\u6AD8\u73F3\u73FB\u3ED6\u{24A3E}\u{24A94}\u{217D9}\u{24A66}\u{203A7}\u{21424}\u{249E5}\u7448\u{24916}\u70A5\u{24976}\u9284\u73E6\u935F\u{204FE}\u9331\u{28ACE}\u{28A16}\u9386\u{28BE7}\u{255D5}\u4935\u{28A82}\u716B"], + ["97a1", "\u{24943}\u{20CFF}\u56A4\u{2061A}\u{20BEB}\u{20CB8}\u5502\u79C4\u{217FA}\u7DFE\u{216C2}\u{24A50}\u{21852}\u452E\u9401\u370A\u{28AC0}\u{249AD}\u59B0\u{218BF}\u{21883}\u{27484}\u5AA1\u36E2\u{23D5B}\u36B0\u925F\u5A79\u{28A81}\u{21862}\u9374\u3CCD\u{20AB4}\u4A96\u398A\u50F4\u3D69\u3D4C\u{2139C}\u7175\u42FB\u{28218}\u6E0F\u{290E4}\u44EB\u6D57\u{27E4F}\u7067\u6CAF\u3CD6\u{23FED}\u{23E2D}\u6E02\u6F0C\u3D6F\u{203F5}\u7551\u36BC\u34C8\u4680\u3EDA\u4871\u59C4\u926E\u493E\u8F41\u{28C1C}\u{26BC0}\u5812\u57C8\u36D6\u{21452}\u70FE\u{24362}\u{24A71}\u{22FE3}\u{212B0}\u{223BD}\u68B9\u6967\u{21398}\u{234E5}\u{27BF4}\u{236DF}\u{28A83}\u{237D6}\u{233FA}\u{24C9F}\u6A1A\u{236AD}\u{26CB7}\u843E\u44DF\u44CE"], + ["9840", "\u{26D26}\u{26D51}\u{26C82}\u{26FDE}\u6F17\u{27109}\u833D\u{2173A}\u83ED\u{26C80}\u{27053}\u{217DB}\u5989\u5A82\u{217B3}\u5A61\u5A71\u{21905}\u{241FC}\u372D\u59EF\u{2173C}\u36C7\u718E\u9390\u669A\u{242A5}\u5A6E\u5A2B\u{24293}\u6A2B\u{23EF9}\u{27736}\u{2445B}\u{242CA}\u711D\u{24259}\u{289E1}\u4FB0\u{26D28}\u5CC2\u{244CE}\u{27E4D}\u{243BD}\u6A0C\u{24256}\u{21304}\u70A6\u7133\u{243E9}\u3DA5\u6CDF\u{2F825}\u{24A4F}\u7E65\u59EB\u5D2F\u3DF3\u5F5C\u{24A5D}\u{217DF}\u7DA4\u8426"], + ["98a1", "\u5485\u{23AFA}\u{23300}\u{20214}\u577E\u{208D5}\u{20619}\u3FE5\u{21F9E}\u{2A2B6}\u7003\u{2915B}\u5D70\u738F\u7CD3\u{28A59}\u{29420}\u4FC8\u7FE7\u72CD\u7310\u{27AF4}\u7338\u7339\u{256F6}\u7341\u7348\u3EA9\u{27B18}\u906C\u71F5\u{248F2}\u73E1\u81F6\u3ECA\u770C\u3ED1\u6CA2\u56FD\u7419\u741E\u741F\u3EE2\u3EF0\u3EF4\u3EFA\u74D3\u3F0E\u3F53\u7542\u756D\u7572\u758D\u3F7C\u75C8\u75DC\u3FC0\u764D\u3FD7\u7674\u3FDC\u767A\u{24F5C}\u7188\u5623\u8980\u5869\u401D\u7743\u4039\u6761\u4045\u35DB\u7798\u406A\u406F\u5C5E\u77BE\u77CB\u58F2\u7818\u70B9\u781C\u40A8\u7839\u7847\u7851\u7866\u8448\u{25535}\u7933\u6803\u7932\u4103"], + ["9940", "\u4109\u7991\u7999\u8FBB\u7A06\u8FBC\u4167\u7A91\u41B2\u7ABC\u8279\u41C4\u7ACF\u7ADB\u41CF\u4E21\u7B62\u7B6C\u7B7B\u7C12\u7C1B\u4260\u427A\u7C7B\u7C9C\u428C\u7CB8\u4294\u7CED\u8F93\u70C0\u{20CCF}\u7DCF\u7DD4\u7DD0\u7DFD\u7FAE\u7FB4\u729F\u4397\u8020\u8025\u7B39\u802E\u8031\u8054\u3DCC\u57B4\u70A0\u80B7\u80E9\u43ED\u810C\u732A\u810E\u8112\u7560\u8114\u4401\u3B39\u8156\u8159\u815A"], + ["99a1", "\u4413\u583A\u817C\u8184\u4425\u8193\u442D\u81A5\u57EF\u81C1\u81E4\u8254\u448F\u82A6\u8276\u82CA\u82D8\u82FF\u44B0\u8357\u9669\u698A\u8405\u70F5\u8464\u60E3\u8488\u4504\u84BE\u84E1\u84F8\u8510\u8538\u8552\u453B\u856F\u8570\u85E0\u4577\u8672\u8692\u86B2\u86EF\u9645\u878B\u4606\u4617\u88AE\u88FF\u8924\u8947\u8991\u{27967}\u8A29\u8A38\u8A94\u8AB4\u8C51\u8CD4\u8CF2\u8D1C\u4798\u585F\u8DC3\u47ED\u4EEE\u8E3A\u55D8\u5754\u8E71\u55F5\u8EB0\u4837\u8ECE\u8EE2\u8EE4\u8EED\u8EF2\u8FB7\u8FC1\u8FCA\u8FCC\u9033\u99C4\u48AD\u98E0\u9213\u491E\u9228\u9258\u926B\u92B1\u92AE\u92BF"], + ["9a40", "\u92E3\u92EB\u92F3\u92F4\u92FD\u9343\u9384\u93AD\u4945\u4951\u9EBF\u9417\u5301\u941D\u942D\u943E\u496A\u9454\u9479\u952D\u95A2\u49A7\u95F4\u9633\u49E5\u67A0\u4A24\u9740\u4A35\u97B2\u97C2\u5654\u4AE4\u60E8\u98B9\u4B19\u98F1\u5844\u990E\u9919\u51B4\u991C\u9937\u9942\u995D\u9962\u4B70\u99C5\u4B9D\u9A3C\u9B0F\u7A83\u9B69\u9B81\u9BDD\u9BF1\u9BF4\u4C6D\u9C20\u376F\u{21BC2}\u9D49\u9C3A"], + ["9aa1", "\u9EFE\u5650\u9D93\u9DBD\u9DC0\u9DFC\u94F6\u8FB6\u9E7B\u9EAC\u9EB1\u9EBD\u9EC6\u94DC\u9EE2\u9EF1\u9EF8\u7AC8\u9F44\u{20094}\u{202B7}\u{203A0}\u691A\u94C3\u59AC\u{204D7}\u5840\u94C1\u37B9\u{205D5}\u{20615}\u{20676}\u{216BA}\u5757\u7173\u{20AC2}\u{20ACD}\u{20BBF}\u546A\u{2F83B}\u{20BCB}\u549E\u{20BFB}\u{20C3B}\u{20C53}\u{20C65}\u{20C7C}\u60E7\u{20C8D}\u567A\u{20CB5}\u{20CDD}\u{20CED}\u{20D6F}\u{20DB2}\u{20DC8}\u6955\u9C2F\u87A5\u{20E04}\u{20E0E}\u{20ED7}\u{20F90}\u{20F2D}\u{20E73}\u5C20\u{20FBC}\u5E0B\u{2105C}\u{2104F}\u{21076}\u671E\u{2107B}\u{21088}\u{21096}\u3647\u{210BF}\u{210D3}\u{2112F}\u{2113B}\u5364\u84AD\u{212E3}\u{21375}\u{21336}\u8B81\u{21577}\u{21619}\u{217C3}\u{217C7}\u4E78\u70BB\u{2182D}\u{2196A}"], + ["9b40", "\u{21A2D}\u{21A45}\u{21C2A}\u{21C70}\u{21CAC}\u{21EC8}\u62C3\u{21ED5}\u{21F15}\u7198\u6855\u{22045}\u69E9\u36C8\u{2227C}\u{223D7}\u{223FA}\u{2272A}\u{22871}\u{2294F}\u82FD\u{22967}\u{22993}\u{22AD5}\u89A5\u{22AE8}\u8FA0\u{22B0E}\u97B8\u{22B3F}\u9847\u9ABD\u{22C4C}"], + ["9b62", "\u{22C88}\u{22CB7}\u{25BE8}\u{22D08}\u{22D12}\u{22DB7}\u{22D95}\u{22E42}\u{22F74}\u{22FCC}\u{23033}\u{23066}\u{2331F}\u{233DE}\u5FB1\u6648\u66BF\u{27A79}\u{23567}\u{235F3}\u7201\u{249BA}\u77D7\u{2361A}\u{23716}\u7E87\u{20346}\u58B5\u670E"], + ["9ba1", "\u6918\u{23AA7}\u{27657}\u{25FE2}\u{23E11}\u{23EB9}\u{275FE}\u{2209A}\u48D0\u4AB8\u{24119}\u{28A9A}\u{242EE}\u{2430D}\u{2403B}\u{24334}\u{24396}\u{24A45}\u{205CA}\u51D2\u{20611}\u599F\u{21EA8}\u3BBE\u{23CFF}\u{24404}\u{244D6}\u5788\u{24674}\u399B\u{2472F}\u{285E8}\u{299C9}\u3762\u{221C3}\u8B5E\u{28B4E}\u99D6\u{24812}\u{248FB}\u{24A15}\u7209\u{24AC0}\u{20C78}\u5965\u{24EA5}\u{24F86}\u{20779}\u8EDA\u{2502C}\u528F\u573F\u7171\u{25299}\u{25419}\u{23F4A}\u{24AA7}\u55BC\u{25446}\u{2546E}\u{26B52}\u91D4\u3473\u{2553F}\u{27632}\u{2555E}\u4718\u{25562}\u{25566}\u{257C7}\u{2493F}\u{2585D}\u5066\u34FB\u{233CC}\u60DE\u{25903}\u477C\u{28948}\u{25AAE}\u{25B89}\u{25C06}\u{21D90}\u57A1\u7151\u6FB6\u{26102}\u{27C12}\u9056\u{261B2}\u{24F9A}\u8B62\u{26402}\u{2644A}"], + ["9c40", "\u5D5B\u{26BF7}\u8F36\u{26484}\u{2191C}\u8AEA\u{249F6}\u{26488}\u{23FEF}\u{26512}\u4BC0\u{265BF}\u{266B5}\u{2271B}\u9465\u{257E1}\u6195\u5A27\u{2F8CD}\u4FBB\u56B9\u{24521}\u{266FC}\u4E6A\u{24934}\u9656\u6D8F\u{26CBD}\u3618\u8977\u{26799}\u{2686E}\u{26411}\u{2685E}\u71DF\u{268C7}\u7B42\u{290C0}\u{20A11}\u{26926}\u9104\u{26939}\u7A45\u9DF0\u{269FA}\u9A26\u{26A2D}\u365F\u{26469}\u{20021}\u7983\u{26A34}\u{26B5B}\u5D2C\u{23519}\u83CF\u{26B9D}\u46D0\u{26CA4}\u753B\u8865\u{26DAE}\u58B6"], + ["9ca1", "\u371C\u{2258D}\u{2704B}\u{271CD}\u3C54\u{27280}\u{27285}\u9281\u{2217A}\u{2728B}\u9330\u{272E6}\u{249D0}\u6C39\u949F\u{27450}\u{20EF8}\u8827\u88F5\u{22926}\u{28473}\u{217B1}\u6EB8\u{24A2A}\u{21820}\u39A4\u36B9\u5C10\u79E3\u453F\u66B6\u{29CAD}\u{298A4}\u8943\u{277CC}\u{27858}\u56D6\u40DF\u{2160A}\u39A1\u{2372F}\u{280E8}\u{213C5}\u71AD\u8366\u{279DD}\u{291A8}\u5A67\u4CB7\u{270AF}\u{289AB}\u{279FD}\u{27A0A}\u{27B0B}\u{27D66}\u{2417A}\u7B43\u797E\u{28009}\u6FB5\u{2A2DF}\u6A03\u{28318}\u53A2\u{26E07}\u93BF\u6836\u975D\u{2816F}\u{28023}\u{269B5}\u{213ED}\u{2322F}\u{28048}\u5D85\u{28C30}\u{28083}\u5715\u9823\u{28949}\u5DAB\u{24988}\u65BE\u69D5\u53D2\u{24AA5}\u{23F81}\u3C11\u6736\u{28090}\u{280F4}\u{2812E}\u{21FA1}\u{2814F}"], + ["9d40", "\u{28189}\u{281AF}\u{2821A}\u{28306}\u{2832F}\u{2838A}\u35CA\u{28468}\u{286AA}\u48FA\u63E6\u{28956}\u7808\u9255\u{289B8}\u43F2\u{289E7}\u43DF\u{289E8}\u{28B46}\u{28BD4}\u59F8\u{28C09}\u8F0B\u{28FC5}\u{290EC}\u7B51\u{29110}\u{2913C}\u3DF7\u{2915E}\u{24ACA}\u8FD0\u728F\u568B\u{294E7}\u{295E9}\u{295B0}\u{295B8}\u{29732}\u{298D1}\u{29949}\u{2996A}\u{299C3}\u{29A28}\u{29B0E}\u{29D5A}\u{29D9B}\u7E9F\u{29EF8}\u{29F23}\u4CA4\u9547\u{2A293}\u71A2\u{2A2FF}\u4D91\u9012\u{2A5CB}\u4D9C\u{20C9C}\u8FBE\u55C1"], + ["9da1", "\u8FBA\u{224B0}\u8FB9\u{24A93}\u4509\u7E7F\u6F56\u6AB1\u4EEA\u34E4\u{28B2C}\u{2789D}\u373A\u8E80\u{217F5}\u{28024}\u{28B6C}\u{28B99}\u{27A3E}\u{266AF}\u3DEB\u{27655}\u{23CB7}\u{25635}\u{25956}\u4E9A\u{25E81}\u{26258}\u56BF\u{20E6D}\u8E0E\u5B6D\u{23E88}\u{24C9E}\u63DE\u62D0\u{217F6}\u{2187B}\u6530\u562D\u{25C4A}\u541A\u{25311}\u3DC6\u{29D98}\u4C7D\u5622\u561E\u7F49\u{25ED8}\u5975\u{23D40}\u8770\u4E1C\u{20FEA}\u{20D49}\u{236BA}\u8117\u9D5E\u8D18\u763B\u9C45\u764E\u77B9\u9345\u5432\u8148\u82F7\u5625\u8132\u8418\u80BD\u55EA\u7962\u5643\u5416\u{20E9D}\u35CE\u5605\u55F1\u66F1\u{282E2}\u362D\u7534\u55F0\u55BA\u5497\u5572\u{20C41}\u{20C96}\u5ED0\u{25148}\u{20E76}\u{22C62}"], + ["9e40", "\u{20EA2}\u9EAB\u7D5A\u55DE\u{21075}\u629D\u976D\u5494\u8CCD\u71F6\u9176\u63FC\u63B9\u63FE\u5569\u{22B43}\u9C72\u{22EB3}\u519A\u34DF\u{20DA7}\u51A7\u544D\u551E\u5513\u7666\u8E2D\u{2688A}\u75B1\u80B6\u8804\u8786\u88C7\u81B6\u841C\u{210C1}\u44EC\u7304\u{24706}\u5B90\u830B\u{26893}\u567B\u{226F4}\u{27D2F}\u{241A3}\u{27D73}\u{26ED0}\u{272B6}\u9170\u{211D9}\u9208\u{23CFC}\u{2A6A9}\u{20EAC}\u{20EF9}\u7266\u{21CA2}\u474E\u{24FC2}\u{27FF9}\u{20FEB}\u40FA"], + ["9ea1", "\u9C5D\u651F\u{22DA0}\u48F3\u{247E0}\u{29D7C}\u{20FEC}\u{20E0A}\u6062\u{275A3}\u{20FED}"], + ["9ead", "\u{26048}\u{21187}\u71A3\u7E8E\u9D50\u4E1A\u4E04\u3577\u5B0D\u6CB2\u5367\u36AC\u39DC\u537D\u36A5\u{24618}\u589A\u{24B6E}\u822D\u544B\u57AA\u{25A95}\u{20979}"], + ["9ec5", "\u3A52\u{22465}\u7374\u{29EAC}\u4D09\u9BED\u{23CFE}\u{29F30}\u4C5B\u{24FA9}\u{2959E}\u{29FDE}\u845C\u{23DB6}\u{272B2}\u{267B3}\u{23720}\u632E\u7D25\u{23EF7}\u{23E2C}\u3A2A\u9008\u52CC\u3E74\u367A\u45E9\u{2048E}\u7640\u5AF0\u{20EB6}\u787A\u{27F2E}\u58A7\u40BF\u567C\u9B8B\u5D74\u7654\u{2A434}\u9E85\u4CE1\u75F9\u37FB\u6119\u{230DA}\u{243F2}"], + ["9ef5", "\u565D\u{212A9}\u57A7\u{24963}\u{29E06}\u5234\u{270AE}\u35AD\u6C4A\u9D7C"], + ["9f40", "\u7C56\u9B39\u57DE\u{2176C}\u5C53\u64D3\u{294D0}\u{26335}\u{27164}\u86AD\u{20D28}\u{26D22}\u{24AE2}\u{20D71}"], + ["9f4f", "\u51FE\u{21F0F}\u5D8E\u9703\u{21DD1}\u9E81\u904C\u7B1F\u9B02\u5CD1\u7BA3\u6268\u6335\u9AFF\u7BCF\u9B2A\u7C7E\u9B2E\u7C42\u7C86\u9C15\u7BFC\u9B09\u9F17\u9C1B\u{2493E}\u9F5A\u5573\u5BC3\u4FFD\u9E98\u4FF2\u5260\u3E06\u52D1\u5767\u5056\u59B7\u5E12\u97C8\u9DAB\u8F5C\u5469\u97B4\u9940\u97BA\u532C\u6130"], + ["9fa1", "\u692C\u53DA\u9C0A\u9D02\u4C3B\u9641\u6980\u50A6\u7546\u{2176D}\u99DA\u5273"], + ["9fae", "\u9159\u9681\u915C"], + ["9fb2", "\u9151\u{28E97}\u637F\u{26D23}\u6ACA\u5611\u918E\u757A\u6285\u{203FC}\u734F\u7C70\u{25C21}\u{23CFD}"], + ["9fc1", "\u{24919}\u76D6\u9B9D\u4E2A\u{20CD4}\u83BE\u8842"], + ["9fc9", "\u5C4A\u69C0\u50ED\u577A\u521F\u5DF5\u4ECE\u6C31\u{201F2}\u4F39\u549C\u54DA\u529A\u8D82\u35FE\u5F0C\u35F3"], + ["9fdb", "\u6B52\u917C\u9FA5\u9B97\u982E\u98B4\u9ABA\u9EA8\u9E84\u717A\u7B14"], + ["9fe7", "\u6BFA\u8818\u7F78"], + ["9feb", "\u5620\u{2A64A}\u8E77\u9F53"], + ["9ff0", "\u8DD4\u8E4F\u9E1C\u8E01\u6282\u{2837D}\u8E28\u8E75\u7AD3\u{24A77}\u7A3E\u78D8\u6CEA\u8A67\u7607"], + ["a040", "\u{28A5A}\u9F26\u6CCE\u87D6\u75C3\u{2A2B2}\u7853\u{2F840}\u8D0C\u72E2\u7371\u8B2D\u7302\u74F1\u8CEB\u{24ABB}\u862F\u5FBA\u88A0\u44B7"], + ["a055", "\u{2183B}\u{26E05}"], + ["a058", "\u8A7E\u{2251B}"], + ["a05b", "\u60FD\u7667\u9AD7\u9D44\u936E\u9B8F\u87F5"], + ["a063", "\u880F\u8CF7\u732C\u9721\u9BB0\u35D6\u72B2\u4C07\u7C51\u994A\u{26159}\u6159\u4C04\u9E96\u617D"], + ["a073", "\u575F\u616F\u62A6\u6239\u62CE\u3A5C\u61E2\u53AA\u{233F5}\u6364\u6802\u35D2"], + ["a0a1", "\u5D57\u{28BC2}\u8FDA\u{28E39}"], + ["a0a6", "\u50D9\u{21D46}\u7906\u5332\u9638\u{20F3B}\u4065"], + ["a0ae", "\u77FE"], + ["a0b0", "\u7CC2\u{25F1A}\u7CDA\u7A2D\u8066\u8063\u7D4D\u7505\u74F2\u8994\u821A\u670C\u8062\u{27486}\u805B\u74F0\u8103\u7724\u8989\u{267CC}\u7553\u{26ED1}\u87A9\u87CE\u81C8\u878C\u8A49\u8CAD\u8B43\u772B\u74F8\u84DA\u3635\u69B2\u8DA6"], + ["a0d4", "\u89A9\u7468\u6DB9\u87C1\u{24011}\u74E7\u3DDB\u7176\u60A4\u619C\u3CD1\u7162\u6077"], + ["a0e2", "\u7F71\u{28B2D}\u7250\u60E9\u4B7E\u5220\u3C18\u{23CC7}\u{25ED7}\u{27656}\u{25531}\u{21944}\u{212FE}\u{29903}\u{26DDC}\u{270AD}\u5CC1\u{261AD}\u{28A0F}\u{23677}\u{200EE}\u{26846}\u{24F0E}\u4562\u5B1F\u{2634C}\u9F50\u9EA6\u{2626B}"], + ["a3c0", "\u2400", 31, "\u2421"], + ["c6a1", "\u2460", 9, "\u2474", 9, "\u2170", 9, "\u4E36\u4E3F\u4E85\u4EA0\u5182\u5196\u51AB\u52F9\u5338\u5369\u53B6\u590A\u5B80\u5DDB\u2F33\u5E7F\u5EF4\u5F50\u5F61\u6534\u65E0\u7592\u7676\u8FB5\u96B6\xA8\u02C6\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\uFF3B\uFF3D\u273D\u3041", 23], + ["c740", "\u3059", 58, "\u30A1\u30A2\u30A3\u30A4"], + ["c7a1", "\u30A5", 81, "\u0410", 5, "\u0401\u0416", 4], + ["c840", "\u041B", 26, "\u0451\u0436", 25, "\u21E7\u21B8\u21B9\u31CF\u{200CC}\u4E5A\u{2008A}\u5202\u4491"], + ["c8a1", "\u9FB0\u5188\u9FB1\u{27607}"], + ["c8cd", "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u309B\u309C\u2E80\u2E84\u2E86\u2E87\u2E88\u2E8A\u2E8C\u2E8D\u2E95\u2E9C\u2E9D\u2EA5\u2EA7\u2EAA\u2EAC\u2EAE\u2EB6\u2EBC\u2EBE\u2EC6\u2ECA\u2ECC\u2ECD\u2ECF\u2ED6\u2ED7\u2EDE\u2EE3"], + ["c8f5", "\u0283\u0250\u025B\u0254\u0275\u0153\xF8\u014B\u028A\u026A"], + ["f9fe", "\uFFED"], + ["fa40", "\u{20547}\u92DB\u{205DF}\u{23FC5}\u854C\u42B5\u73EF\u51B5\u3649\u{24942}\u{289E4}\u9344\u{219DB}\u82EE\u{23CC8}\u783C\u6744\u62DF\u{24933}\u{289AA}\u{202A0}\u{26BB3}\u{21305}\u4FAB\u{224ED}\u5008\u{26D29}\u{27A84}\u{23600}\u{24AB1}\u{22513}\u5029\u{2037E}\u5FA4\u{20380}\u{20347}\u6EDB\u{2041F}\u507D\u5101\u347A\u510E\u986C\u3743\u8416\u{249A4}\u{20487}\u5160\u{233B4}\u516A\u{20BFF}\u{220FC}\u{202E5}\u{22530}\u{2058E}\u{23233}\u{21983}\u5B82\u877D\u{205B3}\u{23C99}\u51B2\u51B8"], + ["faa1", "\u9D34\u51C9\u51CF\u51D1\u3CDC\u51D3\u{24AA6}\u51B3\u51E2\u5342\u51ED\u83CD\u693E\u{2372D}\u5F7B\u520B\u5226\u523C\u52B5\u5257\u5294\u52B9\u52C5\u7C15\u8542\u52E0\u860D\u{26B13}\u5305\u{28ADE}\u5549\u6ED9\u{23F80}\u{20954}\u{23FEC}\u5333\u5344\u{20BE2}\u6CCB\u{21726}\u681B\u73D5\u604A\u3EAA\u38CC\u{216E8}\u71DD\u44A2\u536D\u5374\u{286AB}\u537E\u537F\u{21596}\u{21613}\u77E6\u5393\u{28A9B}\u53A0\u53AB\u53AE\u73A7\u{25772}\u3F59\u739C\u53C1\u53C5\u6C49\u4E49\u57FE\u53D9\u3AAB\u{20B8F}\u53E0\u{23FEB}\u{22DA3}\u53F6\u{20C77}\u5413\u7079\u552B\u6657\u6D5B\u546D\u{26B53}\u{20D74}\u555D\u548F\u54A4\u47A6\u{2170D}\u{20EDD}\u3DB4\u{20D4D}"], + ["fb40", "\u{289BC}\u{22698}\u5547\u4CED\u542F\u7417\u5586\u55A9\u5605\u{218D7}\u{2403A}\u4552\u{24435}\u66B3\u{210B4}\u5637\u66CD\u{2328A}\u66A4\u66AD\u564D\u564F\u78F1\u56F1\u9787\u53FE\u5700\u56EF\u56ED\u{28B66}\u3623\u{2124F}\u5746\u{241A5}\u6C6E\u708B\u5742\u36B1\u{26C7E}\u57E6\u{21416}\u5803\u{21454}\u{24363}\u5826\u{24BF5}\u585C\u58AA\u3561\u58E0\u58DC\u{2123C}\u58FB\u5BFF\u5743\u{2A150}\u{24278}\u93D3\u35A1\u591F\u68A6\u36C3\u6E59"], + ["fba1", "\u{2163E}\u5A24\u5553\u{21692}\u8505\u59C9\u{20D4E}\u{26C81}\u{26D2A}\u{217DC}\u59D9\u{217FB}\u{217B2}\u{26DA6}\u6D71\u{21828}\u{216D5}\u59F9\u{26E45}\u5AAB\u5A63\u36E6\u{249A9}\u5A77\u3708\u5A96\u7465\u5AD3\u{26FA1}\u{22554}\u3D85\u{21911}\u3732\u{216B8}\u5E83\u52D0\u5B76\u6588\u5B7C\u{27A0E}\u4004\u485D\u{20204}\u5BD5\u6160\u{21A34}\u{259CC}\u{205A5}\u5BF3\u5B9D\u4D10\u5C05\u{21B44}\u5C13\u73CE\u5C14\u{21CA5}\u{26B28}\u5C49\u48DD\u5C85\u5CE9\u5CEF\u5D8B\u{21DF9}\u{21E37}\u5D10\u5D18\u5D46\u{21EA4}\u5CBA\u5DD7\u82FC\u382D\u{24901}\u{22049}\u{22173}\u8287\u3836\u3BC2\u5E2E\u6A8A\u5E75\u5E7A\u{244BC}\u{20CD3}\u53A6\u4EB7\u5ED0\u53A8\u{21771}\u5E09\u5EF4\u{28482}"], + ["fc40", "\u5EF9\u5EFB\u38A0\u5EFC\u683E\u941B\u5F0D\u{201C1}\u{2F894}\u3ADE\u48AE\u{2133A}\u5F3A\u{26888}\u{223D0}\u5F58\u{22471}\u5F63\u97BD\u{26E6E}\u5F72\u9340\u{28A36}\u5FA7\u5DB6\u3D5F\u{25250}\u{21F6A}\u{270F8}\u{22668}\u91D6\u{2029E}\u{28A29}\u6031\u6685\u{21877}\u3963\u3DC7\u3639\u5790\u{227B4}\u7971\u3E40\u609E\u60A4\u60B3\u{24982}\u{2498F}\u{27A53}\u74A4\u50E1\u5AA0\u6164\u8424\u6142\u{2F8A6}\u{26ED2}\u6181\u51F4\u{20656}\u6187\u5BAA\u{23FB7}"], + ["fca1", "\u{2285F}\u61D3\u{28B9D}\u{2995D}\u61D0\u3932\u{22980}\u{228C1}\u6023\u615C\u651E\u638B\u{20118}\u62C5\u{21770}\u62D5\u{22E0D}\u636C\u{249DF}\u3A17\u6438\u63F8\u{2138E}\u{217FC}\u6490\u6F8A\u{22E36}\u9814\u{2408C}\u{2571D}\u64E1\u64E5\u947B\u3A66\u643A\u3A57\u654D\u6F16\u{24A28}\u{24A23}\u6585\u656D\u655F\u{2307E}\u65B5\u{24940}\u4B37\u65D1\u40D8\u{21829}\u65E0\u65E3\u5FDF\u{23400}\u6618\u{231F7}\u{231F8}\u6644\u{231A4}\u{231A5}\u664B\u{20E75}\u6667\u{251E6}\u6673\u6674\u{21E3D}\u{23231}\u{285F4}\u{231C8}\u{25313}\u77C5\u{228F7}\u99A4\u6702\u{2439C}\u{24A21}\u3B2B\u69FA\u{237C2}\u675E\u6767\u6762\u{241CD}\u{290ED}\u67D7\u44E9\u6822\u6E50\u923C\u6801\u{233E6}\u{26DA0}\u685D"], + ["fd40", "\u{2346F}\u69E1\u6A0B\u{28ADF}\u6973\u68C3\u{235CD}\u6901\u6900\u3D32\u3A01\u{2363C}\u3B80\u67AC\u6961\u{28A4A}\u42FC\u6936\u6998\u3BA1\u{203C9}\u8363\u5090\u69F9\u{23659}\u{2212A}\u6A45\u{23703}\u6A9D\u3BF3\u67B1\u6AC8\u{2919C}\u3C0D\u6B1D\u{20923}\u60DE\u6B35\u6B74\u{227CD}\u6EB5\u{23ADB}\u{203B5}\u{21958}\u3740\u5421\u{23B5A}\u6BE1\u{23EFC}\u6BDC\u6C37\u{2248B}\u{248F1}\u{26B51}\u6C5A\u8226\u6C79\u{23DBC}\u44C5\u{23DBD}\u{241A4}\u{2490C}\u{24900}"], + ["fda1", "\u{23CC9}\u36E5\u3CEB\u{20D32}\u9B83\u{231F9}\u{22491}\u7F8F\u6837\u{26D25}\u{26DA1}\u{26DEB}\u6D96\u6D5C\u6E7C\u6F04\u{2497F}\u{24085}\u{26E72}\u8533\u{26F74}\u51C7\u6C9C\u6E1D\u842E\u{28B21}\u6E2F\u{23E2F}\u7453\u{23F82}\u79CC\u6E4F\u5A91\u{2304B}\u6FF8\u370D\u6F9D\u{23E30}\u6EFA\u{21497}\u{2403D}\u4555\u93F0\u6F44\u6F5C\u3D4E\u6F74\u{29170}\u3D3B\u6F9F\u{24144}\u6FD3\u{24091}\u{24155}\u{24039}\u{23FF0}\u{23FB4}\u{2413F}\u51DF\u{24156}\u{24157}\u{24140}\u{261DD}\u704B\u707E\u70A7\u7081\u70CC\u70D5\u70D6\u70DF\u4104\u3DE8\u71B4\u7196\u{24277}\u712B\u7145\u5A88\u714A\u716E\u5C9C\u{24365}\u714F\u9362\u{242C1}\u712C\u{2445A}\u{24A27}\u{24A22}\u71BA\u{28BE8}\u70BD\u720E"], + ["fe40", "\u9442\u7215\u5911\u9443\u7224\u9341\u{25605}\u722E\u7240\u{24974}\u68BD\u7255\u7257\u3E55\u{23044}\u680D\u6F3D\u7282\u732A\u732B\u{24823}\u{2882B}\u48ED\u{28804}\u7328\u732E\u73CF\u73AA\u{20C3A}\u{26A2E}\u73C9\u7449\u{241E2}\u{216E7}\u{24A24}\u6623\u36C5\u{249B7}\u{2498D}\u{249FB}\u73F7\u7415\u6903\u{24A26}\u7439\u{205C3}\u3ED7\u745C\u{228AD}\u7460\u{28EB2}\u7447\u73E4\u7476\u83B9\u746C\u3730\u7474\u93F1\u6A2C\u7482\u4953\u{24A8C}"], + ["fea1", "\u{2415F}\u{24A79}\u{28B8F}\u5B46\u{28C03}\u{2189E}\u74C8\u{21988}\u750E\u74E9\u751E\u{28ED9}\u{21A4B}\u5BD7\u{28EAC}\u9385\u754D\u754A\u7567\u756E\u{24F82}\u3F04\u{24D13}\u758E\u745D\u759E\u75B4\u7602\u762C\u7651\u764F\u766F\u7676\u{263F5}\u7690\u81EF\u37F8\u{26911}\u{2690E}\u76A1\u76A5\u76B7\u76CC\u{26F9F}\u8462\u{2509D}\u{2517D}\u{21E1C}\u771E\u7726\u7740\u64AF\u{25220}\u7758\u{232AC}\u77AF\u{28964}\u{28968}\u{216C1}\u77F4\u7809\u{21376}\u{24A12}\u68CA\u78AF\u78C7\u78D3\u96A5\u792E\u{255E0}\u78D7\u7934\u78B1\u{2760C}\u8FB8\u8884\u{28B2B}\u{26083}\u{2261C}\u7986\u8900\u6902\u7980\u{25857}\u799D\u{27B39}\u793C\u79A9\u6E2A\u{27126}\u3EA8\u79C6\u{2910D}\u79D4"] + ]; + } +}); + +// node_modules/iconv-lite/encodings/dbcs-data.js +var require_dbcs_data = __commonJS({ + "node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module2) { + "use strict"; + module2.exports = { + // == Japanese/ShiftJIS ==================================================== + // All japanese encodings are based on JIS X set of standards: + // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF. + // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. + // Has several variations in 1978, 1983, 1990 and 1997. + // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead. + // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233. + // 2 planes, first is superset of 0208, second - revised 0212. + // Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx) + // Byte encodings are: + // * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte + // encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC. + // Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI. + // * EUC-JP: Up to 3 bytes per character. Used mostly on *nixes. + // 0x00-0x7F - lower part of 0201 + // 0x8E, 0xA1-0xDF - upper part of 0201 + // (0xA1-0xFE)x2 - 0208 plane (94x94). + // 0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94). + // * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon. + // Used as-is in ISO2022 family. + // * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, + // 0201-1976 Roman, 0208-1978, 0208-1983. + // * ISO2022-JP-1: Adds esc seq for 0212-1990. + // * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7. + // * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2. + // * ISO2022-JP-2004: Adds 0213-2004 Plane 1. + // + // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes. + // + // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html + shiftjis: { + type: "_dbcs", + table: function() { + return require_shiftjis(); + }, + encodeAdd: { "\xA5": 92, "\u203E": 126 }, + encodeSkipVals: [{ from: 60736, to: 63808 }] + }, + csshiftjis: "shiftjis", + mskanji: "shiftjis", + sjis: "shiftjis", + windows31j: "shiftjis", + ms31j: "shiftjis", + xsjis: "shiftjis", + windows932: "shiftjis", + ms932: "shiftjis", + 932: "shiftjis", + cp932: "shiftjis", + eucjp: { + type: "_dbcs", + table: function() { + return require_eucjp(); + }, + encodeAdd: { "\xA5": 92, "\u203E": 126 } + }, + // TODO: KDDI extension to Shift_JIS + // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes. + // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars. + // == Chinese/GBK ========================================================== + // http://en.wikipedia.org/wiki/GBK + // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder + // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936 + gb2312: "cp936", + gb231280: "cp936", + gb23121980: "cp936", + csgb2312: "cp936", + csiso58gb231280: "cp936", + euccn: "cp936", + // Microsoft's CP936 is a subset and approximation of GBK. + windows936: "cp936", + ms936: "cp936", + 936: "cp936", + cp936: { + type: "_dbcs", + table: function() { + return require_cp936(); + } + }, + // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other. + gbk: { + type: "_dbcs", + table: function() { + return require_cp936().concat(require_gbk_added()); + } + }, + xgbk: "gbk", + isoir58: "gbk", + // GB18030 is an algorithmic extension of GBK. + // Main source: https://www.w3.org/TR/encoding/#gbk-encoder + // http://icu-project.org/docs/papers/gb18030.html + // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml + // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0 + gb18030: { + type: "_dbcs", + table: function() { + return require_cp936().concat(require_gbk_added()); + }, + gb18030: function() { + return require_gb18030_ranges(); + }, + encodeSkipVals: [128], + encodeAdd: { "\u20AC": 41699 } + }, + chinese: "gb18030", + // == Korean =============================================================== + // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same. + windows949: "cp949", + ms949: "cp949", + 949: "cp949", + cp949: { + type: "_dbcs", + table: function() { + return require_cp949(); + } + }, + cseuckr: "cp949", + csksc56011987: "cp949", + euckr: "cp949", + isoir149: "cp949", + korean: "cp949", + ksc56011987: "cp949", + ksc56011989: "cp949", + ksc5601: "cp949", + // == Big5/Taiwan/Hong Kong ================================================ + // There are lots of tables for Big5 and cp950. Please see the following links for history: + // http://moztw.org/docs/big5/ http://www.haible.de/bruno/charsets/conversion-tables/Big5.html + // Variations, in roughly number of defined chars: + // * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT + // * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/ + // * Big5-2003 (Taiwan standard) almost superset of cp950. + // * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers. + // * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. + // many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years. + // Plus, it has 4 combining sequences. + // Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299 + // because big5-hkscs is the only encoding to include astral characters in non-algorithmic way. + // Implementations are not consistent within browsers; sometimes labeled as just big5. + // MS Internet Explorer switches from big5 to big5-hkscs when a patch applied. + // Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31 + // In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s. + // Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt + // http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt + // + // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder + // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong. + windows950: "cp950", + ms950: "cp950", + 950: "cp950", + cp950: { + type: "_dbcs", + table: function() { + return require_cp950(); + } + }, + // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus. + big5: "big5hkscs", + big5hkscs: { + type: "_dbcs", + table: function() { + return require_cp950().concat(require_big5_added()); + }, + encodeSkipVals: [ + // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of + // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU. + // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter. + 36457, + 36463, + 36478, + 36523, + 36532, + 36557, + 36560, + 36695, + 36713, + 36718, + 36811, + 36862, + 36973, + 36986, + 37060, + 37084, + 37105, + 37311, + 37551, + 37552, + 37553, + 37554, + 37585, + 37959, + 38090, + 38361, + 38652, + 39285, + 39798, + 39800, + 39803, + 39878, + 39902, + 39916, + 39926, + 40002, + 40019, + 40034, + 40040, + 40043, + 40055, + 40124, + 40125, + 40144, + 40279, + 40282, + 40388, + 40431, + 40443, + 40617, + 40687, + 40701, + 40800, + 40907, + 41079, + 41180, + 41183, + 36812, + 37576, + 38468, + 38637, + // Step 2 of https://encoding.spec.whatwg.org/#index-big5-pointer: Use last pointer for U+2550, U+255E, U+2561, U+256A, U+5341, or U+5345 + 41636, + 41637, + 41639, + 41638, + 41676, + 41678 + ] + }, + cnbig5: "big5hkscs", + csbig5: "big5hkscs", + xxbig5: "big5hkscs" + }; + } +}); + +// node_modules/iconv-lite/encodings/index.js +var require_encodings = __commonJS({ + "node_modules/iconv-lite/encodings/index.js"(exports2, module2) { + "use strict"; + var mergeModules = require_merge_exports(); + var modules = [ + require_internal(), + require_utf32(), + require_utf16(), + require_utf7(), + require_sbcs_codec(), + require_sbcs_data(), + require_sbcs_data_generated(), + require_dbcs_codec(), + require_dbcs_data() + ]; + for (i = 0; i < modules.length; i++) { + module2 = modules[i]; + mergeModules(exports2, module2); + } + var module2; + var i; + } +}); + +// node_modules/iconv-lite/lib/streams.js +var require_streams = __commonJS({ + "node_modules/iconv-lite/lib/streams.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + module2.exports = function(streamModule) { + var Transform = streamModule.Transform; + function IconvLiteEncoderStream(conv, options) { + this.conv = conv; + options = options || {}; + options.decodeStrings = false; + Transform.call(this, options); + } + IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, { + constructor: { value: IconvLiteEncoderStream } + }); + IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) { + if (typeof chunk !== "string") { + return done(new Error("Iconv encoding stream needs strings as its input.")); + } + try { + var res = this.conv.write(chunk); + if (res && res.length) this.push(res); + done(); + } catch (e) { + done(e); + } + }; + IconvLiteEncoderStream.prototype._flush = function(done) { + try { + var res = this.conv.end(); + if (res && res.length) this.push(res); + done(); + } catch (e) { + done(e); + } + }; + IconvLiteEncoderStream.prototype.collect = function(cb) { + var chunks = []; + this.on("error", cb); + this.on("data", function(chunk) { + chunks.push(chunk); + }); + this.on("end", function() { + cb(null, Buffer2.concat(chunks)); + }); + return this; + }; + function IconvLiteDecoderStream(conv, options) { + this.conv = conv; + options = options || {}; + options.encoding = this.encoding = "utf8"; + Transform.call(this, options); + } + IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, { + constructor: { value: IconvLiteDecoderStream } + }); + IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) { + if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array)) { + return done(new Error("Iconv decoding stream needs buffers as its input.")); + } + try { + var res = this.conv.write(chunk); + if (res && res.length) this.push(res, this.encoding); + done(); + } catch (e) { + done(e); + } + }; + IconvLiteDecoderStream.prototype._flush = function(done) { + try { + var res = this.conv.end(); + if (res && res.length) this.push(res, this.encoding); + done(); + } catch (e) { + done(e); + } + }; + IconvLiteDecoderStream.prototype.collect = function(cb) { + var res = ""; + this.on("error", cb); + this.on("data", function(chunk) { + res += chunk; + }); + this.on("end", function() { + cb(null, res); + }); + return this; + }; + return { + IconvLiteEncoderStream, + IconvLiteDecoderStream + }; + }; + } +}); + +// node_modules/iconv-lite/lib/index.js +var require_lib3 = __commonJS({ + "node_modules/iconv-lite/lib/index.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + var bomHandling = require_bom_handling(); + var mergeModules = require_merge_exports(); + module2.exports.encodings = null; + module2.exports.defaultCharUnicode = "\uFFFD"; + module2.exports.defaultCharSingleByte = "?"; + module2.exports.encode = function encode(str, encoding, options) { + str = "" + (str || ""); + var encoder = module2.exports.getEncoder(encoding, options); + var res = encoder.write(str); + var trail = encoder.end(); + return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res; + }; + module2.exports.decode = function decode(buf, encoding, options) { + if (typeof buf === "string") { + if (!module2.exports.skipDecodeWarning) { + console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding"); + module2.exports.skipDecodeWarning = true; + } + buf = Buffer2.from("" + (buf || ""), "binary"); + } + var decoder = module2.exports.getDecoder(encoding, options); + var res = decoder.write(buf); + var trail = decoder.end(); + return trail ? res + trail : res; + }; + module2.exports.encodingExists = function encodingExists(enc) { + try { + module2.exports.getCodec(enc); + return true; + } catch (e) { + return false; + } + }; + module2.exports.toEncoding = module2.exports.encode; + module2.exports.fromEncoding = module2.exports.decode; + module2.exports._codecDataCache = { __proto__: null }; + module2.exports.getCodec = function getCodec(encoding) { + if (!module2.exports.encodings) { + var raw = require_encodings(); + module2.exports.encodings = { __proto__: null }; + mergeModules(module2.exports.encodings, raw); + } + var enc = module2.exports._canonicalizeEncoding(encoding); + var codecOptions = {}; + while (true) { + var codec = module2.exports._codecDataCache[enc]; + if (codec) { + return codec; + } + var codecDef = module2.exports.encodings[enc]; + switch (typeof codecDef) { + case "string": + enc = codecDef; + break; + case "object": + for (var key in codecDef) { + codecOptions[key] = codecDef[key]; + } + if (!codecOptions.encodingName) { + codecOptions.encodingName = enc; + } + enc = codecDef.type; + break; + case "function": + if (!codecOptions.encodingName) { + codecOptions.encodingName = enc; + } + codec = new codecDef(codecOptions, module2.exports); + module2.exports._codecDataCache[codecOptions.encodingName] = codec; + return codec; + default: + throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')"); + } + } + }; + module2.exports._canonicalizeEncoding = function(encoding) { + return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, ""); + }; + module2.exports.getEncoder = function getEncoder(encoding, options) { + var codec = module2.exports.getCodec(encoding); + var encoder = new codec.encoder(options, codec); + if (codec.bomAware && options && options.addBOM) { + encoder = new bomHandling.PrependBOM(encoder, options); + } + return encoder; + }; + module2.exports.getDecoder = function getDecoder(encoding, options) { + var codec = module2.exports.getCodec(encoding); + var decoder = new codec.decoder(options, codec); + if (codec.bomAware && !(options && options.stripBOM === false)) { + decoder = new bomHandling.StripBOM(decoder, options); + } + return decoder; + }; + module2.exports.enableStreamingAPI = function enableStreamingAPI(streamModule2) { + if (module2.exports.supportsStreams) { + return; + } + var streams = require_streams()(streamModule2); + module2.exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream; + module2.exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream; + module2.exports.encodeStream = function encodeStream(encoding, options) { + return new module2.exports.IconvLiteEncoderStream(module2.exports.getEncoder(encoding, options), options); + }; + module2.exports.decodeStream = function decodeStream(encoding, options) { + return new module2.exports.IconvLiteDecoderStream(module2.exports.getDecoder(encoding, options), options); + }; + module2.exports.supportsStreams = true; + }; + var streamModule; + try { + streamModule = require("stream"); + } catch (e) { + } + if (streamModule && streamModule.Transform) { + module2.exports.enableStreamingAPI(streamModule); + } else { + module2.exports.encodeStream = module2.exports.decodeStream = function() { + throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it."); + }; + } + if (false) { + console.error("iconv-lite warning: js files use non-utf8 encoding. See https://github.com/ashtuchkin/iconv-lite/wiki/Javascript-source-file-encodings for more info."); + } + } +}); + +// node_modules/mysql2/lib/parsers/string.js +var require_string = __commonJS({ + "node_modules/mysql2/lib/parsers/string.js"(exports2) { + "use strict"; + var Iconv = require_lib3(); + var { createLRU } = require_lib2(); + var decoderCache = createLRU({ + max: 500 + }); + var hasFastSlices = typeof Buffer.prototype.utf8Slice === "function" && typeof Buffer.prototype.latin1Slice === "function" && typeof Buffer.prototype.asciiSlice === "function"; + exports2.hasFastUtf8Write = typeof Buffer.prototype.utf8Write === "function"; + function shortAscii(b, s, length) { + if (b[s] >= 128) { + return null; + } + switch (length) { + case 1: { + const c0 = b[s]; + return c0 < 128 ? String.fromCharCode(c0) : null; + } + case 2: { + const c0 = b[s]; + const c1 = b[s + 1]; + return (c0 | c1) < 128 ? String.fromCharCode(c0, c1) : null; + } + case 3: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + return (c0 | c1 | c2) < 128 ? String.fromCharCode(c0, c1, c2) : null; + } + case 4: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + const c3 = b[s + 3]; + return (c0 | c1 | c2 | c3) < 128 ? String.fromCharCode(c0, c1, c2, c3) : null; + } + case 5: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + const c3 = b[s + 3]; + const c4 = b[s + 4]; + return (c0 | c1 | c2 | c3 | c4) < 128 ? String.fromCharCode(c0, c1, c2, c3, c4) : null; + } + case 6: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + const c3 = b[s + 3]; + const c4 = b[s + 4]; + const c5 = b[s + 5]; + return (c0 | c1 | c2 | c3 | c4 | c5) < 128 ? String.fromCharCode(c0, c1, c2, c3, c4, c5) : null; + } + case 7: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + const c3 = b[s + 3]; + const c4 = b[s + 4]; + const c5 = b[s + 5]; + const c6 = b[s + 6]; + return (c0 | c1 | c2 | c3 | c4 | c5 | c6) < 128 ? String.fromCharCode(c0, c1, c2, c3, c4, c5, c6) : null; + } + case 8: { + const c0 = b[s]; + const c1 = b[s + 1]; + const c2 = b[s + 2]; + const c3 = b[s + 3]; + const c4 = b[s + 4]; + const c5 = b[s + 5]; + const c6 = b[s + 6]; + const c7 = b[s + 7]; + return (c0 | c1 | c2 | c3 | c4 | c5 | c6 | c7) < 128 ? String.fromCharCode(c0, c1, c2, c3, c4, c5, c6, c7) : null; + } + default: + return null; + } + } + exports2.SHORT_STRING_MAX_LENGTH = 8; + exports2.decodeShort = function(buffer, encoding, start, end) { + if (hasFastSlices && start >= 0 && start <= end && end <= buffer.length) { + switch (encoding) { + case "utf8": + case "utf-8": { + const short = shortAscii(buffer, start, end - start); + return short !== null ? short : buffer.utf8Slice(start, end); + } + case "latin1": + case "binary": { + const short = shortAscii(buffer, start, end - start); + return short !== null ? short : buffer.latin1Slice(start, end); + } + case "ascii": { + const short = shortAscii(buffer, start, end - start); + return short !== null ? short : buffer.asciiSlice(start, end); + } + default: + break; + } + } + return exports2.decode(buffer, encoding, start, end); + }; + exports2.decode = function(buffer, encoding, start, end, options) { + if (hasFastSlices) { + const len = buffer.length; + if (start <= 0) { + start = 0; + } else if (start >= len) { + return ""; + } else { + start |= 0; + } + if (end === void 0 || end > len) { + end = len; + } else { + end |= 0; + } + if (end <= start) { + return ""; + } + switch (encoding) { + case "utf8": + case "utf-8": + return buffer.utf8Slice(start, end); + case "latin1": + case "binary": + return buffer.latin1Slice(start, end); + case "ascii": + return buffer.asciiSlice(start, end); + default: + break; + } + } + if (Buffer.isEncoding(encoding)) { + return buffer.toString(encoding, start, end); + } + let decoder; + if (!options) { + decoder = decoderCache.get(encoding); + if (!decoder) { + decoder = Iconv.getDecoder(encoding); + decoderCache.set(encoding, decoder); + } + } else { + const decoderArgs = { encoding, options }; + const decoderKey = JSON.stringify(decoderArgs); + decoder = decoderCache.get(decoderKey); + if (!decoder) { + decoder = Iconv.getDecoder(decoderArgs.encoding, decoderArgs.options); + decoderCache.set(decoderKey, decoder); + } + } + const res = decoder.write(buffer.slice(start, end)); + const trail = decoder.end(); + return trail ? res + trail : res; + }; + exports2.encode = function(string, encoding, options) { + if (Buffer.isEncoding(encoding)) { + return Buffer.from(string, encoding); + } + const encoder = Iconv.getEncoder(encoding, options || {}); + const res = encoder.write(string); + const trail = encoder.end(); + return trail && trail.length > 0 ? Buffer.concat([res, trail]) : res; + }; + } +}); + +// node_modules/mysql2/lib/constants/types.js +var require_types = __commonJS({ + "node_modules/mysql2/lib/constants/types.js"(exports2, module2) { + "use strict"; + module2.exports = { + 0: "DECIMAL", + // aka DECIMAL + 1: "TINY", + // aka TINYINT, 1 byte + 2: "SHORT", + // aka SMALLINT, 2 bytes + 3: "LONG", + // aka INT, 4 bytes + 4: "FLOAT", + // aka FLOAT, 4-8 bytes + 5: "DOUBLE", + // aka DOUBLE, 8 bytes + 6: "NULL", + // NULL (used for prepared statements, I think) + 7: "TIMESTAMP", + // aka TIMESTAMP + 8: "LONGLONG", + // aka BIGINT, 8 bytes + 9: "INT24", + // aka MEDIUMINT, 3 bytes + 10: "DATE", + // aka DATE + 11: "TIME", + // aka TIME + 12: "DATETIME", + // aka DATETIME + 13: "YEAR", + // aka YEAR, 1 byte (don't ask) + 14: "NEWDATE", + // aka ? + 15: "VARCHAR", + // aka VARCHAR (?) + 16: "BIT", + // aka BIT, 1-8 byte + 242: "VECTOR", + 245: "JSON", + 246: "NEWDECIMAL", + // aka DECIMAL + 247: "ENUM", + // aka ENUM + 248: "SET", + // aka SET + 249: "TINY_BLOB", + // aka TINYBLOB, TINYTEXT + 250: "MEDIUM_BLOB", + // aka MEDIUMBLOB, MEDIUMTEXT + 251: "LONG_BLOB", + // aka LONGBLOG, LONGTEXT + 252: "BLOB", + // aka BLOB, TEXT + 253: "VAR_STRING", + // aka VARCHAR, VARBINARY + 254: "STRING", + // aka CHAR, BINARY + 255: "GEOMETRY" + // aka GEOMETRY + }; + module2.exports.DECIMAL = 0; + module2.exports.TINY = 1; + module2.exports.SHORT = 2; + module2.exports.LONG = 3; + module2.exports.FLOAT = 4; + module2.exports.DOUBLE = 5; + module2.exports.NULL = 6; + module2.exports.TIMESTAMP = 7; + module2.exports.LONGLONG = 8; + module2.exports.INT24 = 9; + module2.exports.DATE = 10; + module2.exports.TIME = 11; + module2.exports.DATETIME = 12; + module2.exports.YEAR = 13; + module2.exports.NEWDATE = 14; + module2.exports.VARCHAR = 15; + module2.exports.BIT = 16; + module2.exports.VECTOR = 242; + module2.exports.JSON = 245; + module2.exports.NEWDECIMAL = 246; + module2.exports.ENUM = 247; + module2.exports.SET = 248; + module2.exports.TINY_BLOB = 249; + module2.exports.MEDIUM_BLOB = 250; + module2.exports.LONG_BLOB = 251; + module2.exports.BLOB = 252; + module2.exports.VAR_STRING = 253; + module2.exports.STRING = 254; + module2.exports.GEOMETRY = 255; + } +}); + +// node_modules/mysql2/lib/helpers.js +var require_helpers = __commonJS({ + "node_modules/mysql2/lib/helpers.js"(exports2) { + "use strict"; + function srcEscape(str) { + return JSON.stringify({ + [str]: 1 + }).slice(1, -3); + } + exports2.srcEscape = srcEscape; + var highlightFn; + var cardinalRecommended = false; + try { + const REQUIRE_TERMINATOR = ""; + highlightFn = require(`cardinal${REQUIRE_TERMINATOR}`).highlight; + } catch { + highlightFn = (text) => { + if (!cardinalRecommended) { + console.log("For nicer debug output consider install cardinal@^2.0.0"); + cardinalRecommended = true; + } + return text; + }; + } + function printDebugWithCode(msg, code) { + console.log(` + +${msg}: +`); + console.log(`${highlightFn(code)} +`); + } + exports2.printDebugWithCode = printDebugWithCode; + function typeMatch(type, list, Types) { + if (Array.isArray(list)) { + return list.some((t) => type === Types[t]); + } + return !!list; + } + exports2.typeMatch = typeMatch; + var privateObjectProps = /* @__PURE__ */ new Set([ + "__defineGetter__", + "__defineSetter__", + "__lookupGetter__", + "__lookupSetter__", + "__proto__" + ]); + exports2.privateObjectProps = privateObjectProps; + var fieldEscape = (field, isEval = true) => { + if (privateObjectProps.has(field)) { + throw new Error( + `The field name (${field}) can't be the same as an object's private property.` + ); + } + return isEval ? srcEscape(field) : field; + }; + exports2.fieldEscape = fieldEscape; + } +}); + +// node_modules/mysql2/lib/parsers/local_date.js +var require_local_date = __commonJS({ + "node_modules/mysql2/lib/parsers/local_date.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var helpers = require_helpers(); + var MS_PER_HOUR = 36e5; + var MS_PER_DAY = 864e5; + var MAX_CACHED_HOURS = 4096; + var hourOffsets = /* @__PURE__ */ new Map(); + var lastTimezone = readTimezone(); + function readTimezone() { + try { + return process.env.TZ; + } catch { + return void 0; + } + } + function checkTimezone() { + const timezone = readTimezone(); + if (timezone !== lastTimezone) { + lastTimezone = timezone; + hourOffsets.clear(); + } + } + function daysFromCivil(year, month, day) { + const y = month <= 2 ? year - 1 : year; + const era = Math.floor(y / 400); + const yearOfEra = y - era * 400; + const dayOfYear = ((153 * ((month + 9) % 12) + 2) / 5 | 0) + day - 1; + const dayOfEra = yearOfEra * 365 + (yearOfEra / 4 | 0) - (yearOfEra / 100 | 0) + dayOfYear; + return era * 146097 + dayOfEra - 719468; + } + function localTime(wallTime) { + const wall = new Date(wallTime); + return new Date( + wall.getUTCFullYear(), + wall.getUTCMonth(), + wall.getUTCDate(), + wall.getUTCHours(), + wall.getUTCMinutes(), + wall.getUTCSeconds(), + wall.getUTCMilliseconds() + ).getTime(); + } + function proveHourOffset(hour) { + const start = hour * MS_PER_HOUR; + const offset = start - localTime(start); + if (offset !== start + MS_PER_HOUR / 2 - localTime(start + MS_PER_HOUR / 2) || offset !== start + MS_PER_HOUR - 1 - localTime(start + MS_PER_HOUR - 1) || Number.isNaN(offset)) { + return null; + } + return offset; + } + function localDate(year, month, day, hours, minutes, seconds, milliseconds) { + if (year < 100 || month < 1 || month > 12) { + return new Date( + year, + month - 1, + day, + hours, + minutes, + seconds, + milliseconds + ); + } + const wallTime = daysFromCivil(year, month, day) * MS_PER_DAY + hours * MS_PER_HOUR + minutes * 6e4 + seconds * 1e3 + Math.trunc(milliseconds); + const hour = Math.floor(wallTime / MS_PER_HOUR); + let offset = hourOffsets.get(hour); + if (offset === void 0) { + if (hourOffsets.size >= MAX_CACHED_HOURS) { + hourOffsets.clear(); + } + offset = proveHourOffset(hour); + hourOffsets.set(hour, offset); + } + if (offset === null) { + return new Date( + year, + month - 1, + day, + hours, + minutes, + seconds, + milliseconds + ); + } + return new Date(wallTime - offset); + } + function usesLocalDate(field, options, config) { + const timezone = options.timezone || config.timezone; + if (timezone && timezone !== "local") { + return false; + } + const type = field.columnType; + if (type !== Types.DATE && type !== Types.DATETIME && type !== Types.TIMESTAMP && type !== Types.NEWDATE) { + return false; + } + return !helpers.typeMatch( + type, + options.dateStrings || config.dateStrings, + Types + ); + } + module2.exports = { + localDate, + checkTimezone, + usesLocalDate, + _daysFromCivil: daysFromCivil, + _clear() { + hourOffsets.clear(); + } + }; + } +}); + +// node_modules/mysql2/lib/packets/packet.js +var require_packet = __commonJS({ + "node_modules/mysql2/lib/packets/packet.js"(exports2, module2) { + "use strict"; + var ErrorCodeToName = require_errors(); + var NativeBuffer = require("buffer").Buffer; + var Long = require_umd(); + var StringParser = require_string(); + var { localDate } = require_local_date(); + var Types = require_types(); + var ZERO_DATE = "0000-00-00"; + var pad = "000000000000"; + function leftPad(num, value) { + const s = value.toString(); + if (s.length >= num) { + return s; + } + return (pad + s).slice(-num); + } + var minus = "-".charCodeAt(0); + var plus = "+".charCodeAt(0); + var jsonSourceAccessSupported = (() => { + let supported = false; + JSON.parse("0", (key, value, context) => { + supported = context !== void 0 && typeof context.source === "string"; + return value; + }); + return supported; + })(); + var jsonBigNumeral = /\d{16}/; + var jsonIntegerSource = /^-?\d+$/; + function jsonBigNumberReviver(key, value, context) { + if (typeof value === "number" && !Number.isSafeInteger(value) && context !== void 0 && jsonIntegerSource.test(context.source)) { + return context.source; + } + return value; + } + var dot = ".".charCodeAt(0); + var exponent = "e".charCodeAt(0); + var exponentCapital = "E".charCodeAt(0); + var colon = ":".charCodeAt(0); + var lastTimezone; + var lastTimezoneOffset = null; + function timezoneOffsetMinutes(timezone) { + if (timezone === lastTimezone) { + return lastTimezoneOffset; + } + let offset = null; + if (/^[+-]\d{2}:\d{2}$/.test(timezone)) { + offset = (timezone[0] === "-" ? -1 : 1) * (parseInt(timezone.substring(1, 3), 10) * 60 + parseInt(timezone.substring(4), 10)); + } + lastTimezone = timezone; + lastTimezoneOffset = offset; + return offset; + } + var Packet = class _Packet { + constructor(id, buffer, start, end) { + this.sequenceId = id; + this.numPackets = 1; + this.buffer = buffer; + this.start = start; + this.offset = start + 4; + this.end = end; + } + // ============================== + // readers + // ============================== + reset() { + this.offset = this.start + 4; + } + length() { + return this.end - this.start; + } + slice() { + return this.buffer.slice(this.start, this.end); + } + dump() { + console.log( + [this.buffer.asciiSlice(this.start, this.end)], + this.buffer.slice(this.start, this.end), + this.length(), + this.sequenceId + ); + } + haveMoreData() { + return this.end > this.offset; + } + skip(num) { + this.offset += num; + } + readInt8() { + return this.buffer[this.offset++]; + } + readInt16() { + this.offset += 2; + return this.buffer.readUInt16LE(this.offset - 2); + } + readInt24() { + return this.readInt16() + (this.readInt8() << 16); + } + readInt32() { + this.offset += 4; + return this.buffer.readUInt32LE(this.offset - 4); + } + readSInt8() { + return this.buffer.readInt8(this.offset++); + } + readSInt16() { + this.offset += 2; + return this.buffer.readInt16LE(this.offset - 2); + } + readSInt32() { + this.offset += 4; + return this.buffer.readInt32LE(this.offset - 4); + } + readInt64JSNumber() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + return word0 + 4294967296 * word1; + } + readSInt64JSNumber() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + return word0 + 4294967296 * (word1 | 0); + } + readInt64String() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + const res = new Long(word0, word1, true); + return res.toString(); + } + readSInt64String() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + const res = new Long(word0, word1, false); + return res.toString(); + } + readInt64() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + const resNumber = word0 + 4294967296 * word1; + if (Number.isSafeInteger(resNumber)) { + return resNumber; + } + return new Long(word0, word1, true).toString(); + } + readSInt64() { + const word0 = this.readInt32(); + const word1 = this.readInt32(); + const resNumber = word0 + 4294967296 * (word1 | 0); + if (Number.isSafeInteger(resNumber)) { + return resNumber; + } + return new Long(word0, word1, false).toString(); + } + isEOF() { + return this.buffer[this.offset] === 254 && this.length() < 13; + } + eofStatusFlags() { + return this.buffer.readInt16LE(this.offset + 3); + } + eofWarningCount() { + return this.buffer.readInt16LE(this.offset + 1); + } + readLengthCodedNumber(bigNumberStrings, signed) { + const byte1 = this.buffer[this.offset++]; + if (byte1 < 251) { + return byte1; + } + return this.readLengthCodedNumberExt(byte1, bigNumberStrings, signed); + } + readLengthCodedNumberSigned(bigNumberStrings) { + return this.readLengthCodedNumber(bigNumberStrings, true); + } + readLengthCodedNumberExt(tag, bigNumberStrings, signed) { + let word0, word1; + let res; + if (tag === 251) { + return null; + } + if (tag === 252) { + return this.readInt8() + (this.readInt8() << 8); + } + if (tag === 253) { + return this.readInt8() + (this.readInt8() << 8) + (this.readInt8() << 16); + } + if (tag === 254) { + word0 = this.readInt32(); + word1 = this.readInt32(); + if (word1 === 0) { + return word0; + } + if (word1 < 2097152) { + return word1 * 4294967296 + word0; + } + res = new Long(word0, word1, !signed); + const resNumber = res.toNumber(); + const resString = res.toString(); + if (bigNumberStrings || !Number.isSafeInteger(resNumber)) { + return resString; + } + return resNumber; + } + console.trace(); + throw new Error(`Should not reach here: ${tag}`); + } + readFloat() { + const res = this.buffer.readFloatLE(this.offset); + this.offset += 4; + return res; + } + readDouble() { + const res = this.buffer.readDoubleLE(this.offset); + this.offset += 8; + return res; + } + readBuffer(len) { + if (typeof len === "undefined") { + len = this.end - this.offset; + } + this.offset += len; + return this.buffer.slice(this.offset - len, this.offset); + } + // DATE, DATETIME and TIMESTAMP + readDateTime(timezone) { + if (!timezone || timezone === "Z" || timezone === "local") { + const length = this.readInt8(); + if (length === 251) { + return null; + } + let y = 0; + let m = 0; + let d = 0; + let H = 0; + let M = 0; + let S = 0; + let ms = 0; + if (length > 3) { + y = this.readInt16(); + m = this.readInt8(); + d = this.readInt8(); + } + if (length > 6) { + H = this.readInt8(); + M = this.readInt8(); + S = this.readInt8(); + } + if (length > 10) { + ms = this.readInt32() / 1e3; + } + if (y + m + d + H + M + S + ms === 0) { + return /* @__PURE__ */ new Date(NaN); + } + if (timezone === "Z") { + return new Date(Date.UTC(y, m - 1, d, H, M, S, ms)); + } + return localDate(y, m, d, H, M, S, ms); + } + let str = this.readDateTimeString(6, "T", null); + if (str.startsWith(ZERO_DATE)) { + return /* @__PURE__ */ new Date(NaN); + } + if (str.length === 10) { + str += "T00:00:00"; + } + return new Date(str + timezone); + } + readDateTimeString(decimals, timeSep, columnType) { + const length = this.readInt8(); + let y = 0; + let m = 0; + let d = 0; + let H = 0; + let M = 0; + let S = 0; + let ms = 0; + let str = ZERO_DATE; + if (length > 3) { + y = this.readInt16(); + m = this.readInt8(); + d = this.readInt8(); + str = [leftPad(4, y), leftPad(2, m), leftPad(2, d)].join("-"); + } + if (length > 6) { + H = this.readInt8(); + M = this.readInt8(); + S = this.readInt8(); + str += `${timeSep || " "}${[ + leftPad(2, H), + leftPad(2, M), + leftPad(2, S) + ].join(":")}`; + } else if (columnType === Types.DATETIME || columnType === Types.TIMESTAMP) { + str += " 00:00:00"; + } + if (length > 10) { + ms = this.readInt32(); + str += "."; + if (decimals) { + ms = leftPad(6, ms); + if (ms.length > decimals) { + ms = ms.substring(0, decimals); + } + } + str += ms; + } + return str; + } + // TIME - value as a string, Can be negative + readTimeString(convertTtoMs) { + const length = this.readInt8(); + if (length === 0) { + return "00:00:00"; + } + const sign = this.readInt8() ? -1 : 1; + let d = 0; + let H = 0; + let M = 0; + let S = 0; + let ms = 0; + if (length > 6) { + d = this.readInt32(); + H = this.readInt8(); + M = this.readInt8(); + S = this.readInt8(); + } + if (length > 10) { + ms = this.readInt32(); + } + if (convertTtoMs) { + H += d * 24; + M += H * 60; + S += M * 60; + ms += S * 1e3; + ms *= sign; + return ms; + } + return (sign === -1 ? "-" : "") + [leftPad(2, d * 24 + H), leftPad(2, M), leftPad(2, S)].join(":") + (ms ? `.${leftPad(6, ms)}`.replace(/0+$/, "") : ""); + } + readLengthCodedString(encoding) { + const len = this.readLengthCodedNumber(); + if (len === null) { + return null; + } + this.offset += len; + if (len <= StringParser.SHORT_STRING_MAX_LENGTH) { + return StringParser.decodeShort( + this.buffer, + encoding, + this.offset - len, + this.offset + ); + } + return StringParser.decode( + this.buffer, + encoding, + this.offset - len, + this.offset + ); + } + readLengthCodedBuffer() { + const len = this.readLengthCodedNumber(); + if (len === null) { + return null; + } + return this.readBuffer(len); + } + readNullTerminatedString(encoding) { + const start = this.offset; + let end = this.offset; + while (end < this.end && this.buffer[end] !== 0) { + end = end + 1; + } + this.offset = end + 1; + return StringParser.decode(this.buffer, encoding, start, end); + } + // TODO reuse? + readString(len, encoding) { + if (typeof len === "string" && typeof encoding === "undefined") { + encoding = len; + len = void 0; + } + if (typeof len === "undefined") { + len = this.end - this.offset; + } + this.offset += len; + return StringParser.decode( + this.buffer, + encoding, + this.offset - len, + this.offset + ); + } + parseInt(len, supportBigNumbers) { + if (len === null) { + return null; + } + if (len >= 14 && !supportBigNumbers) { + const s = this.buffer.toString("ascii", this.offset, this.offset + len); + this.offset += len; + return Number(s); + } + let result = 0; + const start = this.offset; + const end = this.offset + len; + let sign = 1; + if (len === 0) { + return 0; + } + if (this.buffer[this.offset] === minus) { + this.offset++; + sign = -1; + } + let str; + const numDigits = end - this.offset; + if (supportBigNumbers) { + if (numDigits >= 15) { + str = this.readString(end - this.offset, "binary"); + result = parseInt(str, 10); + if (Number.isSafeInteger(sign * result)) { + return sign * result; + } + return sign === -1 ? `-${str}` : str; + } + if (numDigits > 16) { + str = this.readString(end - this.offset); + return sign === -1 ? `-${str}` : str; + } + } + if (this.buffer[this.offset] === plus) { + this.offset++; + } + while (this.offset < end) { + result *= 10; + result += this.buffer[this.offset] - 48; + this.offset++; + } + const num = result * sign; + if (!supportBigNumbers) { + return num; + } + if (Number.isSafeInteger(num)) { + return num; + } + return this.buffer.toString("ascii", start, end); + } + // note that if value of inputNumberAsString is bigger than MAX_SAFE_INTEGER + // ( or smaller than MIN_SAFE_INTEGER ) the parseIntNoBigCheck result might be + // different from what you would get from Number(inputNumberAsString) + // String(parseIntNoBigCheck) <> String(Number(inputNumberAsString)) <> inputNumberAsString + parseIntNoBigCheck(len) { + if (len === null) { + return null; + } + let result = 0; + const end = this.offset + len; + let sign = 1; + if (len === 0) { + return 0; + } + if (this.buffer[this.offset] === minus) { + this.offset++; + sign = -1; + } + if (this.buffer[this.offset] === plus) { + this.offset++; + } + while (this.offset < end) { + result *= 10; + result += this.buffer[this.offset] - 48; + this.offset++; + } + return result * sign; + } + // adapted from https://github.com/mysqljs/mysql/blob/dc9c152a87ec51a1f647447268917243d2eab1fd/lib/protocol/Parser.js + parseGeometryValue() { + const buffer = this.readLengthCodedBuffer(); + let offset = 4; + if (buffer === null || !buffer.length) { + return null; + } + const bufferLength = buffer.length; + function parseGeometry() { + let x, y, i, j, numPoints, numRings, num, line; + let result = null; + if (offset + 5 > bufferLength) { + return null; + } + const byteOrder = buffer.readUInt8(offset); + offset += 1; + const wkbType = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); + offset += 4; + switch (wkbType) { + case 1: + if (offset + 16 > bufferLength) { + return null; + } + x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + result = { x, y }; + break; + case 2: + if (offset + 4 > bufferLength) { + return null; + } + numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); + offset += 4; + if (numPoints > (bufferLength - offset) / 16) { + return null; + } + result = []; + for (i = numPoints; i > 0; i--) { + if (offset + 16 > bufferLength) { + break; + } + x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + result.push({ x, y }); + } + break; + case 3: + if (offset + 4 > bufferLength) { + return null; + } + numRings = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); + offset += 4; + if (numRings > (bufferLength - offset) / 4) { + return null; + } + result = []; + for (i = numRings; i > 0; i--) { + if (offset + 4 > bufferLength) { + break; + } + numPoints = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); + offset += 4; + line = []; + for (j = numPoints; j > 0; j--) { + if (offset + 16 > bufferLength) { + break; + } + x = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + y = byteOrder ? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); + offset += 8; + line.push({ x, y }); + } + result.push(line); + } + break; + case 4: + // WKBMultiPoint + case 5: + // WKBMultiLineString + case 6: + // WKBMultiPolygon + case 7: + if (offset + 4 > bufferLength) { + return null; + } + num = byteOrder ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); + offset += 4; + if (num > (bufferLength - offset) / 9) { + return null; + } + result = []; + for (i = num; i > 0; i--) { + result.push(parseGeometry()); + } + break; + } + return result; + } + return parseGeometry(); + } + parseVector() { + const bufLen = this.readLengthCodedNumber(); + const vectorEnd = this.offset + bufLen; + const result = []; + while (this.offset < vectorEnd && this.offset < this.end) { + result.push(this.readFloat()); + } + return result; + } + // With supportBigNumbers, unsafe integers become exact strings, + // mirroring the option's behaviour for BIGINT columns + parseJson(encoding, supportBigNumbers) { + const str = this.readLengthCodedString(encoding); + if (supportBigNumbers && jsonSourceAccessSupported && str !== null && jsonBigNumeral.test(str)) { + return JSON.parse(str, jsonBigNumberReviver); + } + return JSON.parse(str); + } + parseDate(timezone) { + const strLen = this.readLengthCodedNumber(); + if (strLen === null) { + return null; + } + if (strLen !== 10) { + return /* @__PURE__ */ new Date(NaN); + } + const y = this.parseInt(4); + this.offset++; + const m = this.parseInt(2); + this.offset++; + const d = this.parseInt(2); + if (!timezone || timezone === "local") { + return localDate(y, m, d, 0, 0, 0, 0); + } + if (timezone === "Z") { + return new Date(Date.UTC(y, m - 1, d)); + } + return /* @__PURE__ */ new Date( + `${leftPad(4, y)}-${leftPad(2, m)}-${leftPad(2, d)}T00:00:00${timezone}` + ); + } + parseDateTime(timezone) { + const len = this.readLengthCodedNumber(); + if (len === null) { + return null; + } + const b = this.buffer; + const s = this.offset; + if (len >= 19 && b[s + 4] === minus && b[s + 7] === minus && b[s + 13] === colon && b[s + 16] === colon) { + const y = (b[s] - 48) * 1e3 + (b[s + 1] - 48) * 100 + (b[s + 2] - 48) * 10 + (b[s + 3] - 48); + const mo = (b[s + 5] - 48) * 10 + (b[s + 6] - 48); + const d = (b[s + 8] - 48) * 10 + (b[s + 9] - 48); + if (mo === 0 || d === 0 || mo > 12 || d > 31) { + this.offset += len; + return /* @__PURE__ */ new Date(NaN); + } + if (y < 100) { + const str2 = StringParser.decode(b, "binary", s, s + len); + this.offset += len; + return !timezone || timezone === "local" ? new Date(str2) : /* @__PURE__ */ new Date(`${str2}${timezone}`); + } + const h = (b[s + 11] - 48) * 10 + (b[s + 12] - 48); + const mi = (b[s + 14] - 48) * 10 + (b[s + 15] - 48); + const se = (b[s + 17] - 48) * 10 + (b[s + 18] - 48); + let ms = 0; + if (len > 20) { + let scale = 100; + for (let i = s + 20; i < s + len && scale >= 1; i++) { + ms += (b[i] - 48) * scale; + scale /= 10; + } + } + this.offset += len; + if (!timezone || timezone === "local") { + return localDate(y, mo, d, h, mi, se, ms); + } + const utc = Date.UTC(y, mo - 1, d, h, mi, se, ms); + if (timezone === "Z") { + return new Date(utc); + } + const offsetMinutes = timezoneOffsetMinutes(timezone); + if (offsetMinutes !== null) { + return new Date(utc - offsetMinutes * 6e4); + } + return /* @__PURE__ */ new Date( + `${StringParser.decode(b, "binary", s, s + len)}${timezone}` + ); + } + const str = StringParser.decode(b, "binary", s, s + len); + this.offset += len; + if (!timezone || timezone === "local") { + return new Date(str); + } + return /* @__PURE__ */ new Date(`${str}${timezone}`); + } + parseFloat(len) { + if (len === null) { + return null; + } + if (len === 0) { + return 0; + } + if (len > 17) { + const str = this.buffer.toString("utf8", this.offset, this.offset + len); + this.offset += len; + return Number.parseFloat(str); + } + let result = 0; + const end = this.offset + len; + let factor = 1; + let pastDot = false; + let charCode = 0; + if (this.buffer[this.offset] === minus) { + this.offset++; + factor = -1; + } + if (this.buffer[this.offset] === plus) { + this.offset++; + } + while (this.offset < end) { + charCode = this.buffer[this.offset]; + if (charCode === dot) { + pastDot = true; + this.offset++; + } else if (charCode === exponent || charCode === exponentCapital) { + const start = end - len; + const str = this.buffer.toString("utf8", start, end); + this.offset = end; + return Number.parseFloat(str); + } else { + result *= 10; + result += this.buffer[this.offset] - 48; + this.offset++; + if (pastDot) { + factor = factor * 10; + } + } + } + return result / factor; + } + parseLengthCodedIntNoBigCheck() { + return this.parseIntNoBigCheck(this.readLengthCodedNumber()); + } + parseLengthCodedInt(supportBigNumbers) { + return this.parseInt(this.readLengthCodedNumber(), supportBigNumbers); + } + parseLengthCodedIntString() { + return this.readLengthCodedString("binary"); + } + parseLengthCodedFloat() { + return this.parseFloat(this.readLengthCodedNumber()); + } + peekByte() { + return this.buffer[this.offset]; + } + // OxFE is often used as "Alt" flag - not ok, not error. + // For example, it's first byte of AuthSwitchRequest + isAlt() { + return this.peekByte() === 254; + } + isError() { + return this.peekByte() === 255; + } + asError(encoding) { + this.reset(); + this.readInt8(); + const errorCode = this.readInt16(); + let sqlState = ""; + if (this.buffer[this.offset] === 35) { + this.skip(1); + sqlState = this.readBuffer(5).toString(); + } + const message = this.readString(void 0, encoding); + const err = new Error(message); + err.code = ErrorCodeToName[errorCode]; + err.errno = errorCode; + err.sqlState = sqlState; + err.sqlMessage = message; + return err; + } + writeInt32(n) { + this.buffer.writeUInt32LE(n, this.offset); + this.offset += 4; + } + writeInt24(n) { + this.writeInt8(n & 255); + this.writeInt16(n >> 8); + } + writeInt16(n) { + this.buffer.writeUInt16LE(n, this.offset); + this.offset += 2; + } + writeInt8(n) { + this.buffer.writeUInt8(n, this.offset); + this.offset++; + } + writeDouble(n) { + this.buffer.writeDoubleLE(n, this.offset); + this.offset += 8; + } + writeFloat(n) { + this.buffer.writeFloatLE(n, this.offset); + this.offset += 4; + } + writeUIntLE(n, bytes) { + if (bytes === 8) { + this.buffer.writeBigUInt64LE(n, this.offset); + } else { + this.buffer.writeUIntLE(Number(n), this.offset, bytes); + } + this.offset += bytes; + } + // must match writeTime's choice of encoding byte for byte + static timeLength({ days, hours, minutes, seconds, microseconds }) { + if (!days && !hours && !minutes && !seconds && !microseconds) { + return 1; + } + return microseconds ? 13 : 9; + } + writeTime({ negative, days, hours, minutes, seconds, microseconds }) { + if (!days && !hours && !minutes && !seconds && !microseconds) { + this.writeInt8(0); + return; + } + this.writeInt8(microseconds ? 12 : 8); + this.writeInt8(negative ? 1 : 0); + this.writeInt32(days); + this.writeInt8(hours); + this.writeInt8(minutes); + this.writeInt8(seconds); + if (microseconds) { + this.writeInt32(microseconds); + } + } + writeBuffer(b) { + b.copy(this.buffer, this.offset); + this.offset += b.length; + } + writeNull() { + this.buffer[this.offset] = 251; + this.offset++; + } + // TODO: refactor following three? + writeNullTerminatedString(s, encoding) { + const buf = StringParser.encode(s, encoding); + this.buffer.length && buf.copy(this.buffer, this.offset); + this.offset += buf.length; + this.writeInt8(0); + } + writeString(s, encoding) { + if (s === null) { + this.writeInt8(251); + return; + } + if (s.length === 0) { + return; + } + const buf = StringParser.encode(s, encoding); + this.buffer.length && buf.copy(this.buffer, this.offset); + this.offset += buf.length; + } + writeLengthCodedString(s, encoding) { + const buf = StringParser.encode(s, encoding); + this.writeLengthCodedNumber(buf.length); + this.buffer.length && buf.copy(this.buffer, this.offset); + this.offset += buf.length; + } + // byteLength, when the caller sized the packet, must be + // Buffer.byteLength(string, 'utf8'); only used where + // Buffer.prototype.utf8Write exists + writeLengthCodedUtf8String(string, byteLength) { + if (byteLength === void 0) { + byteLength = Buffer.byteLength(string, "utf8"); + } + this.writeLengthCodedNumber(byteLength); + this.buffer.utf8Write(string, this.offset, byteLength); + this.offset += byteLength; + } + writeLengthCodedBuffer(b) { + this.writeLengthCodedNumber(b.length); + b.copy(this.buffer, this.offset); + this.offset += b.length; + } + writeLengthCodedNumber(n) { + if (n < 251) { + return this.writeInt8(n); + } + if (n < 65535) { + this.writeInt8(252); + return this.writeInt16(n); + } + if (n < 16777215) { + this.writeInt8(253); + return this.writeInt24(n); + } + if (n === null) { + return this.writeInt8(251); + } + this.writeInt8(254); + this.buffer.writeUInt32LE(n >>> 0, this.offset); + this.offset += 4; + this.buffer.writeUInt32LE(Math.floor(n / 4294967296), this.offset); + this.offset += 4; + return this.offset; + } + writeDate(d, timezone) { + this.buffer.writeUInt8(11, this.offset); + if (!timezone || timezone === "local") { + this.buffer.writeUInt16LE(d.getFullYear(), this.offset + 1); + this.buffer.writeUInt8(d.getMonth() + 1, this.offset + 3); + this.buffer.writeUInt8(d.getDate(), this.offset + 4); + this.buffer.writeUInt8(d.getHours(), this.offset + 5); + this.buffer.writeUInt8(d.getMinutes(), this.offset + 6); + this.buffer.writeUInt8(d.getSeconds(), this.offset + 7); + this.buffer.writeUInt32LE(d.getMilliseconds() * 1e3, this.offset + 8); + } else { + if (timezone !== "Z") { + const offset = (timezone[0] === "-" ? -1 : 1) * (parseInt(timezone.substring(1, 3), 10) * 60 + parseInt(timezone.substring(4), 10)); + if (offset !== 0) { + d = new Date(d.getTime() + 6e4 * offset); + } + } + this.buffer.writeUInt16LE(d.getUTCFullYear(), this.offset + 1); + this.buffer.writeUInt8(d.getUTCMonth() + 1, this.offset + 3); + this.buffer.writeUInt8(d.getUTCDate(), this.offset + 4); + this.buffer.writeUInt8(d.getUTCHours(), this.offset + 5); + this.buffer.writeUInt8(d.getUTCMinutes(), this.offset + 6); + this.buffer.writeUInt8(d.getUTCSeconds(), this.offset + 7); + this.buffer.writeUInt32LE(d.getUTCMilliseconds() * 1e3, this.offset + 8); + } + this.offset += 12; + } + writeHeader(sequenceId) { + const offset = this.offset; + this.offset = 0; + this.writeInt24(this.buffer.length - 4); + this.writeInt8(sequenceId); + this.offset = offset; + } + clone() { + return new _Packet(this.sequenceId, this.buffer, this.start, this.end); + } + type() { + if (this.isEOF()) { + return "EOF"; + } + if (this.isError()) { + return "Error"; + } + if (this.buffer[this.offset] === 0) { + return "maybeOK"; + } + return ""; + } + static lengthCodedNumberLength(n) { + if (n < 251) { + return 1; + } + if (n < 65535) { + return 3; + } + if (n < 16777215) { + return 4; + } + return 9; + } + static lengthCodedStringLength(str, encoding) { + const buf = StringParser.encode(str, encoding); + const slen = buf.length; + return _Packet.lengthCodedNumberLength(slen) + slen; + } + static MockBuffer() { + if (_Packet._mockBuffer) { + return _Packet._mockBuffer; + } + const noop = function() { + }; + const res = Buffer.alloc(0); + for (const op in NativeBuffer.prototype) { + if (typeof res[op] === "function") { + res[op] = noop; + } + } + _Packet._mockBuffer = res; + return res; + } + }; + module2.exports = Packet; + } +}); + +// node_modules/mysql2/lib/packet_parser.js +var require_packet_parser = __commonJS({ + "node_modules/mysql2/lib/packet_parser.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var MAX_PACKET_LENGTH = 16777215; + function readPacketLength(b, off) { + const b0 = b[off]; + const b1 = b[off + 1]; + const b2 = b[off + 2]; + if (b1 + b2 === 0) { + return b0; + } + return b0 + (b1 << 8) + (b2 << 16); + } + var PacketParser = class _PacketParser { + constructor(onPacket, packetHeaderLength) { + if (typeof packetHeaderLength === "undefined") { + packetHeaderLength = 4; + } + this.buffer = []; + this.bufferLength = 0; + this.packetHeaderLength = packetHeaderLength; + this.headerLen = 0; + this.length = 0; + this.largePacketParts = []; + this.firstPacketSequenceId = 0; + this.onPacket = onPacket; + this._reusablePacket = new Packet(0, Buffer.allocUnsafe(4), 0, 4); + this.execute = _PacketParser.prototype.executeStart; + this._flushLargePacket = packetHeaderLength === 7 ? this._flushLargePacket7 : this._flushLargePacket4; + } + _flushLargePacket4() { + const numPackets = this.largePacketParts.length; + this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0])); + const body = Buffer.concat(this.largePacketParts); + const packet = new Packet(this.firstPacketSequenceId, body, 0, body.length); + this.largePacketParts.length = 0; + packet.numPackets = numPackets; + this.onPacket(packet); + } + _flushLargePacket7() { + const numPackets = this.largePacketParts.length; + this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0, 0, 0, 0])); + const body = Buffer.concat(this.largePacketParts); + this.largePacketParts.length = 0; + const packet = new Packet(this.firstPacketSequenceId, body, 0, body.length); + packet.numPackets = numPackets; + this.onPacket(packet); + } + executeStart(chunk) { + let start = 0; + const end = chunk.length; + while (end - start >= 3) { + this.length = readPacketLength(chunk, start); + if (end - start >= this.length + this.packetHeaderLength) { + const sequenceId = chunk[start + 3]; + if (this.length < MAX_PACKET_LENGTH && this.largePacketParts.length === 0) { + const packet = this._reusablePacket; + packet.sequenceId = sequenceId; + packet.numPackets = 1; + packet.buffer = chunk; + packet.start = start; + packet.offset = start + 4; + packet.end = start + this.packetHeaderLength + this.length; + this.onPacket(packet); + } else { + if (this.largePacketParts.length === 0) { + this.firstPacketSequenceId = sequenceId; + } + this.largePacketParts.push( + chunk.slice( + start + this.packetHeaderLength, + start + this.packetHeaderLength + this.length + ) + ); + if (this.length < MAX_PACKET_LENGTH) { + this._flushLargePacket(); + } + } + start += this.packetHeaderLength + this.length; + } else { + this.buffer = [chunk.slice(start + 3, end)]; + this.bufferLength = end - start - 3; + this.execute = _PacketParser.prototype.executePayload; + return; + } + } + if (end - start > 0) { + this.headerLen = end - start; + this.length = chunk[start]; + if (this.headerLen === 2) { + this.length = chunk[start] + (chunk[start + 1] << 8); + this.execute = _PacketParser.prototype.executeHeader3; + } else { + this.execute = _PacketParser.prototype.executeHeader2; + } + } + } + executePayload(chunk) { + let start = 0; + const end = chunk.length; + const remainingPayload = this.length - this.bufferLength + this.packetHeaderLength - 3; + if (end - start >= remainingPayload) { + const payload = Buffer.allocUnsafe(this.length + this.packetHeaderLength); + let offset = 3; + for (let i = 0; i < this.buffer.length; ++i) { + this.buffer[i].copy(payload, offset); + offset += this.buffer[i].length; + } + chunk.copy(payload, offset, start, start + remainingPayload); + const sequenceId = payload[3]; + if (this.length < MAX_PACKET_LENGTH && this.largePacketParts.length === 0) { + const packet = this._reusablePacket; + packet.sequenceId = sequenceId; + packet.numPackets = 1; + packet.buffer = payload; + packet.start = 0; + packet.offset = 4; + packet.end = this.length + this.packetHeaderLength; + this.onPacket(packet); + } else { + if (this.largePacketParts.length === 0) { + this.firstPacketSequenceId = sequenceId; + } + this.largePacketParts.push( + payload.slice( + this.packetHeaderLength, + this.packetHeaderLength + this.length + ) + ); + if (this.length < MAX_PACKET_LENGTH) { + this._flushLargePacket(); + } + } + this.buffer = []; + this.bufferLength = 0; + this.execute = _PacketParser.prototype.executeStart; + start += remainingPayload; + if (end - start > 0) { + return this.execute(chunk.slice(start, end)); + } + } else { + this.buffer.push(chunk); + this.bufferLength += chunk.length; + } + return null; + } + executeHeader2(chunk) { + this.length += chunk[0] << 8; + if (chunk.length > 1) { + this.length += chunk[1] << 16; + this.execute = _PacketParser.prototype.executePayload; + return this.executePayload(chunk.slice(2)); + } + this.execute = _PacketParser.prototype.executeHeader3; + return null; + } + executeHeader3(chunk) { + this.length += chunk[0] << 16; + this.execute = _PacketParser.prototype.executePayload; + return this.executePayload(chunk.slice(1)); + } + }; + module2.exports = PacketParser; + } +}); + +// node_modules/mysql2/lib/packets/auth_next_factor.js +var require_auth_next_factor = __commonJS({ + "node_modules/mysql2/lib/packets/auth_next_factor.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var AuthNextFactor = class _AuthNextFactor { + constructor(opts) { + this.pluginName = opts.pluginName; + this.pluginData = opts.pluginData; + } + toPacket(encoding) { + const length = 6 + this.pluginName.length + this.pluginData.length; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(2); + packet.writeNullTerminatedString(this.pluginName, encoding); + packet.writeBuffer(this.pluginData); + return packet; + } + static fromPacket(packet, encoding) { + packet.readInt8(); + const name = packet.readNullTerminatedString(encoding); + const data = packet.readBuffer(); + return new _AuthNextFactor({ + pluginName: name, + pluginData: data + }); + } + }; + module2.exports = AuthNextFactor; + } +}); + +// node_modules/mysql2/lib/packets/auth_switch_request.js +var require_auth_switch_request = __commonJS({ + "node_modules/mysql2/lib/packets/auth_switch_request.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var AuthSwitchRequest = class _AuthSwitchRequest { + constructor(opts) { + this.pluginName = opts.pluginName; + this.pluginData = opts.pluginData; + } + toPacket() { + const length = 6 + this.pluginName.length + this.pluginData.length; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(254); + packet.writeNullTerminatedString(this.pluginName, "cesu8"); + packet.writeBuffer(this.pluginData); + return packet; + } + static fromPacket(packet) { + packet.readInt8(); + const name = packet.readNullTerminatedString("cesu8"); + const data = packet.readBuffer(); + return new _AuthSwitchRequest({ + pluginName: name, + pluginData: data + }); + } + }; + module2.exports = AuthSwitchRequest; + } +}); + +// node_modules/mysql2/lib/packets/auth_switch_request_more_data.js +var require_auth_switch_request_more_data = __commonJS({ + "node_modules/mysql2/lib/packets/auth_switch_request_more_data.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var AuthSwitchRequestMoreData = class _AuthSwitchRequestMoreData { + constructor(data) { + this.data = data; + } + toPacket() { + const length = 5 + this.data.length; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(1); + packet.writeBuffer(this.data); + return packet; + } + static fromPacket(packet) { + packet.readInt8(); + const data = packet.readBuffer(); + return new _AuthSwitchRequestMoreData(data); + } + static verifyMarker(packet) { + return packet.peekByte() === 1; + } + }; + module2.exports = AuthSwitchRequestMoreData; + } +}); + +// node_modules/mysql2/lib/packets/auth_switch_response.js +var require_auth_switch_response = __commonJS({ + "node_modules/mysql2/lib/packets/auth_switch_response.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var AuthSwitchResponse = class _AuthSwitchResponse { + constructor(data) { + if (!Buffer.isBuffer(data)) { + data = Buffer.from(data); + } + this.data = data; + } + toPacket() { + const length = 4 + this.data.length; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeBuffer(this.data); + return packet; + } + static fromPacket(packet) { + const data = packet.readBuffer(); + return new _AuthSwitchResponse(data); + } + }; + module2.exports = AuthSwitchResponse; + } +}); + +// node_modules/mysql2/lib/packets/binary_row.js +var require_binary_row = __commonJS({ + "node_modules/mysql2/lib/packets/binary_row.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var Packet = require_packet(); + var binaryReader = new Array(256); + var BinaryRow = class _BinaryRow { + constructor(columns) { + this.columns = columns || []; + } + static toPacket(columns, encoding) { + const sequenceId = 0; + let length = 0; + columns.forEach((val) => { + if (val === null || typeof val === "undefined") { + ++length; + return; + } + length += Packet.lengthCodedStringLength(val.toString(10), encoding); + }); + length = length + 2; + const buffer = Buffer.allocUnsafe(length + 4); + const packet = new Packet(sequenceId, buffer, 0, length + 4); + packet.offset = 4; + packet.writeInt8(0); + let bitmap = 0; + let bitValue = 1; + columns.forEach((parameter) => { + if (parameter.type === Types.NULL) { + bitmap += bitValue; + } + bitValue *= 2; + if (bitValue === 256) { + packet.writeInt8(bitmap); + bitmap = 0; + bitValue = 1; + } + }); + if (bitValue !== 1) { + packet.writeInt8(bitmap); + } + columns.forEach((val) => { + if (val === null) { + packet.writeNull(); + return; + } + if (typeof val === "undefined") { + packet.writeInt8(0); + return; + } + packet.writeLengthCodedString(val.toString(10), encoding); + }); + return packet; + } + // TODO: complete list of types... + static fromPacket(fields, packet) { + const columns = new Array(fields.length); + packet.readInt8(); + const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8); + packet.skip(nullBitmapLength); + for (let i = 0; i < columns.length; ++i) { + columns[i] = binaryReader[fields[i].columnType].apply(packet); + } + return new _BinaryRow(columns); + } + }; + binaryReader[Types.DECIMAL] = Packet.prototype.readLengthCodedString; + binaryReader[1] = Packet.prototype.readInt8; + binaryReader[2] = Packet.prototype.readInt16; + binaryReader[3] = Packet.prototype.readInt32; + binaryReader[4] = Packet.prototype.readFloat; + binaryReader[5] = Packet.prototype.readDouble; + binaryReader[6] = Packet.prototype.assertInvalid; + binaryReader[7] = Packet.prototype.readTimestamp; + binaryReader[8] = Packet.prototype.readInt64; + binaryReader[9] = Packet.prototype.readInt32; + binaryReader[10] = Packet.prototype.readTimestamp; + binaryReader[11] = Packet.prototype.readTime; + binaryReader[12] = Packet.prototype.readDateTime; + binaryReader[13] = Packet.prototype.readInt16; + binaryReader[Types.VAR_STRING] = Packet.prototype.readLengthCodedString; + module2.exports = BinaryRow; + } +}); + +// node_modules/mysql2/lib/constants/commands.js +var require_commands = __commonJS({ + "node_modules/mysql2/lib/constants/commands.js"(exports2, module2) { + "use strict"; + module2.exports = { + SLEEP: 0, + // deprecated + QUIT: 1, + INIT_DB: 2, + QUERY: 3, + FIELD_LIST: 4, + CREATE_DB: 5, + DROP_DB: 6, + REFRESH: 7, + SHUTDOWN: 8, + STATISTICS: 9, + PROCESS_INFO: 10, + // deprecated + CONNECT: 11, + // deprecated + PROCESS_KILL: 12, + DEBUG: 13, + PING: 14, + TIME: 15, + // deprecated + DELAYED_INSERT: 16, + // deprecated + CHANGE_USER: 17, + BINLOG_DUMP: 18, + TABLE_DUMP: 19, + CONNECT_OUT: 20, + REGISTER_SLAVE: 21, + STMT_PREPARE: 22, + STMT_EXECUTE: 23, + STMT_SEND_LONG_DATA: 24, + STMT_CLOSE: 25, + STMT_RESET: 26, + SET_OPTION: 27, + STMT_FETCH: 28, + DAEMON: 29, + // deprecated + BINLOG_DUMP_GTID: 30, + RESET_CONNECTION: 31, + // introduced in 5.7.3 + UNKNOWN: 255 + // bad! + }; + } +}); + +// node_modules/mysql2/lib/packets/binlog_dump.js +var require_binlog_dump = __commonJS({ + "node_modules/mysql2/lib/packets/binlog_dump.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCodes = require_commands(); + var BinlogDump = class { + constructor(opts) { + this.binlogPos = opts.binlogPos || 0; + this.serverId = opts.serverId || 0; + this.flags = opts.flags || 0; + this.filename = opts.filename || ""; + } + toPacket() { + const length = 15 + Buffer.byteLength(this.filename, "utf8"); + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(CommandCodes.BINLOG_DUMP); + packet.writeInt32(this.binlogPos); + packet.writeInt16(this.flags); + packet.writeInt32(this.serverId); + packet.writeString(this.filename); + return packet; + } + }; + module2.exports = BinlogDump; + } +}); + +// node_modules/mysql2/lib/constants/client.js +var require_client = __commonJS({ + "node_modules/mysql2/lib/constants/client.js"(exports2) { + "use strict"; + exports2.LONG_PASSWORD = 1; + exports2.FOUND_ROWS = 2; + exports2.LONG_FLAG = 4; + exports2.CONNECT_WITH_DB = 8; + exports2.NO_SCHEMA = 16; + exports2.COMPRESS = 32; + exports2.ODBC = 64; + exports2.LOCAL_FILES = 128; + exports2.IGNORE_SPACE = 256; + exports2.PROTOCOL_41 = 512; + exports2.INTERACTIVE = 1024; + exports2.SSL = 2048; + exports2.IGNORE_SIGPIPE = 4096; + exports2.TRANSACTIONS = 8192; + exports2.RESERVED = 16384; + exports2.SECURE_CONNECTION = 32768; + exports2.MULTI_STATEMENTS = 65536; + exports2.MULTI_RESULTS = 131072; + exports2.PS_MULTI_RESULTS = 262144; + exports2.PLUGIN_AUTH = 524288; + exports2.CONNECT_ATTRS = 1048576; + exports2.PLUGIN_AUTH_LENENC_CLIENT_DATA = 2097152; + exports2.CAN_HANDLE_EXPIRED_PASSWORDS = 4194304; + exports2.SESSION_TRACK = 8388608; + exports2.CLIENT_QUERY_ATTRIBUTES = 134217728; + exports2.SSL_VERIFY_SERVER_CERT = 1073741824; + exports2.REMEMBER_OPTIONS = 2147483648; + exports2.MULTI_FACTOR_AUTHENTICATION = 268435456; + } +}); + +// node_modules/mysql2/lib/auth_41.js +var require_auth_41 = __commonJS({ + "node_modules/mysql2/lib/auth_41.js"(exports2) { + "use strict"; + var crypto = require("crypto"); + function sha1(msg, msg1, msg2) { + const hash = crypto.createHash("sha1"); + hash.update(msg); + if (msg1) { + hash.update(msg1); + } + if (msg2) { + hash.update(msg2); + } + return hash.digest(); + } + function xor(a, b) { + const result = Buffer.allocUnsafe(a.length); + for (let i = 0; i < a.length; i++) { + result[i] = a[i] ^ b[i]; + } + return result; + } + exports2.xor = xor; + function token(password, scramble1, scramble2) { + if (!password) { + return Buffer.alloc(0); + } + const stage1 = sha1(password); + return exports2.calculateTokenFromPasswordSha(stage1, scramble1, scramble2); + } + exports2.calculateTokenFromPasswordSha = function(passwordSha, scramble1, scramble2) { + const authPluginData1 = scramble1.slice(0, 8); + const authPluginData2 = scramble2.slice(0, 12); + const stage2 = sha1(passwordSha); + const stage3 = sha1(authPluginData1, authPluginData2, stage2); + return xor(stage3, passwordSha); + }; + exports2.calculateToken = token; + exports2.verifyToken = function(publicSeed1, publicSeed2, token2, doubleSha) { + const hashStage1 = xor(token2, sha1(publicSeed1, publicSeed2, doubleSha)); + const candidateHash2 = sha1(hashStage1); + return candidateHash2.compare(doubleSha) === 0; + }; + exports2.doubleSha1 = function(password) { + return sha1(sha1(password)); + }; + function xorRotating(a, seed) { + const result = Buffer.allocUnsafe(a.length); + const seedLen = seed.length; + for (let i = 0; i < a.length; i++) { + result[i] = a[i] ^ seed[i % seedLen]; + } + return result; + } + exports2.xorRotating = xorRotating; + } +}); + +// node_modules/mysql2/lib/constants/charset_encodings.js +var require_charset_encodings = __commonJS({ + "node_modules/mysql2/lib/constants/charset_encodings.js"(exports2, module2) { + "use strict"; + var encodings = [ + "utf8", + "big5", + "latin2", + "dec8", + "cp850", + "latin1", + "hp8", + "koi8r", + "latin1", + "latin2", + "swe7", + "ascii", + "eucjp", + "sjis", + "cp1251", + "latin1", + "hebrew", + "utf8", + "tis620", + "euckr", + "latin7", + "latin2", + "koi8u", + "cp1251", + "gb2312", + "greek", + "cp1250", + "latin2", + "gbk", + "cp1257", + "latin5", + "latin1", + "armscii8", + "cesu8", + "cp1250", + "ucs2", + "cp866", + "keybcs2", + "macintosh", + "macroman", + "cp852", + "latin7", + "latin7", + "macintosh", + "cp1250", + "utf8", + "utf8", + "latin1", + "latin1", + "latin1", + "cp1251", + "cp1251", + "cp1251", + "macroman", + "utf16", + "utf16", + "utf16-le", + "cp1256", + "cp1257", + "cp1257", + "utf32", + "utf32", + "utf16-le", + "binary", + "armscii8", + "ascii", + "cp1250", + "cp1256", + "cp866", + "dec8", + "greek", + "hebrew", + "hp8", + "keybcs2", + "koi8r", + "koi8u", + "cesu8", + "latin2", + "latin5", + "latin7", + "cp850", + "cp852", + "swe7", + "cesu8", + "big5", + "euckr", + "gb2312", + "gbk", + "sjis", + "tis620", + "ucs2", + "eucjp", + "geostd8", + "geostd8", + "latin1", + "cp932", + "cp932", + "eucjpms", + "eucjpms", + "cp1250", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf16", + "utf8", + "utf8", + "utf8", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "ucs2", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "ucs2", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf32", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "cesu8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "cesu8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "gb18030", + "gb18030", + "gb18030", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8", + "utf8" + ]; + var padSpaceLength = encodings.length; + for (let id = 1025; id < 1024 + padSpaceLength; id++) { + encodings[id] = encodings[id - 1024]; + } + var uca1400Blocks = [ + [2048, "cesu8"], + // utf8mb3 + [2304, "utf8"], + // utf8mb4 + [2560, "ucs2"], + // ucs2 + [2816, "utf16"], + // utf16 + [3072, "utf32"] + // utf32 + ]; + for (const [start, encoding] of uca1400Blocks) { + for (let id = start; id < start + 256; id++) { + encodings[id] = encoding; + } + } + module2.exports = encodings; + } +}); + +// node_modules/mysql2/lib/packets/change_user.js +var require_change_user = __commonJS({ + "node_modules/mysql2/lib/packets/change_user.js"(exports2, module2) { + "use strict"; + var CommandCode = require_commands(); + var ClientConstants = require_client(); + var Packet = require_packet(); + var auth41 = require_auth_41(); + var CharsetToEncoding = require_charset_encodings(); + var ChangeUser = class { + constructor(opts) { + this.flags = opts.flags; + this.user = opts.user || ""; + this.database = opts.database || ""; + this.password = opts.password || ""; + this.passwordSha1 = opts.passwordSha1; + this.authPluginData1 = opts.authPluginData1; + this.authPluginData2 = opts.authPluginData2; + this.connectAttributes = opts.connectAttributes || {}; + let authToken; + if (this.passwordSha1) { + authToken = auth41.calculateTokenFromPasswordSha( + this.passwordSha1, + this.authPluginData1, + this.authPluginData2 + ); + } else { + authToken = auth41.calculateToken( + this.password, + this.authPluginData1, + this.authPluginData2 + ); + } + this.authToken = authToken; + this.charsetNumber = opts.charsetNumber; + } + // TODO + // ChangeUser.fromPacket = function(packet) + // }; + serializeToBuffer(buffer) { + const isSet = (flag) => this.flags & ClientConstants[flag]; + const packet = new Packet(0, buffer, 0, buffer.length); + packet.offset = 4; + const encoding = CharsetToEncoding[this.charsetNumber]; + packet.writeInt8(CommandCode.CHANGE_USER); + packet.writeNullTerminatedString(this.user, encoding); + if (isSet("SECURE_CONNECTION")) { + packet.writeInt8(this.authToken.length); + packet.writeBuffer(this.authToken); + } else { + packet.writeBuffer(this.authToken); + packet.writeInt8(0); + } + packet.writeNullTerminatedString(this.database, encoding); + packet.writeInt16(this.charsetNumber); + if (isSet("PLUGIN_AUTH")) { + packet.writeNullTerminatedString("mysql_native_password", "latin1"); + } + if (isSet("CONNECT_ATTRS")) { + const connectAttributes = this.connectAttributes; + const attrNames = Object.keys(connectAttributes); + let keysLength = 0; + for (let k = 0; k < attrNames.length; ++k) { + keysLength += Packet.lengthCodedStringLength(attrNames[k], encoding); + keysLength += Packet.lengthCodedStringLength( + connectAttributes[attrNames[k]], + encoding + ); + } + packet.writeLengthCodedNumber(keysLength); + for (let k = 0; k < attrNames.length; ++k) { + packet.writeLengthCodedString(attrNames[k], encoding); + packet.writeLengthCodedString( + connectAttributes[attrNames[k]], + encoding + ); + } + } + return packet; + } + toPacket() { + if (typeof this.user !== "string") { + throw new Error('"user" connection config property must be a string'); + } + if (typeof this.database !== "string") { + throw new Error('"database" connection config property must be a string'); + } + const p = this.serializeToBuffer(Packet.MockBuffer()); + return this.serializeToBuffer(Buffer.allocUnsafe(p.offset)); + } + }; + module2.exports = ChangeUser; + } +}); + +// node_modules/mysql2/lib/packets/close_statement.js +var require_close_statement = __commonJS({ + "node_modules/mysql2/lib/packets/close_statement.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCodes = require_commands(); + var CloseStatement = class { + constructor(id) { + this.id = id; + } + // note: no response sent back + toPacket() { + const packet = new Packet(0, Buffer.allocUnsafe(9), 0, 9); + packet.offset = 4; + packet.writeInt8(CommandCodes.STMT_CLOSE); + packet.writeInt32(this.id); + return packet; + } + }; + module2.exports = CloseStatement; + } +}); + +// node_modules/mysql2/lib/constants/field_flags.js +var require_field_flags = __commonJS({ + "node_modules/mysql2/lib/constants/field_flags.js"(exports2) { + "use strict"; + exports2.NOT_NULL = 1; + exports2.PRI_KEY = 2; + exports2.UNIQUE_KEY = 4; + exports2.MULTIPLE_KEY = 8; + exports2.BLOB = 16; + exports2.UNSIGNED = 32; + exports2.ZEROFILL = 64; + exports2.BINARY = 128; + exports2.ENUM = 256; + exports2.AUTO_INCREMENT = 512; + exports2.TIMESTAMP = 1024; + exports2.SET = 2048; + exports2.NO_DEFAULT_VALUE = 4096; + exports2.ON_UPDATE_NOW = 8192; + exports2.NUM = 32768; + } +}); + +// node_modules/mysql2/lib/packets/column_definition.js +var require_column_definition = __commonJS({ + "node_modules/mysql2/lib/packets/column_definition.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var StringParser = require_string(); + var CharsetToEncoding = require_charset_encodings(); + var fields = ["catalog", "schema", "table", "orgTable", "name", "orgName"]; + var ColumnDefinition = class { + constructor(packet, clientEncoding, mariadbExtendedMetadata) { + this._buf = packet.buffer; + this._clientEncoding = clientEncoding; + this._catalogLength = packet.readLengthCodedNumber(); + this._catalogStart = packet.offset; + packet.offset += this._catalogLength; + this._schemaLength = packet.readLengthCodedNumber(); + this._schemaStart = packet.offset; + packet.offset += this._schemaLength; + this._tableLength = packet.readLengthCodedNumber(); + this._tableStart = packet.offset; + packet.offset += this._tableLength; + this._orgTableLength = packet.readLengthCodedNumber(); + this._orgTableStart = packet.offset; + packet.offset += this._orgTableLength; + const _nameLength = packet.readLengthCodedNumber(); + const _nameStart = packet.offset; + packet.offset += _nameLength; + this._orgNameLength = packet.readLengthCodedNumber(); + this._orgNameStart = packet.offset; + packet.offset += this._orgNameLength; + if (mariadbExtendedMetadata) { + this._parseMariadbExtendedMetadata(packet); + } + packet.skip(1); + this.characterSet = packet.readInt16(); + this.encoding = CharsetToEncoding[this.characterSet]; + this.name = StringParser.decodeShort( + this._buf, + this.encoding === "binary" ? this._clientEncoding : this.encoding, + _nameStart, + _nameStart + _nameLength + ); + this.columnLength = packet.readInt32(); + this.columnType = packet.readInt8(); + this.type = this.columnType; + this.flags = packet.readInt16(); + this.decimals = packet.readInt8(); + } + _parseMariadbExtendedMetadata(packet) { + const extendedMetadataLength = packet.readLengthCodedNumber() || 0; + const extendedMetadataEnd = Math.min( + packet.offset + extendedMetadataLength, + packet.end + ); + while (packet.offset < extendedMetadataEnd) { + const id = packet.readInt8(); + const value = packet.readLengthCodedString("ascii"); + if (id === 0) { + this.extendedTypeName = value; + } else if (id === 1) { + this.extendedFormat = value; + } + } + packet.offset = extendedMetadataEnd; + } + inspect() { + return { + catalog: this.catalog, + schema: this.schema, + name: this.name, + orgName: this.orgName, + table: this.table, + orgTable: this.orgTable, + characterSet: this.characterSet, + encoding: this.encoding, + columnLength: this.columnLength, + type: this.columnType, + flags: this.flags, + decimals: this.decimals + }; + } + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](depth, inspectOptions, inspect) { + const Types = require_types(); + const typeNames = []; + for (const t in Types) { + typeNames[Types[t]] = t; + } + const fiedFlags = require_field_flags(); + const flagNames = []; + const inspectFlags = this.flags; + for (const f in fiedFlags) { + if (inspectFlags & fiedFlags[f]) { + if (f === "PRI_KEY") { + flagNames.push("PRIMARY KEY"); + } else if (f === "NOT_NULL") { + flagNames.push("NOT NULL"); + } else if (f === "BINARY") { + } else if (f === "MULTIPLE_KEY") { + } else if (f === "NO_DEFAULT_VALUE") { + } else if (f === "BLOB") { + } else if (f === "UNSIGNED") { + } else if (f === "TIMESTAMP") { + } else if (f === "ON_UPDATE_NOW") { + flagNames.push("ON UPDATE CURRENT_TIMESTAMP"); + } else { + flagNames.push(f); + } + } + } + if (depth > 1) { + return inspect({ + ...this.inspect(), + typeName: typeNames[this.columnType], + flags: flagNames + }); + } + const isUnsigned = this.flags & fiedFlags.UNSIGNED; + let typeName = typeNames[this.columnType]; + if (typeName === "BLOB") { + if (this.columnLength === 4294967295) { + typeName = "LONGTEXT"; + } else if (this.columnLength === 67108860) { + typeName = "MEDIUMTEXT"; + } else if (this.columnLength === 262140) { + typeName = "TEXT"; + } else if (this.columnLength === 1020) { + typeName = "TINYTEXT"; + } else { + typeName = `BLOB(${this.columnLength})`; + } + } else if (typeName === "VAR_STRING") { + typeName = `VARCHAR(${Math.ceil(this.columnLength / 4)})`; + } else if (typeName === "TINY") { + if (this.columnLength === 3 && isUnsigned || this.columnLength === 4 && !isUnsigned) { + typeName = "TINYINT"; + } else { + typeName = `TINYINT(${this.columnLength})`; + } + } else if (typeName === "LONGLONG") { + if (this.columnLength === 20) { + typeName = "BIGINT"; + } else { + typeName = `BIGINT(${this.columnLength})`; + } + } else if (typeName === "SHORT") { + if (isUnsigned && this.columnLength === 5) { + typeName = "SMALLINT"; + } else if (!isUnsigned && this.columnLength === 6) { + typeName = "SMALLINT"; + } else { + typeName = `SMALLINT(${this.columnLength})`; + } + } else if (typeName === "LONG") { + if (isUnsigned && this.columnLength === 10) { + typeName = "INT"; + } else if (!isUnsigned && this.columnLength === 11) { + typeName = "INT"; + } else { + typeName = `INT(${this.columnLength})`; + } + } else if (typeName === "INT24") { + if (isUnsigned && this.columnLength === 8) { + typeName = "MEDIUMINT"; + } else if (!isUnsigned && this.columnLength === 9) { + typeName = "MEDIUMINT"; + } else { + typeName = `MEDIUMINT(${this.columnLength})`; + } + } else if (typeName === "DOUBLE") { + if (this.columnLength === 22 && this.decimals === 31) { + typeName = "DOUBLE"; + } else { + typeName = `DOUBLE(${this.columnLength},${this.decimals})`; + } + } else if (typeName === "FLOAT") { + if (this.columnLength === 12 && this.decimals === 31) { + typeName = "FLOAT"; + } else { + typeName = `FLOAT(${this.columnLength},${this.decimals})`; + } + } else if (typeName === "NEWDECIMAL") { + if (this.columnLength === 11 && this.decimals === 0) { + typeName = "DECIMAL"; + } else if (this.decimals === 0) { + if (isUnsigned) { + typeName = `DECIMAL(${this.columnLength})`; + } else { + typeName = `DECIMAL(${this.columnLength - 1})`; + } + } else { + typeName = `DECIMAL(${this.columnLength - 2},${this.decimals})`; + } + } else { + typeName = `${typeNames[this.columnType]}(${this.columnLength})`; + } + if (isUnsigned) { + typeName += " UNSIGNED"; + } + return `\`${this.name}\` ${[typeName, ...flagNames].join(" ")}`; + } + static toPacket(column, sequenceId) { + let length = 17; + fields.forEach((field) => { + length += Packet.lengthCodedStringLength( + column[field], + CharsetToEncoding[column.characterSet] + ); + }); + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(sequenceId, buffer, 0, length); + function writeField(name) { + packet.writeLengthCodedString( + column[name], + CharsetToEncoding[column.characterSet] + ); + } + packet.offset = 4; + fields.forEach(writeField); + packet.writeInt8(12); + packet.writeInt16(column.characterSet); + packet.writeInt32(column.columnLength); + packet.writeInt8(column.columnType); + packet.writeInt16(column.flags); + packet.writeInt8(column.decimals); + packet.writeInt16(0); + return packet; + } + // node-mysql compatibility: alias "db" to "schema" + get db() { + return this.schema; + } + }; + var addString = function(name) { + const cacheKey = `_${name}Value`; + const startKey = `_${name}Start`; + const lengthKey = `_${name}Length`; + ColumnDefinition.prototype[cacheKey] = void 0; + Object.defineProperty(ColumnDefinition.prototype, name, { + get: function() { + const cached = this[cacheKey]; + if (cached !== void 0) { + return cached; + } + const start = this[startKey]; + const end = start + this[lengthKey]; + const val = StringParser.decode( + this._buf, + this.encoding === "binary" ? this._clientEncoding : this.encoding, + start, + end + ); + this[cacheKey] = val; + return val; + } + }); + }; + addString("catalog"); + addString("schema"); + addString("table"); + addString("orgTable"); + addString("orgName"); + ColumnDefinition.prototype.extendedTypeName = void 0; + ColumnDefinition.prototype.extendedFormat = void 0; + module2.exports = ColumnDefinition; + } +}); + +// node_modules/mysql2/lib/constants/cursor.js +var require_cursor = __commonJS({ + "node_modules/mysql2/lib/constants/cursor.js"(exports2, module2) { + "use strict"; + module2.exports = { + NO_CURSOR: 0, + READ_ONLY: 1, + FOR_UPDATE: 2, + SCROLLABLE: 3, + PARAMETER_COUNT_AVAILABLE: 8 + }; + } +}); + +// node_modules/mysql2/lib/packets/typed_parameter.js +var require_typed_parameter = __commonJS({ + "node_modules/mysql2/lib/packets/typed_parameter.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var Packet = require_packet(); + var StringParser = require_string(); + var INTEGER_BYTES = { + [Types.TINY]: 1, + [Types.SHORT]: 2, + [Types.YEAR]: 2, + [Types.INT24]: 4, + [Types.LONG]: 4, + [Types.LONGLONG]: 8 + }; + var TEMPORAL = [Types.DATE, Types.DATETIME, Types.TIMESTAMP]; + var WIRE_TYPE = { + [Types.INT24]: Types.LONG, + [Types.YEAR]: Types.SHORT, + [Types.ENUM]: Types.STRING, + [Types.SET]: Types.STRING, + [Types.VECTOR]: Types.BLOB + }; + var HINT_UPGRADABLE = /* @__PURE__ */ new Set([ + Types.TINY, + Types.SHORT, + Types.LONG, + Types.LONGLONG + ]); + var LENGTH_CODED = [ + Types.DECIMAL, + Types.NEWDECIMAL, + Types.VARCHAR, + Types.VAR_STRING, + Types.STRING, + Types.ENUM, + Types.SET, + Types.JSON, + Types.VECTOR, + Types.TINY_BLOB, + Types.MEDIUM_BLOB, + Types.LONG_BLOB, + Types.BLOB + ]; + function writeNothing() { + } + var TIME_PATTERN = /^(-)?(\d+):([0-5]?\d):([0-5]?\d)(?:\.(\d{1,6}))?$/; + var TypedParameter = class { + constructor(type, value, unsigned) { + this.type = type; + this.value = value; + this.unsigned = unsigned; + } + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() { + const name = Types[this.type] || `0x${this.type.toString(16)}`; + return `${name}${this.unsigned ? " UNSIGNED" : ""}(${String(this.value)})`; + } + }; + function toInteger(value, name) { + switch (typeof value) { + case "bigint": + return value; + case "boolean": + return value ? 1n : 0n; + case "number": + if (!Number.isInteger(value)) { + throw new TypeError( + `${name} parameter must be an integer, got ${value}` + ); + } + if (!Number.isSafeInteger(value)) { + throw new RangeError( + `${name} parameter ${value} exceeds Number.MAX_SAFE_INTEGER and has already lost precision; pass a string or BigInt instead` + ); + } + return BigInt(value); + case "string": + try { + return BigInt(value.trim()); + } catch (cause) { + throw new TypeError( + `${name} parameter must be an integer, got ${JSON.stringify(value)}`, + { cause } + ); + } + default: + throw new TypeError( + `${name} parameter must be an integer, got ${typeof value}` + ); + } + } + function checkedInteger(value, type, bytes, unsigned) { + const name = Types[type]; + const bits = BigInt(bytes * 8); + const n = toInteger(value, name); + const min = unsigned ? 0n : -(1n << bits - 1n); + const max = unsigned ? (1n << bits) - 1n : (1n << bits - 1n) - 1n; + if (n < min || n > max) { + throw new RangeError( + `${name}${unsigned ? " UNSIGNED" : ""} parameter out of range: ${n} is not within ${min}..${max}` + ); + } + return n; + } + function integerHint(value, type, unsigned) { + const bytes = INTEGER_BYTES[type]; + if (!bytes || !HINT_UPGRADABLE.has(type)) { + return null; + } + let n; + if (typeof value === "bigint") { + n = value; + } else if (typeof value === "boolean") { + n = value ? 1n : 0n; + } else if (typeof value === "number" && Number.isSafeInteger(value)) { + n = BigInt(value); + } else { + return null; + } + const bits = BigInt(bytes * 8); + const min = unsigned ? 0n : -(1n << bits - 1n); + const max = unsigned ? (1n << bits) - 1n : (1n << bits - 1n) - 1n; + if (n < min || n > max) { + return null; + } + return new TypedParameter(type, n, unsigned); + } + function wireType(type, jsonAsString) { + if (type === Types.JSON && jsonAsString) { + return Types.VAR_STRING; + } + return WIRE_TYPE[type] || type; + } + function integerEncoder(type, bytes) { + return (value, unsigned) => { + const wire = BigInt.asUintN( + bytes * 8, + checkedInteger(value, type, bytes, unsigned) + ); + return { + value: bytes === 8 ? wire : Number(wire), + length: bytes, + writer(v) { + this.writeUIntLE(v, bytes); + } + }; + }; + } + function toDate(value, name) { + const date = value instanceof Date ? value : new Date(value); + if (Number.isNaN(date.getTime())) { + throw new TypeError( + `${name} parameter must be a valid Date, got ${String(value)}` + ); + } + return date; + } + function temporalEncoder(type, timezone) { + const name = Types[type]; + return (value) => ({ + value: toDate(value, name), + length: 12, + writer(v) { + this.writeDate(v, timezone); + } + }); + } + function toTimeParts(value) { + if (typeof value === "number") { + const negative = value < 0; + let rest = Math.abs(value); + const microseconds = Math.round(rest % 1e3 * 1e3); + rest = Math.floor(rest / 1e3); + const seconds = rest % 60; + const minutes = Math.floor(rest / 60) % 60; + const totalHours = Math.floor(rest / 3600); + return { + negative, + days: Math.floor(totalHours / 24), + hours: totalHours % 24, + minutes, + seconds, + microseconds + }; + } + const match = TIME_PATTERN.exec(String(value)); + if (!match) { + throw new TypeError( + `TIME parameter must be 'HH:MM:SS[.ffffff]' or milliseconds, got ${JSON.stringify(String(value))}` + ); + } + const hours = Number(match[2]); + return { + negative: Boolean(match[1]), + days: Math.floor(hours / 24), + hours: hours % 24, + minutes: Number(match[3]), + seconds: Number(match[4]), + microseconds: match[5] ? Number(match[5].padEnd(6, "0")) : 0 + }; + } + function timeEncoder() { + return (value) => { + const parts = toTimeParts(value); + return { + value: parts, + length: Packet.timeLength(parts), + writer(v) { + this.writeTime(v); + } + }; + }; + } + function lengthCodedEncoder(encoding) { + return (value) => { + if (!Buffer.isBuffer(value)) { + const string = typeof value === "string" ? value : String(value); + if (StringParser.hasFastUtf8Write && (encoding === "utf8" || encoding === "utf-8")) { + const byteLength = Buffer.byteLength(string, "utf8"); + return { + value: string, + length: Packet.lengthCodedNumberLength(byteLength) + byteLength, + byteLength, + writer: Packet.prototype.writeLengthCodedUtf8String + }; + } + value = StringParser.encode(string, encoding); + } + return { + value, + length: Packet.lengthCodedNumberLength(value.length) + value.length, + writer: Packet.prototype.writeLengthCodedBuffer + }; + }; + } + function jsonEncoder(encoding) { + const encodeText = lengthCodedEncoder(encoding); + return (value) => encodeText( + typeof value === "string" || Buffer.isBuffer(value) ? value : JSON.stringify(value) + ); + } + function encoderFor(type, encoding, timezone) { + if (INTEGER_BYTES[type]) { + return integerEncoder(type, INTEGER_BYTES[type]); + } + if (type === Types.DOUBLE) { + return (value) => ({ + value: Number(value), + length: 8, + writer: Packet.prototype.writeDouble + }); + } + if (type === Types.FLOAT) { + return (value) => ({ + value: Number(value), + length: 4, + writer: Packet.prototype.writeFloat + }); + } + if (TEMPORAL.includes(type)) { + return temporalEncoder(type, timezone); + } + if (type === Types.TIME) { + return timeEncoder(); + } + if (type === Types.JSON) { + return jsonEncoder(encoding); + } + if (LENGTH_CODED.includes(type)) { + return lengthCodedEncoder(encoding); + } + throw new TypeError( + `No parameter encoder for MySQL type 0x${type.toString(16)}` + ); + } + function encodeTypedParameter(parameter, encoding, timezone, jsonAsString) { + if (parameter.value === null || parameter.type === Types.NULL) { + return { + value: "", + type: wireType(parameter.type, jsonAsString), + length: 0, + writer: writeNothing, + unsigned: parameter.unsigned, + isNull: true + }; + } + const encoded = encoderFor( + parameter.type, + encoding, + timezone + )(parameter.value, parameter.unsigned); + return { + ...encoded, + type: wireType(parameter.type, jsonAsString), + unsigned: parameter.unsigned + }; + } + var ALIASES = { + MEDIUMTEXT: "MEDIUM_BLOB", + LONGTEXT: "LONG_BLOB", + TINYINT: "TINY", + SMALLINT: "SHORT", + MEDIUMINT: "INT24", + INT: "LONG", + INTEGER: "LONG", + BIGINT: "LONGLONG", + REAL: "DOUBLE", + CHAR: "STRING", + VARBINARY: "VAR_STRING", + BINARY: "STRING", + TEXT: "BLOB" + }; + var SUPPORTED = [ + ...Object.keys(INTEGER_BYTES), + Types.FLOAT, + Types.DOUBLE, + Types.TIME, + ...TEMPORAL, + ...LENGTH_CODED + ].map(Number); + var types = /* @__PURE__ */ Object.create(null); + for (const type of SUPPORTED) { + const name = Types[type]; + const bytes = INTEGER_BYTES[type]; + const build = bytes ? (value, unsigned) => new TypedParameter( + type, + value === null ? null : checkedInteger(value, type, bytes, unsigned), + unsigned + ) : (value, unsigned) => new TypedParameter(type, value, unsigned); + const factory = (value) => build(value, false); + if (bytes) { + factory.unsigned = (value) => build(value, true); + } + types[name] = factory; + } + types.NULL = () => new TypedParameter(Types.NULL, null, false); + for (const [alias, target] of Object.entries(ALIASES)) { + if (types[target] && !types[alias]) { + types[alias] = types[target]; + } + } + module2.exports = { + TypedParameter, + encodeTypedParameter, + integerHint, + types + }; + } +}); + +// node_modules/mysql2/lib/packets/encode_parameter.js +var require_encode_parameter = __commonJS({ + "node_modules/mysql2/lib/packets/encode_parameter.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var Packet = require_packet(); + var StringParser = require_string(); + var { + TypedParameter, + encodeTypedParameter, + integerHint + } = require_typed_parameter(); + var FieldFlags = require_field_flags(); + function isJSON(value) { + return Array.isArray(value) || value.constructor === Object || typeof value.toJSON === "function" && !Buffer.isBuffer(value); + } + function toParameter(value, encoding, timezone, jsonAsString, hint) { + if (value instanceof TypedParameter) { + return encodeTypedParameter(value, encoding, timezone, jsonAsString); + } + if (hint) { + const hinted = integerHint( + value, + hint.columnType, + Boolean(hint.flags & FieldFlags.UNSIGNED) + ); + if (hinted) { + return encodeTypedParameter(hinted, encoding, timezone, jsonAsString); + } + } + let type = Types.VAR_STRING; + let length; + let writer = Packet.prototype.writeLengthCodedBuffer; + if (value !== null) { + switch (typeof value) { + case "undefined": + throw new TypeError("Bind parameters must not contain undefined"); + case "number": + type = Types.DOUBLE; + length = 8; + writer = Packet.prototype.writeDouble; + break; + case "boolean": + value = value | 0; + type = Types.TINY; + length = 1; + writer = Packet.prototype.writeInt8; + break; + case "object": + if (Object.prototype.toString.call(value) === "[object Date]") { + type = Types.DATETIME; + length = 12; + writer = function(value2) { + return Packet.prototype.writeDate.call(this, value2, timezone); + }; + } else if (isJSON(value)) { + value = JSON.stringify(value); + if (!jsonAsString) { + type = Types.JSON; + } + } else if (Buffer.isBuffer(value)) { + type = Types.BLOB; + length = Packet.lengthCodedNumberLength(value.length) + value.length; + writer = Packet.prototype.writeLengthCodedBuffer; + } + break; + default: + value = value.toString(); + } + } else { + value = ""; + type = Types.NULL; + length = 0; + writer = writeNothing; + } + let byteLength; + if (length === void 0) { + if (typeof value === "string" && StringParser.hasFastUtf8Write && (encoding === "utf8" || encoding === "utf-8")) { + byteLength = Buffer.byteLength(value, "utf8"); + length = Packet.lengthCodedNumberLength(byteLength) + byteLength; + writer = Packet.prototype.writeLengthCodedUtf8String; + } else { + value = StringParser.encode(value, encoding); + length = Packet.lengthCodedNumberLength(value.length) + value.length; + } + } + return { + value, + type, + length, + byteLength, + writer, + unsigned: false, + isNull: type === Types.NULL + }; + } + function writeNothing() { + } + module2.exports = { toParameter, isJSON }; + } +}); + +// node_modules/mysql2/lib/packets/execute.js +var require_execute = __commonJS({ + "node_modules/mysql2/lib/packets/execute.js"(exports2, module2) { + "use strict"; + var CursorType = require_cursor(); + var CommandCodes = require_commands(); + var ClientConstants = require_client(); + var Types = require_types(); + var Packet = require_packet(); + var StringParser = require_string(); + var CharsetToEncoding = require_charset_encodings(); + var { toParameter } = require_encode_parameter(); + var Execute = class { + constructor(id, parameters, charsetNumber, timezone, attributes, clientFlags, jsonAsString, parameterDefinitions) { + this.id = id; + this.parameters = parameters; + this.encoding = CharsetToEncoding[charsetNumber]; + this.timezone = timezone; + this.attributes = attributes; + this.clientFlags = clientFlags || 0; + this.jsonAsString = jsonAsString || false; + this.parameterDefinitions = parameterDefinitions || []; + } + static fromPacket(packet, encoding) { + const stmtId = packet.readInt32(); + const flags = packet.readInt8(); + const iterationCount = packet.readInt32(); + let i = packet.offset; + while (i < packet.end - 1) { + if ((packet.buffer[i + 1] === Types.VAR_STRING || packet.buffer[i + 1] === Types.BLOB || packet.buffer[i + 1] === Types.NULL || packet.buffer[i + 1] === Types.DOUBLE || packet.buffer[i + 1] === Types.TINY || packet.buffer[i + 1] === Types.DATETIME || packet.buffer[i + 1] === Types.JSON) && packet.buffer[i] === 1 && packet.buffer[i + 2] === 0) { + break; + } else { + packet.readInt8(); + } + i++; + } + const types = []; + for (let i2 = packet.offset + 1; i2 < packet.end - 1; i2++) { + if ((packet.buffer[i2] === Types.VAR_STRING || packet.buffer[i2] === Types.BLOB || packet.buffer[i2] === Types.NULL || packet.buffer[i2] === Types.DOUBLE || packet.buffer[i2] === Types.TINY || packet.buffer[i2] === Types.DATETIME || packet.buffer[i2] === Types.JSON) && packet.buffer[i2 + 1] === 0) { + types.push(packet.buffer[i2]); + packet.skip(2); + } + } + packet.skip(1); + const values = []; + for (let i2 = 0; i2 < types.length; i2++) { + if (types[i2] === Types.VAR_STRING) { + values.push(packet.readLengthCodedString(encoding)); + } else if (types[i2] === Types.BLOB) { + values.push(packet.readLengthCodedBuffer()); + } else if (types[i2] === Types.DOUBLE) { + values.push(packet.readDouble()); + } else if (types[i2] === Types.TINY) { + values.push(packet.readInt8()); + } else if (types[i2] === Types.DATETIME) { + values.push(packet.readDateTime()); + } else if (types[i2] === Types.JSON) { + values.push(JSON.parse(packet.readLengthCodedString(encoding))); + } + if (types[i2] === Types.NULL) { + values.push(null); + } + } + return { stmtId, flags, iterationCount, values }; + } + toPacket() { + const useQueryAttributes = this.clientFlags & ClientConstants.CLIENT_QUERY_ATTRIBUTES; + const attrNames = useQueryAttributes && this.attributes ? Object.keys(this.attributes) : []; + const numParams = this.parameters ? this.parameters.length : 0; + const numAttrs = attrNames.length; + const totalParams = numParams + numAttrs; + let length = 14; + if (useQueryAttributes) { + length += Packet.lengthCodedNumberLength(totalParams); + } + let allParams = null; + let attrNameBuffers = null; + if (totalParams > 0) { + allParams = new Array(totalParams); + for (let i = 0; i < numParams; i++) { + allParams[i] = toParameter( + this.parameters[i], + this.encoding, + this.timezone, + this.jsonAsString, + this.parameterDefinitions[i] + ); + } + for (let i = 0; i < numAttrs; i++) { + allParams[numParams + i] = toParameter( + this.attributes[attrNames[i]], + this.encoding, + this.timezone + ); + } + length += (totalParams + 7 >> 3) + 1 + totalParams * 2; + if (useQueryAttributes) { + length += numParams; + attrNameBuffers = new Array(numAttrs); + for (let i = 0; i < numAttrs; i++) { + const name = StringParser.encode(attrNames[i], this.encoding); + attrNameBuffers[i] = name; + length += Packet.lengthCodedNumberLength(name.length) + name.length; + } + } + for (let i = 0; i < totalParams; i++) { + if (!allParams[i].isNull) { + length += allParams[i].length; + } + } + } + const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length); + packet.offset = 4; + packet.writeInt8(CommandCodes.STMT_EXECUTE); + packet.writeInt32(this.id); + let cursorFlags = CursorType.NO_CURSOR; + if (useQueryAttributes) { + cursorFlags |= CursorType.PARAMETER_COUNT_AVAILABLE; + } + packet.writeInt8(cursorFlags); + packet.writeInt32(1); + if (useQueryAttributes) { + packet.writeLengthCodedNumber(totalParams); + } + if (totalParams > 0) { + let bitmap = 0; + let bitValue = 1; + for (let i = 0; i < totalParams; i++) { + if (allParams[i].isNull) { + bitmap |= bitValue; + } + bitValue *= 2; + if (bitValue === 256) { + packet.writeInt8(bitmap); + bitmap = 0; + bitValue = 1; + } + } + if (bitValue !== 1) { + packet.writeInt8(bitmap); + } + packet.writeInt8(1); + for (let i = 0; i < totalParams; i++) { + const parameter = allParams[i]; + packet.writeInt8(parameter.type); + packet.writeInt8(parameter.unsigned ? 128 : 0); + if (useQueryAttributes) { + if (i < numParams) { + packet.writeInt8(0); + } else { + packet.writeLengthCodedBuffer(attrNameBuffers[i - numParams]); + } + } + } + for (let i = 0; i < totalParams; i++) { + const parameter = allParams[i]; + if (!parameter.isNull) { + parameter.writer.call(packet, parameter.value, parameter.byteLength); + } + } + } + if (packet.offset !== length) { + throw new Error( + `Internal error: COM_STMT_EXECUTE serialized ${packet.offset - 4} bytes, expected ${length - 4}` + ); + } + return packet; + } + }; + module2.exports = Execute; + } +}); + +// node_modules/mysql2/lib/packets/handshake.js +var require_handshake = __commonJS({ + "node_modules/mysql2/lib/packets/handshake.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var ClientConstants = require_client(); + var Handshake = class _Handshake { + constructor(args) { + this.protocolVersion = args.protocolVersion; + this.serverVersion = args.serverVersion; + this.capabilityFlags = args.capabilityFlags; + this.connectionId = args.connectionId; + this.authPluginData1 = args.authPluginData1; + this.authPluginData2 = args.authPluginData2; + this.characterSet = args.characterSet; + this.statusFlags = args.statusFlags; + this.authPluginName = args.authPluginName; + this.mariadbExtendedCapabilityFlags = args.mariadbExtendedCapabilityFlags; + } + setScrambleData(cb) { + require("crypto").randomBytes(20, (err, data) => { + if (err) { + cb(err); + return; + } + this.authPluginData1 = data.slice(0, 8); + this.authPluginData2 = data.slice(8, 20); + cb(); + }); + } + toPacket(sequenceId) { + const length = 68 + Buffer.byteLength(this.serverVersion, "utf8"); + const buffer = Buffer.alloc(length + 4, 0); + const packet = new Packet(sequenceId, buffer, 0, length + 4); + packet.offset = 4; + packet.writeInt8(this.protocolVersion); + packet.writeString(this.serverVersion, "cesu8"); + packet.writeInt8(0); + packet.writeInt32(this.connectionId); + packet.writeBuffer(this.authPluginData1); + packet.writeInt8(0); + const capabilityFlagsBuffer = Buffer.allocUnsafe(4); + capabilityFlagsBuffer.writeUInt32LE(this.capabilityFlags, 0); + packet.writeBuffer(capabilityFlagsBuffer.slice(0, 2)); + packet.writeInt8(this.characterSet); + packet.writeInt16(this.statusFlags); + packet.writeBuffer(capabilityFlagsBuffer.slice(2, 4)); + packet.writeInt8(21); + packet.skip(10); + packet.writeBuffer(this.authPluginData2); + packet.writeInt8(0); + packet.writeString("mysql_native_password", "latin1"); + packet.writeInt8(0); + return packet; + } + static fromPacket(packet) { + const args = {}; + args.protocolVersion = packet.readInt8(); + args.serverVersion = packet.readNullTerminatedString("cesu8"); + args.connectionId = packet.readInt32(); + args.authPluginData1 = packet.readBuffer(8); + packet.skip(1); + const capabilityFlagsBuffer = Buffer.allocUnsafe(4); + capabilityFlagsBuffer[0] = packet.readInt8(); + capabilityFlagsBuffer[1] = packet.readInt8(); + if (packet.haveMoreData()) { + args.characterSet = packet.readInt8(); + args.statusFlags = packet.readInt16(); + capabilityFlagsBuffer[2] = packet.readInt8(); + capabilityFlagsBuffer[3] = packet.readInt8(); + args.capabilityFlags = capabilityFlagsBuffer.readUInt32LE(0); + if (args.capabilityFlags & ClientConstants.PLUGIN_AUTH) { + args.authPluginDataLength = packet.readInt8(); + } else { + args.authPluginDataLength = 0; + packet.skip(1); + } + packet.skip(6); + if (args.capabilityFlags & ClientConstants.LONG_PASSWORD) { + packet.skip(4); + args.mariadbExtendedCapabilityFlags = 0; + } else { + args.mariadbExtendedCapabilityFlags = packet.readInt32(); + } + } else { + args.capabilityFlags = capabilityFlagsBuffer.readUInt16LE(0); + args.mariadbExtendedCapabilityFlags = 0; + } + const isSecureConnection = args.capabilityFlags & ClientConstants.SECURE_CONNECTION; + if (isSecureConnection) { + const authPluginDataLength = args.authPluginDataLength; + if (authPluginDataLength === 0) { + args.authPluginDataLength = 20; + args.authPluginData2 = packet.readBuffer(12); + packet.skip(1); + } else { + const len = Math.max(13, authPluginDataLength - 8); + args.authPluginData2 = packet.readBuffer(len); + } + } + if (args.capabilityFlags & ClientConstants.PLUGIN_AUTH) { + args.authPluginName = packet.readNullTerminatedString("ascii"); + } + return new _Handshake(args); + } + }; + module2.exports = Handshake; + } +}); + +// node_modules/mysql2/lib/packets/handshake_response.js +var require_handshake_response = __commonJS({ + "node_modules/mysql2/lib/packets/handshake_response.js"(exports2, module2) { + "use strict"; + var ClientConstants = require_client(); + var CharsetToEncoding = require_charset_encodings(); + var Packet = require_packet(); + var auth41 = require_auth_41(); + var HandshakeResponse = class { + constructor(handshake) { + this.user = handshake.user || ""; + this.database = handshake.database || ""; + this.password = handshake.password || ""; + this.passwordSha1 = handshake.passwordSha1; + this.authPluginData1 = handshake.authPluginData1; + this.authPluginData2 = handshake.authPluginData2; + this.compress = handshake.compress; + this.clientFlags = handshake.flags; + this.mariadbExtendedClientFlags = handshake.mariadbExtendedClientFlags || 0; + if (handshake.authToken !== void 0 && handshake.authPluginName !== void 0) { + if (!Buffer.isBuffer(handshake.authToken)) { + throw new TypeError( + "HandshakeResponse authToken must be a Buffer when provided" + ); + } + if (typeof handshake.authPluginName !== "string") { + throw new TypeError( + "HandshakeResponse authPluginName must be a string when provided" + ); + } + this.authToken = handshake.authToken; + this.authPluginName = handshake.authPluginName; + } else { + let authToken; + if (this.passwordSha1) { + authToken = auth41.calculateTokenFromPasswordSha( + this.passwordSha1, + this.authPluginData1, + this.authPluginData2 + ); + } else { + authToken = auth41.calculateToken( + this.password, + this.authPluginData1, + this.authPluginData2 + ); + } + this.authToken = authToken; + this.authPluginName = "mysql_native_password"; + } + this.charsetNumber = handshake.charsetNumber; + this.encoding = CharsetToEncoding[handshake.charsetNumber]; + this.connectAttributes = handshake.connectAttributes; + } + serializeResponse(buffer) { + const isSet = (flag) => this.clientFlags & ClientConstants[flag]; + const packet = new Packet(0, buffer, 0, buffer.length); + packet.offset = 4; + packet.writeInt32(this.clientFlags); + packet.writeInt32(0); + packet.writeInt8(this.charsetNumber); + packet.skip(19); + packet.writeInt32(this.mariadbExtendedClientFlags); + const encoding = this.encoding; + packet.writeNullTerminatedString(this.user, encoding); + let k; + if (isSet("PLUGIN_AUTH_LENENC_CLIENT_DATA")) { + packet.writeLengthCodedNumber(this.authToken.length); + packet.writeBuffer(this.authToken); + } else if (isSet("SECURE_CONNECTION")) { + packet.writeInt8(this.authToken.length); + packet.writeBuffer(this.authToken); + } else { + packet.writeBuffer(this.authToken); + packet.writeInt8(0); + } + if (isSet("CONNECT_WITH_DB")) { + packet.writeNullTerminatedString(this.database, encoding); + } + if (isSet("PLUGIN_AUTH")) { + packet.writeNullTerminatedString( + this.authPluginName || "mysql_native_password", + "latin1" + ); + } + if (isSet("CONNECT_ATTRS")) { + const connectAttributes = this.connectAttributes || {}; + const attrNames = Object.keys(connectAttributes); + let keysLength = 0; + for (k = 0; k < attrNames.length; ++k) { + keysLength += Packet.lengthCodedStringLength(attrNames[k], encoding); + keysLength += Packet.lengthCodedStringLength( + connectAttributes[attrNames[k]], + encoding + ); + } + packet.writeLengthCodedNumber(keysLength); + for (k = 0; k < attrNames.length; ++k) { + packet.writeLengthCodedString(attrNames[k], encoding); + packet.writeLengthCodedString( + connectAttributes[attrNames[k]], + encoding + ); + } + } + return packet; + } + toPacket() { + if (typeof this.user !== "string") { + throw new Error('"user" connection config property must be a string'); + } + if (typeof this.database !== "string") { + throw new Error('"database" connection config property must be a string'); + } + const p = this.serializeResponse(Packet.MockBuffer()); + return this.serializeResponse(Buffer.alloc(p.offset)); + } + static fromPacket(packet, serverFlags = 4294967295) { + const args = {}; + args.clientFlags = packet.readInt32(); + function isSet(flag) { + return args.clientFlags & serverFlags & ClientConstants[flag]; + } + args.maxPacketSize = packet.readInt32(); + args.charsetNumber = packet.readInt8(); + const encoding = CharsetToEncoding[args.charsetNumber]; + args.encoding = encoding; + packet.skip(23); + args.user = packet.readNullTerminatedString(encoding); + let authTokenLength; + if (isSet("PLUGIN_AUTH_LENENC_CLIENT_DATA")) { + authTokenLength = packet.readLengthCodedNumber(encoding); + args.authToken = packet.readBuffer(authTokenLength); + } else if (isSet("SECURE_CONNECTION")) { + authTokenLength = packet.readInt8(); + args.authToken = packet.readBuffer(authTokenLength); + } else { + args.authToken = packet.readNullTerminatedString(encoding); + } + if (isSet("CONNECT_WITH_DB")) { + args.database = packet.readNullTerminatedString(encoding); + } + if (isSet("PLUGIN_AUTH")) { + args.authPluginName = packet.readNullTerminatedString(encoding); + } + if (isSet("CONNECT_ATTRS")) { + const keysLength = packet.readLengthCodedNumber(encoding); + const keysEnd = packet.offset + keysLength; + const attrs = {}; + while (packet.offset < keysEnd) { + attrs[packet.readLengthCodedString(encoding)] = packet.readLengthCodedString(encoding); + } + args.connectAttributes = attrs; + } + return args; + } + }; + module2.exports = HandshakeResponse; + } +}); + +// node_modules/mysql2/lib/packets/prepare_statement.js +var require_prepare_statement = __commonJS({ + "node_modules/mysql2/lib/packets/prepare_statement.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCodes = require_commands(); + var StringParser = require_string(); + var CharsetToEncoding = require_charset_encodings(); + var PrepareStatement = class { + constructor(sql, charsetNumber) { + this.query = sql; + this.charsetNumber = charsetNumber; + this.encoding = CharsetToEncoding[charsetNumber]; + } + toPacket() { + if (StringParser.hasFastUtf8Write && (this.encoding === "utf8" || this.encoding === "utf-8")) { + const length2 = 5 + Buffer.byteLength(this.query, "utf8"); + const buffer2 = Buffer.allocUnsafe(length2); + buffer2[4] = CommandCodes.STMT_PREPARE; + buffer2.utf8Write(this.query, 5, length2 - 5); + const packet2 = new Packet(0, buffer2, 0, length2); + packet2.offset = length2; + return packet2; + } + const buf = StringParser.encode(this.query, this.encoding); + const length = 5 + buf.length; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(CommandCodes.STMT_PREPARE); + packet.writeBuffer(buf); + return packet; + } + }; + module2.exports = PrepareStatement; + } +}); + +// node_modules/mysql2/lib/packets/prepared_statement_header.js +var require_prepared_statement_header = __commonJS({ + "node_modules/mysql2/lib/packets/prepared_statement_header.js"(exports2, module2) { + "use strict"; + var PreparedStatementHeader = class { + constructor(packet) { + packet.skip(1); + this.id = packet.readInt32(); + this.fieldCount = packet.readInt16(); + this.parameterCount = packet.readInt16(); + packet.skip(1); + this.warningCount = packet.readInt16(); + } + }; + module2.exports = PreparedStatementHeader; + } +}); + +// node_modules/mysql2/lib/packets/query.js +var require_query = __commonJS({ + "node_modules/mysql2/lib/packets/query.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCode = require_commands(); + var StringParser = require_string(); + var CharsetToEncoding = require_charset_encodings(); + var ClientConstants = require_client(); + var { toParameter } = require_encode_parameter(); + var { hasFastUtf8Write } = StringParser; + function toQueryPacket(buffer, headerLength, length) { + buffer[4] = CommandCode.QUERY; + if (headerLength === 7) { + buffer[5] = 0; + buffer[6] = 1; + } + const packet = new Packet(0, buffer, 0, length); + packet.offset = length; + return packet; + } + var Query = class { + constructor(sql, charsetNumber, attributes, clientFlags) { + this.query = sql; + this.charsetNumber = charsetNumber; + this.encoding = CharsetToEncoding[charsetNumber]; + this.attributes = attributes; + this.clientFlags = clientFlags || 0; + } + toPacket() { + const useQueryAttributes = this.clientFlags & ClientConstants.CLIENT_QUERY_ATTRIBUTES; + const attributeCount = useQueryAttributes && this.attributes ? Object.keys(this.attributes).length : 0; + if (attributeCount === 0) { + const headerLength = useQueryAttributes ? 7 : 5; + if (hasFastUtf8Write && (this.encoding === "utf8" || this.encoding === "utf-8")) { + const length3 = headerLength + Buffer.byteLength(this.query, "utf8"); + const buffer2 = Buffer.allocUnsafe(length3); + buffer2.utf8Write(this.query, headerLength, length3 - headerLength); + return toQueryPacket(buffer2, headerLength, length3); + } + if (Buffer.isEncoding(this.encoding)) { + const length3 = headerLength + Buffer.byteLength(this.query, this.encoding); + const buffer2 = Buffer.allocUnsafe(length3); + buffer2.write(this.query, headerLength, this.encoding); + return toQueryPacket(buffer2, headerLength, length3); + } + const sqlBuffer2 = StringParser.encode(this.query, this.encoding); + const length2 = headerLength + sqlBuffer2.length; + const buffer = Buffer.allocUnsafe(length2); + sqlBuffer2.copy(buffer, headerLength); + return toQueryPacket(buffer, headerLength, length2); + } + const names = Object.keys(this.attributes); + const parameters = new Array(attributeCount); + const nameBuffers = new Array(attributeCount); + let length = 5 + Packet.lengthCodedNumberLength(attributeCount) + 1 + (attributeCount + 7 >> 3) + 1 + attributeCount * 2; + for (let i = 0; i < attributeCount; i++) { + parameters[i] = toParameter( + this.attributes[names[i]], + this.encoding, + "local" + ); + const name = StringParser.encode(names[i], this.encoding); + nameBuffers[i] = name; + length += Packet.lengthCodedNumberLength(name.length) + name.length; + if (!parameters[i].isNull) { + length += parameters[i].length; + } + } + const sqlBuffer = StringParser.encode(this.query, this.encoding); + length += sqlBuffer.length; + const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length); + packet.offset = 4; + packet.writeInt8(CommandCode.QUERY); + packet.writeLengthCodedNumber(attributeCount); + packet.writeLengthCodedNumber(1); + let bitmap = 0; + let bitValue = 1; + for (let i = 0; i < attributeCount; i++) { + if (parameters[i].isNull) { + bitmap |= bitValue; + } + bitValue *= 2; + if (bitValue === 256) { + packet.writeInt8(bitmap); + bitmap = 0; + bitValue = 1; + } + } + if (bitValue !== 1) { + packet.writeInt8(bitmap); + } + packet.writeInt8(1); + for (let i = 0; i < attributeCount; i++) { + packet.writeInt8(parameters[i].type); + packet.writeInt8(parameters[i].unsigned ? 128 : 0); + packet.writeLengthCodedBuffer(nameBuffers[i]); + } + for (let i = 0; i < attributeCount; i++) { + if (!parameters[i].isNull) { + parameters[i].writer.call( + packet, + parameters[i].value, + parameters[i].byteLength + ); + } + } + packet.writeBuffer(sqlBuffer); + if (packet.offset !== length) { + throw new Error( + `Internal error: COM_QUERY serialized ${packet.offset - 4} bytes, expected ${length - 4}` + ); + } + return packet; + } + }; + module2.exports = Query; + } +}); + +// node_modules/mysql2/lib/packets/register_slave.js +var require_register_slave = __commonJS({ + "node_modules/mysql2/lib/packets/register_slave.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCodes = require_commands(); + var RegisterSlave = class { + constructor(opts) { + this.serverId = opts.serverId || 0; + this.slaveHostname = opts.slaveHostname || ""; + this.slaveUser = opts.slaveUser || ""; + this.slavePassword = opts.slavePassword || ""; + this.slavePort = opts.slavePort || 0; + this.replicationRank = opts.replicationRank || 0; + this.masterId = opts.masterId || 0; + } + toPacket() { + const length = 15 + // TODO: should be ascii? + Buffer.byteLength(this.slaveHostname, "utf8") + Buffer.byteLength(this.slaveUser, "utf8") + Buffer.byteLength(this.slavePassword, "utf8") + 3 + 4; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(CommandCodes.REGISTER_SLAVE); + packet.writeInt32(this.serverId); + packet.writeInt8(Buffer.byteLength(this.slaveHostname, "utf8")); + packet.writeString(this.slaveHostname); + packet.writeInt8(Buffer.byteLength(this.slaveUser, "utf8")); + packet.writeString(this.slaveUser); + packet.writeInt8(Buffer.byteLength(this.slavePassword, "utf8")); + packet.writeString(this.slavePassword); + packet.writeInt16(this.slavePort); + packet.writeInt32(this.replicationRank); + packet.writeInt32(this.masterId); + return packet; + } + }; + module2.exports = RegisterSlave; + } +}); + +// node_modules/mysql2/lib/packets/reset_connection.js +var require_reset_connection = __commonJS({ + "node_modules/mysql2/lib/packets/reset_connection.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var CommandCodes = require_commands(); + var ResetConnection = class { + constructor() { + } + toPacket() { + const packet = new Packet(0, Buffer.alloc(5), 0, 5); + packet.offset = 4; + packet.writeInt8(CommandCodes.RESET_CONNECTION); + return packet; + } + }; + module2.exports = ResetConnection; + } +}); + +// node_modules/mysql2/lib/constants/server_status.js +var require_server_status = __commonJS({ + "node_modules/mysql2/lib/constants/server_status.js"(exports2) { + "use strict"; + exports2.SERVER_STATUS_IN_TRANS = 1; + exports2.SERVER_STATUS_AUTOCOMMIT = 2; + exports2.SERVER_MORE_RESULTS_EXISTS = 8; + exports2.SERVER_QUERY_NO_GOOD_INDEX_USED = 16; + exports2.SERVER_QUERY_NO_INDEX_USED = 32; + exports2.SERVER_STATUS_CURSOR_EXISTS = 64; + exports2.SERVER_STATUS_LAST_ROW_SENT = 128; + exports2.SERVER_STATUS_DB_DROPPED = 256; + exports2.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512; + exports2.SERVER_STATUS_METADATA_CHANGED = 1024; + exports2.SERVER_QUERY_WAS_SLOW = 2048; + exports2.SERVER_PS_OUT_PARAMS = 4096; + exports2.SERVER_STATUS_IN_TRANS_READONLY = 8192; + exports2.SERVER_SESSION_STATE_CHANGED = 16384; + } +}); + +// node_modules/mysql2/lib/constants/encoding_charset.js +var require_encoding_charset = __commonJS({ + "node_modules/mysql2/lib/constants/encoding_charset.js"(exports2, module2) { + "use strict"; + module2.exports = { + big5: 1, + latin2: 2, + dec8: 3, + cp850: 4, + latin1: 5, + hp8: 6, + koi8r: 7, + swe7: 10, + ascii: 11, + eucjp: 12, + sjis: 13, + cp1251: 14, + hebrew: 16, + tis620: 18, + euckr: 19, + latin7: 20, + koi8u: 22, + gb2312: 24, + greek: 25, + cp1250: 26, + gbk: 28, + cp1257: 29, + latin5: 30, + armscii8: 32, + cesu8: 33, + ucs2: 35, + cp866: 36, + keybcs2: 37, + macintosh: 38, + macroman: 39, + cp852: 40, + utf8: 45, + utf8mb4: 45, + utf16: 54, + utf16le: 56, + cp1256: 57, + utf32: 60, + binary: 63, + geostd8: 92, + cp932: 95, + eucjpms: 97, + gb18030: 248, + utf8mb3: 192 + }; + } +}); + +// node_modules/mysql2/lib/constants/session_track.js +var require_session_track = __commonJS({ + "node_modules/mysql2/lib/constants/session_track.js"(exports2) { + "use strict"; + exports2.SYSTEM_VARIABLES = 0; + exports2.SCHEMA = 1; + exports2.STATE_CHANGE = 2; + exports2.STATE_GTIDS = 3; + exports2.TRANSACTION_CHARACTERISTICS = 4; + exports2.TRANSACTION_STATE = 5; + exports2.FIRST_KEY = exports2.SYSTEM_VARIABLES; + exports2.LAST_KEY = exports2.TRANSACTION_STATE; + } +}); + +// node_modules/mysql2/lib/packets/resultset_header.js +var require_resultset_header = __commonJS({ + "node_modules/mysql2/lib/packets/resultset_header.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var ClientConstants = require_client(); + var ServerSatusFlags = require_server_status(); + var EncodingToCharset = require_encoding_charset(); + var sessionInfoTypes = require_session_track(); + var ResultSetHeader = class { + constructor(packet, connection) { + const bigNumberStrings = connection.config.bigNumberStrings; + const encoding = connection.serverEncoding; + const flags = connection._handshakePacket.capabilityFlags; + const isSet = function(flag) { + return flags & ClientConstants[flag]; + }; + if (packet.buffer[packet.offset] !== 0) { + this.fieldCount = packet.readLengthCodedNumber(); + if (this.fieldCount === null) { + this.infileName = packet.readString(void 0, encoding); + } + return; + } + this.fieldCount = packet.readInt8(); + this.affectedRows = packet.readLengthCodedNumber(bigNumberStrings); + this.insertId = packet.readLengthCodedNumberSigned(bigNumberStrings); + this.info = ""; + if (isSet("PROTOCOL_41")) { + this.serverStatus = packet.readInt16(); + this.warningStatus = packet.readInt16(); + } else if (isSet("TRANSACTIONS")) { + this.serverStatus = packet.readInt16(); + } + let stateChanges = null; + if (isSet("SESSION_TRACK") && packet.offset < packet.end) { + this.info = packet.readLengthCodedString(encoding); + if (this.serverStatus & ServerSatusFlags.SERVER_SESSION_STATE_CHANGED) { + let len = packet.offset < packet.end ? packet.readLengthCodedNumber() : 0; + const end = packet.offset + len; + let type, key, stateEnd; + if (len > 0) { + stateChanges = { + systemVariables: {}, + schema: null, + gtids: [], + trackStateChange: null + }; + } + while (packet.offset < end) { + type = packet.readInt8(); + len = packet.readLengthCodedNumber(); + stateEnd = packet.offset + len; + if (type === sessionInfoTypes.SYSTEM_VARIABLES) { + key = packet.readLengthCodedString(encoding); + const val = packet.readLengthCodedString(encoding); + stateChanges.systemVariables[key] = val; + if (key === "character_set_client") { + const charsetNumber = EncodingToCharset[val]; + if (typeof charsetNumber !== "undefined") { + connection.config.charsetNumber = charsetNumber; + } + } + } else if (type === sessionInfoTypes.SCHEMA) { + key = packet.readLengthCodedString(encoding); + stateChanges.schema = key; + } else if (type === sessionInfoTypes.STATE_CHANGE) { + stateChanges.trackStateChange = packet.readLengthCodedString(encoding); + } else if (type === sessionInfoTypes.STATE_GTIDS) { + const _unknownString = packet.readLengthCodedString(encoding); + const gtid = packet.readLengthCodedString(encoding); + stateChanges.gtids = gtid.split(","); + } else { + } + packet.offset = stateEnd; + } + } + } else { + this.info = packet.readString(void 0, encoding); + } + if (stateChanges) { + this.stateChanges = stateChanges; + } + const m = this.info.match(/\schanged:\s*(\d+)/i); + if (m !== null) { + this.changedRows = parseInt(m[1], 10); + } else { + this.changedRows = 0; + } + } + // TODO: should be consistent instance member, but it's just easier here to have just function + static toPacket(fieldCount, insertId) { + let length = 4 + Packet.lengthCodedNumberLength(fieldCount); + if (typeof insertId !== "undefined") { + length += Packet.lengthCodedNumberLength(insertId); + } + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeLengthCodedNumber(fieldCount); + if (typeof insertId !== "undefined") { + packet.writeLengthCodedNumber(insertId); + } + return packet; + } + }; + module2.exports = ResultSetHeader; + } +}); + +// node_modules/mysql2/lib/packets/ssl_request.js +var require_ssl_request = __commonJS({ + "node_modules/mysql2/lib/packets/ssl_request.js"(exports2, module2) { + "use strict"; + var ClientConstants = require_client(); + var Packet = require_packet(); + var SSLRequest = class { + constructor(flags, charset, mariadbExtendedClientFlags) { + this.clientFlags = flags | ClientConstants.SSL; + this.charset = charset; + this.mariadbExtendedClientFlags = mariadbExtendedClientFlags || 0; + } + toPacket() { + const length = 36; + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + buffer.fill(0); + packet.offset = 4; + packet.writeInt32(this.clientFlags); + packet.writeInt32(0); + packet.writeInt8(this.charset); + packet.skip(19); + packet.writeInt32(this.mariadbExtendedClientFlags); + return packet; + } + }; + module2.exports = SSLRequest; + } +}); + +// node_modules/mysql2/lib/packets/text_row.js +var require_text_row = __commonJS({ + "node_modules/mysql2/lib/packets/text_row.js"(exports2, module2) { + "use strict"; + var Packet = require_packet(); + var TextRow = class _TextRow { + constructor(columns) { + this.columns = columns || []; + } + static fromPacket(packet) { + const columns = []; + while (packet.haveMoreData()) { + columns.push(packet.readLengthCodedString()); + } + return new _TextRow(columns); + } + static toPacket(columns, encoding) { + const sequenceId = 0; + let length = 0; + columns.forEach((val) => { + if (val === null || typeof val === "undefined") { + ++length; + return; + } + length += Packet.lengthCodedStringLength(val.toString(10), encoding); + }); + const buffer = Buffer.allocUnsafe(length + 4); + const packet = new Packet(sequenceId, buffer, 0, length + 4); + packet.offset = 4; + columns.forEach((val) => { + if (val === null) { + packet.writeNull(); + return; + } + if (typeof val === "undefined") { + packet.writeInt8(0); + return; + } + packet.writeLengthCodedString(val.toString(10), encoding); + }); + return packet; + } + }; + module2.exports = TextRow; + } +}); + +// node_modules/mysql2/lib/packets/index.js +var require_packets = __commonJS({ + "node_modules/mysql2/lib/packets/index.js"(exports2, module2) { + "use strict"; + var process2 = require("process"); + var AuthNextFactor = require_auth_next_factor(); + var AuthSwitchRequest = require_auth_switch_request(); + var AuthSwitchRequestMoreData = require_auth_switch_request_more_data(); + var AuthSwitchResponse = require_auth_switch_response(); + var BinaryRow = require_binary_row(); + var BinlogDump = require_binlog_dump(); + var ChangeUser = require_change_user(); + var CloseStatement = require_close_statement(); + var ColumnDefinition = require_column_definition(); + var Execute = require_execute(); + var Handshake = require_handshake(); + var HandshakeResponse = require_handshake_response(); + var PrepareStatement = require_prepare_statement(); + var PreparedStatementHeader = require_prepared_statement_header(); + var Query = require_query(); + var RegisterSlave = require_register_slave(); + var ResetConnection = require_reset_connection(); + var ResultSetHeader = require_resultset_header(); + var SSLRequest = require_ssl_request(); + var TextRow = require_text_row(); + var ctorMap = { + AuthNextFactor, + AuthSwitchRequest, + AuthSwitchRequestMoreData, + AuthSwitchResponse, + BinaryRow, + BinlogDump, + ChangeUser, + CloseStatement, + ColumnDefinition, + Execute, + Handshake, + HandshakeResponse, + PrepareStatement, + PreparedStatementHeader, + Query, + RegisterSlave, + ResetConnection, + ResultSetHeader, + SSLRequest, + TextRow + }; + Object.entries(ctorMap).forEach(([name, ctor]) => { + module2.exports[name] = ctor; + if (process2.env.NODE_DEBUG) { + if (ctor.prototype.toPacket) { + const old = ctor.prototype.toPacket; + ctor.prototype.toPacket = function() { + const p = old.call(this); + p._name = name; + return p; + }; + } + } + }); + var Packet = require_packet(); + exports2.Packet = Packet; + var OK = class { + static toPacket(args, encoding) { + args = args || {}; + const affectedRows = args.affectedRows || 0; + const insertId = args.insertId || 0; + const serverStatus = args.serverStatus || 0; + const warningCount = args.warningCount || 0; + const message = args.message || ""; + let length = 9 + Packet.lengthCodedNumberLength(affectedRows); + length += Packet.lengthCodedNumberLength(insertId); + const buffer = Buffer.allocUnsafe(length); + const packet = new Packet(0, buffer, 0, length); + packet.offset = 4; + packet.writeInt8(0); + packet.writeLengthCodedNumber(affectedRows); + packet.writeLengthCodedNumber(insertId); + packet.writeInt16(serverStatus); + packet.writeInt16(warningCount); + packet.writeString(message, encoding); + packet._name = "OK"; + return packet; + } + }; + exports2.OK = OK; + var EOF = class { + static toPacket(warnings, statusFlags) { + if (typeof warnings === "undefined") { + warnings = 0; + } + if (typeof statusFlags === "undefined") { + statusFlags = 0; + } + const packet = new Packet(0, Buffer.allocUnsafe(9), 0, 9); + packet.offset = 4; + packet.writeInt8(254); + packet.writeInt16(warnings); + packet.writeInt16(statusFlags); + packet._name = "EOF"; + return packet; + } + }; + exports2.EOF = EOF; + var Error2 = class _Error { + static toPacket(args, encoding) { + const length = 13 + Buffer.byteLength(args.message, "utf8"); + const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length); + packet.offset = 4; + packet.writeInt8(255); + packet.writeInt16(args.code); + packet.writeString("#_____", encoding); + packet.writeString(args.message, encoding); + packet._name = "Error"; + return packet; + } + static fromPacket(packet) { + packet.readInt8(); + const code = packet.readInt16(); + packet.readString(1, "ascii"); + packet.readString(5, "ascii"); + const message = packet.readNullTerminatedString("utf8"); + const error = new _Error(); + error.message = message; + error.code = code; + return error; + } + }; + exports2.Error = Error2; + } +}); + +// node_modules/mysql2/lib/commands/command.js +var require_command = __commonJS({ + "node_modules/mysql2/lib/commands/command.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var Timers = require("timers"); + var Command = class extends EventEmitter { + constructor() { + super(); + this.next = null; + } + // slow. debug only + stateName() { + const state = this.next; + for (const i in this) { + if (this[i] === state && i !== "next") { + return i; + } + } + return "unknown name"; + } + execute(packet, connection) { + if (!this.next) { + this.next = this.start; + connection._resetSequenceId(); + } + if (packet && packet.isError()) { + const err = packet.asError(connection.clientEncoding); + err.sql = this.sql || this.query; + if (this.queryTimeout) { + Timers.clearTimeout(this.queryTimeout); + this.queryTimeout = null; + } + if (this.onResult) { + this.onResult(err); + this.emit("end"); + } else { + this.emit("error", err); + this.emit("end"); + } + return true; + } + this.next = this.next(packet, connection); + if (this.next) { + return false; + } + this.emit("end"); + return true; + } + }; + module2.exports = Command; + } +}); + +// node_modules/mysql2/lib/constants/mariadb_client.js +var require_mariadb_client = __commonJS({ + "node_modules/mysql2/lib/constants/mariadb_client.js"(exports2) { + "use strict"; + exports2.MARIADB_CLIENT_PROGRESS = 1; + exports2.MARIADB_CLIENT_COM_MULTI = 2; + exports2.MARIADB_CLIENT_STMT_BULK_OPERATIONS = 4; + exports2.MARIADB_CLIENT_EXTENDED_METADATA = 8; + exports2.MARIADB_CLIENT_CACHE_METADATA = 16; + exports2.MARIADB_CLIENT_BULK_UNIT_RESULTS = 32; + } +}); + +// node_modules/mysql2/lib/auth_plugins/sha256_password.js +var require_sha256_password = __commonJS({ + "node_modules/mysql2/lib/auth_plugins/sha256_password.js"(exports2, module2) { + "use strict"; + var PLUGIN_NAME = "sha256_password"; + var crypto = require("crypto"); + var { xorRotating } = require_auth_41(); + var Tls = require("tls"); + var REQUEST_SERVER_KEY_PACKET = Buffer.from([1]); + var STATE_INITIAL = 0; + var STATE_WAIT_SERVER_KEY = 1; + var STATE_FINAL = -1; + function encrypt(password, scramble, key) { + const stage1 = xorRotating(Buffer.from(`${password}\0`, "utf8"), scramble); + return crypto.publicEncrypt( + { + key, + oaepHash: "sha1" + }, + stage1 + ); + } + module2.exports = (pluginOptions = {}) => ({ connection }) => { + let state = 0; + let scramble = null; + const password = connection.config.password; + const authWithKey = (serverKey) => { + const _password = encrypt(password, scramble, serverKey); + state = STATE_FINAL; + return _password; + }; + return (data) => { + switch (state) { + case STATE_INITIAL: + if (connection.stream instanceof Tls.TLSSocket && connection.stream.encrypted === true) { + return Buffer.from(`${password}\0`, "utf8"); + } + scramble = data.slice(0, 20); + if (pluginOptions.serverPublicKey) { + return authWithKey(pluginOptions.serverPublicKey); + } + state = STATE_WAIT_SERVER_KEY; + return REQUEST_SERVER_KEY_PACKET; + case STATE_WAIT_SERVER_KEY: + if (pluginOptions.onServerPublicKey) { + pluginOptions.onServerPublicKey(data); + } + return authWithKey(data); + case STATE_FINAL: + throw new Error( + `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_FINAL state.` + ); + } + throw new Error( + `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in state ${state}` + ); + }; + }; + } +}); + +// node_modules/mysql2/lib/auth_plugins/caching_sha2_password.js +var require_caching_sha2_password = __commonJS({ + "node_modules/mysql2/lib/auth_plugins/caching_sha2_password.js"(exports2, module2) { + "use strict"; + var PLUGIN_NAME = "caching_sha2_password"; + var crypto = require("crypto"); + var { xor, xorRotating } = require_auth_41(); + var REQUEST_SERVER_KEY_PACKET = Buffer.from([2]); + var FAST_AUTH_SUCCESS_PACKET = Buffer.from([3]); + var PERFORM_FULL_AUTHENTICATION_PACKET = Buffer.from([4]); + var STATE_INITIAL = 0; + var STATE_TOKEN_SENT = 1; + var STATE_WAIT_SERVER_KEY = 2; + var STATE_FINAL = -1; + function sha256(msg) { + const hash = crypto.createHash("sha256"); + hash.update(msg); + return hash.digest(); + } + function calculateToken(password, scramble) { + if (!password) { + return Buffer.alloc(0); + } + const stage1 = sha256(Buffer.from(password)); + const stage2 = sha256(stage1); + const stage3 = sha256(Buffer.concat([stage2, scramble])); + return xor(stage1, stage3); + } + function encrypt(password, scramble, key) { + const stage1 = xorRotating(Buffer.from(`${password}\0`, "utf8"), scramble); + return crypto.publicEncrypt( + { + key, + oaepHash: "sha1", + padding: crypto.constants.RSA_PKCS1_OAEP_PADDING + }, + stage1 + ); + } + var pluginFactory = (pluginOptions = {}) => ({ connection }) => { + let state = 0; + let scramble = null; + const password = connection.config.password; + const authWithKey = (serverKey) => { + const _password = encrypt(password, scramble, serverKey); + state = STATE_FINAL; + return _password; + }; + return (data) => { + switch (state) { + case STATE_INITIAL: + scramble = data.slice(0, 20); + state = STATE_TOKEN_SENT; + return calculateToken(password, scramble); + case STATE_TOKEN_SENT: + if (FAST_AUTH_SUCCESS_PACKET.equals(data)) { + state = STATE_FINAL; + return null; + } + if (PERFORM_FULL_AUTHENTICATION_PACKET.equals(data)) { + const isSecureConnection = typeof pluginOptions.overrideIsSecure === "undefined" ? connection.config.ssl || connection.config.socketPath : pluginOptions.overrideIsSecure; + if (isSecureConnection) { + state = STATE_FINAL; + return Buffer.from(`${password}\0`, "utf8"); + } + if (pluginOptions.serverPublicKey) { + return authWithKey(pluginOptions.serverPublicKey); + } + state = STATE_WAIT_SERVER_KEY; + return REQUEST_SERVER_KEY_PACKET; + } + throw new Error( + `Invalid AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_TOKEN_SENT state.` + ); + case STATE_WAIT_SERVER_KEY: + if (pluginOptions.onServerPublicKey) { + pluginOptions.onServerPublicKey(data); + } + return authWithKey(data); + case STATE_FINAL: + throw new Error( + `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_FINAL state.` + ); + } + throw new Error( + `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in state ${state}` + ); + }; + }; + module2.exports = pluginFactory; + module2.exports.calculateToken = calculateToken; + } +}); + +// node_modules/mysql2/lib/auth_plugins/mysql_native_password.js +var require_mysql_native_password = __commonJS({ + "node_modules/mysql2/lib/auth_plugins/mysql_native_password.js"(exports2, module2) { + "use strict"; + var auth41 = require_auth_41(); + module2.exports = (pluginOptions) => ({ connection, command }) => { + const password = command.password || pluginOptions.password || connection.config.password; + const passwordSha1 = command.passwordSha1 || pluginOptions.passwordSha1 || connection.config.passwordSha1; + return (data) => { + const authPluginData1 = data.slice(0, 8); + const authPluginData2 = data.slice(8, 20); + let authToken; + if (passwordSha1) { + authToken = auth41.calculateTokenFromPasswordSha( + passwordSha1, + authPluginData1, + authPluginData2 + ); + } else { + authToken = auth41.calculateToken( + password, + authPluginData1, + authPluginData2 + ); + } + return authToken; + }; + }; + } +}); + +// node_modules/mysql2/lib/auth_plugins/mysql_clear_password.js +var require_mysql_clear_password = __commonJS({ + "node_modules/mysql2/lib/auth_plugins/mysql_clear_password.js"(exports2, module2) { + "use strict"; + function bufferFromStr(str) { + return Buffer.from(`${str}\0`); + } + var create_mysql_clear_password_plugin = (pluginOptions) => function mysql_clear_password_plugin({ connection, command }) { + const password = command.password || pluginOptions.password || connection.config.password; + return function() { + return bufferFromStr(password); + }; + }; + module2.exports = create_mysql_clear_password_plugin; + } +}); + +// node_modules/mysql2/lib/commands/auth_switch.js +var require_auth_switch = __commonJS({ + "node_modules/mysql2/lib/commands/auth_switch.js"(exports2, module2) { + "use strict"; + var Packets = require_packets(); + var sha256_password = require_sha256_password(); + var caching_sha2_password = require_caching_sha2_password(); + var mysql_native_password = require_mysql_native_password(); + var mysql_clear_password = require_mysql_clear_password(); + var standardAuthPlugins = Object.assign(/* @__PURE__ */ Object.create(null), { + sha256_password: sha256_password({}), + caching_sha2_password: caching_sha2_password({}), + mysql_native_password: mysql_native_password({}), + mysql_clear_password: mysql_clear_password({}) + }); + function getAuthPlugin(pluginName, connection) { + const customPlugins = connection.config.authPlugins; + if (customPlugins && Object.prototype.hasOwnProperty.call(customPlugins, pluginName)) { + return customPlugins[pluginName]; + } + return standardAuthPlugins[pluginName]; + } + function warnLegacyAuthSwitch() { + console.warn( + "WARNING! authSwitchHandler api is deprecated, please use new authPlugins api" + ); + } + function authSwitchPluginError(error, command) { + error.code = "AUTH_SWITCH_PLUGIN_ERROR"; + error.fatal = true; + command.emit("error", error); + } + function authSwitchRequest(packet, connection, command) { + const { pluginName, pluginData } = Packets.AuthSwitchRequest.fromPacket(packet); + if (connection.config.authSwitchHandler && pluginName !== "mysql_native_password") { + const legacySwitchHandler = connection.config.authSwitchHandler; + warnLegacyAuthSwitch(); + legacySwitchHandler({ pluginName, pluginData }, (err, data) => { + if (err) { + return authSwitchPluginError(err, command); + } + connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket()); + }); + return; + } + if (pluginName === "mysql_clear_password") { + const hasCustomPlugin = connection.config.authPlugins && Object.prototype.hasOwnProperty.call( + connection.config.authPlugins, + "mysql_clear_password" + ); + if (!hasCustomPlugin && !connection.config.enableCleartextPlugin) { + const err = new Error( + "Server requested authentication using mysql_clear_password, which sends the password in plaintext over the network and is disabled by default. To enable it, set the `enableCleartextPlugin` option to `true` in your connection configuration, or provide a custom `mysql_clear_password` auth plugin via the `authPlugins` option. Only use this over a secure connection (TLS/SSL)." + ); + err.code = "MYSQL_CLEAR_PASSWORD_NOT_ENABLED"; + err.fatal = true; + throw err; + } + } + const authPlugin = getAuthPlugin(pluginName, connection); + if (!authPlugin) { + throw new Error( + `Server requests authentication using unknown plugin ${pluginName}. See ${"TODO: add plugins doco here"} on how to configure or author authentication plugins.` + ); + } + connection._authPlugin = authPlugin({ connection, command }); + Promise.resolve(connection._authPlugin(pluginData)).then((data) => { + if (data) { + connection.writePacket(new Packets.AuthSwitchResponse(data).toPacket()); + } + }).catch((err) => { + authSwitchPluginError(err, command); + }); + } + function authSwitchRequestMoreData(packet, connection, command) { + const { data } = Packets.AuthSwitchRequestMoreData.fromPacket(packet); + if (connection.config.authSwitchHandler) { + const legacySwitchHandler = connection.config.authSwitchHandler; + warnLegacyAuthSwitch(); + legacySwitchHandler({ pluginData: data }, (err, data2) => { + if (err) { + return authSwitchPluginError(err, command); + } + connection.writePacket(new Packets.AuthSwitchResponse(data2).toPacket()); + }); + return; + } + if (!connection._authPlugin) { + throw new Error( + "AuthPluginMoreData received but no auth plugin instance found" + ); + } + Promise.resolve(connection._authPlugin(data)).then((data2) => { + if (data2) { + connection.writePacket(new Packets.AuthSwitchResponse(data2).toPacket()); + } + }).catch((err) => { + authSwitchPluginError(err, command); + }); + } + module2.exports = { + authSwitchRequest, + authSwitchRequestMoreData, + getAuthPlugin, + standardAuthPlugins + }; + } +}); + +// node_modules/mysql2/lib/compressed_protocol.js +var require_compressed_protocol = __commonJS({ + "node_modules/mysql2/lib/compressed_protocol.js"(exports2, module2) { + "use strict"; + var zlib = require("zlib"); + var PacketParser = require_packet_parser(); + var MIN_COMPRESS_LENGTH = 50; + var MAX_SYNC_INFLATE_LENGTH = 16384; + var MAX_SYNC_DEFLATE_LENGTH = 4096; + var Queue = class { + constructor() { + this._queue = []; + this._running = false; + } + push(fn) { + this._queue.push(fn); + if (!this._running) { + this._running = true; + process.nextTick(() => this._next()); + } + } + _next() { + const task = this._queue.shift(); + if (!task) { + this._running = false; + return; + } + task({ + done: () => process.nextTick(() => this._next()) + }); + } + }; + function handleCompressedPacket(packet) { + const connection = this; + const deflatedLength = packet.readInt24(); + const body = packet.readBuffer(); + const numPackets = packet.numPackets; + if (!connection.inflateQueue._running) { + if (deflatedLength === 0) { + connection._bumpCompressedSequenceId(numPackets); + connection._inflatedPacketsParser.execute(body); + return; + } + if (deflatedLength <= MAX_SYNC_INFLATE_LENGTH) { + let data; + try { + data = zlib.inflateSync(body, { maxOutputLength: deflatedLength }); + } catch (err) { + connection._handleNetworkError(err); + return; + } + connection._bumpCompressedSequenceId(numPackets); + connection._inflatedPacketsParser.execute(data); + return; + } + } + if (deflatedLength !== 0) { + connection.inflateQueue.push((task) => { + zlib.inflate(body, { maxOutputLength: deflatedLength }, (err, data) => { + if (err) { + connection._handleNetworkError(err); + return; + } + connection._bumpCompressedSequenceId(numPackets); + connection._inflatedPacketsParser.execute(data); + task.done(); + }); + }); + } else { + connection.inflateQueue.push((task) => { + connection._bumpCompressedSequenceId(numPackets); + connection._inflatedPacketsParser.execute(body); + task.done(); + }); + } + } + function writeCompressedFrame(connection, seqId, packetLen, buffer, compressed) { + const compressHeader = Buffer.allocUnsafe(7); + const compressedLength = compressed === null ? packetLen : compressed.length; + if (compressed === null) { + packetLen = 0; + } + compressHeader.writeUInt8(compressedLength & 255, 0); + compressHeader.writeUInt16LE(compressedLength >> 8, 1); + compressHeader.writeUInt8(seqId, 3); + compressHeader.writeUInt8(packetLen & 255, 4); + compressHeader.writeUInt16LE(packetLen >> 8, 5); + connection.writeUncompressed(compressHeader); + connection.writeUncompressed(compressed === null ? buffer : compressed); + } + function writeCompressed(buffer) { + const MAX_COMPRESSED_LENGTH = 16777210; + let start; + if (buffer.length > MAX_COMPRESSED_LENGTH) { + for (start = 0; start < buffer.length; start += MAX_COMPRESSED_LENGTH) { + writeCompressed.call( + this, + buffer.slice(start, start + MAX_COMPRESSED_LENGTH) + ); + } + return; + } + const connection = this; + const packetLen = buffer.length; + const seqId = connection.compressedSequenceId; + connection._bumpCompressedSequenceId(1); + if (!connection.deflateQueue._running) { + if (packetLen < MIN_COMPRESS_LENGTH) { + writeCompressedFrame(connection, seqId, packetLen, buffer, null); + return; + } + if (packetLen <= MAX_SYNC_DEFLATE_LENGTH) { + let compressed; + try { + compressed = zlib.deflateSync(buffer); + } catch (err) { + connection._handleFatalError(err); + return; + } + writeCompressedFrame( + connection, + seqId, + packetLen, + buffer, + compressed.length < packetLen ? compressed : null + ); + return; + } + } + connection.deflateQueue.push((task) => { + zlib.deflate(buffer, (err, compressed) => { + if (err) { + connection._handleFatalError(err); + return; + } + writeCompressedFrame( + connection, + seqId, + packetLen, + buffer, + compressed.length < packetLen ? compressed : null + ); + task.done(); + }); + }); + } + function enableCompression(connection) { + connection._lastWrittenPacketId = 0; + connection._lastReceivedPacketId = 0; + connection._handleCompressedPacket = handleCompressedPacket; + connection._inflatedPacketsParser = new PacketParser((p) => { + connection.handlePacket(p); + }, 4); + connection._inflatedPacketsParser._lastPacket = 0; + connection.packetParser = new PacketParser((packet) => { + connection._handleCompressedPacket(packet); + }, 7); + connection.writeUncompressed = connection.write; + connection.write = writeCompressed; + connection.inflateQueue = new Queue(); + connection.deflateQueue = new Queue(); + } + module2.exports = { + enableCompression, + Queue + }; + } +}); + +// node_modules/mysql2/lib/commands/client_handshake.js +var require_client_handshake = __commonJS({ + "node_modules/mysql2/lib/commands/client_handshake.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var ClientConstants = require_client(); + var MariaDBClientConstants = require_mariadb_client(); + var CharsetToEncoding = require_charset_encodings(); + var auth41 = require_auth_41(); + var { getAuthPlugin } = require_auth_switch(); + var { + calculateToken: calculateSha2Token + } = require_caching_sha2_password(); + function flagNames(flags) { + const res = []; + for (const c in ClientConstants) { + if (flags & ClientConstants[c]) { + res.push(c.replace(/_/g, " ").toLowerCase()); + } + } + return res; + } + var ClientHandshake = class _ClientHandshake extends Command { + constructor(clientFlags) { + super(); + this.handshake = null; + this.clientFlags = clientFlags; + this.mariadbExtendedClientFlags = 0; + this.authenticationFactor = 0; + } + start() { + return _ClientHandshake.prototype.handshakeInit; + } + sendSSLRequest(connection) { + const sslRequest = new Packets.SSLRequest( + this.clientFlags, + connection.config.charsetNumber, + this.mariadbExtendedClientFlags + ); + connection.writePacket(sslRequest.toPacket()); + } + sendCredentials(connection) { + if (connection.config.debug) { + console.log( + "Sending handshake packet: flags:%d=(%s)", + this.clientFlags, + flagNames(this.clientFlags).join(", ") + ); + } + this.user = connection.config.user; + this.password = connection.config.password; + this.password1 = connection.config.password; + this.password2 = connection.config.password2; + this.password3 = connection.config.password3; + this.passwordSha1 = connection.config.passwordSha1; + this.database = connection.config.database; + this.authPluginName = this.handshake.authPluginName; + const serverAuthMethod = this.handshake.authPluginName; + const isSecureConnection = connection.config.ssl || connection.config.socketPath; + const authPluginData = this.handshake.authPluginData1 && this.handshake.authPluginData2 ? Buffer.concat([ + this.handshake.authPluginData1, + this.handshake.authPluginData2 + ]).slice(0, 20) : Buffer.alloc(20); + const hasCustomAuthPlugin = connection.config.authPlugins && Object.prototype.hasOwnProperty.call( + connection.config.authPlugins, + serverAuthMethod + ); + const hasLegacyAuthSwitchHandler = typeof connection.config.authSwitchHandler === "function"; + const canUseDirectAuth = !hasCustomAuthPlugin && !hasLegacyAuthSwitchHandler && this.canUseAuthMethodDirectly(serverAuthMethod, isSecureConnection) && (serverAuthMethod !== "mysql_clear_password" || connection.config.enableCleartextPlugin); + const clientAuthMethod = canUseDirectAuth ? serverAuthMethod : "mysql_native_password"; + const authToken = this.calculateAuthToken( + clientAuthMethod, + this.password, + authPluginData + ); + if (connection.config.debug) { + console.log( + "Server auth method: %s, Using auth method: %s", + serverAuthMethod, + clientAuthMethod + ); + } + const handshakeResponse = new Packets.HandshakeResponse({ + flags: this.clientFlags, + mariadbExtendedClientFlags: this.mariadbExtendedClientFlags, + user: this.user, + database: this.database, + password: this.password, + passwordSha1: this.passwordSha1, + charsetNumber: connection.config.charsetNumber, + authPluginData1: this.handshake.authPluginData1, + authPluginData2: this.handshake.authPluginData2, + compress: connection.config.compress, + connectAttributes: connection.config.connectAttributes, + authToken, + authPluginName: clientAuthMethod + }); + connection.writePacket(handshakeResponse.toPacket()); + if (clientAuthMethod !== "mysql_native_password") { + this.initializeAuthPlugin(clientAuthMethod, authPluginData, connection); + } + } + calculateNativePasswordAuthToken(authPluginData) { + const authPluginData1 = authPluginData.slice(0, 8); + const authPluginData2 = authPluginData.slice(8, 20); + let authToken; + if (this.passwordSha1) { + authToken = auth41.calculateTokenFromPasswordSha( + this.passwordSha1, + authPluginData1, + authPluginData2 + ); + } else { + authToken = auth41.calculateToken( + this.password, + authPluginData1, + authPluginData2 + ); + } + return authToken; + } + calculateSha256Token(password, scramble) { + return calculateSha2Token(password, scramble); + } + // Helper: Calculate auth token for a specific auth method + calculateAuthToken(authMethod, password, authPluginData) { + switch (authMethod) { + case "mysql_native_password": + return this.calculateNativePasswordAuthToken(authPluginData); + case "caching_sha2_password": + return this.calculateSha256Token(password, authPluginData); + case "sha256_password": + case "mysql_clear_password": + return password ? Buffer.from(`${password}\0`, "utf8") : Buffer.alloc(0); + default: + return this.calculateNativePasswordAuthToken(authPluginData); + } + } + // Helper: Determine if we can use a specific auth method directly + canUseAuthMethodDirectly(authMethod, isSecureConnection) { + switch (authMethod) { + case "mysql_native_password": + case "caching_sha2_password": + return true; + case "sha256_password": + case "mysql_clear_password": + return isSecureConnection; + default: + return false; + } + } + // Helper: Initialize auth plugin for handling subsequent AuthMoreData packets + initializeAuthPlugin(authMethod, authPluginData, connection) { + const authPlugin = getAuthPlugin(authMethod, connection); + if (!authPlugin) { + return; + } + const pluginHandler = authPlugin({ connection, command: this }); + connection._authPlugin = pluginHandler; + try { + Promise.resolve(pluginHandler(authPluginData)).catch((err) => { + if (connection.config.debug) { + console.log("Auth plugin initialization:", err.message); + } + }); + } catch (err) { + if (connection.config.debug) { + console.log("Auth plugin initialization error:", err.message); + } + } + } + handshakeInit(helloPacket, connection) { + this.on("error", (e) => { + connection._fatalError = e; + connection._protocolError = e; + }); + this.handshake = Packets.Handshake.fromPacket(helloPacket); + if (connection.config.debug) { + console.log( + "Server hello packet: capability flags:%d=(%s)", + this.handshake.capabilityFlags, + flagNames(this.handshake.capabilityFlags).join(", ") + ); + } + connection.serverCapabilityFlags = this.handshake.capabilityFlags; + connection.serverEncoding = CharsetToEncoding[this.handshake.characterSet]; + connection.connectionId = this.handshake.connectionId; + connection._isMariaDB = /mariadb/i.test(this.handshake.serverVersion); + if (this.handshake.mariadbExtendedCapabilityFlags & MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA) { + this.clientFlags &= ~ClientConstants.LONG_PASSWORD; + this.mariadbExtendedClientFlags |= MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA; + } + connection._mariadbExtendedMetadata = Boolean( + this.mariadbExtendedClientFlags & MariaDBClientConstants.MARIADB_CLIENT_EXTENDED_METADATA + ); + const serverSSLSupport = this.handshake.capabilityFlags & ClientConstants.SSL; + const multiFactorAuthentication = this.handshake.capabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION; + this.clientFlags = this.clientFlags | multiFactorAuthentication; + connection.config.compress = connection.config.compress && this.handshake.capabilityFlags & ClientConstants.COMPRESS; + this.clientFlags = this.clientFlags | connection.config.compress; + if (connection.config.ssl) { + if (!serverSSLSupport) { + const err = new Error("Server does not support secure connection"); + err.code = "HANDSHAKE_NO_SSL_SUPPORT"; + err.fatal = true; + this.emit("error", err); + return false; + } + this.clientFlags |= ClientConstants.SSL; + this.sendSSLRequest(connection); + connection.startTLS((err) => { + if (err) { + err.code = "HANDSHAKE_SSL_ERROR"; + err.fatal = true; + this.emit("error", err); + return; + } + this.sendCredentials(connection); + }); + } else { + this.sendCredentials(connection); + } + if (multiFactorAuthentication) { + this.authenticationFactor = 1; + } + return _ClientHandshake.prototype.handshakeResult; + } + handshakeResult(packet, connection) { + const marker = packet.peekByte(); + if (marker === 254 || marker === 1 || marker === 2) { + const authSwitch = require_auth_switch(); + try { + if (marker === 1) { + authSwitch.authSwitchRequestMoreData(packet, connection, this); + } else { + if (this.authenticationFactor !== 0) { + connection.config.password = this[`password${this.authenticationFactor}`]; + this.authenticationFactor += 1; + } + authSwitch.authSwitchRequest(packet, connection, this); + } + return _ClientHandshake.prototype.handshakeResult; + } catch (err) { + if (!err.code) { + err.code = "AUTH_SWITCH_PLUGIN_ERROR"; + } + err.fatal = true; + if (this.onResult) { + this.onResult(err); + } else { + this.emit("error", err); + } + return null; + } + } + if (marker !== 0) { + const err = new Error("Unexpected packet during handshake phase"); + err.code = "HANDSHAKE_UNKNOWN_ERROR"; + err.fatal = true; + if (this.onResult) { + this.onResult(err); + } else { + this.emit("error", err); + } + return null; + } + if (!connection.authorized) { + connection.authorized = true; + if (connection.config.compress) { + const enableCompression = require_compressed_protocol().enableCompression; + enableCompression(connection); + } + } + if (this.onResult) { + this.onResult(null); + } + return null; + } + }; + module2.exports = ClientHandshake; + } +}); + +// node_modules/mysql2/lib/commands/server_handshake.js +var require_server_handshake = __commonJS({ + "node_modules/mysql2/lib/commands/server_handshake.js"(exports2, module2) { + "use strict"; + var CommandCode = require_commands(); + var Errors = require_errors(); + var Command = require_command(); + var Packets = require_packets(); + var ServerHandshake = class _ServerHandshake extends Command { + constructor(args) { + super(); + this.args = args; + } + start(packet, connection) { + const serverHelloPacket = new Packets.Handshake(this.args); + this.serverHello = serverHelloPacket; + serverHelloPacket.setScrambleData((err) => { + if (err) { + connection.emit("error", new Error("Error generating random bytes")); + return; + } + connection.writePacket(serverHelloPacket.toPacket(0)); + }); + return _ServerHandshake.prototype.readClientReply; + } + readClientReply(packet, connection) { + const clientHelloReply = Packets.HandshakeResponse.fromPacket( + packet, + this.args.capabilityFlags + ); + connection.clientHelloReply = clientHelloReply; + if (this.args.authCallback) { + this.args.authCallback( + { + user: clientHelloReply.user, + database: clientHelloReply.database, + address: connection.stream.remoteAddress, + authPluginData1: this.serverHello.authPluginData1, + authPluginData2: this.serverHello.authPluginData2, + authToken: clientHelloReply.authToken + }, + (err, mysqlError) => { + if (!mysqlError) { + connection.writeOk(); + } else { + connection.writeError({ + message: mysqlError.message || "", + code: mysqlError.code || 1045 + }); + connection.close(); + } + } + ); + } else { + connection.writeOk(); + } + return _ServerHandshake.prototype.dispatchCommands; + } + _isStatement(query, name) { + const firstWord = query.split(" ")[0].toUpperCase(); + return firstWord === name; + } + dispatchCommands(packet, connection) { + let knownCommand = true; + const encoding = connection.clientHelloReply.encoding; + const commandCode = packet.readInt8(); + switch (commandCode) { + case CommandCode.STMT_PREPARE: + if (connection.listeners("stmt_prepare").length) { + const query = packet.readString(void 0, encoding); + connection.emit("stmt_prepare", query); + } else { + connection.writeError({ + code: Errors.HA_ERR_INTERNAL_ERROR, + message: "No query handler for prepared statements." + }); + } + break; + case CommandCode.STMT_EXECUTE: + if (connection.listeners("stmt_execute").length) { + const { stmtId, flags, iterationCount, values } = Packets.Execute.fromPacket(packet, encoding); + connection.emit( + "stmt_execute", + stmtId, + flags, + iterationCount, + values + ); + } else { + connection.writeError({ + code: Errors.HA_ERR_INTERNAL_ERROR, + message: "No query handler for execute statements." + }); + } + break; + case CommandCode.QUIT: + if (connection.listeners("quit").length) { + connection.emit("quit"); + } else { + connection.stream.end(); + } + break; + case CommandCode.INIT_DB: + if (connection.listeners("init_db").length) { + const schemaName = packet.readString(void 0, encoding); + connection.emit("init_db", schemaName); + } else { + connection.writeOk(); + } + break; + case CommandCode.QUERY: + if (connection.listeners("query").length) { + const query = packet.readString(void 0, encoding); + if (this._isStatement(query, "PREPARE") || this._isStatement(query, "SET")) { + connection.emit("stmt_prepare", query); + } else if (this._isStatement(query, "EXECUTE")) { + connection.emit("stmt_execute", null, null, null, null, query); + } else connection.emit("query", query); + } else { + connection.writeError({ + code: Errors.HA_ERR_INTERNAL_ERROR, + message: "No query handler" + }); + } + break; + case CommandCode.FIELD_LIST: + if (connection.listeners("field_list").length) { + const table = packet.readNullTerminatedString(encoding); + const fields = packet.readString(void 0, encoding); + connection.emit("field_list", table, fields); + } else { + connection.writeError({ + code: Errors.ER_WARN_DEPRECATED_SYNTAX, + message: "As of MySQL 5.7.11, COM_FIELD_LIST is deprecated and will be removed in a future version of MySQL." + }); + } + break; + case CommandCode.PING: + if (connection.listeners("ping").length) { + connection.emit("ping"); + } else { + connection.writeOk(); + } + break; + default: + knownCommand = false; + } + if (connection.listeners("packet").length) { + connection.emit("packet", packet.clone(), knownCommand, commandCode); + } else if (!knownCommand) { + console.log("Unknown command:", commandCode); + } + return _ServerHandshake.prototype.dispatchCommands; + } + }; + module2.exports = ServerHandshake; + } +}); + +// node_modules/mysql2/lib/constants/charsets.js +var require_charsets = __commonJS({ + "node_modules/mysql2/lib/constants/charsets.js"(exports2) { + "use strict"; + exports2.BIG5_CHINESE_CI = 1; + exports2.LATIN2_CZECH_CS = 2; + exports2.DEC8_SWEDISH_CI = 3; + exports2.CP850_GENERAL_CI = 4; + exports2.LATIN1_GERMAN1_CI = 5; + exports2.HP8_ENGLISH_CI = 6; + exports2.KOI8R_GENERAL_CI = 7; + exports2.LATIN1_SWEDISH_CI = 8; + exports2.LATIN2_GENERAL_CI = 9; + exports2.SWE7_SWEDISH_CI = 10; + exports2.ASCII_GENERAL_CI = 11; + exports2.UJIS_JAPANESE_CI = 12; + exports2.SJIS_JAPANESE_CI = 13; + exports2.CP1251_BULGARIAN_CI = 14; + exports2.LATIN1_DANISH_CI = 15; + exports2.HEBREW_GENERAL_CI = 16; + exports2.TIS620_THAI_CI = 18; + exports2.EUCKR_KOREAN_CI = 19; + exports2.LATIN7_ESTONIAN_CS = 20; + exports2.LATIN2_HUNGARIAN_CI = 21; + exports2.KOI8U_GENERAL_CI = 22; + exports2.CP1251_UKRAINIAN_CI = 23; + exports2.GB2312_CHINESE_CI = 24; + exports2.GREEK_GENERAL_CI = 25; + exports2.CP1250_GENERAL_CI = 26; + exports2.LATIN2_CROATIAN_CI = 27; + exports2.GBK_CHINESE_CI = 28; + exports2.CP1257_LITHUANIAN_CI = 29; + exports2.LATIN5_TURKISH_CI = 30; + exports2.LATIN1_GERMAN2_CI = 31; + exports2.ARMSCII8_GENERAL_CI = 32; + exports2.UTF8_GENERAL_CI = 33; + exports2.CP1250_CZECH_CS = 34; + exports2.UCS2_GENERAL_CI = 35; + exports2.CP866_GENERAL_CI = 36; + exports2.KEYBCS2_GENERAL_CI = 37; + exports2.MACCE_GENERAL_CI = 38; + exports2.MACROMAN_GENERAL_CI = 39; + exports2.CP852_GENERAL_CI = 40; + exports2.LATIN7_GENERAL_CI = 41; + exports2.LATIN7_GENERAL_CS = 42; + exports2.MACCE_BIN = 43; + exports2.CP1250_CROATIAN_CI = 44; + exports2.UTF8MB4_GENERAL_CI = 45; + exports2.UTF8MB4_BIN = 46; + exports2.LATIN1_BIN = 47; + exports2.LATIN1_GENERAL_CI = 48; + exports2.LATIN1_GENERAL_CS = 49; + exports2.CP1251_BIN = 50; + exports2.CP1251_GENERAL_CI = 51; + exports2.CP1251_GENERAL_CS = 52; + exports2.MACROMAN_BIN = 53; + exports2.UTF16_GENERAL_CI = 54; + exports2.UTF16_BIN = 55; + exports2.UTF16LE_GENERAL_CI = 56; + exports2.CP1256_GENERAL_CI = 57; + exports2.CP1257_BIN = 58; + exports2.CP1257_GENERAL_CI = 59; + exports2.UTF32_GENERAL_CI = 60; + exports2.UTF32_BIN = 61; + exports2.UTF16LE_BIN = 62; + exports2.BINARY = 63; + exports2.ARMSCII8_BIN = 64; + exports2.ASCII_BIN = 65; + exports2.CP1250_BIN = 66; + exports2.CP1256_BIN = 67; + exports2.CP866_BIN = 68; + exports2.DEC8_BIN = 69; + exports2.GREEK_BIN = 70; + exports2.HEBREW_BIN = 71; + exports2.HP8_BIN = 72; + exports2.KEYBCS2_BIN = 73; + exports2.KOI8R_BIN = 74; + exports2.KOI8U_BIN = 75; + exports2.UTF8_TOLOWER_CI = 76; + exports2.LATIN2_BIN = 77; + exports2.LATIN5_BIN = 78; + exports2.LATIN7_BIN = 79; + exports2.CP850_BIN = 80; + exports2.CP852_BIN = 81; + exports2.SWE7_BIN = 82; + exports2.UTF8_BIN = 83; + exports2.BIG5_BIN = 84; + exports2.EUCKR_BIN = 85; + exports2.GB2312_BIN = 86; + exports2.GBK_BIN = 87; + exports2.SJIS_BIN = 88; + exports2.TIS620_BIN = 89; + exports2.UCS2_BIN = 90; + exports2.UJIS_BIN = 91; + exports2.GEOSTD8_GENERAL_CI = 92; + exports2.GEOSTD8_BIN = 93; + exports2.LATIN1_SPANISH_CI = 94; + exports2.CP932_JAPANESE_CI = 95; + exports2.CP932_BIN = 96; + exports2.EUCJPMS_JAPANESE_CI = 97; + exports2.EUCJPMS_BIN = 98; + exports2.CP1250_POLISH_CI = 99; + exports2.UTF16_UNICODE_CI = 101; + exports2.UTF16_ICELANDIC_CI = 102; + exports2.UTF16_LATVIAN_CI = 103; + exports2.UTF16_ROMANIAN_CI = 104; + exports2.UTF16_SLOVENIAN_CI = 105; + exports2.UTF16_POLISH_CI = 106; + exports2.UTF16_ESTONIAN_CI = 107; + exports2.UTF16_SPANISH_CI = 108; + exports2.UTF16_SWEDISH_CI = 109; + exports2.UTF16_TURKISH_CI = 110; + exports2.UTF16_CZECH_CI = 111; + exports2.UTF16_DANISH_CI = 112; + exports2.UTF16_LITHUANIAN_CI = 113; + exports2.UTF16_SLOVAK_CI = 114; + exports2.UTF16_SPANISH2_CI = 115; + exports2.UTF16_ROMAN_CI = 116; + exports2.UTF16_PERSIAN_CI = 117; + exports2.UTF16_ESPERANTO_CI = 118; + exports2.UTF16_HUNGARIAN_CI = 119; + exports2.UTF16_SINHALA_CI = 120; + exports2.UTF16_GERMAN2_CI = 121; + exports2.UTF16_CROATIAN_CI = 122; + exports2.UTF16_UNICODE_520_CI = 123; + exports2.UTF16_VIETNAMESE_CI = 124; + exports2.UCS2_UNICODE_CI = 128; + exports2.UCS2_ICELANDIC_CI = 129; + exports2.UCS2_LATVIAN_CI = 130; + exports2.UCS2_ROMANIAN_CI = 131; + exports2.UCS2_SLOVENIAN_CI = 132; + exports2.UCS2_POLISH_CI = 133; + exports2.UCS2_ESTONIAN_CI = 134; + exports2.UCS2_SPANISH_CI = 135; + exports2.UCS2_SWEDISH_CI = 136; + exports2.UCS2_TURKISH_CI = 137; + exports2.UCS2_CZECH_CI = 138; + exports2.UCS2_DANISH_CI = 139; + exports2.UCS2_LITHUANIAN_CI = 140; + exports2.UCS2_SLOVAK_CI = 141; + exports2.UCS2_SPANISH2_CI = 142; + exports2.UCS2_ROMAN_CI = 143; + exports2.UCS2_PERSIAN_CI = 144; + exports2.UCS2_ESPERANTO_CI = 145; + exports2.UCS2_HUNGARIAN_CI = 146; + exports2.UCS2_SINHALA_CI = 147; + exports2.UCS2_GERMAN2_CI = 148; + exports2.UCS2_CROATIAN_CI = 149; + exports2.UCS2_UNICODE_520_CI = 150; + exports2.UCS2_VIETNAMESE_CI = 151; + exports2.UCS2_GENERAL_MYSQL500_CI = 159; + exports2.UTF32_UNICODE_CI = 160; + exports2.UTF32_ICELANDIC_CI = 161; + exports2.UTF32_LATVIAN_CI = 162; + exports2.UTF32_ROMANIAN_CI = 163; + exports2.UTF32_SLOVENIAN_CI = 164; + exports2.UTF32_POLISH_CI = 165; + exports2.UTF32_ESTONIAN_CI = 166; + exports2.UTF32_SPANISH_CI = 167; + exports2.UTF32_SWEDISH_CI = 168; + exports2.UTF32_TURKISH_CI = 169; + exports2.UTF32_CZECH_CI = 170; + exports2.UTF32_DANISH_CI = 171; + exports2.UTF32_LITHUANIAN_CI = 172; + exports2.UTF32_SLOVAK_CI = 173; + exports2.UTF32_SPANISH2_CI = 174; + exports2.UTF32_ROMAN_CI = 175; + exports2.UTF32_PERSIAN_CI = 176; + exports2.UTF32_ESPERANTO_CI = 177; + exports2.UTF32_HUNGARIAN_CI = 178; + exports2.UTF32_SINHALA_CI = 179; + exports2.UTF32_GERMAN2_CI = 180; + exports2.UTF32_CROATIAN_CI = 181; + exports2.UTF32_UNICODE_520_CI = 182; + exports2.UTF32_VIETNAMESE_CI = 183; + exports2.UTF8_UNICODE_CI = 192; + exports2.UTF8_ICELANDIC_CI = 193; + exports2.UTF8_LATVIAN_CI = 194; + exports2.UTF8_ROMANIAN_CI = 195; + exports2.UTF8_SLOVENIAN_CI = 196; + exports2.UTF8_POLISH_CI = 197; + exports2.UTF8_ESTONIAN_CI = 198; + exports2.UTF8_SPANISH_CI = 199; + exports2.UTF8_SWEDISH_CI = 200; + exports2.UTF8_TURKISH_CI = 201; + exports2.UTF8_CZECH_CI = 202; + exports2.UTF8_DANISH_CI = 203; + exports2.UTF8_LITHUANIAN_CI = 204; + exports2.UTF8_SLOVAK_CI = 205; + exports2.UTF8_SPANISH2_CI = 206; + exports2.UTF8_ROMAN_CI = 207; + exports2.UTF8_PERSIAN_CI = 208; + exports2.UTF8_ESPERANTO_CI = 209; + exports2.UTF8_HUNGARIAN_CI = 210; + exports2.UTF8_SINHALA_CI = 211; + exports2.UTF8_GERMAN2_CI = 212; + exports2.UTF8_CROATIAN_CI = 213; + exports2.UTF8_UNICODE_520_CI = 214; + exports2.UTF8_VIETNAMESE_CI = 215; + exports2.UTF8_GENERAL_MYSQL500_CI = 223; + exports2.UTF8MB4_UNICODE_CI = 224; + exports2.UTF8MB4_ICELANDIC_CI = 225; + exports2.UTF8MB4_LATVIAN_CI = 226; + exports2.UTF8MB4_ROMANIAN_CI = 227; + exports2.UTF8MB4_SLOVENIAN_CI = 228; + exports2.UTF8MB4_POLISH_CI = 229; + exports2.UTF8MB4_ESTONIAN_CI = 230; + exports2.UTF8MB4_SPANISH_CI = 231; + exports2.UTF8MB4_SWEDISH_CI = 232; + exports2.UTF8MB4_TURKISH_CI = 233; + exports2.UTF8MB4_CZECH_CI = 234; + exports2.UTF8MB4_DANISH_CI = 235; + exports2.UTF8MB4_LITHUANIAN_CI = 236; + exports2.UTF8MB4_SLOVAK_CI = 237; + exports2.UTF8MB4_SPANISH2_CI = 238; + exports2.UTF8MB4_ROMAN_CI = 239; + exports2.UTF8MB4_PERSIAN_CI = 240; + exports2.UTF8MB4_ESPERANTO_CI = 241; + exports2.UTF8MB4_HUNGARIAN_CI = 242; + exports2.UTF8MB4_SINHALA_CI = 243; + exports2.UTF8MB4_GERMAN2_CI = 244; + exports2.UTF8MB4_CROATIAN_CI = 245; + exports2.UTF8MB4_UNICODE_520_CI = 246; + exports2.UTF8MB4_VIETNAMESE_CI = 247; + exports2.GB18030_CHINESE_CI = 248; + exports2.GB18030_BIN = 249; + exports2.GB18030_UNICODE_520_CI = 250; + exports2.UTF8_GENERAL50_CI = 253; + exports2.UTF8MB4_0900_AI_CI = 255; + exports2.UTF8MB4_DE_PB_0900_AI_CI = 256; + exports2.UTF8MB4_IS_0900_AI_CI = 257; + exports2.UTF8MB4_LV_0900_AI_CI = 258; + exports2.UTF8MB4_RO_0900_AI_CI = 259; + exports2.UTF8MB4_SL_0900_AI_CI = 260; + exports2.UTF8MB4_PL_0900_AI_CI = 261; + exports2.UTF8MB4_ET_0900_AI_CI = 262; + exports2.UTF8MB4_ES_0900_AI_CI = 263; + exports2.UTF8MB4_SV_0900_AI_CI = 264; + exports2.UTF8MB4_TR_0900_AI_CI = 265; + exports2.UTF8MB4_CS_0900_AI_CI = 266; + exports2.UTF8MB4_DA_0900_AI_CI = 267; + exports2.UTF8MB4_LT_0900_AI_CI = 268; + exports2.UTF8MB4_SK_0900_AI_CI = 269; + exports2.UTF8MB4_ES_TRAD_0900_AI_CI = 270; + exports2.UTF8MB4_LA_0900_AI_CI = 271; + exports2.UTF8MB4_EO_0900_AI_CI = 273; + exports2.UTF8MB4_HU_0900_AI_CI = 274; + exports2.UTF8MB4_HR_0900_AI_CI = 275; + exports2.UTF8MB4_VI_0900_AI_CI = 277; + exports2.UTF8MB4_0900_AS_CS = 278; + exports2.UTF8MB4_DE_PB_0900_AS_CS = 279; + exports2.UTF8MB4_IS_0900_AS_CS = 280; + exports2.UTF8MB4_LV_0900_AS_CS = 281; + exports2.UTF8MB4_RO_0900_AS_CS = 282; + exports2.UTF8MB4_SL_0900_AS_CS = 283; + exports2.UTF8MB4_PL_0900_AS_CS = 284; + exports2.UTF8MB4_ET_0900_AS_CS = 285; + exports2.UTF8MB4_ES_0900_AS_CS = 286; + exports2.UTF8MB4_SV_0900_AS_CS = 287; + exports2.UTF8MB4_TR_0900_AS_CS = 288; + exports2.UTF8MB4_CS_0900_AS_CS = 289; + exports2.UTF8MB4_DA_0900_AS_CS = 290; + exports2.UTF8MB4_LT_0900_AS_CS = 291; + exports2.UTF8MB4_SK_0900_AS_CS = 292; + exports2.UTF8MB4_ES_TRAD_0900_AS_CS = 293; + exports2.UTF8MB4_LA_0900_AS_CS = 294; + exports2.UTF8MB4_EO_0900_AS_CS = 296; + exports2.UTF8MB4_HU_0900_AS_CS = 297; + exports2.UTF8MB4_HR_0900_AS_CS = 298; + exports2.UTF8MB4_VI_0900_AS_CS = 300; + exports2.UTF8MB4_JA_0900_AS_CS = 303; + exports2.UTF8MB4_JA_0900_AS_CS_KS = 304; + exports2.UTF8MB4_0900_AS_CI = 305; + exports2.UTF8MB4_RU_0900_AI_CI = 306; + exports2.UTF8MB4_RU_0900_AS_CS = 307; + exports2.UTF8MB4_ZH_0900_AS_CS = 308; + exports2.UTF8MB4_0900_BIN = 309; + exports2.BIG5 = exports2.BIG5_CHINESE_CI; + exports2.DEC8 = exports2.DEC8_SWEDISH_CI; + exports2.CP850 = exports2.CP850_GENERAL_CI; + exports2.HP8 = exports2.HP8_ENGLISH_CI; + exports2.KOI8R = exports2.KOI8R_GENERAL_CI; + exports2.LATIN1 = exports2.LATIN1_SWEDISH_CI; + exports2.LATIN2 = exports2.LATIN2_GENERAL_CI; + exports2.SWE7 = exports2.SWE7_SWEDISH_CI; + exports2.ASCII = exports2.ASCII_GENERAL_CI; + exports2.UJIS = exports2.UJIS_JAPANESE_CI; + exports2.SJIS = exports2.SJIS_JAPANESE_CI; + exports2.HEBREW = exports2.HEBREW_GENERAL_CI; + exports2.TIS620 = exports2.TIS620_THAI_CI; + exports2.EUCKR = exports2.EUCKR_KOREAN_CI; + exports2.KOI8U = exports2.KOI8U_GENERAL_CI; + exports2.GB2312 = exports2.GB2312_CHINESE_CI; + exports2.GREEK = exports2.GREEK_GENERAL_CI; + exports2.CP1250 = exports2.CP1250_GENERAL_CI; + exports2.GBK = exports2.GBK_CHINESE_CI; + exports2.LATIN5 = exports2.LATIN5_TURKISH_CI; + exports2.ARMSCII8 = exports2.ARMSCII8_GENERAL_CI; + exports2.UTF8 = exports2.UTF8_GENERAL_CI; + exports2.UCS2 = exports2.UCS2_GENERAL_CI; + exports2.CP866 = exports2.CP866_GENERAL_CI; + exports2.KEYBCS2 = exports2.KEYBCS2_GENERAL_CI; + exports2.MACCE = exports2.MACCE_GENERAL_CI; + exports2.MACROMAN = exports2.MACROMAN_GENERAL_CI; + exports2.CP852 = exports2.CP852_GENERAL_CI; + exports2.LATIN7 = exports2.LATIN7_GENERAL_CI; + exports2.UTF8MB4 = exports2.UTF8MB4_GENERAL_CI; + exports2.CP1251 = exports2.CP1251_GENERAL_CI; + exports2.UTF16 = exports2.UTF16_GENERAL_CI; + exports2.UTF16LE = exports2.UTF16LE_GENERAL_CI; + exports2.CP1256 = exports2.CP1256_GENERAL_CI; + exports2.CP1257 = exports2.CP1257_GENERAL_CI; + exports2.UTF32 = exports2.UTF32_GENERAL_CI; + exports2.CP932 = exports2.CP932_JAPANESE_CI; + exports2.EUCJPMS = exports2.EUCJPMS_JAPANESE_CI; + exports2.GB18030 = exports2.GB18030_CHINESE_CI; + exports2.GEOSTD8 = exports2.GEOSTD8_GENERAL_CI; + } +}); + +// node_modules/is-property/is-property.js +var require_is_property = __commonJS({ + "node_modules/is-property/is-property.js"(exports2, module2) { + "use strict"; + function isProperty(str) { + return /^[$A-Z\_a-z\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc][$A-Z\_a-z\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc0-9\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19b0-\u19c0\u19c8\u19c9\u19d0-\u19d9\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1dc0-\u1de6\u1dfc-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f]*$/.test(str); + } + module2.exports = isProperty; + } +}); + +// node_modules/generate-function/index.js +var require_generate_function = __commonJS({ + "node_modules/generate-function/index.js"(exports2, module2) { + var util = require("util"); + var isProperty = require_is_property(); + var INDENT_START = /[\{\[]/; + var INDENT_END = /[\}\]]/; + var RESERVED = [ + "do", + "if", + "in", + "for", + "let", + "new", + "try", + "var", + "case", + "else", + "enum", + "eval", + "null", + "this", + "true", + "void", + "with", + "await", + "break", + "catch", + "class", + "const", + "false", + "super", + "throw", + "while", + "yield", + "delete", + "export", + "import", + "public", + "return", + "static", + "switch", + "typeof", + "default", + "extends", + "finally", + "package", + "private", + "continue", + "debugger", + "function", + "arguments", + "interface", + "protected", + "implements", + "instanceof", + "NaN", + "undefined" + ]; + var RESERVED_MAP = {}; + for (i = 0; i < RESERVED.length; i++) { + RESERVED_MAP[RESERVED[i]] = true; + } + var i; + var isVariable = function(name) { + return isProperty(name) && !RESERVED_MAP.hasOwnProperty(name); + }; + var formats = { + s: function(s) { + return "" + s; + }, + d: function(d) { + return "" + Number(d); + }, + o: function(o) { + return JSON.stringify(o); + } + }; + var genfun = function() { + var lines = []; + var indent = 0; + var vars = {}; + var push = function(str) { + var spaces = ""; + while (spaces.length < indent * 2) spaces += " "; + lines.push(spaces + str); + }; + var pushLine = function(line2) { + if (INDENT_END.test(line2.trim()[0]) && INDENT_START.test(line2[line2.length - 1])) { + indent--; + push(line2); + indent++; + return; + } + if (INDENT_START.test(line2[line2.length - 1])) { + push(line2); + indent++; + return; + } + if (INDENT_END.test(line2.trim()[0])) { + indent--; + push(line2); + return; + } + push(line2); + }; + var line = function(fmt) { + if (!fmt) return line; + if (arguments.length === 1 && fmt.indexOf("\n") > -1) { + var lines2 = fmt.trim().split("\n"); + for (var i2 = 0; i2 < lines2.length; i2++) { + pushLine(lines2[i2].trim()); + } + } else { + pushLine(util.format.apply(util, arguments)); + } + return line; + }; + line.scope = {}; + line.formats = formats; + line.sym = function(name) { + if (!name || !isVariable(name)) name = "tmp"; + if (!vars[name]) vars[name] = 0; + return name + (vars[name]++ || ""); + }; + line.property = function(obj, name) { + if (arguments.length === 1) { + name = obj; + obj = ""; + } + name = name + ""; + if (isProperty(name)) return obj ? obj + "." + name : name; + return obj ? obj + "[" + JSON.stringify(name) + "]" : JSON.stringify(name); + }; + line.toString = function() { + return lines.join("\n"); + }; + line.toFunction = function(scope) { + if (!scope) scope = {}; + var src = "return (" + line.toString() + ")"; + Object.keys(line.scope).forEach(function(key) { + if (!scope[key]) scope[key] = line.scope[key]; + }); + var keys = Object.keys(scope).map(function(key) { + return key; + }); + var vals = keys.map(function(key) { + return scope[key]; + }); + return Function.apply(null, keys.concat(src)).apply(null, vals); + }; + if (arguments.length) line.apply(null, arguments); + return line; + }; + genfun.formats = formats; + module2.exports = genfun; + } +}); + +// node_modules/mysql2/lib/parsers/text_parser.js +var require_text_parser = __commonJS({ + "node_modules/mysql2/lib/parsers/text_parser.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var Charsets = require_charsets(); + var helpers = require_helpers(); + var genFunc = require_generate_function(); + var parserCache = require_parser_cache(); + var LocalDate = require_local_date(); + var typeNames = []; + for (const t in Types) { + typeNames[Types[t]] = t; + } + function readCodeFor(field, encodingExpr, config, options) { + const type = field.columnType; + const charset = field.characterSet; + const supportBigNumbers = Boolean( + options.supportBigNumbers || config.supportBigNumbers + ); + const bigNumberStrings = Boolean( + options.bigNumberStrings || config.bigNumberStrings + ); + const timezone = options.timezone || config.timezone; + const dateStrings = options.dateStrings || config.dateStrings; + if (field.extendedFormat === "json") { + return config.jsonStrings ? `packet.readLengthCodedString(${encodingExpr})` : `packet.parseJson(${encodingExpr}, ${supportBigNumbers})`; + } + switch (type) { + case Types.TINY: + case Types.SHORT: + case Types.LONG: + case Types.INT24: + case Types.YEAR: + return "packet.parseLengthCodedIntNoBigCheck()"; + case Types.LONGLONG: + if (supportBigNumbers && bigNumberStrings) { + return "packet.parseLengthCodedIntString()"; + } + return `packet.parseLengthCodedInt(${supportBigNumbers})`; + case Types.FLOAT: + case Types.DOUBLE: + return "packet.parseLengthCodedFloat()"; + case Types.NULL: + return "packet.readLengthCodedNumber()"; + case Types.DECIMAL: + case Types.NEWDECIMAL: + if (config.decimalNumbers) { + return "packet.parseLengthCodedFloat()"; + } + return 'packet.readLengthCodedString("ascii")'; + case Types.DATE: + if (helpers.typeMatch(type, dateStrings, Types)) { + return 'packet.readLengthCodedString("ascii")'; + } + return `packet.parseDate(${helpers.srcEscape(timezone)})`; + case Types.DATETIME: + case Types.TIMESTAMP: + if (helpers.typeMatch(type, dateStrings, Types)) { + return 'packet.readLengthCodedString("ascii")'; + } + return `packet.parseDateTime(${helpers.srcEscape(timezone)})`; + case Types.TIME: + return 'packet.readLengthCodedString("ascii")'; + case Types.GEOMETRY: + return "packet.parseGeometryValue()"; + case Types.VECTOR: + return "packet.parseVector()"; + case Types.JSON: + return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : `packet.parseJson("utf8", ${supportBigNumbers})`; + default: + if (charset === Charsets.BINARY) { + return "packet.readLengthCodedBuffer()"; + } + return `packet.readLengthCodedString(${encodingExpr})`; + } + } + function compile(fields, options, config) { + if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") { + options.typeCast = config.typeCast; + } + function wrap(field, _this) { + return { + type: typeNames[field.columnType], + extendedTypeName: field.extendedTypeName, + extendedFormat: field.extendedFormat, + length: field.columnLength, + db: field.schema, + table: field.table, + name: field.name, + string: function(encoding = field.encoding) { + if (field.columnType === Types.JSON && encoding === field.encoding) { + console.warn( + `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\`` + ); + } + return _this.packet.readLengthCodedString(encoding); + }, + buffer: function() { + return _this.packet.readLengthCodedBuffer(); + }, + geometry: function() { + return _this.packet.parseGeometryValue(); + } + }; + } + const parserFn = genFunc(); + parserFn("(function () {")("return class TextRow {"); + parserFn("constructor(fields) {"); + if (typeof options.typeCast === "function") { + parserFn("const _this = this;"); + parserFn("for(let i=0; i LocalDate.usesLocalDate(field, options, config))) { + parserFn("LocalDate.checkTimezone();"); + } + parserFn("}"); + parserFn("next(packet, fields, options) {"); + parserFn("this.packet = packet;"); + if (options.rowsAsArray) { + parserFn(`const result = new Array(${fields.length});`); + } else { + parserFn("const result = {};"); + } + const resultTables = {}; + let resultTablesArray = []; + if (options.nestTables === true) { + for (let i = 0; i < fields.length; i++) { + resultTables[fields[i].table] = 1; + } + resultTablesArray = Object.keys(resultTables); + for (let i = 0; i < resultTablesArray.length; i++) { + parserFn(`result[${helpers.fieldEscape(resultTablesArray[i])}] = {};`); + } + } + let lvalue = ""; + let fieldName = ""; + let tableName = ""; + for (let i = 0; i < fields.length; i++) { + fieldName = helpers.fieldEscape(fields[i].name); + if (typeof options.nestTables === "string") { + lvalue = `result[${helpers.fieldEscape(fields[i].table + options.nestTables + fields[i].name)}]`; + } else if (options.nestTables === true) { + tableName = helpers.fieldEscape(fields[i].table); + parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`); + lvalue = `result[${tableName}][${fieldName}]`; + } else if (options.rowsAsArray) { + lvalue = `result[${i.toString(10)}]`; + } else { + lvalue = `result[${fieldName}]`; + } + if (options.typeCast === false) { + parserFn(`${lvalue} = packet.readLengthCodedBuffer();`); + } else { + const encodingExpr = `fields[${i}].encoding`; + const readCode = readCodeFor(fields[i], encodingExpr, config, options); + if (typeof options.typeCast === "function") { + parserFn( + `${lvalue} = options.typeCast(this.wrap${i}, function() { return ${readCode} });` + ); + } else { + parserFn(`${lvalue} = ${readCode};`); + } + } + } + parserFn("return result;"); + parserFn("}"); + parserFn("};")("})()"); + if (config.debug) { + helpers.printDebugWithCode( + "Compiled text protocol row parser", + parserFn.toString() + ); + } + return parserFn.toFunction({ wrap, LocalDate }); + } + function getTextParser(fields, options, config) { + return parserCache.getParser("text", fields, options, config, compile); + } + module2.exports = getTextParser; + } +}); + +// node_modules/mysql2/lib/parsers/static_text_parser.js +var require_static_text_parser = __commonJS({ + "node_modules/mysql2/lib/parsers/static_text_parser.js"(exports2, module2) { + "use strict"; + var Types = require_types(); + var Charsets = require_charsets(); + var helpers = require_helpers(); + var LocalDate = require_local_date(); + var typeNames = []; + for (const t in Types) { + typeNames[Types[t]] = t; + } + function readField({ + packet, + field, + type, + charset, + encoding, + config, + options + }) { + const supportBigNumbers = Boolean( + options.supportBigNumbers || config.supportBigNumbers + ); + const bigNumberStrings = Boolean( + options.bigNumberStrings || config.bigNumberStrings + ); + const timezone = options.timezone || config.timezone; + const dateStrings = options.dateStrings || config.dateStrings; + if (field.extendedFormat === "json") { + return config.jsonStrings ? packet.readLengthCodedString(encoding) : packet.parseJson(encoding, supportBigNumbers); + } + switch (type) { + case Types.TINY: + case Types.SHORT: + case Types.LONG: + case Types.INT24: + case Types.YEAR: + return packet.parseLengthCodedIntNoBigCheck(); + case Types.LONGLONG: + if (supportBigNumbers && bigNumberStrings) { + return packet.parseLengthCodedIntString(); + } + return packet.parseLengthCodedInt(supportBigNumbers); + case Types.FLOAT: + case Types.DOUBLE: + return packet.parseLengthCodedFloat(); + case Types.NULL: + case Types.DECIMAL: + case Types.NEWDECIMAL: + if (config.decimalNumbers) { + return packet.parseLengthCodedFloat(); + } + return packet.readLengthCodedString("ascii"); + case Types.DATE: + if (helpers.typeMatch(type, dateStrings, Types)) { + return packet.readLengthCodedString("ascii"); + } + return packet.parseDate(timezone); + case Types.DATETIME: + case Types.TIMESTAMP: + if (helpers.typeMatch(type, dateStrings, Types)) { + return packet.readLengthCodedString("ascii"); + } + return packet.parseDateTime(timezone); + case Types.TIME: + return packet.readLengthCodedString("ascii"); + case Types.GEOMETRY: + return packet.parseGeometryValue(); + case Types.VECTOR: + return packet.parseVector(); + case Types.JSON: + return config.jsonStrings ? packet.readLengthCodedString("utf8") : packet.parseJson("utf8", supportBigNumbers); + default: + if (charset === Charsets.BINARY) { + return packet.readLengthCodedBuffer(); + } + return packet.readLengthCodedString(encoding); + } + } + function createTypecastField(field, packet) { + return { + type: typeNames[field.columnType], + extendedTypeName: field.extendedTypeName, + extendedFormat: field.extendedFormat, + length: field.columnLength, + db: field.schema, + table: field.table, + name: field.name, + string: function(encoding = field.encoding) { + if (field.columnType === Types.JSON && encoding === field.encoding) { + console.warn( + `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\`` + ); + } + return packet.readLengthCodedString(encoding); + }, + buffer: function() { + return packet.readLengthCodedBuffer(); + }, + geometry: function() { + return packet.parseGeometryValue(); + } + }; + } + function getTextParser(fields, options, config) { + if (fields.some((field) => LocalDate.usesLocalDate(field, options, config))) { + LocalDate.checkTimezone(); + } + return { + next(packet, fields2, options2) { + const result = options2.rowsAsArray ? [] : {}; + for (let i = 0; i < fields2.length; i++) { + const field = fields2[i]; + const typeCast = options2.typeCast ? options2.typeCast : config.typeCast; + const next = () => readField({ + packet, + field, + type: field.columnType, + encoding: field.encoding, + charset: field.characterSet, + config, + options: options2 + }); + let value; + if (options2.typeCast === false) { + value = packet.readLengthCodedBuffer(); + } else if (typeof typeCast === "function") { + value = typeCast(createTypecastField(field, packet), next); + } else { + value = next(); + } + if (options2.rowsAsArray) { + result.push(value); + } else if (typeof options2.nestTables === "string") { + result[`${helpers.fieldEscape(field.table, false)}${options2.nestTables}${helpers.fieldEscape(field.name, false)}`] = value; + } else if (options2.nestTables) { + const tableName = helpers.fieldEscape(field.table, false); + if (!result[tableName]) { + result[tableName] = {}; + } + result[tableName][helpers.fieldEscape(field.name, false)] = value; + } else { + result[helpers.fieldEscape(field.name, false)] = value; + } + } + return result; + } + }; + } + module2.exports = getTextParser; + } +}); + +// node_modules/mysql2/package.json +var require_package = __commonJS({ + "node_modules/mysql2/package.json"(exports2, module2) { + module2.exports = { + name: "mysql2", + version: "3.24.6", + description: "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS", + main: "index.js", + typings: "typings/mysql/index", + type: "commonjs", + scripts: { + lint: "biome lint --error-on-warnings && prettier --check .", + "lint:fix": "biome lint --write . && prettier --write .", + test: "poku", + "test:bun": "bun poku", + "test:deno": "deno run -A npm:poku", + "test:docker:up": "docker compose -f test/docker-compose.yml up --abort-on-container-exit --remove-orphans", + "test:docker:down": "docker compose -f test/docker-compose.yml down", + "test:docker:node": "npm run test:docker:up -- node && npm run test:docker:down", + "test:docker:bun": "npm run test:docker:up -- bun && npm run test:docker:down", + "test:docker:deno": "npm run test:docker:up -- deno && npm run test:docker:down", + "test:docker:coverage": "npm run test:docker:up -- coverage && npm run test:docker:down", + "test:coverage": "c8 npm test", + "test:build": "rollup -c", + typecheck: 'cd "test/tsc-build" && tsc -p "tsconfig.json" && cd .. && tsc -p "tsconfig.json" --noEmit', + "src:typecheck": "tsc -p src/tsconfig.json --noEmit && tsc -p tools/src/tsconfig.json", + "src:build": "tsx tools/src/clean.mts && tsc -p src/tsconfig.json", + "src:test": "npm run src:build && tsx tools/src/prepare-tests.mts && poku --config=tools/src/poku.config.mts", + "src:test:bun": "npm run src:build && tsx tools/src/prepare-tests.mts && bun poku --config=tools/src/poku.config.mts", + "src:test:deno": "npm run src:build && tsx tools/src/prepare-tests.mts && deno run -A npm:poku --config=tools/src/poku.config.mts", + benchmark: "node ./benchmarks/benchmark.js", + "wait-port": "wait-on" + }, + repository: { + type: "git", + url: "git+https://github.com/sidorares/node-mysql2.git" + }, + homepage: "https://sidorares.github.io/node-mysql2/docs", + keywords: [ + "mysql", + "client", + "server" + ], + files: [ + "lib", + "typings/mysql", + "index.js", + "index.d.ts", + "promise.js", + "promise.d.ts" + ], + exports: { + ".": "./index.js", + "./package.json": "./package.json", + "./promise": "./promise.js", + "./promise.js": "./promise.js" + }, + engines: { + node: ">= 8.0" + }, + author: "Andrey Sidorov ", + license: "MIT", + dependencies: { + "aws-ssl-profiles": "^1.1.2", + "generate-function": "^2.3.1", + "iconv-lite": "^0.7.3", + long: "^5.3.2", + "lru.min": "^1.1.4", + "named-placeholders": "^1.1.6", + "sql-escaper": "^1.5.1" + }, + peerDependencies: { + "@types/node": ">= 8" + }, + devDependencies: { + "@biomejs/biome": "^2.5.7", + "@ianvs/prettier-plugin-sort-imports": "^4.7.1", + "@pokujs/multi-suite": "^1.0.2", + "@rollup/plugin-commonjs": "^29.0.3", + "@rollup/plugin-json": "^6.1.0", + "@rollup/plugin-node-resolve": "^16.0.3", + "@types/node": "^26.2.0", + "assert-diff": "^3.0.4", + benchmark: "^2.1.4", + c8: "^12.0.0", + "error-stack-parser": "^2.1.4", + poku: "^4.5.0", + portfinder: "^1.0.38", + prettier: "^3.9.6", + rollup: "^4.62.4", + tsx: "^4.23.11", + typescript: "^7.0.2" + } + }; + } +}); + +// node_modules/aws-ssl-profiles/lib/profiles/ca/defaults.js +var require_defaults = __commonJS({ + "node_modules/aws-ssl-profiles/lib/profiles/ca/defaults.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.defaults = void 0; + exports2.defaults = [ + "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJAM2ZN/+nPi27MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBhZi1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkxMDI4MTgwNTU4WhcNMjQxMDI2MTgwNTU4WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgYWYtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwR2351uPMZaJk2gMGT+1sk8HE9MQh2rc\n/sCnbxGn2p1c7Oi9aBbd/GiFijeJb2BXvHU+TOq3d3Jjqepq8tapXVt4ojbTJNyC\nJ5E7r7KjTktKdLxtBE1MK25aY+IRJjtdU6vG3KiPKUT1naO3xs3yt0F76WVuFivd\n9OHv2a+KHvPkRUWIxpmAHuMY9SIIMmEZtVE7YZGx5ah0iO4JzItHcbVR0y0PBH55\narpFBddpIVHCacp1FUPxSEWkOpI7q0AaU4xfX0fe1BV5HZYRKpBOIp1TtZWvJD+X\njGUtL1BEsT5vN5g9MkqdtYrC+3SNpAk4VtpvJrdjraI/hhvfeXNnAwIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEi/\nWWMcBJsoGXg+EZwkQ0MscZQwHwYDVR0jBBgwFoAUEEi/WWMcBJsoGXg+EZwkQ0Ms\ncZQwDQYJKoZIhvcNAQELBQADggEBAGDZ5js5Pc/gC58LJrwMPXFhJDBS8QuDm23C\nFFUdlqucskwOS3907ErK1ZkmVJCIqFLArHqskFXMAkRZ2PNR7RjWLqBs+0znG5yH\nhRKb4DXzhUFQ18UBRcvT6V6zN97HTRsEEaNhM/7k8YLe7P8vfNZ28VIoJIGGgv9D\nwQBBvkxQ71oOmAG0AwaGD0ORGUfbYry9Dz4a4IcUsZyRWRMADixgrFv6VuETp26s\n/+z+iqNaGWlELBKh3iQCT6Y/1UnkPLO42bxrCSyOvshdkYN58Q2gMTE1SVTqyo8G\nLw8lLAz9bnvUSgHzB3jRrSx6ggF/WRMRYlR++y6LXP4SAsSAaC0=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJAJYM4LxvTZA6MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBldS1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkxMDMwMjAyMDM2WhcNMjQxMDI4MjAyMDM2WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgZXUtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqM921jXCXeqpRNCS9CBPOe5N7gMaEt+D\ns5uR3riZbqzRlHGiF1jZihkXfHAIQewDwy+Yz+Oec1aEZCQMhUHxZJPusuX0cJfj\nb+UluFqHIijL2TfXJ3D0PVLLoNTQJZ8+GAPECyojAaNuoHbdVqxhOcznMsXIXVFq\nyVLKDGvyKkJjai/iSPDrQMXufg3kWt0ISjNLvsG5IFXgP4gttsM8i0yvRd4QcHoo\nDjvH7V3cS+CQqW5SnDrGnHToB0RLskE1ET+oNOfeN9PWOxQprMOX/zmJhnJQlTqD\nQP7jcf7SddxrKFjuziFiouskJJyNDsMjt1Lf60+oHZhed2ogTeifGwIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFBAF\ncgJe/BBuZiGeZ8STfpkgRYQwHwYDVR0jBBgwFoAUFBAFcgJe/BBuZiGeZ8STfpkg\nRYQwDQYJKoZIhvcNAQELBQADggEBAKAYUtlvDuX2UpZW9i1QgsjFuy/ErbW0dLHU\ne/IcFtju2z6RLZ+uF+5A8Kme7IKG1hgt8s+w9TRVQS/7ukQzoK3TaN6XKXRosjtc\no9Rm4gYWM8bmglzY1TPNaiI4HC7546hSwJhubjN0bXCuj/0sHD6w2DkiGuwKNAef\nyTu5vZhPkeNyXLykxkzz7bNp2/PtMBnzIp+WpS7uUDmWyScGPohKMq5PqvL59z+L\nZI3CYeMZrJ5VpXUg3fNNIz/83N3G0sk7wr0ohs/kHTP7xPOYB0zD7Ku4HA0Q9Swf\nWX0qr6UQgTPMjfYDLffI7aEId0gxKw1eGYc6Cq5JAZ3ipi/cBFc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJANew34ehz5l8MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBtZS1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkwNTEwMjE0ODI3WhcNMjQwNTA4MjE0ODI3WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgbWUtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp7BYV88MukcY+rq0r79+C8UzkT30fEfT\naPXbx1d6M7uheGN4FMaoYmL+JE1NZPaMRIPTHhFtLSdPccInvenRDIatcXX+jgOk\nUA6lnHQ98pwN0pfDUyz/Vph4jBR9LcVkBbe0zdoKKp+HGbMPRU0N2yNrog9gM5O8\ngkU/3O2csJ/OFQNnj4c2NQloGMUpEmedwJMOyQQfcUyt9CvZDfIPNnheUS29jGSw\nERpJe/AENu8Pxyc72jaXQuD+FEi2Ck6lBkSlWYQFhTottAeGvVFNCzKszCntrtqd\nrdYUwurYsLTXDHv9nW2hfDUQa0mhXf9gNDOBIVAZugR9NqNRNyYLHQIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54cf\nDjgwBx4ycBH8+/r8WXdaiqYwHwYDVR0jBBgwFoAU54cfDjgwBx4ycBH8+/r8WXda\niqYwDQYJKoZIhvcNAQELBQADggEBAIIMTSPx/dR7jlcxggr+O6OyY49Rlap2laKA\neC/XI4ySP3vQkIFlP822U9Kh8a9s46eR0uiwV4AGLabcu0iKYfXjPkIprVCqeXV7\nny9oDtrbflyj7NcGdZLvuzSwgl9SYTJp7PVCZtZutsPYlbJrBPHwFABvAkMvRtDB\nhitIg4AESDGPoCl94sYHpfDfjpUDMSrAMDUyO6DyBdZH5ryRMAs3lGtsmkkNUrso\naTW6R05681Z0mvkRdb+cdXtKOSuDZPoe2wJJIaz3IlNQNSrB5TImMYgmt6iAsFhv\n3vfTSTKrZDNTJn4ybG6pq1zWExoXsktZPylJly6R3RBwV6nwqBM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBjCCAu6gAwIBAgIJAMc0ZzaSUK51MA0GCSqGSIb3DQEBCwUAMIGPMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkw\nODIyMTcwODUwWhcNMjQwODIyMTcwODUwWjCBjzELMAkGA1UEBhMCVVMxEDAOBgNV\nBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoMGUFtYXpv\nbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxIDAeBgNV\nBAMMF0FtYXpvbiBSRFMgUm9vdCAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEArXnF/E6/Qh+ku3hQTSKPMhQQlCpoWvnIthzX6MK3p5a0eXKZ\noWIjYcNNG6UwJjp4fUXl6glp53Jobn+tWNX88dNH2n8DVbppSwScVE2LpuL+94vY\n0EYE/XxN7svKea8YvlrqkUBKyxLxTjh+U/KrGOaHxz9v0l6ZNlDbuaZw3qIWdD/I\n6aNbGeRUVtpM6P+bWIoxVl/caQylQS6CEYUk+CpVyJSkopwJlzXT07tMoDL5WgX9\nO08KVgDNz9qP/IGtAcRduRcNioH3E9v981QO1zt/Gpb2f8NqAjUUCUZzOnij6mx9\nMcZ+9cWX88CRzR0vQODWuZscgI08NvM69Fn2SQIDAQABo2MwYTAOBgNVHQ8BAf8E\nBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc19g2LzLA5j0Kxc0LjZa\npmD/vB8wHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJKoZIhvcN\nAQELBQADggEBAHAG7WTmyjzPRIM85rVj+fWHsLIvqpw6DObIjMWokpliCeMINZFV\nynfgBKsf1ExwbvJNzYFXW6dihnguDG9VMPpi2up/ctQTN8tm9nDKOy08uNZoofMc\nNUZxKCEkVKZv+IL4oHoeayt8egtv3ujJM6V14AstMQ6SwvwvA93EP/Ug2e4WAXHu\ncbI1NAbUgVDqp+DRdfvZkgYKryjTWd/0+1fS8X1bBZVWzl7eirNVnHbSH2ZDpNuY\n0SBd8dj5F6ld3t58ydZbrTHze7JJOd8ijySAp4/kiu9UfZWuTPABzDa/DSdz9Dk/\nzPW4CXXvhLmE02TA9/HeCw3KEHIwicNuEfw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEEDCCAvigAwIBAgIJAKFMXyltvuRdMA0GCSqGSIb3DQEBCwUAMIGUMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJEUyBCZXRhIFJvb3QgMjAxOSBDQTAe\nFw0xOTA4MTkxNzM4MjZaFw0yNDA4MTkxNzM4MjZaMIGUMQswCQYDVQQGEwJVUzEQ\nMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UECgwZ\nQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEl\nMCMGA1UEAwwcQW1hem9uIFJEUyBCZXRhIFJvb3QgMjAxOSBDQTCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBAMkZdnIH9ndatGAcFo+DppGJ1HUt4x+zeO+0\nZZ29m0sfGetVulmTlv2d5b66e+QXZFWpcPQMouSxxYTW08TbrQiZngKr40JNXftA\natvzBqIImD4II0ZX5UEVj2h98qe/ypW5xaDN7fEa5e8FkYB1TEemPaWIbNXqchcL\ntV7IJPr3Cd7Z5gZJlmujIVDPpMuSiNaal9/6nT9oqN+JSM1fx5SzrU5ssg1Vp1vv\n5Xab64uOg7wCJRB9R2GC9XD04odX6VcxUAGrZo6LR64ZSifupo3l+R5sVOc5i8NH\nskdboTzU9H7+oSdqoAyhIU717PcqeDum23DYlPE2nGBWckE+eT8CAwEAAaNjMGEw\nDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFK2hDBWl\nsbHzt/EHd0QYOooqcFPhMB8GA1UdIwQYMBaAFK2hDBWlsbHzt/EHd0QYOooqcFPh\nMA0GCSqGSIb3DQEBCwUAA4IBAQAO/718k8EnOqJDx6wweUscGTGL/QdKXUzTVRAx\nJUsjNUv49mH2HQVEW7oxszfH6cPCaupNAddMhQc4C/af6GHX8HnqfPDk27/yBQI+\nyBBvIanGgxv9c9wBbmcIaCEWJcsLp3HzXSYHmjiqkViXwCpYfkoV3Ns2m8bp+KCO\ny9XmcCKRaXkt237qmoxoh2sGmBHk2UlQtOsMC0aUQ4d7teAJG0q6pbyZEiPyKZY1\nXR/UVxMJL0Q4iVpcRS1kaNCMfqS2smbLJeNdsan8pkw1dvPhcaVTb7CvjhJtjztF\nYfDzAI5794qMlWxwilKMmUvDlPPOTen8NNHkLwWvyFCH7Doh\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEFjCCAv6gAwIBAgIJAMzYZJ+R9NBVMA0GCSqGSIb3DQEBCwUAMIGXMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEoMCYGA1UEAwwfQW1hem9uIFJEUyBQcmV2aWV3IFJvb3QgMjAxOSBD\nQTAeFw0xOTA4MjEyMjI5NDlaFw0yNDA4MjEyMjI5NDlaMIGXMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEoMCYGA1UEAwwfQW1hem9uIFJEUyBQcmV2aWV3IFJvb3QgMjAxOSBDQTCCASIw\nDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM7kkS6vjgKKQTPynC2NjdN5aPPV\nO71G0JJS/2ARVBVJd93JLiGovVJilfWYfwZCs4gTRSSjrUD4D4HyqCd6A+eEEtJq\nM0DEC7i0dC+9WNTsPszuB206Jy2IUmxZMIKJAA1NHSbIMjB+b6/JhbSUi7nKdbR/\nbrj83bF+RoSA+ogrgX7mQbxhmFcoZN9OGaJgYKsKWUt5Wqv627KkGodUK8mDepgD\nS3ZfoRQRx3iceETpcmHJvaIge6+vyDX3d9Z22jmvQ4AKv3py2CmU2UwuhOltFDwB\n0ddtb39vgwrJxaGfiMRHpEP1DfNLWHAnA69/pgZPwIggidS+iBPUhgucMp8CAwEA\nAaNjMGEwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFGnTGpQuQ2H/DZlXMQijZEhjs7TdMB8GA1UdIwQYMBaAFGnTGpQuQ2H/DZlXMQij\nZEhjs7TdMA0GCSqGSIb3DQEBCwUAA4IBAQC3xz1vQvcXAfpcZlngiRWeqU8zQAMQ\nLZPCFNv7PVk4pmqX+ZiIRo4f9Zy7TrOVcboCnqmP/b/mNq0gVF4O+88jwXJZD+f8\n/RnABMZcnGU+vK0YmxsAtYU6TIb1uhRFmbF8K80HHbj9vSjBGIQdPCbvmR2zY6VJ\nBYM+w9U9hp6H4DVMLKXPc1bFlKA5OBTgUtgkDibWJKFOEPW3UOYwp9uq6pFoN0AO\nxMTldqWFsOF3bJIlvOY0c/1EFZXu3Ns6/oCP//Ap9vumldYMUZWmbK+gK33FPOXV\n8BQ6jNC29icv7lLDpRPwjibJBXX+peDR5UK4FdYcswWEB1Tix5X8dYu6\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQTAeFw0xOTEw\nMjgxODA2NTNaFw0yNDEwMjgxODA2NTNaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBhZi1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAvtV1OqmFa8zCVQSKOvPUJERLVFtd4rZmDpImc5rIoeBk7w/P\n9lcKUJjO8R/w1a2lJXx3oQ81tiY0Piw6TpT62YWVRMWrOw8+Vxq1dNaDSFp9I8d0\nUHillSSbOk6FOrPDp+R6AwbGFqUDebbN5LFFoDKbhNmH1BVS0a6YNKpGigLRqhka\ncClPslWtPqtjbaP3Jbxl26zWzLo7OtZl98dR225pq8aApNBwmtgA7Gh60HK/cX0t\n32W94n8D+GKSg6R4MKredVFqRTi9hCCNUu0sxYPoELuM+mHiqB5NPjtm92EzCWs+\n+vgWhMc6GxG+82QSWx1Vj8sgLqtE/vLrWddf5QIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUuLB4gYVJrSKJj/Gz\npqc6yeA+RcAwHwYDVR0jBBgwFoAUEEi/WWMcBJsoGXg+EZwkQ0MscZQwDQYJKoZI\nhvcNAQELBQADggEBABauYOZxUhe9/RhzGJ8MsWCz8eKcyDVd4FCnY6Qh+9wcmYNT\nLtnD88LACtJKb/b81qYzcB0Em6+zVJ3Z9jznfr6buItE6es9wAoja22Xgv44BTHL\nrimbgMwpTt3uEMXDffaS0Ww6YWb3pSE0XYI2ISMWz+xRERRf+QqktSaL39zuiaW5\ntfZMre+YhohRa/F0ZQl3RCd6yFcLx4UoSPqQsUl97WhYzwAxZZfwvLJXOc4ATt3u\nVlCUylNDkaZztDJc/yN5XQoK9W5nOt2cLu513MGYKbuarQr8f+gYU8S+qOyuSRSP\nNRITzwCRVnsJE+2JmcRInn/NcanB7uOGqTvJ9+c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQTAeFw0xOTEw\nMzAyMDIxMzBaFw0yNDEwMzAyMDIxMzBaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBldS1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAtEyjYcajx6xImJn8Vz1zjdmL4ANPgQXwF7+tF7xccmNAZETb\nbzb3I9i5fZlmrRaVznX+9biXVaGxYzIUIR3huQ3Q283KsDYnVuGa3mk690vhvJbB\nQIPgKa5mVwJppnuJm78KqaSpi0vxyCPe3h8h6LLFawVyWrYNZ4okli1/U582eef8\nRzJp/Ear3KgHOLIiCdPDF0rjOdCG1MOlDLixVnPn9IYOciqO+VivXBg+jtfc5J+L\nAaPm0/Yx4uELt1tkbWkm4BvTU/gBOODnYziITZM0l6Fgwvbwgq5duAtKW+h031lC\n37rEvrclqcp4wrsUYcLAWX79ZyKIlRxcAdvEhQIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU7zPyc0azQxnBCe7D\nb9KAadH1QSEwHwYDVR0jBBgwFoAUFBAFcgJe/BBuZiGeZ8STfpkgRYQwDQYJKoZI\nhvcNAQELBQADggEBAFGaNiYxg7yC/xauXPlaqLCtwbm2dKyK9nIFbF/7be8mk7Q3\nMOA0of1vGHPLVQLr6bJJpD9MAbUcm4cPAwWaxwcNpxOjYOFDaq10PCK4eRAxZWwF\nNJRIRmGsl8NEsMNTMCy8X+Kyw5EzH4vWFl5Uf2bGKOeFg0zt43jWQVOX6C+aL3Cd\npRS5MhmYpxMG8irrNOxf4NVFE2zpJOCm3bn0STLhkDcV/ww4zMzObTJhiIb5wSWn\nEXKKWhUXuRt7A2y1KJtXpTbSRHQxE++69Go1tWhXtRiULCJtf7wF2Ksm0RR/AdXT\n1uR1vKyH5KBJPX3ppYkQDukoHTFR0CpB+G84NLo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQTAeFw0xOTA1\nMTAyMTU4NDNaFw0yNTA2MDExMjAwMDBaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBtZS1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAudOYPZH+ihJAo6hNYMB5izPVBe3TYhnZm8+X3IoaaYiKtsp1\nJJhkTT0CEejYIQ58Fh4QrMUyWvU8qsdK3diNyQRoYLbctsBPgxBR1u07eUJDv38/\nC1JlqgHmMnMi4y68Iy7ymv50QgAMuaBqgEBRI1R6Lfbyrb2YvH5txjJyTVMwuCfd\nYPAtZVouRz0JxmnfsHyxjE+So56uOKTDuw++Ho4HhZ7Qveej7XB8b+PIPuroknd3\nFQB5RVbXRvt5ZcVD4F2fbEdBniF7FAF4dEiofVCQGQ2nynT7dZdEIPfPdH3n7ZmE\nlAOmwHQ6G83OsiHRBLnbp+QZRgOsjkHJxT20bQIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUOEVDM7VomRH4HVdA\nQvIMNq2tXOcwHwYDVR0jBBgwFoAU54cfDjgwBx4ycBH8+/r8WXdaiqYwDQYJKoZI\nhvcNAQELBQADggEBAHhvMssj+Th8IpNePU6RH0BiL6o9c437R3Q4IEJeFdYL+nZz\nPW/rELDPvLRUNMfKM+KzduLZ+l29HahxefejYPXtvXBlq/E/9czFDD4fWXg+zVou\nuDXhyrV4kNmP4S0eqsAP/jQHPOZAMFA4yVwO9hlqmePhyDnszCh9c1PfJSBh49+b\n4w7i/L3VBOMt8j3EKYvqz0gVfpeqhJwL4Hey8UbVfJRFJMJzfNHpePqtDRAY7yjV\nPYquRaV2ab/E+/7VFkWMM4tazYz/qsYA2jSH+4xDHvYk8LnsbcrF9iuidQmEc5sb\nFgcWaSKG4DJjcI5k7AJLWcXyTDt21Ci43LE+I9Q=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgICVIYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDQxNzEz\nMDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\nem9uIFJEUyBhcC1zb3V0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDUYOz1hGL42yUCrcsMSOoU8AeD/3KgZ4q7gP+vAz1WnY9K/kim\neWN/2Qqzlo3+mxSFQFyD4MyV3+CnCPnBl9Sh1G/F6kThNiJ7dEWSWBQGAB6HMDbC\nBaAsmUc1UIz8sLTL3fO+S9wYhA63Wun0Fbm/Rn2yk/4WnJAaMZcEtYf6e0KNa0LM\np/kN/70/8cD3iz3dDR8zOZFpHoCtf0ek80QqTich0A9n3JLxR6g6tpwoYviVg89e\nqCjQ4axxOkWWeusLeTJCcY6CkVyFvDAKvcUl1ytM5AiaUkXblE7zDFXRM4qMMRdt\nlPm8d3pFxh0fRYk8bIKnpmtOpz3RIctDrZZxAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBT99wKJftD3jb4sHoHG\ni3uGlH6W6TAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAZ17hhr3dII3hUfuHQ1hPWGrpJOX/G9dLzkprEIcCidkmRYl+\nhu1Pe3caRMh/17+qsoEErmnVq5jNY9X1GZL04IZH8YbHc7iRHw3HcWAdhN8633+K\njYEB2LbJ3vluCGnCejq9djDb6alOugdLMJzxOkHDhMZ6/gYbECOot+ph1tQuZXzD\ntZ7prRsrcuPBChHlPjmGy8M9z8u+kF196iNSUGC4lM8vLkHM7ycc1/ZOwRq9aaTe\niOghbQQyAEe03MWCyDGtSmDfr0qEk+CHN+6hPiaL8qKt4s+V9P7DeK4iW08ny8Ox\nAVS7u0OK/5+jKMAMrKwpYrBydOjTUTHScocyNw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICQ2QwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDUxODQ2\nMjlaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBzYS1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAMMvR+ReRnOzqJzoaPipNTt1Z2VA968jlN1+SYKUrYM3No+Vpz0H\nM6Tn0oYB66ByVsXiGc28ulsqX1HbHsxqDPwvQTKvO7SrmDokoAkjJgLocOLUAeld\n5AwvUjxGRP6yY90NV7X786MpnYb2Il9DIIaV9HjCmPt+rjy2CZjS0UjPjCKNfB8J\nbFjgW6GGscjeyGb/zFwcom5p4j0rLydbNaOr9wOyQrtt3ZQWLYGY9Zees/b8pmcc\nJt+7jstZ2UMV32OO/kIsJ4rMUn2r/uxccPwAc1IDeRSSxOrnFKhW3Cu69iB3bHp7\nJbawY12g7zshE4I14sHjv3QoXASoXjx4xgMCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFI1Fc/Ql2jx+oJPgBVYq\nccgP0pQ8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQB4VVVabVp70myuYuZ3vltQIWqSUMhkaTzehMgGcHjMf9iLoZ/I\n93KiFUSGnek5cRePyS9wcpp0fcBT3FvkjpUdCjVtdttJgZFhBxgTd8y26ImdDDMR\n4+BUuhI5msvjL08f+Vkkpu1GQcGmyFVPFOy/UY8iefu+QyUuiBUnUuEDd49Hw0Fn\n/kIPII6Vj82a2mWV/Q8e+rgN8dIRksRjKI03DEoP8lhPlsOkhdwU6Uz9Vu6NOB2Q\nLs1kbcxAc7cFSyRVJEhh12Sz9d0q/CQSTFsVJKOjSNQBQfVnLz1GwO/IieUEAr4C\njkTntH0r1LX5b/GwN4R887LvjAEdTbg1his7\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIDAIkHMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTA2MTc0\nMDIxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\nc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\nU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\nYXpvbiBSRFMgdXMtd2VzdC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDD2yzbbAl77OofTghDMEf624OvU0eS9O+lsdO0QlbfUfWa1Kd6\n0WkgjkLZGfSRxEHMCnrv4UPBSK/Qwn6FTjkDLgemhqBtAnplN4VsoDL+BkRX4Wwq\n/dSQJE2b+0hm9w9UMVGFDEq1TMotGGTD2B71eh9HEKzKhGzqiNeGsiX4VV+LJzdH\nuM23eGisNqmd4iJV0zcAZ+Gbh2zK6fqTOCvXtm7Idccv8vZZnyk1FiWl3NR4WAgK\nAkvWTIoFU3Mt7dIXKKClVmvssG8WHCkd3Xcb4FHy/G756UZcq67gMMTX/9fOFM/v\nl5C0+CHl33Yig1vIDZd+fXV1KZD84dEJfEvHAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBR+ap20kO/6A7pPxo3+\nT3CfqZpQWjAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAHCJky2tPjPttlDM/RIqExupBkNrnSYnOK4kr9xJ3sl8UF2DA\nPAnYsjXp3rfcjN/k/FVOhxwzi3cXJF/2Tjj39Bm/OEfYTOJDNYtBwB0VVH4ffa/6\ntZl87jaIkrxJcreeeHqYMnIxeN0b/kliyA+a5L2Yb0VPjt9INq34QDc1v74FNZ17\n4z8nr1nzg4xsOWu0Dbjo966lm4nOYIGBRGOKEkHZRZ4mEiMgr3YLkv8gSmeitx57\nZ6dVemNtUic/LVo5Iqw4n3TBS0iF2C1Q1xT/s3h+0SXZlfOWttzSluDvoMv5PvCd\npFjNn+aXLAALoihL1MJSsxydtsLjOBro5eK0Vw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICOFAwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAxNzQ2\nMjFaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAzU72e6XbaJbi4HjJoRNjKxzUEuChKQIt7k3CWzNnmjc5\n8I1MjCpa2W1iw1BYVysXSNSsLOtUsfvBZxi/1uyMn5ZCaf9aeoA9UsSkFSZBjOCN\nDpKPCmfV1zcEOvJz26+1m8WDg+8Oa60QV0ou2AU1tYcw98fOQjcAES0JXXB80P2s\n3UfkNcnDz+l4k7j4SllhFPhH6BQ4lD2NiFAP4HwoG6FeJUn45EPjzrydxjq6v5Fc\ncQ8rGuHADVXotDbEhaYhNjIrsPL+puhjWfhJjheEw8c4whRZNp6gJ/b6WEes/ZhZ\nh32DwsDsZw0BfRDUMgUn8TdecNexHUw8vQWeC181hwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwW9bWgkWkr0U\nlrOsq2kvIdrECDgwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAEugF0Gj7HVhX0ehPZoGRYRt3PBuI2YjfrrJRTZ9X5wc\n9T8oHmw07mHmNy1qqWvooNJg09bDGfB0k5goC2emDiIiGfc/kvMLI7u+eQOoMKj6\nmkfCncyRN3ty08Po45vTLBFZGUvtQmjM6yKewc4sXiASSBmQUpsMbiHRCL72M5qV\nobcJOjGcIdDTmV1BHdWT+XcjynsGjUqOvQWWhhLPrn4jWe6Xuxll75qlrpn3IrIx\nCRBv/5r7qbcQJPOgwQsyK4kv9Ly8g7YT1/vYBlR3cRsYQjccw5ceWUj2DrMVWhJ4\nprf+E3Aa4vYmLLOUUvKnDQ1k3RGNu56V0tonsQbfsaM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECjCCAvKgAwIBAgICEzUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAyMDUy\nMjVaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\nem9uIFJEUyBjYS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\nggEPADCCAQoCggEBAOxHqdcPSA2uBjsCP4DLSlqSoPuQ/X1kkJLusVRKiQE2zayB\nviuCBt4VB9Qsh2rW3iYGM+usDjltGnI1iUWA5KHcvHszSMkWAOYWLiMNKTlg6LCp\nXnE89tvj5dIH6U8WlDvXLdjB/h30gW9JEX7S8supsBSci2GxEzb5mRdKaDuuF/0O\nqvz4YE04pua3iZ9QwmMFuTAOYzD1M72aOpj+7Ac+YLMM61qOtU+AU6MndnQkKoQi\nqmUN2A9IFaqHFzRlSdXwKCKUA4otzmz+/N3vFwjb5F4DSsbsrMfjeHMo6o/nb6Nh\nYDb0VJxxPee6TxSuN7CQJ2FxMlFUezcoXqwqXD0CAwEAAaNmMGQwDgYDVR0PAQH/\nBAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFDGGpon9WfIpsggE\nCxHq8hZ7E2ESMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\nSIb3DQEBCwUAA4IBAQAvpeQYEGZvoTVLgV9rd2+StPYykMsmFjWQcyn3dBTZRXC2\nlKq7QhQczMAOhEaaN29ZprjQzsA2X/UauKzLR2Uyqc2qOeO9/YOl0H3qauo8C/W9\nr8xqPbOCDLEXlOQ19fidXyyEPHEq5WFp8j+fTh+s8WOx2M7IuC0ANEetIZURYhSp\nxl9XOPRCJxOhj7JdelhpweX0BJDNHeUFi0ClnFOws8oKQ7sQEv66d5ddxqqZ3NVv\nRbCvCtEutQMOUMIuaygDlMn1anSM8N7Wndx8G6+Uy67AnhjGx7jw/0YPPxopEj6x\nJXP8j0sJbcT9K/9/fPVLNT25RvQ/93T2+IQL4Ca2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICYpgwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExNzMx\nNDhaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAMk3YdSZ64iAYp6MyyKtYJtNzv7zFSnnNf6vv0FB4VnfITTMmOyZ\nLXqKAT2ahZ00hXi34ewqJElgU6eUZT/QlzdIu359TEZyLVPwURflL6SWgdG01Q5X\nO++7fSGcBRyIeuQWs9FJNIIqK8daF6qw0Rl5TXfu7P9dBc3zkgDXZm2DHmxGDD69\n7liQUiXzoE1q2Z9cA8+jirDioJxN9av8hQt12pskLQumhlArsMIhjhHRgF03HOh5\ntvi+RCfihVOxELyIRTRpTNiIwAqfZxxTWFTgfn+gijTmd0/1DseAe82aYic8JbuS\nEMbrDduAWsqrnJ4GPzxHKLXX0JasCUcWyMECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPLtsq1NrwJXO13C9eHt\nsLY11AGwMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQAnWBKj5xV1A1mYd0kIgDdkjCwQkiKF5bjIbGkT3YEFFbXoJlSP\n0lZZ/hDaOHI8wbLT44SzOvPEEmWF9EE7SJzkvSdQrUAWR9FwDLaU427ALI3ngNHy\nlGJ2hse1fvSRNbmg8Sc9GBv8oqNIBPVuw+AJzHTacZ1OkyLZrz1c1QvwvwN2a+Jd\nvH0V0YIhv66llKcYDMUQJAQi4+8nbRxXWv6Gq3pvrFoorzsnkr42V3JpbhnYiK+9\nnRKd4uWl62KRZjGkfMbmsqZpj2fdSWMY1UGyN1k+kDmCSWYdrTRDP0xjtIocwg+A\nJ116n4hV/5mbA0BaPiS2krtv17YAeHABZcvz\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECjCCAvKgAwIBAgICV2YwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExOTM2\nMjBaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\nem9uIFJEUyBldS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\nggEPADCCAQoCggEBAMEx54X2pHVv86APA0RWqxxRNmdkhAyp2R1cFWumKQRofoFv\nn+SPXdkpIINpMuEIGJANozdiEz7SPsrAf8WHyD93j/ZxrdQftRcIGH41xasetKGl\nI67uans8d+pgJgBKGb/Z+B5m+UsIuEVekpvgpwKtmmaLFC/NCGuSsJoFsRqoa6Gh\nm34W6yJoY87UatddCqLY4IIXaBFsgK9Q/wYzYLbnWM6ZZvhJ52VMtdhcdzeTHNW0\n5LGuXJOF7Ahb4JkEhoo6TS2c0NxB4l4MBfBPgti+O7WjR3FfZHpt18A6Zkq6A2u6\nD/oTSL6c9/3sAaFTFgMyL3wHb2YlW0BPiljZIqECAwEAAaNmMGQwDgYDVR0PAQH/\nBAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFOcAToAc6skWffJa\nTnreaswAfrbcMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\nSIb3DQEBCwUAA4IBAQA1d0Whc1QtspK496mFWfFEQNegLh0a9GWYlJm+Htcj5Nxt\nDAIGXb+8xrtOZFHmYP7VLCT5Zd2C+XytqseK/+s07iAr0/EPF+O2qcyQWMN5KhgE\ncXw2SwuP9FPV3i+YAm11PBVeenrmzuk9NrdHQ7TxU4v7VGhcsd2C++0EisrmquWH\nmgIfmVDGxphwoES52cY6t3fbnXmTkvENvR+h3rj+fUiSz0aSo+XZUGHPgvuEKM/W\nCBD9Smc9CBoBgvy7BgHRgRUmwtABZHFUIEjHI5rIr7ZvYn+6A0O6sogRfvVYtWFc\nqpyrW1YX8mD0VlJ8fGKM3G+aCOsiiPKDV/Uafrm+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgICGAcwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIxODE5\nNDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\nem9uIFJEUyBldS1ub3J0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQCiIYnhe4UNBbdBb/nQxl5giM0XoVHWNrYV5nB0YukA98+TPn9v\nAoj1RGYmtryjhrf01Kuv8SWO+Eom95L3zquoTFcE2gmxCfk7bp6qJJ3eHOJB+QUO\nXsNRh76fwDzEF1yTeZWH49oeL2xO13EAx4PbZuZpZBttBM5zAxgZkqu4uWQczFEs\nJXfla7z2fvWmGcTagX10O5C18XaFroV0ubvSyIi75ue9ykg/nlFAeB7O0Wxae88e\nuhiBEFAuLYdqWnsg3459NfV8Yi1GnaitTym6VI3tHKIFiUvkSiy0DAlAGV2iiyJE\nq+DsVEO4/hSINJEtII4TMtysOsYPpINqeEzRAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBRR0UpnbQyjnHChgmOc\nhnlc0PogzTAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAKJD4xVzSf4zSGTBJrmamo86jl1NHQxXUApAZuBZEc8tqC6TI\nT5CeoSr9CMuVC8grYyBjXblC4OsM5NMvmsrXl/u5C9dEwtBFjo8mm53rOOIm1fxl\nI1oYB/9mtO9ANWjkykuLzWeBlqDT/i7ckaKwalhLODsRDO73vRhYNjsIUGloNsKe\npxw3dzHwAZx4upSdEVG4RGCZ1D0LJ4Gw40OfD69hfkDfRVVxKGrbEzqxXRvovmDc\ntKLdYZO/6REoca36v4BlgIs1CbUXJGLSXUwtg7YXGLSVBJ/U0+22iGJmBSNcoyUN\ncjPFD9JQEhDDIYYKSGzIYpvslvGc4T5ISXFiuQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICZIEwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIyMTMy\nMzJaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBALGiwqjiF7xIjT0Sx7zB3764K2T2a1DHnAxEOr+/EIftWKxWzT3u\nPFwS2eEZcnKqSdRQ+vRzonLBeNLO4z8aLjQnNbkizZMBuXGm4BqRm1Kgq3nlLDQn\n7YqdijOq54SpShvR/8zsO4sgMDMmHIYAJJOJqBdaus2smRt0NobIKc0liy7759KB\n6kmQ47Gg+kfIwxrQA5zlvPLeQImxSoPi9LdbRoKvu7Iot7SOa+jGhVBh3VdqndJX\n7tm/saj4NE375csmMETFLAOXjat7zViMRwVorX4V6AzEg1vkzxXpA9N7qywWIT5Y\nfYaq5M8i6vvLg0CzrH9fHORtnkdjdu1y+0MCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFFOhOx1yt3Z7mvGB9jBv\n2ymdZwiOMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQBehqY36UGDvPVU9+vtaYGr38dBbp+LzkjZzHwKT1XJSSUc2wqM\nhnCIQKilonrTIvP1vmkQi8qHPvDRtBZKqvz/AErW/ZwQdZzqYNFd+BmOXaeZWV0Q\noHtDzXmcwtP8aUQpxN0e1xkWb1E80qoy+0uuRqb/50b/R4Q5qqSfJhkn6z8nwB10\n7RjLtJPrK8igxdpr3tGUzfAOyiPrIDncY7UJaL84GFp7WWAkH0WG3H8Y8DRcRXOU\nmqDxDLUP3rNuow3jnGxiUY+gGX5OqaZg4f4P6QzOSmeQYs6nLpH0PiN00+oS1BbD\nbpWdZEttILPI+vAYkU4QuBKKDjJL6HbSd+cn\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIDAIVCMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTEzMTcw\nNjQxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\nc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\nU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\nYXpvbiBSRFMgdXMtZWFzdC0yIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDE+T2xYjUbxOp+pv+gRA3FO24+1zCWgXTDF1DHrh1lsPg5k7ht\n2KPYzNc+Vg4E+jgPiW0BQnA6jStX5EqVh8BU60zELlxMNvpg4KumniMCZ3krtMUC\nau1NF9rM7HBh+O+DYMBLK5eSIVt6lZosOb7bCi3V6wMLA8YqWSWqabkxwN4w0vXI\n8lu5uXXFRemHnlNf+yA/4YtN4uaAyd0ami9+klwdkZfkrDOaiy59haOeBGL8EB/c\ndbJJlguHH5CpCscs3RKtOOjEonXnKXldxarFdkMzi+aIIjQ8GyUOSAXHtQHb3gZ4\nnS6Ey0CMlwkB8vUObZU9fnjKJcL5QCQqOfwvAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQUPuRHohPxx4VjykmH\n6usGrLL1ETAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAUdR9Vb3y33Yj6X6KGtuthZ08SwjImVQPtknzpajNE5jOJAh8\nquvQnU9nlnMO85fVDU1Dz3lLHGJ/YG1pt1Cqq2QQ200JcWCvBRgdvH6MjHoDQpqZ\nHvQ3vLgOGqCLNQKFuet9BdpsHzsctKvCVaeBqbGpeCtt3Hh/26tgx0rorPLw90A2\nV8QSkZJjlcKkLa58N5CMM8Xz8KLWg3MZeT4DmlUXVCukqK2RGuP2L+aME8dOxqNv\nOnOz1zrL5mR2iJoDpk8+VE/eBDmJX40IJk6jBjWoxAO/RXq+vBozuF5YHN1ujE92\ntO8HItgTp37XT8bJBAiAnt5mxw+NLSqtxk2QdQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICY4kwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTMyMDEx\nNDJaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAr5u9OuLL/OF/fBNUX2kINJLzFl4DnmrhnLuSeSnBPgbb\nqddjf5EFFJBfv7IYiIWEFPDbDG5hoBwgMup5bZDbas+ZTJTotnnxVJTQ6wlhTmns\neHECcg2pqGIKGrxZfbQhlj08/4nNAPvyYCTS0bEcmQ1emuDPyvJBYDDLDU6AbCB5\n6Z7YKFQPTiCBblvvNzchjLWF9IpkqiTsPHiEt21sAdABxj9ityStV3ja/W9BfgxH\nwzABSTAQT6FbDwmQMo7dcFOPRX+hewQSic2Rn1XYjmNYzgEHisdUsH7eeXREAcTw\n61TRvaLH8AiOWBnTEJXPAe6wYfrcSd1pD0MXpoB62wIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUytwMiomQOgX5\nIchd+2lDWRUhkikwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBACf6lRDpfCD7BFRqiWM45hqIzffIaysmVfr+Jr+fBTjP\nuYe/ba1omSrNGG23bOcT9LJ8hkQJ9d+FxUwYyICQNWOy6ejicm4z0C3VhphbTPqj\nyjpt9nG56IAcV8BcRJh4o/2IfLNzC/dVuYJV8wj7XzwlvjysenwdrJCoLadkTr1h\neIdG6Le07sB9IxrGJL9e04afk37h7c8ESGSE4E+oS4JQEi3ATq8ne1B9DQ9SasXi\nIRmhNAaISDzOPdyLXi9N9V9Lwe/DHcja7hgLGYx3UqfjhLhOKwp8HtoZORixAmOI\nHfILgNmwyugAbuZoCazSKKBhQ0wgO0WZ66ZKTMG8Oho=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICUYkwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxODIx\nMTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyB1cy13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBANCEZBZyu6yJQFZBJmSUZfSZd3Ui2gitczMKC4FLr0QzkbxY+cLa\nuVONIOrPt4Rwi+3h/UdnUg917xao3S53XDf1TDMFEYp4U8EFPXqCn/GXBIWlU86P\nPvBN+gzw3nS+aco7WXb+woTouvFVkk8FGU7J532llW8o/9ydQyDIMtdIkKTuMfho\nOiNHSaNc+QXQ32TgvM9A/6q7ksUoNXGCP8hDOkSZ/YOLiI5TcdLh/aWj00ziL5bj\npvytiMZkilnc9dLY9QhRNr0vGqL0xjmWdoEXz9/OwjmCihHqJq+20MJPsvFm7D6a\n2NKybR9U+ddrjb8/iyLOjURUZnj5O+2+OPcCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFEBxMBdv81xuzqcK5TVu\npHj+Aor8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQBZkfiVqGoJjBI37aTlLOSjLcjI75L5wBrwO39q+B4cwcmpj58P\n3sivv+jhYfAGEbQnGRzjuFoyPzWnZ1DesRExX+wrmHsLLQbF2kVjLZhEJMHF9eB7\nGZlTPdTzHErcnuXkwA/OqyXMpj9aghcQFuhCNguEfnROY9sAoK2PTfnTz9NJHL+Q\nUpDLEJEUfc0GZMVWYhahc0x38ZnSY2SKacIPECQrTI0KpqZv/P+ijCEcMD9xmYEb\njL4en+XKS1uJpw5fIU5Sj0MxhdGstH6S84iAE5J3GM3XHklGSFwwqPYvuTXvANH6\nuboynxRgSae59jIlAK6Jrr6GWMwQRbgcaAlW\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICEkYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxOTUz\nNDdaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAufodI2Flker8q7PXZG0P0vmFSlhQDw907A6eJuF/WeMo\nGHnll3b4S6nC3oRS3nGeRMHbyU2KKXDwXNb3Mheu+ox+n5eb/BJ17eoj9HbQR1cd\ngEkIciiAltf8gpMMQH4anP7TD+HNFlZnP7ii3geEJB2GGXSxgSWvUzH4etL67Zmn\nTpGDWQMB0T8lK2ziLCMF4XAC/8xDELN/buHCNuhDpxpPebhct0T+f6Arzsiswt2j\n7OeNeLLZwIZvVwAKF7zUFjC6m7/VmTQC8nidVY559D6l0UhhU0Co/txgq3HVsMOH\nPbxmQUwJEKAzQXoIi+4uZzHFZrvov/nDTNJUhC6DqwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwaZpaCme+EiV\nM5gcjeHZSTgOn4owHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAAR6a2meCZuXO2TF9bGqKGtZmaah4pH2ETcEVUjkvXVz\nsl+ZKbYjrun+VkcMGGKLUjS812e7eDF726ptoku9/PZZIxlJB0isC/0OyixI8N4M\nNsEyvp52XN9QundTjkl362bomPnHAApeU0mRbMDRR2JdT70u6yAzGLGsUwMkoNnw\n1VR4XKhXHYGWo7KMvFrZ1KcjWhubxLHxZWXRulPVtGmyWg/MvE6KF+2XMLhojhUL\n+9jB3Fpn53s6KMx5tVq1x8PukHmowcZuAF8k+W4gk8Y68wIwynrdZrKRyRv6CVtR\nFZ8DeJgoNZT3y/GT254VqMxxfuy2Ccb/RInd16tEvVk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICOYIwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTcyMDA1\nMjlaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEA4dMak8W+XW8y/2F6nRiytFiA4XLwePadqWebGtlIgyCS\nkbug8Jv5w7nlMkuxOxoUeD4WhI6A9EkAn3r0REM/2f0aYnd2KPxeqS2MrtdxxHw1\nxoOxk2x0piNSlOz6yog1idsKR5Wurf94fvM9FdTrMYPPrDabbGqiBMsZZmoHLvA3\nZ+57HEV2tU0Ei3vWeGIqnNjIekS+E06KhASxrkNU5vi611UsnYZlSi0VtJsH4UGV\nLhnHl53aZL0YFO5mn/fzuNG/51qgk/6EFMMhaWInXX49Dia9FnnuWXwVwi6uX1Wn\n7kjoHi5VtmC8ZlGEHroxX2DxEr6bhJTEpcLMnoQMqwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUsUI5Cb3SWB8+\ngv1YLN/ABPMdxSAwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAJAF3E9PM1uzVL8YNdzb6fwJrxxqI2shvaMVmC1mXS+w\nG0zh4v2hBZOf91l1EO0rwFD7+fxoI6hzQfMxIczh875T6vUXePKVOCOKI5wCrDad\nzQbVqbFbdhsBjF4aUilOdtw2qjjs9JwPuB0VXN4/jY7m21oKEOcnpe36+7OiSPjN\nxngYewCXKrSRqoj3mw+0w/+exYj3Wsush7uFssX18av78G+ehKPIVDXptOCP/N7W\n8iKVNeQ2QGTnu2fzWsGUSvMGyM7yqT+h1ILaT//yQS8er511aHMLc142bD4D9VSy\nDgactwPDTShK/PXqhvNey9v/sKXm4XatZvwcc8KYlW4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICcEUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNjU2\nMjBaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAndtkldmHtk4TVQAyqhAvtEHSMb6pLhyKrIFved1WO3S7\n+I+bWwv9b2W/ljJxLq9kdT43bhvzonNtI4a1LAohS6bqyirmk8sFfsWT3akb+4Sx\n1sjc8Ovc9eqIWJCrUiSvv7+cS7ZTA9AgM1PxvHcsqrcUXiK3Jd/Dax9jdZE1e15s\nBEhb2OEPE+tClFZ+soj8h8Pl2Clo5OAppEzYI4LmFKtp1X/BOf62k4jviXuCSst3\nUnRJzE/CXtjmN6oZySVWSe0rQYuyqRl6//9nK40cfGKyxVnimB8XrrcxUN743Vud\nQQVU0Esm8OVTX013mXWQXJHP2c0aKkog8LOga0vobQIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQULmoOS1mFSjj+\nsnUPx4DgS3SkLFYwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAAkVL2P1M2/G9GM3DANVAqYOwmX0Xk58YBHQu6iiQg4j\nb4Ky/qsZIsgT7YBsZA4AOcPKQFgGTWhe9pvhmXqoN3RYltN8Vn7TbUm/ZVDoMsrM\ngwv0+TKxW1/u7s8cXYfHPiTzVSJuOogHx99kBW6b2f99GbP7O1Sv3sLq4j6lVvBX\nFiacf5LAWC925nvlTzLlBgIc3O9xDtFeAGtZcEtxZJ4fnGXiqEnN4539+nqzIyYq\nnvlgCzyvcfRAxwltrJHuuRu6Maw5AGcd2Y0saMhqOVq9KYKFKuD/927BTrbd2JVf\n2sGWyuPZPCk3gq+5pCjbD0c6DkhcMGI6WwxvM5V/zSM=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICJDQwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNzAz\nMTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTMgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAL9bL7KE0n02DLVtlZ2PL+g/BuHpMYFq2JnE2RgompGurDIZdjmh\n1pxfL3nT+QIVMubuAOy8InRfkRxfpxyjKYdfLJTPJG+jDVL+wDcPpACFVqoV7Prg\npVYEV0lc5aoYw4bSeYFhdzgim6F8iyjoPnObjll9mo4XsHzSoqJLCd0QC+VG9Fw2\nq+GDRZrLRmVM2oNGDRbGpGIFg77aRxRapFZa8SnUgs2AqzuzKiprVH5i0S0M6dWr\ni+kk5epmTtkiDHceX+dP/0R1NcnkCPoQ9TglyXyPdUdTPPRfKCq12dftqll+u4mV\nARdN6WFjovxax8EAP2OAUTi1afY+1JFMj+sCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFLfhrbrO5exkCVgxW0x3\nY2mAi8lNMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQAigQ5VBNGyw+OZFXwxeJEAUYaXVoP/qrhTOJ6mCE2DXUVEoJeV\nSxScy/TlFA9tJXqmit8JH8VQ/xDL4ubBfeMFAIAo4WzNWDVoeVMqphVEcDWBHsI1\nAETWzfsapRS9yQekOMmxg63d/nV8xewIl8aNVTHdHYXMqhhik47VrmaVEok1UQb3\nO971RadLXIEbVd9tjY5bMEHm89JsZDnDEw1hQXBb67Elu64OOxoKaHBgUH8AZn/2\nzFsL1ynNUjOhCSAA15pgd1vjwc0YsBbAEBPcHBWYBEyME6NLNarjOzBl4FMtATSF\nwWCKRGkvqN8oxYhwR2jf2rR5Mu4DWkK5Q8Ep\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICJVUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTkxODE2\nNTNaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyB1cy1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAM3i/k2u6cqbMdcISGRvh+m+L0yaSIoOXjtpNEoIftAipTUYoMhL\nInXGlQBVA4shkekxp1N7HXe1Y/iMaPEyb3n+16pf3vdjKl7kaSkIhjdUz3oVUEYt\ni8Z/XeJJ9H2aEGuiZh3kHixQcZczn8cg3dA9aeeyLSEnTkl/npzLf//669Ammyhs\nXcAo58yvT0D4E0D/EEHf2N7HRX7j/TlyWvw/39SW0usiCrHPKDLxByLojxLdHzso\nQIp/S04m+eWn6rmD+uUiRteN1hI5ncQiA3wo4G37mHnUEKo6TtTUh+sd/ku6a8HK\nglMBcgqudDI90s1OpuIAWmuWpY//8xEG2YECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPqhoWZcrVY9mU7tuemR\nRBnQIj1jMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQB6zOLZ+YINEs72heHIWlPZ8c6WY8MDU+Be5w1M+BK2kpcVhCUK\nPJO4nMXpgamEX8DIiaO7emsunwJzMSvavSPRnxXXTKIc0i/g1EbiDjnYX9d85DkC\nE1LaAUCmCZBVi9fIe0H2r9whIh4uLWZA41oMnJx/MOmo3XyMfQoWcqaSFlMqfZM4\n0rNoB/tdHLNuV4eIdaw2mlHxdWDtF4oH+HFm+2cVBUVC1jXKrFv/euRVtsTT+A6i\nh2XBHKxQ1Y4HgAn0jACP2QSPEmuoQEIa57bEKEcZsBR8SDY6ZdTd2HLRIApcCOSF\nMRM8CKLeF658I0XgF8D5EsYoKPsA+74Z+jDH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEETCCAvmgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZQxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSUwIwYDVQQDDBxBbWF6b24gUkRTIEJldGEgUm9vdCAyMDE5IENBMB4XDTE5MDgy\nMDE3MTAwN1oXDTI0MDgxOTE3MzgyNlowgZkxCzAJBgNVBAYTAlVTMRMwEQYDVQQI\nDApXYXNoaW5ndG9uMRAwDgYDVQQHDAdTZWF0dGxlMSIwIAYDVQQKDBlBbWF6b24g\nV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMSowKAYDVQQD\nDCFBbWF6b24gUkRTIEJldGEgdXMtZWFzdC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3\nDQEBAQUAA4IBDwAwggEKAoIBAQDTNCOlotQcLP8TP82U2+nk0bExVuuMVOgFeVMx\nvbUHZQeIj9ikjk+jm6eTDnnkhoZcmJiJgRy+5Jt69QcRbb3y3SAU7VoHgtraVbxF\nQDh7JEHI9tqEEVOA5OvRrDRcyeEYBoTDgh76ROco2lR+/9uCvGtHVrMCtG7BP7ZB\nsSVNAr1IIRZZqKLv2skKT/7mzZR2ivcw9UeBBTUf8xsfiYVBvMGoEsXEycjYdf6w\nWV+7XS7teNOc9UgsFNN+9AhIBc1jvee5E//72/4F8pAttAg/+mmPUyIKtekNJ4gj\nOAR2VAzGx1ybzWPwIgOudZFHXFduxvq4f1hIRPH0KbQ/gkRrAgMBAAGjZjBkMA4G\nA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTkvpCD\n6C43rar9TtJoXr7q8dkrrjAfBgNVHSMEGDAWgBStoQwVpbGx87fxB3dEGDqKKnBT\n4TANBgkqhkiG9w0BAQsFAAOCAQEAJd9fOSkwB3uVdsS+puj6gCER8jqmhd3g/J5V\nZjk9cKS8H0e8pq/tMxeJ8kpurPAzUk5RkCspGt2l0BSwmf3ahr8aJRviMX6AuW3/\ng8aKplTvq/WMNGKLXONa3Sq8591J+ce8gtOX/1rDKmFI4wQ/gUzOSYiT991m7QKS\nFr6HMgFuz7RNJbb3Fy5cnurh8eYWA7mMv7laiLwTNsaro5qsqErD5uXuot6o9beT\na+GiKinEur35tNxAr47ax4IRubuIzyfCrezjfKc5raVV2NURJDyKP0m0CCaffAxE\nqn2dNfYc3v1D8ypg3XjHlOzRo32RB04o8ALHMD9LSwsYDLpMag==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEFzCCAv+gAwIBAgICFSUwDQYJKoZIhvcNAQELBQAwgZcxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSgwJgYDVQQDDB9BbWF6b24gUkRTIFByZXZpZXcgUm9vdCAyMDE5IENBMB4XDTE5\nMDgyMTIyMzk0N1oXDTI0MDgyMTIyMjk0OVowgZwxCzAJBgNVBAYTAlVTMRMwEQYD\nVQQIDApXYXNoaW5ndG9uMRAwDgYDVQQHDAdTZWF0dGxlMSIwIAYDVQQKDBlBbWF6\nb24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMS0wKwYD\nVQQDDCRBbWF6b24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIDIwMTkgQ0EwggEiMA0G\nCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD0dB/U7qRnSf05wOi7m10Pa2uPMTJv\nr6U/3Y17a5prq5Zr4++CnSUYarG51YuIf355dKs+7Lpzs782PIwCmLpzAHKWzix6\npOaTQ+WZ0+vUMTxyqgqWbsBgSCyP7pVBiyqnmLC/L4az9XnscrbAX4pNaoJxsuQe\nmzBo6yofjQaAzCX69DuqxFkVTRQnVy7LCFkVaZtjNAftnAHJjVgQw7lIhdGZp9q9\nIafRt2gteihYfpn+EAQ/t/E4MnhrYs4CPLfS7BaYXBycEKC5Muj1l4GijNNQ0Efo\nxG8LSZz7SNgUvfVwiNTaqfLP3AtEAWiqxyMyh3VO+1HpCjT7uNBFtmF3AgMBAAGj\nZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQW\nBBQtinkdrj+0B2+qdXngV2tgHnPIujAfBgNVHSMEGDAWgBRp0xqULkNh/w2ZVzEI\no2RIY7O03TANBgkqhkiG9w0BAQsFAAOCAQEAtJdqbCxDeMc8VN1/RzCabw9BIL/z\n73Auh8eFTww/sup26yn8NWUkfbckeDYr1BrXa+rPyLfHpg06kwR8rBKyrs5mHwJx\nbvOzXD/5WTdgreB+2Fb7mXNvWhenYuji1MF+q1R2DXV3I05zWHteKX6Dajmx+Uuq\nYq78oaCBSV48hMxWlp8fm40ANCL1+gzQ122xweMFN09FmNYFhwuW+Ao+Vv90ZfQG\nPYwTvN4n/gegw2TYcifGZC2PNX74q3DH03DXe5fvNgRW5plgz/7f+9mS+YHd5qa9\ntYTPUvoRbi169ou6jicsMKUKPORHWhiTpSCWR1FMMIbsAcsyrvtIsuaGCQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQdOCSuA9psBpQd8EI368/0DANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHNhLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTE5MTgwNjI2WhgPMjA2MTA1MTkxOTA2MjZaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgc2EtZWFzdC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN6ftL6w8v3dB2yW\nLjCxSP1D7ZsOTeLZOSCz1Zv0Gkd0XLhil5MdHOHBvwH/DrXqFU2oGzCRuAy+aZis\nDardJU6ChyIQIciXCO37f0K23edhtpXuruTLLwUwzeEPdcnLPCX+sWEn9Y5FPnVm\npCd6J8edH2IfSGoa9LdErkpuESXdidLym/w0tWG/O2By4TabkNSmpdrCL00cqI+c\nprA8Bx1jX8/9sY0gpAovtuFaRN+Ivg3PAnWuhqiSYyQ5nC2qDparOWuDiOhpY56E\nEgmTvjwqMMjNtExfYx6Rv2Ndu50TriiNKEZBzEtkekwXInTupmYTvc7U83P/959V\nUiQ+WSMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4uYHdH0+\nbUeh81Eq2l5/RJbW+vswDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQBhxcExJ+w74bvDknrPZDRgTeMLYgbVJjx2ExH7/Ac5FZZWcpUpFwWMIJJxtewI\nAnhryzM3tQYYd4CG9O+Iu0+h/VVfW7e4O3joWVkxNMb820kQSEwvZfA78aItGwOY\nWSaFNVRyloVicZRNJSyb1UL9EiJ9ldhxm4LTT0ax+4ontI7zTx6n6h8Sr6r/UOvX\nd9T5aUUENWeo6M9jGupHNn3BobtL7BZm2oS8wX8IVYj4tl0q5T89zDi2x0MxbsIV\n5ZjwqBQ5JWKv7ASGPb+z286RjPA9R2knF4lJVZrYuNV90rHvI/ECyt/JrDqeljGL\nBLl1W/UsvZo6ldLIpoMbbrb5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBDCCAuygAwIBAgIQUfVbqapkLYpUqcLajpTJWzANBgkqhkiG9w0BAQsFADCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIG1lLWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwIBcNMjIwNTA2MjMyMDA5WhgPMjA2MjA1MDcwMDIwMDlaMIGa\nMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5j\nLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMzAxBgNVBAMMKkFt\nYXpvbiBSRFMgbWUtY2VudHJhbC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJIeovu3\newI9FVitXMQzvkh34aQ6WyI4NO3YepfJaePiv3cnyFGYHN2S1cR3UQcLWgypP5va\nj6bfroqwGbCbZZcb+6cyOB4ceKO9Ws1UkcaGHnNDcy5gXR7aCW2OGTUfinUuhd2d\n5bOGgV7JsPbpw0bwJ156+MwfOK40OLCWVbzy8B1kITs4RUPNa/ZJnvIbiMu9rdj4\n8y7GSFJLnKCjlOFUkNI5LcaYvI1+ybuNgphT3nuu5ZirvTswGakGUT/Q0J3dxP0J\npDfg5Sj/2G4gXiaM0LppVOoU5yEwVewhQ250l0eQAqSrwPqAkdTg9ng360zqCFPE\nJPPcgI1tdGUgneECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU\n/2AJVxWdZxc8eJgdpbwpW7b0f7IwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB\nCwUAA4IBAQBYm63jTu2qYKJ94gKnqc+oUgqmb1mTXmgmp/lXDbxonjszJDOXFbri\n3CCO7xB2sg9bd5YWY8sGKHaWmENj3FZpCmoefbUx++8D7Mny95Cz8R32rNcwsPTl\nebpd9A/Oaw5ug6M0x/cNr0qzF8Wk9Dx+nFEimp8RYQdKvLDfNFZHjPa1itnTiD8M\nTorAqj+VwnUGHOYBsT/0NY12tnwXdD+ATWfpEHdOXV+kTMqFFwDyhfgRVNpTc+os\nygr8SwhnSCpJPB/EYl2S7r+tgAbJOkuwUvGT4pTqrzDQEhwE7swgepnHC87zhf6l\nqN6mVpSnQKQLm6Ob5TeCEFgcyElsF5bH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAOxu0I1QuMAhIeszB3fJIlkwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy13ZXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI0MjIwNjU5WhgPMjEyMTA1MjQyMzA2NTlaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtd2VzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEz4bylRcGqqDWdP7gQIIoTHdBK6FNtKH1\n4SkEIXRXkYDmRvL9Bci1MuGrwuvrka5TDj4b7e+csY0llEzHpKfq6nJPFljoYYP9\nuqHFkv77nOpJJ633KOr8IxmeHW5RXgrZo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQQikVz8wmjd9eDFRXzBIU8OseiGzAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwf06Mcrpw1O0EBLBBrp84m37NYtOkE/0Z0O+C7D41wnXi\nEQdn6PXUVgdD23Gj82SrAjEAklhKs+liO1PtN15yeZR1Io98nFve+lLptaLakZcH\n+hfFuUtCqMbaI8CdvJlKnPqT\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIGCTCCA/GgAwIBAgIRALyWMTyCebLZOGcZZQmkmfcwDQYJKoZIhvcNAQEMBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIFJTQTQwOTYgRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI0MjAyODAzWhgPMjEyMTA1MjQyMTI4MDNa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTMgUm9vdCBDQSBSU0E0MDk2IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA\nwGFiyDyCrGqgdn4fXG12cxKAAfVvhMea1mw5h9CVRoavkPqhzQpAitSOuMB9DeiP\nwQyqcsiGl/cTEau4L+AUBG8b9v26RlY48exUYBXj8CieYntOT9iNw5WtdYJa3kF/\nJxgI+HDMzE9cmHDs5DOO3S0uwZVyra/xE1ymfSlpOeUIOTpHRJv97CBUEpaZMUW5\nSr6GruuOwFVpO5FX3A/jQlcS+UN4GjSRgDUJuqg6RRQldEZGCVCCmodbByvI2fGm\nreGpsPJD54KkmAX08nOR8e5hkGoHxq0m2DLD4SrOFmt65vG47qnuwplWJjtk9B3Z\n9wDoopwZLBOtlkPIkUllWm1P8EuHC1IKOA+wSP6XdT7cy8S77wgyHzR0ynxv7q/l\nvlZtH30wnNqFI0y9FeogD0TGMCHcnGqfBSicJXPy9T4fU6f0r1HwqKwPp2GArwe7\ndnqLTj2D7M9MyVtFjEs6gfGWXmu1y5uDrf+CszurE8Cycoma+OfjjuVQgWOCy7Nd\njJswPxAroTzVfpgoxXza4ShUY10woZu0/J+HmNmqK7lh4NS75q1tz75in8uTZDkV\nbe7GK+SEusTrRgcf3tlgPjSTWG3veNzFDF2Vn1GLJXmuZfhdlVQDBNXW4MNREExS\ndG57kJjICpT+r8X+si+5j51gRzkSnMYs7VHulpxfcwECAwEAAaNCMEAwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4JWOpDBmUBuWKvGPZelw87ezhL8wDgYDVR0P\nAQH/BAQDAgGGMA0GCSqGSIb3DQEBDAUAA4ICAQBRNLMql7itvXSEFQRAnyOjivHz\nl5IlWVQjAbOUr6ogZcwvK6YpxNAFW5zQr8F+fdkiypLz1kk5irx9TIpff0BWC9hQ\n/odMPO8Gxn8+COlSvc+dLsF2Dax3Hvz0zLeKMo+cYisJOzpdR/eKd0/AmFdkvQoM\nAOK9n0yYvVJU2IrSgeJBiiCarpKSeAktEVQ4rvyacQGr+QAPkkjRwm+5LHZKK43W\nnNnggRli9N/27qYtc5bgr3AaQEhEXMI4RxPRXCLsod0ehMGWyRRK728a+6PMMJAJ\nWHOU0x7LCEMPP/bvpLj3BdvSGqNor4ZtyXEbwREry1uzsgODeRRns5acPwTM6ff+\nCmxO2NZ0OktIUSYRmf6H/ZFlZrIhV8uWaIwEJDz71qvj7buhQ+RFDZ9CNL64C0X6\nmf0zJGEpddjANHaaVky+F4gYMtEy2K2Lcm4JGTdyIzUoIe+atzCnRp0QeIcuWtF+\ns8AjDYCVFNypcMmqbRmNpITSnOoCHSRuVkY3gutVoYyMLbp8Jm9SJnCIlEWTA6Rm\nwADOMGZJVn5/XRTRuetVOB3KlQDjs9OO01XN5NzGSZO2KT9ngAUfh9Eqhf1iRWSP\nnZlRbQ2NRCuY/oJ5N59mLGxnNJSE7giEKEBRhTQ/XEPIUYAUPD5fca0arKRJwbol\nl9Se1Hsq0ZU5f+OZKQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n5zT5+Bs=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nHing\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRANxgyBbnxgTEOpDul2ZnC0UwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNjEwMTgxOTA3WhgPMjA2MTA2MTAxOTE5MDda\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nxnwSDAChrMkfk5TA4Dk8hKzStDlSlONzmd3fTG0Wqr5+x3EmFT6Ksiu/WIwEl9J2\nK98UI7vYyuZfCxUKb1iMPeBdVGqk0zb92GpURd+Iz/+K1ps9ZLeGBkzR8mBmAi1S\nOfpwKiTBzIv6E8twhEn4IUpHsdcuX/2Y78uESpJyM8O5CpkG0JaV9FNEbDkJeBUQ\nAo2qqNcH4R0Qcr5pyeqA9Zto1RswgL06BQMI9dTpfwSP5VvkvcNUaLl7Zv5WzLQE\nJzORWePvdPzzvWEkY/3FPjxBypuYwssKaERW0fkPDmPtykktP9W/oJolKUFI6pXp\ny+Y6p6/AVdnQD2zZjW5FhQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT+jEKs96LC+/X4BZkUYUkzPfXdqTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIGQqgqcQ6XSGkmNebzR6DhadTbfDmbYeN5N0Vuzv+Tdmufb\ntMGjdjnYMg4B+IVnTKQb+Ox3pL9gbX6KglGK8HupobmIRtwKVth+gYYz3m0SL/Nk\nhaWPYzOm0x3tJm8jSdufJcEob4/ATce9JwseLl76pSWdl5A4lLjnhPPKudUDfH+1\nBLNUi3lxpp6GkC8aWUPtupnhZuXddolTLOuA3GwTZySI44NfaFRm+o83N1jp+EwD\n6e94M4cTRzjUv6J3MZmSbdtQP/Tk1uz2K4bQZGP0PZC3bVpqiesdE/xr+wbu8uHr\ncM1JXH0AmXf1yIkTgyWzmvt0k1/vgcw5ixAqvvE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEATCCAumgAwIBAgIRAMhw98EQU18mIji+unM2YH8wDQYJKoZIhvcNAQELBQAw\ngZgxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwo\nQW1hem9uIFJEUyBhcC1zb3V0aC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMjA2MDYyMTQyMjJaGA8yMDYyMDYwNjIyNDIyMlowgZgx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwoQW1h\nem9uIFJEUyBhcC1zb3V0aC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwH\nU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAIeeRoLfTm+7\nvqm7ZlFSx+1/CGYHyYrOOryM4/Z3dqYVHFMgWTR7V3ziO8RZ6yUanrRcWVX3PZbF\nAfX0KFE8OgLsXEZIX8odSrq86+/Th5eZOchB2fDBsUB7GuN2rvFBbM8lTI9ivVOU\nlbuTnYyb55nOXN7TpmH2bK+z5c1y9RVC5iQsNAl6IJNvSN8VCqXh31eK5MlKB4DT\n+Y3OivCrSGsjM+UR59uZmwuFB1h+icE+U0p9Ct3Mjq3MzSX5tQb6ElTNGlfmyGpW\nKh7GQ5XU1KaKNZXoJ37H53woNSlq56bpVrKI4uv7ATpdpFubOnSLtpsKlpLdR3sy\nWs245200pC8CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0ki\n6+eWvsnBjQhMxwMW5pwn7DgwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUA\nA4IBAQB2V8lv0aqbYQpj/bmVv/83QfE4vOxKCJAHv7DQ35cJsTyBdF+8pBczzi3t\n3VNL5IUgW6WkyuUOWnE0eqAFOUVj0yTS1jSAtfl3vOOzGJZmWBbqm9BKEdu1D8O6\nsB8bnomwiab2tNDHPmUslpdDqdabbkWwNWzLJ97oGFZ7KNODMEPXWKWNxg33iHfS\n/nlmnrTVI3XgaNK9qLZiUrxu9Yz5gxi/1K+sG9/Dajd32ZxjRwDipOLiZbiXQrsd\nqzIMY4GcWf3g1gHL5mCTfk7dG22h/rhPyGV0svaDnsb+hOt6sv1McMN6Y3Ou0mtM\n/UaAXojREmJmTSCNvs2aBny3/2sy\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAMnRxsKLYscJV8Qv5pWbL7swCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBzYS1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTgxNjAxWhgPMjEyMTA1MTkxOTE2MDFaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgc2EtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEjFOCZgTNVKxLKhUxffiDEvTLFhrmIqdO\ndKqVdgDoELEzIHWDdC+19aDPitbCYtBVHl65ITu/9pn6mMUl5hhUNtfZuc6A+Iw1\nsBe0v0qI3y9Q9HdQYrGgeHDh8M5P7E2ho0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBS5L7/8M0TzoBZk39Ps7BkfTB4yJTAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwI43O0NtWKTgnVv9z0LO5UMZYgSve7GvGTwqktZYCMObE\nrUI4QerXM9D6JwLy09mqAjEAypfkdLyVWtaElVDUyHFkihAS1I1oUxaaDrynLNQK\nOu/Ay+ns+J+GyvyDUjBpVVW1\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nzDY=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAK5EYG3iHserxMqgg+0EFjgwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI0MjAyMzE2WhgPMjA2MTA1MjQyMTIzMTZa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\ns1L6TtB84LGraLHVC+rGPhLBW2P0oN/91Rq3AnYwqDOuTom7agANwEjvLq7dSRG/\nsIfZsSV/ABTgArZ5sCmLjHFZAo8Kd45yA9byx20RcYtAG8IZl+q1Cri+s0XefzyO\nU6mlfXZkVe6lzjlfXBkrlE/+5ifVbJK4dqOS1t9cWIpgKqv5fbE6Qbq4LVT+5/WM\nVd2BOljuBMGMzdZubqFKFq4mzTuIYfnBm7SmHlZfTdfBYPP1ScNuhpjuzw4n3NCR\nEdU6dQv04Q6th4r7eiOCwbWI9LkmVbvBe3ylhH63lApC7MiiPYLlB13xBubVHVhV\nq1NHoNTi+zA3MN9HWicRxQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSuxoqm0/wjNiZLvqv+JlQwsDvTPDAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAFfTK/j5kv90uIbM8VaFdVbr/6weKTwehafT0pAk1bfLVX+7\nuf8oHgYiyKTTl0DFQicXejghXTeyzwoEkWSR8c6XkhD5vYG3oESqmt/RGvvoxz11\nrHHy7yHYu7RIUc3VQG60c4qxXv/1mWySGwVwJrnuyNT9KZXPevu3jVaWOVHEILaK\nHvzQ2YEcWBPmde/zEseO2QeeGF8FL45Q1d66wqIP4nNUd2pCjeTS5SpB0MMx7yi9\nki1OH1pv8tOuIdimtZ7wkdB8+JSZoaJ81b8sRrydRwJyvB88rftuI3YB4WwGuONT\nZezUPsmaoK69B0RChB0ofDpAaviF9V3xOWvVZfo=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n1axqeKpI0F5SBUPsaVNYY2uNFg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIQCREfzzVyDTMcNME+gWnTCTANBgkqhkiG9w0BAQsFADCB\nnDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTUwMwYDVQQDDCxB\nbWF6b24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4G\nA1UEBwwHU2VhdHRsZTAgFw0yMTA1MjQyMDQyMzNaGA8yMDYxMDUyNDIxNDIzM1ow\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDL\n1MT6br3L/4Pq87DPXtcjlXN3cnbNk2YqRAZHJayStTz8VtsFcGPJOpk14geRVeVk\ne9uKFHRbcyr/RM4owrJTj5X4qcEuATYZbo6ou/rW2kYzuWFZpFp7lqm0vasV4Z9F\nfChlhwkNks0UbM3G+psCSMNSoF19ERunj7w2c4E62LwujkeYLvKGNepjnaH10TJL\n2krpERd+ZQ4jIpObtRcMH++bTrvklc+ei8W9lqrVOJL+89v2piN3Ecdd389uphst\nqQdb1BBVXbhUrtuGHgVf7zKqN1SkCoktoWxVuOprVWhSvr7akaWeq0UmlvbEsujU\nvADqxGMcJFyCzxx3CkJjAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O\nBBYEFFk8UJmlhoxFT3PP12PvhvazHjT4MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG\n9w0BAQsFAAOCAQEAfFtr2lGoWVXmWAsIo2NYre7kzL8Xb9Tx7desKxCCz5HOOvIr\n8JMB1YK6A7IOvQsLJQ/f1UnKRh3X3mJZjKIywfrMSh0FiDf+rjcEzXxw2dGtUem4\nA+WMvIA3jwxnJ90OQj5rQ8bg3iPtE6eojzo9vWQGw/Vu48Dtw1DJo9210Lq/6hze\nhPhNkFh8fMXNT7Q1Wz/TJqJElyAQGNOXhyGpHKeb0jHMMhsy5UNoW5hLeMS5ffao\nTBFWEJ1gVfxIU9QRxSh+62m46JIg+dwDlWv8Aww14KgepspRbMqDuaM2cinoejv6\nt3dyOyHHrsOyv3ffZUKtQhQbQr+sUcL89lARsg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAIJLTMpzGNxqHZ4t+c1MlCIwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBhcC1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIxMzAzM1oYDzIwNjEwNTI1MjIzMDMzWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDtdHut0ZhJ9Nn2\nMpVafFcwHdoEzx06okmmhjJsNy4l9QYVeh0UUoek0SufRNMRF4d5ibzpgZol0Y92\n/qKWNe0jNxhEj6sXyHsHPeYtNBPuDMzThfbvsLK8z7pBP7vVyGPGuppqW/6m4ZBB\nlcc9fsf7xpZ689iSgoyjiT6J5wlVgmCx8hFYc/uvcRtfd8jAHvheug7QJ3zZmIye\nV4htOW+fRVWnBjf40Q+7uTv790UAqs0Zboj4Yil+hER0ibG62y1g71XcCyvcVpto\n2/XW7Y9NCgMNqQ7fGN3wR1gjtSYPd7DO32LTzYhutyvfbpAZjsAHnoObmoljcgXI\nQjfBcCFpAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFJI3aWLg\nCS5xqU5WYVaeT5s8lpO0MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAUwATpJOcGVOs3hZAgJwznWOoTzOVJKfrqBum7lvkVH1vBwxBl9CahaKj3ZOt\nYYp2qJzhDUWludL164DL4ZjS6eRedLRviyy5cRy0581l1MxPWTThs27z+lCC14RL\nPJZNVYYdl7Jy9Q5NsQ0RBINUKYlRY6OqGDySWyuMPgno2GPbE8aynMdKP+f6G/uE\nYHOf08gFDqTsbyfa70ztgVEJaRooVf5JJq4UQtpDvVswW2reT96qi6tXPKHN5qp3\n3wI0I1Mp4ePmiBKku2dwYzPfrJK/pQlvu0Gu5lKOQ65QdotwLAAoaFqrf9za1yYs\nINUkHLWIxDds+4OHNYcerGp5Dw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nUhnJzzoe6M+LfGHkVQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQSAG6j2WHtWUUuLGJTPb1nTAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE2MzgyNloYDzIxMjEwNTIwMTczODI2WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE2eqwU4FOzW8RV1W381Bd\nolhDOrqoMqzWli21oDUt7y8OnXM/lmAuOS6sr8Nt61BLVbONdbr+jgCYw75KabrK\nZGg3siqvMOgabIKkKuXO14wtrGyGDt7dnKXg5ERGYOZlo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBS1Acp2WYxOcblv5ikZ3ZIbRCCW+zAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAJL84J08PBprxmsAKPTotBuVI3MyW1r8\nxQ0i8lgCQUf8GcmYjQ0jI4oZyv+TuYJAcwIxAP9Xpzq0Docxb+4N1qVhpiOfWt1O\nFnemFiy9m1l+wv6p3riQMPV7mBVpklmijkIv3Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRALZLcqCVIJ25maDPE3sbPCIwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIxMjEzOTM5WhgPMjA2MTA1MjEyMjM5Mzla\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nypKc+6FfGx6Gl6fQ78WYS29QoKgQiur58oxR3zltWeg5fqh9Z85K5S3UbRSTqWWu\nXcfnkz0/FS07qHX+nWAGU27JiQb4YYqhjZNOAq8q0+ptFHJ6V7lyOqXBq5xOzO8f\n+0DlbJSsy7GEtJp7d7QCM3M5KVY9dENVZUKeJwa8PC5StvwPx4jcLeZRJC2rAVDG\nSW7NAInbATvr9ssSh03JqjXb+HDyywiqoQ7EVLtmtXWimX+0b3/2vhqcH5jgcKC9\nIGFydrjPbv4kwMrKnm6XlPZ9L0/3FMzanXPGd64LQVy51SI4d5Xymn0Mw2kMX8s6\nNf05OsWcDzJ1n6/Q1qHSxQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRmaIc8eNwGP7i6P7AJrNQuK6OpFzAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIBeHfGwz3S2zwIUIpqEEI5/sMySDeS+3nJR+woWAHeO0C8i\nBJdDh+kzzkP0JkWpr/4NWz84/IdYo1lqASd1Kopz9aT1+iROXaWr43CtbzjXb7/X\nZv7eZZFC8/lS5SROq42pPWl4ekbR0w8XGQElmHYcWS41LBfKeHCUwv83ATF0XQ6I\n4t+9YSqZHzj4vvedrvcRInzmwWJaal9s7Z6GuwTGmnMsN3LkhZ+/GD6oW3pU/Pyh\nEtWqffjsLhfcdCs3gG8x9BbkcJPH5aPAVkPn4wc8wuXg6xxb9YGsQuY930GWTYRf\nschbgjsuqznW4HHakq4WNhs1UdTSTKkRdZz7FUQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEDzCCAvegAwIBAgIRAM2zAbhyckaqRim63b+Tib8wDQYJKoZIhvcNAQELBQAw\ngZ8xCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE4MDYGA1UEAwwv\nQW1hem9uIFJEUyBQcmV2aWV3IHVzLWVhc3QtMiBSb290IENBIFJTQTIwNDggRzEx\nEDAOBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTE4MjA0OTQ1WhgPMjA2MTA1MTgyMTQ5\nNDVaMIGfMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\ncywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExODA2BgNV\nBAMML0FtYXpvbiBSRFMgUHJldmlldyB1cy1lYXN0LTIgUm9vdCBDQSBSU0EyMDQ4\nIEcxMRAwDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\nCgKCAQEA1ybjQMH1MkbvfKsWJaCTXeCSN1SG5UYid+Twe+TjuSqaXWonyp4WRR5z\ntlkqq+L2MWUeQQAX3S17ivo/t84mpZ3Rla0cx39SJtP3BiA2BwfUKRjhPwOjmk7j\n3zrcJjV5k1vSeLNOfFFSlwyDiVyLAE61lO6onBx+cRjelu0egMGq6WyFVidTdCmT\nQ9Zw3W6LTrnPvPmEyjHy2yCHzH3E50KSd/5k4MliV4QTujnxYexI2eR8F8YQC4m3\nDYjXt/MicbqA366SOoJA50JbgpuVv62+LSBu56FpzY12wubmDZsdn4lsfYKiWxUy\nuc83a2fRXsJZ1d3whxrl20VFtLFHFQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/\nMB0GA1UdDgQWBBRC0ytKmDYbfz0Bz0Psd4lRQV3aNTAOBgNVHQ8BAf8EBAMCAYYw\nDQYJKoZIhvcNAQELBQADggEBAGv8qZu4uaeoF6zsbumauz6ea6tdcWt+hGFuwGrb\ntRbI85ucAmVSX06x59DJClsb4MPhL1XmqO3RxVMIVVfRwRHWOsZQPnXm8OYQ2sny\nrYuFln1COOz1U/KflZjgJmxbn8x4lYiTPZRLarG0V/OsCmnLkQLPtEl/spMu8Un7\nr3K8SkbWN80gg17Q8EV5mnFwycUx9xsTAaFItuG0en9bGsMgMmy+ZsDmTRbL+lcX\nFq8r4LT4QjrFz0shrzCwuuM4GmcYtBSxlacl+HxYEtAs5k10tmzRf6OYlY33tGf6\n1tkYvKryxDPF/EDgGp/LiBwx6ixYMBfISoYASt4V/ylAlHA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtTCCAjqgAwIBAgIRAK9BSZU6nIe6jqfODmuVctYwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBjYS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTIxMjIxMzA5WhgPMjEyMTA1MjEyMzEzMDlaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgY2EtY2VudHJhbC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEUkEERcgxneT5H+P+fERcbGmf\nbVx+M7rNWtgWUr6w+OBENebQA9ozTkeSg4c4M+qdYSObFqjxITdYxT1z/nHz1gyx\nOKAhLjWu+nkbRefqy3RwXaWT680uUaAP6ccnkZOMo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBSN6fxlg0s5Wny08uRBYZcQ3TUoyzAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaQAwZgIxAORaz+MBVoFBTmZ93j2G2vYTwA6T5hWzBWrx\nCrI54pKn5g6At56DBrkjrwZF5T1enAIxAJe/LZ9xpDkAdxDgGJFN8gZYLRWc0NRy\nRb4hihy5vj9L+w9uKc9VfEBIFuhT7Z3ljg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQB/57HSuaqUkLaasdjxUdPjANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE3NDAzNFoYDzIwNjEwNTE5MTg0MDM0WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtbkaoVsUS76o\nTgLFmcnaB8cswBk1M3Bf4IVRcwWT3a1HeJSnaJUqWHCJ+u3ip/zGVOYl0gN1MgBb\nMuQRIJiB95zGVcIa6HZtx00VezDTr3jgGWRHmRjNVCCHGmxOZWvJjsIE1xavT/1j\nQYV/ph4EZEIZ/qPq7e3rHohJaHDe23Z7QM9kbyqp2hANG2JtU/iUhCxqgqUHNozV\nZd0l5K6KnltZQoBhhekKgyiHqdTrH8fWajYl5seD71bs0Axowb+Oh0rwmrws3Db2\nDh+oc2PwREnjHeca9/1C6J2vhY+V0LGaJmnnIuOANrslx2+bgMlyhf9j0Bv8AwSi\ndSWsobOhNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQb7vJT\nVciLN72yJGhaRKLn6Krn2TAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAAxEj8N9GslReAQnNOBpGl8SLgCMTejQ6AW/bapQvzxrZrfVOZOYwp/5oV0f\n9S1jcGysDM+DrmfUJNzWxq2Y586R94WtpH4UpJDGqZp+FuOVJL313te4609kopzO\nlDdmd+8z61+0Au93wB1rMiEfnIMkOEyt7D2eTFJfJRKNmnPrd8RjimRDlFgcLWJA\n3E8wca67Lz/G0eAeLhRHIXv429y8RRXDtKNNz0wA2RwURWIxyPjn1fHjA9SPDkeW\nE1Bq7gZj+tBnrqz+ra3yjZ2blss6Ds3/uRY6NYqseFTZWmQWT7FolZEnT9vMUitW\nI0VynUbShVpGf6946e0vgaaKw20=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQGyUVTaVjYJvWhroVEiHPpDANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHVzLXdlc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTE5MTkwNDA2WhgPMjA2MTA1MTkyMDA0MDZaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgdXMtd2VzdC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANhyXpJ0t4nigRDZ\nEwNtFOem1rM1k8k5XmziHKDvDk831p7QsX9ZOxl/BT59Pu/P+6W6SvasIyKls1sW\nFJIjFF+6xRQcpoE5L5evMgN/JXahpKGeQJPOX9UEXVW5B8yi+/dyUitFT7YK5LZA\nMqWBN/LtHVPa8UmE88RCDLiKkqiv229tmwZtWT7nlMTTCqiAHMFcryZHx0pf9VPh\nx/iPV8p2gBJnuPwcz7z1kRKNmJ8/cWaY+9w4q7AYlAMaq/rzEqDaN2XXevdpsYAK\nTMMj2kji4x1oZO50+VPNfBl5ZgJc92qz1ocF95SAwMfOUsP8AIRZkf0CILJYlgzk\n/6u6qZECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5jfcS9o\n+LwL517HpB6hG+PmpBswDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQAcQ6lsqxi63MtpGk9XK8mCxGRLCad51+MF6gcNz6i6PAqhPOoKCoFqdj4cEQTF\nF8dCfa3pvfJhxV6RIh+t5FCk/y6bWT8Ls/fYKVo6FhHj57bcemWsw/Z0XnROdVfK\nYqbc7zvjCPmwPHEqYBhjU34NcY4UF9yPmlLOL8uO1JKXa3CAR0htIoW4Pbmo6sA4\n6P0co/clW+3zzsQ92yUCjYmRNeSbdXbPfz3K/RtFfZ8jMtriRGuO7KNxp8MqrUho\nHK8O0mlSUxGXBZMNicfo7qY8FD21GIPH9w5fp5oiAl7lqFzt3E3sCLD3IiVJmxbf\nfUwpGd1XZBBSdIxysRLM6j48\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrTCCAjOgAwIBAgIQU+PAILXGkpoTcpF200VD/jAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIGFwLWVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjUyMTQ1MTFaGA8yMTIxMDUyNTIyNDUxMVowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyBhcC1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAAT3tFKE8Kw1sGQAvNLlLhd8OcGhlc7MiW/s\nNXm3pOiCT4vZpawKvHBzD76Kcv+ZZzHRxQEmG1/muDzZGlKR32h8AAj+NNO2Wy3d\nCKTtYMiVF6Z2zjtuSkZQdjuQbe4eQ7qjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFAiSQOp16Vv0Ohpvqcbd2j5RmhYNMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNoADBlAjBVsi+5Ape0kOhMt/WFkANkslD4qXA5uqhrfAtH29Xzz2NV\ntR7akiA771OaIGB/6xsCMQCZt2egCtbX7J0WkuZ2KivTh66jecJr5DHvAP4X2xtS\nF/5pS+AUhcKTEGjI9jDH3ew=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQT5mGlavQzFHsB7hV6Mmy6TAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNDIwNTAxNVoYDzIxMjEwNTI0MjE1MDE1WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEcm4BBBjYK7clwm0HJRWS\nflt3iYwoJbIXiXn9c1y3E+Vb7bmuyKhS4eO8mwO4GefUcXObRfoHY2TZLhMJLVBQ\n7MN2xDc0RtZNj07BbGD3VAIFRTDX0mH9UNYd0JQM3t/Oo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBRrd5ITedfAwrGo4FA9UaDaGFK3rjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAPBNqmVv1IIA3EZyQ6XuVf4gj79/DMO8\nbkicNS1EcBpUqbSuU4Zwt2BYc8c/t7KVOQIxAOHoWkoKZPiKyCxfMtJpCZySUG+n\nsXgB/LOyWE5BJcXUfm+T1ckeNoWeUUMOLmnJjg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAJcDeinvdNrDQBeJ8+t38WQwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtNCBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjIwNTI1MTY0OTE2WhgPMjA2MjA1MjUxNzQ5MTZa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTQgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nk8DBNkr9tMoIM0NHoFiO7cQfSX0cOMhEuk/CHt0fFx95IBytx7GHCnNzpM27O5z6\nx6iRhfNnx+B6CrGyCzOjxvPizneY+h+9zfvNz9jj7L1I2uYMuiNyOKR6FkHR46CT\n1CiArfVLLPaTqgD/rQjS0GL2sLHS/0dmYipzynnZcs613XT0rAWdYDYgxDq7r/Yi\nXge5AkWQFkMUq3nOYDLCyGGfQqWKkwv6lZUHLCDKf+Y0Uvsrj8YGCI1O8mF0qPCQ\nlmlfaDvbuBu1AV+aabmkvyFj3b8KRIlNLEtQ4N8KGYR2Jdb82S4YUGIOAt4wuuFt\n1B7AUDLk3V/u+HTWiwfoLQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSNpcjz6ArWBtAA+Gz6kyyZxrrgdDAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAGJEd7UgOzHYIcQRSF7nSYyjLROyalaIV9AX4WXW/Cqlul1c\nMblP5etDZm7A/thliZIWAuyqv2bNicmS3xKvNy6/QYi1YgxZyy/qwJ3NdFl067W0\nt8nGo29B+EVK94IPjzFHWShuoktIgp+dmpijB7wkTIk8SmIoe9yuY4+hzgqk+bo4\nms2SOXSN1DoQ75Xv+YmztbnZM8MuWhL1T7hA4AMorzTQLJ9Pof8SpSdMHeDsHp0R\n01jogNFkwy25nw7cL62nufSuH2fPYGWXyNDg+y42wKsKWYXLRgUQuDVEJ2OmTFMB\nT0Vf7VuNijfIA9hkN2d3K53m/9z5WjGPSdOjGhg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQRiwspKyrO0xoxDgSkqLZczANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHVzLXdlc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTI0MjE1OTAwWhgPMjA2MTA1MjQyMjU5MDBaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgdXMtd2VzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL53Jk3GsKiu+4bx\njDfsevWbwPCNJ3H08Zp7GWhvI3Tgi39opfHYv2ku2BKFjK8N2L6RvNPSR8yplv5j\nY0tK0U+XVNl8o0ibhqRDhbTuh6KL8CFINWYzAajuxFS+CF0U6c1Q3tXLBdALxA7l\nFlXJ71QrP06W31kRe7kvgrvO7qWU3/OzUf9qYw4LSiR1/VkvvRCTqcVNw09clw/M\nJbw6FSgweN65M9j7zPbjGAXSHkXyxH1Erin2fa+B9PE4ZDgX9cp2C1DHewYJQL/g\nSepwwcudVNRN1ibKH7kpMrgPnaNIVNx5sXVsTjk6q2ZqYw3SVHegltJpLy/cZReP\nmlivF2kCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmTcQd6o1\nCuS65MjBrMwQ9JJjmBwwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQAKSDSIzl956wVddPThf2VAzI8syw9ngSwsEHZvxVGHBvu5gg618rDyguVCYX9L\n4Kw/xJrk6S3qxOS2ZDyBcOpsrBskgahDFIunzoRP3a18ARQVq55LVgfwSDQiunch\nBd05cnFGLoiLkR5rrkgYaP2ftn3gRBRaf0y0S3JXZ2XB3sMZxGxavYq9mfiEcwB0\nLMTMQ1NYzahIeG6Jm3LqRqR8HkzP/Ztq4dT2AtSLvFebbNMiWqeqT7OcYp94HTYT\nzqrtaVdUg9bwyAUCDgy0GV9RHDIdNAOInU/4LEETovrtuBU7Z1q4tcHXvN6Hd1H8\ngMb0mCG5I393qW5hFsA/diFb\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAPQAvihfjBg/JDbj6U64K98wDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIwMTYyODQxWhgPMjA2MTA1MjAxNzI4NDFa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nvJ9lgyksCxkBlY40qOzI1TCj/Q0FVGuPL/Z1Mw2YN0l+41BDv0FHApjTUkIKOeIP\nnwDwpXTa3NjYbk3cOZ/fpH2rYJ++Fte6PNDGPgKppVCUh6x3jiVZ1L7wOgnTdK1Q\nTrw8440IDS5eLykRHvz8OmwvYDl0iIrt832V0QyOlHTGt6ZJ/aTQKl12Fy3QBLv7\nstClPzvHTrgWqVU6uidSYoDtzHbU7Vda7YH0wD9IUoMBf7Tu0rqcE4uH47s2XYkc\nSdLEoOg/Ngs7Y9B1y1GCyj3Ux7hnyvCoRTw014QyNB7dTatFMDvYlrRDGG14KeiU\nUL7Vo/+EejWI31eXNLw84wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQkgTWFsNg6wA3HbbihDQ4vpt1E2zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAGz1Asiw7hn5WYUj8RpOCzpE0h/oBZcnxP8wulzZ5Xd0YxWO\n0jYUcUk3tTQy1QvoY+Q5aCjg6vFv+oFBAxkib/SmZzp4xLisZIGlzpJQuAgRkwWA\n6BVMgRS+AaOMQ6wKPgz1x4v6T0cIELZEPq3piGxvvqkcLZKdCaeC3wCS6sxuafzZ\n4qA3zMwWuLOzRftgX2hQto7d/2YkRXga7jSvQl3id/EI+xrYoH6zIWgjdU1AUaNq\nNGT7DIo47vVMfnd9HFZNhREsd4GJE83I+JhTqIxiKPNxrKgESzyADmNPt0gXDnHo\ntbV1pMZz5HpJtjnP/qVZhEK5oB0tqlKPv9yx074=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICuTCCAj6gAwIBAgIRAKp1Rn3aL/g/6oiHVIXtCq8wCgYIKoZIzj0EAwMwgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMTA1MjQyMDMyMTdaGA8yMTIxMDUyNDIxMzIxN1owgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABGTYWPILeBJXfcL3Dz4z\nEWMUq78xB1HpjBwHoTURYfcMd5r96BTVG6yaUBWnAVCMeeD6yTG9a1eVGNhG14Hk\nZAEjgLiNB7RRbEG5JZ/XV7W/vODh09WCst2y9SLKsdgeAaNCMEAwDwYDVR0TAQH/\nBAUwAwEB/zAdBgNVHQ4EFgQUoE0qZHmDCDB+Bnm8GUa/evpfPwgwDgYDVR0PAQH/\nBAQDAgGGMAoGCCqGSM49BAMDA2kAMGYCMQCnil5MMwhY3qoXv0xvcKZGxGPaBV15\n0CCssCKn0oVtdJQfJQ3Jrf3RSaEyijXIJsoCMQC35iJi4cWoNX3N/qfgnHohW52O\nB5dg0DYMqy5cNZ40+UcAanRMyqNQ6P7fy3umGco=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQPXnDTPegvJrI98qz8WxrMjAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIEJldGEgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxODIxNDAxMloYDzIxMjEwNTE4MjI0MDEyWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIEJldGEgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEI0sR7gwutK5AB46hM761\ngcLTGBIYlURSEoM1jcBwy56CL+3CJKZwLLyJ7qoOKfWbu5GsVLUTWS8MV6Nw33cx\n2KQD2svb694wi+Px2f4n9+XHkEFQw8BbiodDD7RZA70fo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBTQSioOvnVLEMXwNSDg+zgln/vAkjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAMwu1hqm5Bc98uE/E0B5iMYbBQ4kpMxO\ntP8FTfz5UR37HUn26nXE0puj6S/Ffj4oJgIwXI7s2c26tFQeqzq6u3lrNJHp5jC9\nUxlo/hEJOLoDj5jnpxo8dMAtCNoQPaHdfL0P\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjWgAwIBAgIQGKVv+5VuzEZEBzJ+bVfx2zAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTc1MDU5WhgPMjEyMTA1MTkxODUwNTlaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYXAtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABMqdLJ0tZF/DGFZTKZDrGRJZID8ivC2I\nJRCYTWweZKCKSCAzoiuGGHzJhr5RlLHQf/QgmFcgXsdmO2n3CggzhA4tOD9Ip7Lk\nP05eHd2UPInyPCHRgmGjGb0Z+RdQ6zkitKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUC1yhRgVqU5bR8cGzOUCIxRpl4EYwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2cAMGQCMG0c/zLGECRPzGKJvYCkpFTCUvdP4J74YP0v/dPvKojL\nt/BrR1Tg4xlfhaib7hPc7wIwFvgqHes20CubQnZmswbTKLUrgSUW4/lcKFpouFd2\nt2/ewfi/0VhkeUW+IiHhOMdU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\niHcaqd60QKpfiH2A3A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQPaVGRuu86nh/ylZVCLB0MzAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMDMxNloYDzIxMjEwNTI1MjMwMzE2WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEexNURoB9KE93MEtEAlJG\nobz4LS/pD2hc8Gczix1WhVvpJ8bN5zCDXaKdnDMCebetyRQsmQ2LYlfmCwpZwSDu\n0zowB11Pt3I5Avu2EEcuKTlKIDMBeZ1WWuOd3Tf7MEAMo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBSaYbZPBvFLikSAjpa8mRJvyArMxzAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAOEJkuh3Zjb7Ih/zuNRd1RBqmIYcnyw0\nnwUZczKXry+9XebYj3VQxSRNadrarPWVqgIxAMg1dyGoDAYjY/L/9YElyMnvHltO\nPwpJShmqHvCLc/mXMgjjYb/akK7yGthvW6j/uQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n6YYLNPRrj3mi9T/f\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAMkvdFnVDb0mWWFiXqnKH68wCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy13ZXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTkxMzI0WhgPMjEyMTA1MTkyMDEzMjRaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtd2VzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEy86DB+9th/0A5VcWqMSWDxIUblWTt/R0\nao6Z2l3vf2YDF2wt1A2NIOGpfQ5+WAOJO/IQmnV9LhYo+kacB8sOnXdQa6biZZkR\nIyouUfikVQAKWEJnh1Cuo5YMM4E2sUt5o0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQ8u3OnecANmG8OoT7KLWDuFzZwBTAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwQ817qkb7mWJFnieRAN+m9W3E0FLVKaV3zC5aYJUk2fcZ\nTaUx3oLp3jPLGvY5+wgeAjEA6wAicAki4ZiDfxvAIuYiIe1OS/7H5RA++R8BH6qG\niRzUBM/FItFpnkus7u/eTkvo\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQS/+Ryfgb/IOVEa1pWoe8oTAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLXNvdXRoLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjIwNjA2MjE1NDQyWhgPMjEyMjA2MDYyMjU0NDJaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYXAtc291dGgtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDsX6fhdUWBQpYTdseBD/P3s96Dtw2Iw\nOrXKNToCnmX5nMkUGdRn9qKNiz1pw3EPzaPxShbYwQ7LYP09ENK/JN4QQjxMihxC\njLFxS85nhBQQQGRCWikDAe38mD8fSvREQKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUIh1xZiseQYFjPYKJmGbruAgRH+AwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMFudS4zLy+UUGrtgNLtRMcu/DZ9BUzV4NdHxo0bkG44O\nthnjl4+wTKI6VbyAbj2rkgIxAOHps8NMITU5DpyiMnKTxV8ubb/WGHrLl0BjB8Lw\nETVJk5DNuZvsIIcm7ykk6iL4Tw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIGBDCCA+ygAwIBAgIQDcEmNIAVrDpUw5cH5ynutDANBgkqhkiG9w0BAQwFADCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIG1lLWNlbnRyYWwtMSBSb290IENBIFJTQTQwOTYgRzExEDAOBgNV\nBAcMB1NlYXR0bGUwIBcNMjIwNTA3MDA0MDIzWhgPMjEyMjA1MDcwMTQwMjNaMIGa\nMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5j\nLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMzAxBgNVBAMMKkFt\nYXpvbiBSRFMgbWUtY2VudHJhbC0xIFJvb3QgQ0EgUlNBNDA5NiBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKvADk8t\nFl9bFlU5sajLPPDSOUpPAkKs6iPlz+27o1GJC88THcOvf3x0nVAcu9WYe9Qaas+4\nj4a0vv51agqyODRD/SNi2HnqW7DbtLPAm6KBHe4twl28ItB/JD5g7u1oPAHFoXMS\ncH1CZEAs5RtlZGzJhcBXLFsHNv/7+SCLyZ7+2XFh9OrtgU4wMzkHoRNndhfwV5bu\n17bPTwuH+VxH37zXf1mQ/KjhuJos0C9dL0FpjYBAuyZTAWhZKs8dpSe4DI544z4w\ngkwUB4bC2nA1TBzsywEAHyNuZ/xRjNpWvx0ToWAA2iFJqC3VO3iKcnBplMvaUuMt\njwzVSNBnKcoabXCZL2XDLt4YTZR8FSwz05IvsmwcPB7uNTBXq3T9sjejW8QQK3vT\ntzyfLq4jKmQE7PoS6cqYm+hEPm2hDaC/WP9bp3FdEJxZlPH26fq1b7BWYWhQ9pBA\nNv9zTnzdR1xohTyOJBUFQ81ybEzabqXqVXUIANqIOaNcTB09/sLJ7+zuMhp3mwBu\nLtjfJv8PLuT1r63bU3seROhKA98b5KfzjvbvPSg3vws78JQyoYGbqNyDfyjVjg3U\nv//AdVuPie6PNtdrW3upZY4Qti5IjP9e3kimaJ+KAtTgMRG56W0WxD3SP7+YGGbG\nKhntDOkKsN39hLpn9UOafTIqFu7kIaueEy/NAgMBAAGjQjBAMA8GA1UdEwEB/wQF\nMAMBAf8wHQYDVR0OBBYEFHAems86dTwdZbLe8AaPy3kfIUVoMA4GA1UdDwEB/wQE\nAwIBhjANBgkqhkiG9w0BAQwFAAOCAgEAOBHpp0ICx81kmeoBcZTrMdJs2gnhcd85\nFoSCjXx9H5XE5rmN/lQcxxOgj8hr3uPuLdLHu+i6THAyzjrl2NA1FWiqpfeECGmy\n0jm7iZsYORgGQYp/VKnDrwnKNSqlZvOuRr0kfUexwFlr34Y4VmupvEOK/RdGsd3S\n+3hiemcHse9ST/sJLHx962AWMkN86UHPscJEe4+eT3f2Wyzg6La8ARwdWZSNS+WH\nZfybrncMmuiXuUdHv9XspPsqhKgtHhcYeXOGUtrwQPLe3+VJZ0LVxhlTWr9951GZ\nGfmWwTV/9VsyKVaCFIXeQ6L+gjcKyEzYF8wpMtQlSc7FFqwgC4bKxvMBSaRy88Nr\nlV2+tJD/fr8zGUeBK44Emon0HKDBWGX+/Hq1ZIv0Da0S+j6LbA4fusWxtGfuGha+\nluhHgVInCpALIOamiBEdGhILkoTtx7JrYppt3/Raqg9gUNCOOYlCvGhqX7DXeEfL\nDGabooiY2FNWot6h04JE9nqGj5QqT8D6t/TL1nzxhRPzbcSDIHUd/b5R+a0bAA+7\nYTU6JqzEVCWKEIEynYmqikgLMGB/OzWsgyEL6822QW6hJAQ78XpbNeCzrICF4+GC\n7KShLnwuWoWpAb26268lvOEvCTFM47VC6jNQl97md+2SA9Ma81C9wflid2M83Wle\ncuLMVcQZceE=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQAhAteLRCvizAElaWORFU2zANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE3MDkxNloYDzIwNjEwNTIwMTgwOTE2WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+qg7JAcOVKjh\nN83SACnBFZPyB63EusfDr/0V9ZdL8lKcmZX9sv/CqoBo3N0EvBqHQqUUX6JvFb7F\nXrMUZ740kr28gSRALfXTFgNODjXeDsCtEkKRTkac/UM8xXHn+hR7UFRPHS3e0GzI\niLiwQWDkr0Op74W8aM0CfaVKvh2bp4BI1jJbdDnQ9OKXpOxNHGUf0ZGb7TkNPkgI\nb2CBAc8J5o3H9lfw4uiyvl6Fz5JoP+A+zPELAioYBXDrbE7wJeqQDJrETWqR9VEK\nBXURCkVnHeaJy123MpAX2ozf4pqk0V0LOEOZRS29I+USF5DcWr7QIXR/w2I8ws1Q\n7ys+qbE+kQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQFJ16n\n1EcCMOIhoZs/F9sR+Jy++zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAOc5nXbT3XTDEZsxX2iD15YrQvmL5m13B3ImZWpx/pqmObsgx3/dg75rF2nQ\nqS+Vl+f/HLh516pj2BPP/yWCq12TRYigGav8UH0qdT3CAClYy2o+zAzUJHm84oiB\nud+6pFVGkbqpsY+QMpJUbZWu52KViBpJMYsUEy+9cnPSFRVuRAHjYynSiLk2ZEjb\nWkdc4x0nOZR5tP0FgrX0Ve2KcjFwVQJVZLgOUqmFYQ/G0TIIGTNh9tcmR7yp+xJR\nA2tbPV2Z6m9Yxx4E8lLEPNuoeouJ/GR4CkMEmF8cLwM310t174o3lKKUXJ4Vs2HO\nWj2uN6R9oI+jGLMSswTzCNV1vgc=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICuDCCAj6gAwIBAgIRAOocLeZWjYkG/EbHmscuy8gwCgYIKoZIzj0EAwMwgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMTA1MjEyMTUwMDFaGA8yMTIxMDUyMTIyNTAwMVowgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABCEr3jq1KtRncnZfK5cq\nbtY0nW6ZG3FMbh7XwBIR6Ca0f8llGZ4vJEC1pXgiM/4Dh045B9ZIzNrR54rYOIfa\n2NcYZ7mk06DjIQML64hbAxbQzOAuNzLPx268MrlL2uW2XaNCMEAwDwYDVR0TAQH/\nBAUwAwEB/zAdBgNVHQ4EFgQUln75pChychwN4RfHl+tOinMrfVowDgYDVR0PAQH/\nBAQDAgGGMAoGCCqGSM49BAMDA2gAMGUCMGiyPINRU1mwZ4Crw01vpuPvxZxb2IOr\nyX3RNlOIu4We1H+5dQk5tIvH8KGYFbWEpAIxAO9NZ6/j9osMhLgZ0yj0WVjb+uZx\nYlZR9fyFisY/jNfX7QhSk+nrc3SFLRUNtpXrng==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBTCCAu2gAwIBAgIRAKiaRZatN8eiz9p0s0lu0rQwDQYJKoZIhvcNAQELBQAw\ngZoxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEzMDEGA1UEAwwq\nQW1hem9uIFJEUyBjYS1jZW50cmFsLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUyMTIyMDIzNVoYDzIwNjEwNTIxMjMwMjM1WjCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGNhLWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCygVMf\nqB865IR9qYRBRFHn4eAqGJOCFx+UbraQZmjr/mnRqSkY+nhbM7Pn/DWOrRnxoh+w\nq5F9ZxdZ5D5T1v6kljVwxyfFgHItyyyIL0YS7e2h7cRRscCM+75kMedAP7icb4YN\nLfWBqfKHbHIOqvvQK8T6+Emu/QlG2B5LvuErrop9K0KinhITekpVIO4HCN61cuOe\nCADBKF/5uUJHwS9pWw3uUbpGUwsLBuhJzCY/OpJlDqC8Y9aToi2Ivl5u3/Q/sKjr\n6AZb9lx4q3J2z7tJDrm5MHYwV74elGSXoeoG8nODUqjgklIWAPrt6lQ3WJpO2kug\n8RhCdSbWkcXHfX95AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFOIxhqTPkKVqKBZvMWtKewKWDvDBMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\nAQsFAAOCAQEAqoItII89lOl4TKvg0I1EinxafZLXIheLcdGCxpjRxlZ9QMQUN3yb\ny/8uFKBL0otbQgJEoGhxm4h0tp54g28M6TN1U0332dwkjYxUNwvzrMaV5Na55I2Z\n1hq4GB3NMXW+PvdtsgVOZbEN+zOyOZ5MvJHEQVkT3YRnf6avsdntltcRzHJ16pJc\nY8rR7yWwPXh1lPaPkxddrCtwayyGxNbNmRybjR48uHRhwu7v2WuAMdChL8H8bp89\nTQLMrMHgSbZfee9hKhO4Zebelf1/cslRSrhkG0ESq6G5MUINj6lMg2g6F0F7Xz2v\nncD/vuRN5P+vT8th/oZ0Q2Gc68Pun0cn/g==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAJYlnmkGRj4ju/2jBQsnXJYwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyB1cy1lYXN0LTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMTIzMDQ0NFoYDzIwNjEwNTIyMDAwNDQ0WjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIHVzLWVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC74V3eigv+pCj5\nnqDBqplY0Jp16pTeNB06IKbzb4MOTvNde6QjsZxrE1xUmprT8LxQqN9tI3aDYEYk\nb9v4F99WtQVgCv3Y34tYKX9NwWQgwS1vQwnIR8zOFBYqsAsHEkeJuSqAB12AYUSd\nZv2RVFjiFmYJho2X30IrSLQfS/IE3KV7fCyMMm154+/K1Z2IJlcissydEAwgsUHw\nedrE6CxJVkkJ3EvIgG4ugK/suxd8eEMztaQYJwSdN8TdfT59LFuSPl7zmF3fIBdJ\n//WexcQmGabaJ7Xnx+6o2HTfkP8Zzzzaq8fvjAcvA7gyFH5EP26G2ZqMG+0y4pTx\nSPVTrQEXAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIWWuNEF\nsUMOC82XlfJeqazzrkPDMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAgClmxcJaQTGpEZmjElL8G2Zc8lGc+ylGjiNlSIw8X25/bcLRptbDA90nuP+q\nzXAMhEf0ccbdpwxG/P5a8JipmHgqQLHfpkvaXx+0CuP++3k+chAJ3Gk5XtY587jX\n+MJfrPgjFt7vmMaKmynndf+NaIJAYczjhJj6xjPWmGrjM3MlTa9XesmelMwP3jep\nbApIWAvCYVjGndbK9byyMq1nyj0TUzB8oJZQooaR3MMjHTmADuVBylWzkRMxbKPl\n4Nlsk4Ef1JvIWBCzsMt+X17nuKfEatRfp3c9tbpGlAE/DSP0W2/Lnayxr4RpE9ds\nICF35uSis/7ZlsftODUe8wtpkQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nPqj2\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nKDPtFEk=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQVZ5Y/KqjR4XLou8MCD5pOjAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC00IFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIyMDUyNTE2NTgzM1oYDzIxMjIwNTI1MTc1ODMzWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC00IFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEbo473OmpD5vkckdJajXg\nbrhmNFyoSa0WCY1njuZC2zMFp3zP6rX4I1r3imrYnJd9pFH/aSiV/r6L5ACE5RPx\n4qdg5SQ7JJUaZc3DWsTOiOed7BCZSzM+KTYK/2QzDMApo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBTmogc06+1knsej1ltKUOdWFvwgsjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAIs7TlLMbGTWNXpGiKf9DxaM07d/iDHe\nF/Vv/wyWSTGdobxBL6iArQNVXz0Gr4dvPAIwd0rsoa6R0x5mtvhdRPtM37FYrbHJ\npbV+OMusQqcSLseunLBoCHenvJW0QOCQ8EDY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICvTCCAkOgAwIBAgIQCIY7E/bFvFN2lK9Kckb0dTAKBggqhkjOPQQDAzCBnjEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTcwNQYDVQQDDC5BbWF6\nb24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUxODIxMDUxMFoYDzIxMjEwNTE4MjIwNTEwWjCB\nnjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTcwNQYDVQQDDC5B\nbWF6b24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEMI0hzf1JCEOI\nEue4+DmcNnSs2i2UaJxHMrNGGfU7b42a7vwP53F7045ffHPBGP4jb9q02/bStZzd\nVHqfcgqkSRI7beBKjD2mfz82hF/wJSITTgCLs+NRpS6zKMFOFHUNo0IwQDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBS8uF/6hk5mPLH4qaWv9NVZaMmyTjAOBgNV\nHQ8BAf8EBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAO7Pu9wzLyM0X7Q08uLIL+vL\nqaxe3UFuzFTWjM16MLJHbzLf1i9IDFKz+Q4hXCSiJwIwClMBsqT49BPUxVsJnjGr\nEbyEk6aOOVfY1p2yQL649zh3M4h8okLnwf+bYIb1YpeU\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQY+JhwFEQTe36qyRlUlF8ozANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE5MjQxNloYDzIwNjEwNTE5MjAyNDE2WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnIye77j6ev40\n8wRPyN2OdKFSUfI9jB20Or2RLO+RDoL43+USXdrze0Wv4HMRLqaen9BcmCfaKMp0\nE4SFo47bXK/O17r6G8eyq1sqnHE+v288mWtYH9lAlSamNFRF6YwA7zncmE/iKL8J\n0vePHMHP/B6svw8LULZCk+nZk3tgxQn2+r0B4FOz+RmpkoVddfqqUPMbKUxhM2wf\nfO7F6bJaUXDNMBPhCn/3ayKCjYr49ErmnpYV2ZVs1i34S+LFq39J7kyv6zAgbHv9\n+/MtRMoRB1CjpqW0jIOZkHBdYcd1o9p1zFn591Do1wPkmMsWdjIYj+6e7UXcHvOB\n2+ScIRAcnwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQGtq2W\nYSyMMxpdQ3IZvcGE+nyZqTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAEgoP3ixJsKSD5FN8dQ01RNHERl/IFbA7TRXfwC+L1yFocKnQh4Mp/msPRSV\n+OeHIvemPW/wtZDJzLTOFJ6eTolGekHK1GRTQ6ZqsWiU2fmiOP8ks4oSpI+tQ9Lw\nVrfZqTiEcS5wEIqyfUAZZfKDo7W1xp+dQWzfczSBuZJZwI5iaha7+ILM0r8Ckden\nTVTapc5pLSoO15v0ziRuQ2bT3V3nwu/U0MRK44z+VWOJdSiKxdnOYDs8hFNnKhfe\nklbTZF7kW7WbiNYB43OaAQBJ6BALZsIskEaqfeZT8FD71uN928TcEQyBDXdZpRN+\niGQZDGhht0r0URGMDSs9waJtTfA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\ndIA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAPVSMfFitmM5PhmbaOFoGfUwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyB1cy1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMzQ1N1oYDzIwNjEwNTI1MjMzNDU3WjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIHVzLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDu9H7TBeGoDzMr\ndxN6H8COntJX4IR6dbyhnj5qMD4xl/IWvp50lt0VpmMd+z2PNZzx8RazeGC5IniV\n5nrLg0AKWRQ2A/lGGXbUrGXCSe09brMQCxWBSIYe1WZZ1iU1IJ/6Bp4D2YEHpXrW\nbPkOq5x3YPcsoitgm1Xh8ygz6vb7PsvJvPbvRMnkDg5IqEThapPjmKb8ZJWyEFEE\nQRrkCIRueB1EqQtJw0fvP4PKDlCJAKBEs/y049FoOqYpT3pRy0WKqPhWve+hScMd\n6obq8kxTFy1IHACjHc51nrGII5Bt76/MpTWhnJIJrCnq1/Uc3Qs8IVeb+sLaFC8K\nDI69Sw6bAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE7PCopt\nlyOgtXX0Y1lObBUxuKaCMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAFj+bX8gLmMNefr5jRJfHjrL3iuZCjf7YEZgn89pS4z8408mjj9z6Q5D1H7yS\njNETVV8QaJip1qyhh5gRzRaArgGAYvi2/r0zPsy+Tgf7v1KGL5Lh8NT8iCEGGXwF\ng3Ir+Nl3e+9XUp0eyyzBIjHtjLBm6yy8rGk9p6OtFDQnKF5OxwbAgip42CD75r/q\np421maEDDvvRFR4D+99JZxgAYDBGqRRceUoe16qDzbMvlz0A9paCZFclxeftAxv6\nQlR5rItMz/XdzpBJUpYhdzM0gCzAzdQuVO5tjJxmXhkSMcDP+8Q+Uv6FA9k2VpUV\nE/O5jgpqUJJ2Hc/5rs9VkAPXeA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQW0yuFCle3uj4vWiGU0SaGzAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTkzNTE2WhgPMjEyMTA1MTkyMDM1MTZaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYWYtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDPiKNZSaXs3Un/J/v+LTsFDANHpi7en\noL2qh0u0DoqNzEBTbBjvO23bLN3k599zh6CY3HKW0r2k1yaIdbWqt4upMCRCcUFi\nI4iedAmubgzh56wJdoMZztjXZRwDthTkJKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUWbYkcrvVSnAWPR5PJhIzppcAnZIwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMCESGqpat93CjrSEjE7z+Hbvz0psZTHwqaxuiH64GKUm\nmYynIiwpKHyBrzjKBmeDoQIxANGrjIo6/b8Jl6sdIZQI18V0pAyLfLiZjlHVOnhM\nMOTVgr82ZuPoEHTX78MxeMnYlw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAIbsx8XOl0sgTNiCN4O+18QwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI1MjE1NDU4WhgPMjA2MTA1MjUyMjU0NTha\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\ntROxwXWCgn5R9gI/2Ivjzaxc0g95ysBjoJsnhPdJEHQb7w3y2kWrVWU3Y9fOitgb\nCEsnEC3PrhRnzNVW0fPsK6kbvOeCmjvY30rdbxbc8h+bjXfGmIOgAkmoULEr6Hc7\nG1Q/+tvv4lEwIs7bEaf+abSZxRJbZ0MBxhbHn7UHHDiMZYvzK+SV1MGCxx7JVhrm\nxWu3GC1zZCsGDhB9YqY9eR6PmjbqA5wy8vqbC57dZZa1QVtWIQn3JaRXn+faIzHx\nnLMN5CEWihsdmHBXhnRboXprE/OS4MFv1UrQF/XM/h5RBeCywpHePpC+Oe1T3LNC\niP8KzRFrjC1MX/WXJnmOVQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS33XbXAUMs1znyZo4B0+B3D68WFTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBADuadd2EmlpueY2VlrIIPC30QkoA1EOSoCmZgN6124apkoY1\nHiV4r+QNPljN4WP8gmcARnNkS7ZeR4fvWi8xPh5AxQCpiaBMw4gcbTMCuKDV68Pw\nP2dZCTMspvR3CDfM35oXCufdtFnxyU6PAyINUqF/wyTHguO3owRFPz64+sk3r2pT\nWHmJjG9E7V+KOh0s6REgD17Gqn6C5ijLchSrPUHB0wOIkeLJZndHxN/76h7+zhMt\nfFeNxPWHY2MfpcaLjz4UREzZPSB2U9k+y3pW1omCIcl6MQU9itGx/LpQE+H3ZeX2\nM2bdYd5L+ow+bdbGtsVKOuN+R9Dm17YpswF+vyQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nEm4Hy3A=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\njGKc3k6UNxpg\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n0Ws=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtDCCAjqgAwIBAgIRAMyaTlVLN0ndGp4ffwKAfoMwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBtZS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjIwNTA3MDA0NDM3WhgPMjEyMjA1MDcwMTQ0MzdaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgbWUtY2VudHJhbC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE19nCV1nsI6CohSor13+B25cr\nzg+IHdi9Y3L7ziQnHWI6yjBazvnKD+oC71aRRlR8b5YXsYGUQxWzPLHN7EGPcSGv\nbzA9SLG1KQYCJaQ0m9Eg/iGrwKWOgylbhVw0bCxoo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBS4KsknsJXM9+QPEkBdZxUPaLr11zAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaAAwZQIxAJaRgrYIEfXQMZQQDxMTYS0azpyWSseQooXo\nL3nYq4OHGBgYyQ9gVjvRYWU85PXbfgIwdi82DtANQFkCu+j+BU0JBY/uRKPEeYzo\nJG92igKIcXPqCoxIJ7lJbbzmuf73gQu5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nTspdjbg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAJZFh4s9aZGzKaTMLrSb4acwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBCZXRhIHVzLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTE4MjEyODQxWhgPMjA2MTA1MTgyMjI4NDFa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgQmV0YSB1cy1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\n17i2yoU6diep+WrqxIn2CrDEO2NdJVwWTSckx4WMZlLpkQDoymSmkNHjq9ADIApD\nA31Cx+843apL7wub8QkFZD0Tk7/ThdHWJOzcAM3ov98QBPQfOC1W5zYIIRP2F+vQ\nTRETHQnLcW3rLv0NMk5oQvIKpJoC9ett6aeVrzu+4cU4DZVWYlJUoC/ljWzCluau\n8blfW0Vwin6OB7s0HCG5/wijQWJBU5SrP/KAIPeQi1GqG5efbqAXDr/ple0Ipwyo\nXjjl73LenGUgqpANlC9EAT4i7FkJcllLPeK3NcOHjuUG0AccLv1lGsHAxZLgjk/x\nz9ZcnVV9UFWZiyJTKxeKPwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRWyMuZUo4gxCR3Luf9/bd2AqZ7CjAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIqN2DlIKlvDFPO0QUZQVFbsi/tLdYM98/vvzBpttlTGVMyD\ngJuQeHVz+MnhGIwoCGOlGU3OOUoIlLAut0+WG74qYczn43oA2gbMd7HoD7oL/IGg\nnjorBwJVcuuLv2G//SqM3nxGcLRtkRnQ+lvqPxMz9+0fKFUn6QcIDuF0QSfthLs2\nWSiGEPKO9c9RSXdRQ4pXA7c3hXng8P4A2ZmdciPne5Nu4I4qLDGZYRrRLRkNTrOi\nTyS6r2HNGUfgF7eOSeKt3NWL+mNChcYj71/Vycf5edeczpUgfnWy9WbPrK1svKyl\naAs2xg+X6O8qB+Mnj2dNBzm+lZIS3sIlm+nO9sg=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAPAlEk8VJPmEzVRRaWvTh2AwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI1MjI0MTU1WhgPMjEyMTA1MjUyMzQxNTVaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEx5xjrup8II4HOJw15NTnS3H5yMrQGlbj\nEDA5MMGnE9DmHp5dACIxmPXPMe/99nO7wNdl7G71OYPCgEvWm0FhdvVUeTb3LVnV\nBnaXt32Ek7/oxGk1T+Df03C+W0vmuJ+wo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBTGXmqBWN/1tkSea4pNw0oHrjk2UDAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAIqqZWCSrIkZ7zsv/FygtAusW6yvlL935YAWYPVXU30m\njkMFLM+/RJ9GMvnO8jHfCgIwB+whlkcItzE9CRQ6CsMo/d5cEHDUu/QW6jSIh9BR\nOGh9pTYPVkUbBiKPA7lVVhre\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nnWS0\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nUfff2jrbfbzECn1ELg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nfejbXelUSJSzDIdY\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nPtjwbKW0hYAhIttT0Q==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQQRBQTs6Y3H1DDbpHGta3lzAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0zIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDYxMTAwMTI0M1oYDzIxMjEwNjExMDExMjQzWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0zIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEs0942Xj4m/gKA+WA6F5h\nAHYuek9eGpzTRoLJddM4rEV1T3eSueytMVKOSlS3Ub9IhyQrH2D8EHsLYk9ktnGR\npATk0kCYTqFbB7onNo070lmMJmGT/Q7NgwC8cySChFxbo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBQ20iKBKiNkcbIZRu0y1uoF1yJTEzAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIwYv0wTSrpQTaPaarfLN8Xcqrqu3hzl07n\nFrESIoRw6Cx77ZscFi2/MV6AFyjCV/TlAjEAhpwJ3tpzPXpThRML8DMJYZ3YgMh3\nCMuLqhPpla3cL0PhybrD27hJWl29C4el6aMO\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrDCCAjOgAwIBAgIQGcztRyV40pyMKbNeSN+vXTAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIHVzLWVhc3QtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjEyMzE1NTZaGA8yMTIxMDUyMjAwMTU1NlowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyB1cy1lYXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQfDcv+GGRESD9wT+I5YIPRsD3L+/jsiIis\nTr7t9RSbFl+gYpO7ZbDXvNbV5UGOC5lMJo/SnqFRTC6vL06NF7qOHfig3XO8QnQz\n6T5uhhrhnX2RSY3/10d2kTyHq3ZZg3+jQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFLDyD3PRyNXpvKHPYYxjHXWOgfPnMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNnADBkAjB20HQp6YL7CqYD82KaLGzgw305aUKw2aMrdkBR29J183jY\n6Ocj9+Wcif9xnRMS+7oCMAvrt03rbh4SU9BohpRUcQ2Pjkh7RoY0jDR4Xq4qzjNr\n5UFr3BXpFvACxXF51BksGQ==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjWgAwIBAgIQeKbS5zvtqDvRtwr5H48cAjAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIwMTcxOTU1WhgPMjEyMTA1MjAxODE5NTVaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgbWUtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABEKjgUaAPmUlRMEQdBC7BScAGosJ1zRV\nLDd38qTBjzgmwBfQJ5ZfGIvyEK5unB09MB4e/3qqK5I/L6Qn5Px/n5g4dq0c7MQZ\nu7G9GBYm90U3WRJBf7lQrPStXaRnS4A/O6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUNKcAbGEIn03/vkwd8g6jNyiRdD4wDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2cAMGQCMHIeTrjenCSYuGC6txuBt/0ZwnM/ciO9kHGWVCoK8QLs\njGghb5/YSFGZbmQ6qpGlSAIwVOQgdFfTpEfe5i+Vs9frLJ4QKAfc27cTNYzRIM0I\nE+AJgK4C4+DiyyMzOpiCfmvq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nWT1QcNdw7ntUJP/w\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQARky6+5PNFRkFVOp3Ob1CTAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjIwNTIzMTg0MTI4WhgPMjEyMjA1MjMxOTQxMjdaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgZXUtc291dGgtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABNVGL5oF7cfIBxKyWd2PVK/S5yQfaJY3\nQFHWvEdt6951n9JhiiPrHzfVHsxZp1CBjILRMzjgRbYWmc8qRoLkgGE7htGdwudJ\nFa/WuKzO574Prv4iZXUnVGTboC7JdvKbh6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUgDeIIEKynwUbNXApdIPnmRWieZwwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMEOOJfucrST+FxuqJkMZyCM3gWGZaB+/w6+XUAJC6hFM\nuSTY0F44/bERkA4XhH+YGAIxAIpJQBakCA1/mXjsTnQ+0El9ty+LODp8ibkn031c\n8DKDS7pR9UK7ZYdR6zFg3ZCjQw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjOgAwIBAgIQJvkWUcYLbnxtuwnyjMmntDAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIGV1LXdlc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjUyMjI2MTJaGA8yMTIxMDUyNTIzMjYxMlowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyBldS13ZXN0LTMgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAARENn8uHCyjn1dFax4OeXxvbV861qsXFD9G\nDshumTmFzWWHN/69WN/AOsxy9XN5S7Cgad4gQgeYYYgZ5taw+tFo/jQvCLY//uR5\nuihcLuLJ78opvRPvD9kbWZ6oXfBtFkWjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFKiK3LpoF+gDnqPldGSwChBPCYciMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNpADBmAjEA+7qfvRlnvF1Aosyp9HzxxCbN7VKu+QXXPhLEBWa5oeWW\nUOcifunf/IVLC4/FGCsLAjEAte1AYp+iJyOHDB8UYkhBE/1sxnFaTiEPbvQBU0wZ\nSuwWVLhu2wWDuSW+K7tTuL8p\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAKeDpqX5WFCGNo94M4v69sUwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBldS13ZXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMTgzM1oYDzIwNjEwNTI1MjMxODMzWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXdlc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCcKOTEMTfzvs4H\nWtJR8gI7GXN6xesulWtZPv21oT+fLGwJ+9Bv8ADCGDDrDxfeH/HxJmzG9hgVAzVn\n4g97Bn7q07tGZM5pVi96/aNp11velZT7spOJKfJDZTlGns6DPdHmx48whpdO+dOb\n6+eR0VwCIv+Vl1fWXgoACXYCoKjhxJs+R+fwY//0JJ1YG8yjZ+ghLCJmvlkOJmE1\nTCPUyIENaEONd6T+FHGLVYRRxC2cPO65Jc4yQjsXvvQypoGgx7FwD5voNJnFMdyY\n754JGPOOe/SZdepN7Tz7UEq8kn7NQSbhmCsgA/Hkjkchz96qN/YJ+H/okiQUTNB0\neG9ogiVFAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFjayw9Y\nMjbxfF14XAhMM2VPl0PfMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAAtmx6d9+9CWlMoU0JCirtp4dSS41bBfb9Oor6GQ8WIr2LdfZLL6uES/ubJPE\n1Sh5Vu/Zon5/MbqLMVrfniv3UpQIof37jKXsjZJFE1JVD/qQfRzG8AlBkYgHNEiS\nVtD4lFxERmaCkY1tjKB4Dbd5hfhdrDy29618ZjbSP7NwAfnwb96jobCmMKgxVGiH\nUqsLSiEBZ33b2hI7PJ6iTJnYBWGuiDnsWzKRmheA4nxwbmcQSfjbrNwa93w3caL2\nv/4u54Kcasvcu3yFsUwJygt8z43jsGAemNZsS7GWESxVVlW93MJRn6M+MMakkl9L\ntWaXdHZ+KUV7LhfYLb0ajvb40w==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBDCCAuygAwIBAgIQJ5oxPEjefCsaESSwrxk68DANBgkqhkiG9w0BAQsFADCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGV1LWNlbnRyYWwtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwIBcNMjIwNjA2MjExNzA1WhgPMjA2MjA2MDYyMjE3MDVaMIGa\nMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5j\nLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMzAxBgNVBAMMKkFt\nYXpvbiBSRFMgZXUtY2VudHJhbC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALTQt5eX\ng+VP3BjO9VBkWJhE0GfLrU/QIk32I6WvrnejayTrlup9H1z4QWlXF7GNJrqScRMY\nKhJHlcP05aPsx1lYco6pdFOf42ybXyWHHJdShj4A5glU81GTT+VrXGzHSarLmtua\neozkQgPpDsSlPt0RefyTyel7r3Cq+5K/4vyjCTcIqbfgaGwTU36ffjM1LaPCuE4O\nnINMeD6YuImt2hU/mFl20FZ+IZQUIFZZU7pxGLqTRz/PWcH8tDDxnkYg7tNuXOeN\nJbTpXrw7St50/E9ZQ0llGS+MxJD8jGRAa/oL4G/cwnV8P2OEPVVkgN9xDDQeieo0\n3xkzolkDkmeKOnUCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU\nbwu8635iQGQMRanekesORM8Hkm4wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB\nCwUAA4IBAQAgN6LE9mUgjsj6xGCX1afYE69fnmCjjb0rC6eEe1mb/QZNcyw4XBIW\n6+zTXo4mjZ4ffoxb//R0/+vdTE7IvaLgfAZgFsLKJCtYDDstXZj8ujQnGR9Pig3R\nW+LpNacvOOSJSawNQq0Xrlcu55AU4buyD5VjcICnfF1dqBMnGTnh27m/scd/ZMx/\nkapHZ/fMoK2mAgSX/NvUKF3UkhT85vSSM2BTtET33DzCPDQTZQYxFBa4rFRmFi4c\nBLlmIReiCGyh3eJhuUUuYAbK6wLaRyPsyEcIOLMQmZe1+gAFm1+1/q5Ke9ugBmjf\nPbTWjsi/lfZ5CdVAhc5lmZj/l5aKqwaS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAKKPTYKln9L4NTx9dpZGUjowCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBldS13ZXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIxMjI1NTIxWhgPMjEyMTA1MjEyMzU1MjFaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgZXUtd2VzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE/owTReDvaRqdmbtTzXbyRmEpKCETNj6O\nhZMKH0F8oU9Tmn8RU7kQQj6xUKEyjLPrFBN7c+26TvrVO1KmJAvbc8bVliiJZMbc\nC0yV5PtJTalvlMZA1NnciZuhxaxrzlK1o0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBT4i5HaoHtrs7Mi8auLhMbKM1XevDAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAK9A+8/lFdX4XJKgfP+ZLy5ySXC2E0Spoy12Gv2GdUEZ\np1G7c1KbWVlyb1d6subzkQIwKyH0Naf/3usWfftkmq8SzagicKz5cGcEUaULq4tO\nGzA/AMpr63IDBAqkZbMDTCmH\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQTgIvwTDuNWQo0Oe1sOPQEzAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI0MjEwNjM4WhgPMjEyMTA1MjQyMjA2MzhaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgZXUtbm9ydGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJuzXLU8q6WwSKXBvx8BbdIi3mPhb7Xo\nrNJBfuMW1XRj5BcKH1ZoGaDGw+BIIwyBJg8qNmCK8kqIb4cH8/Hbo3Y+xBJyoXq/\ncuk8aPrxiNoRsKWwiDHCsVxaK9L7GhHHAqNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUYgcsdU4fm5xtuqLNppkfTHM2QMYwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMQDz/Rm89+QJOWJecYAmYcBWCcETASyoK1kbr4vw7Hsg\n7Ew3LpLeq4IRmTyuiTMl0gMCMAa0QSjfAnxBKGhAnYxcNJSntUyyMpaXzur43ec0\n3D8npJghwC4DuICtKEkQiI5cSg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nu3UBpZI=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtDCCAjmgAwIBAgIQenQbcP/Zbj9JxvZ+jXbRnTAKBggqhkjOPQQDAzCBmTEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTIwMAYDVQQDDClBbWF6\nb24gUkRTIGV1LWNlbnRyYWwtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwH\nU2VhdHRsZTAgFw0yMTA1MjEyMjMzMjRaGA8yMTIxMDUyMTIzMzMyNFowgZkxCzAJ\nBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMw\nEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1hem9u\nIFJEUyBldS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATlBHiEM9LoEb1Hdnd5j2VpCDOU\n5nGuFoBD8ROUCkFLFh5mHrHfPXwBc63heW9WrP3qnDEm+UZEUvW7ROvtWCTPZdLz\nZ4XaqgAlSqeE2VfUyZOZzBSgUUJk7OlznXfkCMOjQjBAMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDT/ThjQZl42Nv/4Z/7JYaPNMly2MA4GA1UdDwEB/wQEAwIB\nhjAKBggqhkjOPQQDAwNpADBmAjEAnZWmSgpEbmq+oiCa13l5aGmxSlfp9h12Orvw\nDq/W5cENJz891QD0ufOsic5oGq1JAjEAp5kSJj0MxJBTHQze1Aa9gG4sjHBxXn98\n4MP1VGsQuhfndNHQb4V0Au7OWnOeiobq\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAMgnyikWz46xY6yRgiYwZ3swDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBldS13ZXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE2NDkxMloYDzIwNjEwNTIwMTc0OTEyWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXdlc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCi8JYOc9cYSgZH\ngYPxLk6Xcc7HqzamvsnjYU98Dcb98y6iDqS46Ra2Ne02MITtU5MDL+qjxb8WGDZV\nRUA9ZS69tkTO3gldW8QdiSh3J6hVNJQW81F0M7ZWgV0gB3n76WCmfT4IWos0AXHM\n5v7M/M4tqVmCPViQnZb2kdVlM3/Xc9GInfSMCgNfwHPTXl+PXX+xCdNBePaP/A5C\n5S0oK3HiXaKGQAy3K7VnaQaYdiv32XUatlM4K2WS4AMKt+2cw3hTCjlmqKRHvYFQ\nveWCXAuc+U5PQDJ9SuxB1buFJZhT4VP3JagOuZbh5NWpIbOTxlAJOb5pGEDuJTKi\n1gQQQVEFAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNXm+N87\nOFxK9Af/bjSxDCiulGUzMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAkqIbkgZ45spvrgRQ6n9VKzDLvNg+WciLtmVrqyohwwJbj4pYvWwnKQCkVc7c\nhUOSBmlSBa5REAPbH5o8bdt00FPRrD6BdXLXhaECKgjsHe1WW08nsequRKD8xVmc\n8bEX6sw/utBeBV3mB+3Zv7ejYAbDFM4vnRsWtO+XqgReOgrl+cwdA6SNQT9oW3e5\nrSQ+VaXgJtl9NhkiIysq9BeYigxqS/A13pHQp0COMwS8nz+kBPHhJTsajHCDc8F4\nHfLi6cgs9G0gaRhT8FCH66OdGSqn196sE7Y3bPFFFs/3U+vxvmQgoZC6jegQXAg5\nPrxd+VNXtNI/azitTysQPumH7A==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEBTCCAu2gAwIBAgIRAO8bekN7rUReuNPG8pSTKtEwDQYJKoZIhvcNAQELBQAw\ngZoxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEzMDEGA1UEAwwq\nQW1hem9uIFJEUyBldS1jZW50cmFsLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUyMTIyMjM0N1oYDzIwNjEwNTIxMjMyMzQ3WjCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGV1LWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCTTYds\nTray+Q9VA5j5jTh5TunHKFQzn68ZbOzdqaoi/Rq4ohfC0xdLrxCpfqn2TGDHN6Zi\n2qGK1tWJZEd1H0trhzd9d1CtGK+3cjabUmz/TjSW/qBar7e9MA67/iJ74Gc+Ww43\nA0xPNIWcL4aLrHaLm7sHgAO2UCKsrBUpxErOAACERScVYwPAfu79xeFcX7DmcX+e\nlIqY16pQAvK2RIzrekSYfLFxwFq2hnlgKHaVgZ3keKP+nmXcXmRSHQYUUr72oYNZ\nHcNYl2+gxCc9ccPEHM7xncVEKmb5cWEWvVoaysgQ+osi5f5aQdzgC2X2g2daKbyA\nXL/z5FM9GHpS5BJjAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFBDAiJ7Py9/A9etNa/ebOnx5l5MGMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\nAQsFAAOCAQEALMh/+81fFPdJV/RrJUeoUvFCGMp8iaANu97NpeJyKitNOv7RoeVP\nWjivS0KcCqZaDBs+p6IZ0sLI5ZH098LDzzytcfZg0PsGqUAb8a0MiU/LfgDCI9Ee\njsOiwaFB8k0tfUJK32NPcIoQYApTMT2e26lPzYORSkfuntme2PTHUnuC7ikiQrZk\nP+SZjWgRuMcp09JfRXyAYWIuix4Gy0eZ4rpRuaTK6mjAb1/LYoNK/iZ/gTeIqrNt\nl70OWRsWW8jEmSyNTIubGK/gGGyfuZGSyqoRX6OKHESkP6SSulbIZHyJ5VZkgtXo\n2XvyRyJ7w5pFyoofrL3Wv0UF8yt/GDszmg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n2jpC\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nFEv9Bg==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICsDCCAjagAwIBAgIRAMgApnfGYPpK/fD0dbN2U4YwCgYIKoZIzj0EAwMwgZcx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwnQW1h\nem9uIFJEUyBldS1zb3V0aC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMCAXDTIxMDUxOTE4MzgxMVoYDzIxMjEwNTE5MTkzODExWjCBlzELMAkG\nA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzAR\nBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6b24g\nUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0\nbGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQfEWl6d4qSuIoECdZPp+39LaKsfsX7\nTHs3/RrtT0+h/jl3bjZ7Qc68k16x+HGcHbaayHfqD0LPdzH/kKtNSfQKqemdxDQh\nZ4pwkixJu8T1VpXZ5zzCvBXCl75UqgEFS92jQjBAMA8GA1UdEwEB/wQFMAMBAf8w\nHQYDVR0OBBYEFFPrSNtWS5JU+Tvi6ABV231XbjbEMA4GA1UdDwEB/wQEAwIBhjAK\nBggqhkjOPQQDAwNoADBlAjEA+a7hF1IrNkBd2N/l7IQYAQw8chnRZDzh4wiGsZsC\n6A83maaKFWUKIb3qZYXFSi02AjAbp3wxH3myAmF8WekDHhKcC2zDvyOiKLkg9Y6v\nZVmyMR043dscQbcsVoacOYv198c=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICtDCCAjqgAwIBAgIRAPhVkIsQ51JFhD2kjFK5uAkwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBldS1jZW50cmFsLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjIwNjA2MjEyOTE3WhgPMjEyMjA2MDYyMjI5MTdaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgZXUtY2VudHJhbC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEA5xnIEBtG5b2nmbj49UEwQza\nyX0844fXjccYzZ8xCDUe9dS2XOUi0aZlGblgSe/3lwjg8fMcKXLObGGQfgIx1+5h\nAIBjORis/dlyN5q/yH4U5sjS8tcR0GDGVHrsRUZCo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBRK+lSGutXf4DkTjR3WNfv4+KeNFTAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaAAwZQIxAJ4NxQ1Gerqr70ZrnUqc62Vl8NNqTzInamCG\nKce3FTsMWbS9qkgrjZkO9QqOcGIw/gIwSLrwUT+PKr9+H9eHyGvpq9/3AIYSnFkb\nCf3dyWPiLKoAtLFwjzB/CkJlsAS1c8dS\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nr1o=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\nwOx+\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n89cEIGdbjsA=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQYjbPSg4+RNRD3zNxO1fuKDANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNDIwNTkyMVoYDzIwNjEwNTI0MjE1OTIxWjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA179eQHxcV0YL\nXMkqEmhSBazHhnRVd8yICbMq82PitE3BZcnv1Z5Zs/oOgNmMkOKae4tCXO/41JCX\nwAgbs/eWWi+nnCfpQ/FqbLPg0h3dqzAgeszQyNl9IzTzX4Nd7JFRBVJXPIIKzlRf\n+GmFsAhi3rYgDgO27pz3ciahVSN+CuACIRYnA0K0s9lhYdddmrW/SYeWyoB7jPa2\nLmWpAs7bDOgS4LlP2H3eFepBPgNufRytSQUVA8f58lsE5w25vNiUSnrdlvDrIU5n\nQwzc7NIZCx4qJpRbSKWrUtbyJriWfAkGU7i0IoainHLn0eHp9bWkwb9D+C/tMk1X\nERZw2PDGkwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSFmR7s\ndAblusFN+xhf1ae0KUqhWTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAHsXOpjPMyH9lDhPM61zYdja1ebcMVgfUvsDvt+w0xKMKPhBzYDMs/cFOi1N\nQ8LV79VNNfI2NuvFmGygcvTIR+4h0pqqZ+wjWl3Kk5jVxCrbHg3RBX02QLumKd/i\nkwGcEtTUvTssn3SM8bgM0/1BDXgImZPC567ciLvWDo0s/Fe9dJJC3E0G7d/4s09n\nOMdextcxFuWBZrBm/KK3QF0ByA8MG3//VXaGO9OIeeOJCpWn1G1PjT1UklYhkg61\nEbsTiZVA2DLd1BGzfU4o4M5mo68l0msse/ndR1nEY6IywwpgIFue7+rEleDh6b9d\nPYkG1rHVw2I0XDG4o17aOn5E94I=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQC6W4HFghUkkgyQw14a6JljANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIyMDUyMzE4MTYzMloYDzIwNjIwNTIzMTkxNjMyWjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAiM/t4FV2R9Nx\nUQG203UY83jInTa/6TMq0SPyg617FqYZxvz2kkx09x3dmxepUg9ttGMlPgjsRZM5\nLCFEi1FWk+hxHzt7vAdhHES5tdjwds3aIkgNEillmRDVrUsbrDwufLaa+MMDO2E1\nwQ/JYFXw16WBCCi2g1EtyQ2Xp+tZDX5IWOTnvhZpW8vVDptZ2AcJ5rMhfOYO3OsK\n5EF0GGA5ldzuezP+BkrBYGJ4wVKGxeaq9+5AT8iVZrypjwRkD7Y5CurywK3+aBwm\ns9Q5Nd8t45JCOUzYp92rFKsCriD86n/JnEvgDfdP6Hvtm0/DkwXK40Wz2q0Zrd0k\nmjP054NRPwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRR7yqd\nSfKcX2Q8GzhcVucReIpewTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAEszBRDwXcZyNm07VcFwI1Im94oKwKccuKYeJEsizTBsVon8VpEiMwDs+yGu\n3p8kBhvkLwWybkD/vv6McH7T5b9jDX2DoOudqYnnaYeypsPH/00Vh3LvKagqzQza\norWLx+0tLo8xW4BtU+Wrn3JId8LvAhxyYXTn9bm+EwPcStp8xGLwu53OPD1RXYuy\nuu+3ps/2piP7GVfou7H6PRaqbFHNfiGg6Y+WA0HGHiJzn8uLmrRJ5YRdIOOG9/xi\nqTmAZloUNM7VNuurcMM2hWF494tQpsQ6ysg2qPjbBqzlGoOt3GfBTOZmqmwmqtam\nK7juWM/mdMQAJ3SMlE5wI8nVdx4=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAL9SdzVPcpq7GOpvdGoM80IwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBldS13ZXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIwMTY1ODA3WhgPMjEyMTA1MjAxNzU4MDdaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgZXUtd2VzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEJWDgXebvwjR+Ce+hxKOLbnsfN5W5dOlP\nZn8kwWnD+SLkU81Eac/BDJsXGrMk6jFD1vg16PEkoSevsuYWlC8xR6FmT6F6pmeh\nfsMGOyJpfK4fyoEPhKeQoT23lFIc5Orjo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSVNAN1CHAz0eZ77qz2adeqjm31TzAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAMlQeHbcjor49jqmcJ9gRLWdEWpXG8thIf6zfYQ/OEAg\nd7GDh4fR/OUk0VfjsBUN/gIwZB0bGdXvK38s6AAE/9IT051cz/wMe9GIrX1MnL1T\n1F5OqnXJdiwfZRRTHsRQ/L00\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----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\n1YfpdH2jp30=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQTDc+UgTRtYO7ZGTQ8UWKDDANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIGV1LXdlc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTIxMjI0NjI0WhgPMjA2MTA1MjEyMzQ2MjRaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgZXUtd2VzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM1oGtthQ1YiVIC2\ni4u4swMAGxAjc/BZp0yq0eP5ZQFaxnxs7zFAPabEWsrjeDzrRhdVO0h7zskrertP\ngblGhfD20JfjvCHdP1RUhy/nzG+T+hn6Takan/GIgs8grlBMRHMgBYHW7tklhjaH\n3F7LujhceAHhhgp6IOrpb6YTaTTaJbF3GTmkqxSJ3l1LtEoWz8Al/nL/Ftzxrtez\nVs6ebpvd7sw37sxmXBWX2OlvUrPCTmladw9OrllGXtCFw4YyLe3zozBlZ3cHzQ0q\nlINhpRcajTMfZrsiGCkQtoJT+AqVJPS2sHjqsEH8yiySW9Jbq4zyMbM1yqQ2vnnx\nMJgoYMcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaQG88UnV\nJPTI+Pcti1P+q3H7pGYwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQBAkgr75V0sEJimC6QRiTVWEuj2Khy7unjSfudbM6zumhXEU2/sUaVLiYy6cA/x\n3v0laDle6T07x9g64j5YastE/4jbzrGgIINFlY0JnaYmR3KZEjgi1s1fkRRf3llL\nPJm9u4Q1mbwAMQK/ZjLuuRcL3uRIHJek18nRqT5h43GB26qXyvJqeYYpYfIjL9+/\nYiZAbSRRZG+Li23cmPWrbA1CJY121SB+WybCbysbOXzhD3Sl2KSZRwSw4p2HrFtV\n1Prk0dOBtZxCG9luf87ultuDZpfS0w6oNBAMXocgswk24ylcADkkFxBWW+7BETn1\nEpK+t1Lm37mU4sxtuha00XAi\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQcY44/8NUvBwr6LlHfRy7KjANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE4MjcxOFoYDzIwNjEwNTE5MTkyNzE4WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0UaBeC+Usalu\nEtXnV7+PnH+gi7/71tI/jkKVGKuhD2JDVvqLVoqbMHRh3+wGMvqKCjbHPcC2XMWv\n566fpAj4UZ9CLB5fVzss+QVNTl+FH2XhEzigopp+872ajsNzcZxrMkifxGb4i0U+\nt0Zi+UrbL5tsfP2JonKR1crOrbS6/DlzHBjIiJazGOQcMsJjNuTOItLbMohLpraA\n/nApa3kOvI7Ufool1/34MG0+wL3UUA4YkZ6oBJVxjZvvs6tI7Lzz/SnhK2widGdc\nsnbLqBpHNIZQSorVoiwcFaRBGYX/uzYkiw44Yfa4cK2V/B5zgu1Fbr0gbI2am4eh\nyVYyg4jPawIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBS9gM1m\nIIjyh9O5H/7Vj0R/akI7UzAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAF0Sm9HC2AUyedBVnwgkVXMibnYChOzz7T+0Y+fOLXYAEXex2s8oqGeZdGYX\nJHkjBn7JXu7LM+TpTbPbFFDoc1sgMguD/ls+8XsqAl1CssW+amryIL+jfcfbgQ+P\nICwEUD9hGdjBgJ5WcuS+qqxHsEIlFNci3HxcxfBa9VsWs5TjI7Vsl4meL5lf7ZyL\nwDV7dHRuU+cImqG1MIvPRIlvPnT7EghrCYi2VCPhP2pM/UvShuwVnkz4MJ29ebIk\nWR9kpblFxFdE92D5UUvMCjC2kmtgzNiErvTcwIvOO9YCbBHzRB1fFiWrXUHhJWq9\nIkaxR5icb/IpAV0A1lYZEWMVsfQ=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIGATCCA+mgAwIBAgIRAMa0TPL+QgbWfUPpYXQkf8wwDQYJKoZIhvcNAQEMBQAw\ngZgxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwo\nQW1hem9uIFJEUyBldS1ub3J0aC0xIFJvb3QgQ0EgUlNBNDA5NiBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMTA1MjQyMTAzMjBaGA8yMTIxMDUyNDIyMDMyMFowgZgx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwoQW1h\nem9uIFJEUyBldS1ub3J0aC0xIFJvb3QgQ0EgUlNBNDA5NiBHMTEQMA4GA1UEBwwH\nU2VhdHRsZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANhS9LJVJyWp\n6Rudy9t47y6kzvgnFYDrvJVtgEK0vFn5ifdlHE7xqMz4LZqWBFTnS+3oidwVRqo7\ntqsuuElsouStO8m315/YUzKZEPmkw8h5ufWt/lg3NTCoUZNkB4p4skr7TspyMUwE\nVdlKQuWTCOLtofwmWT+BnFF3To6xTh3XPlT3ssancw27Gob8kJegD7E0TSMVsecP\nB8je65+3b8CGwcD3QB3kCTGLy87tXuS2+07pncHvjMRMBdDQQQqhXWsRSeUNg0IP\nxdHTWcuwMldYPWK5zus9M4dCNBDlmZjKdcZZVUOKeBBAm7Uo7CbJCk8r/Fvfr6mw\nnXXDtuWhqn/WhJiI/y0QU27M+Hy5CQMxBwFsfAjJkByBpdXmyYxUgTmMpLf43p7H\noWfH1xN0cT0OQEVmAQjMakauow4AQLNkilV+X6uAAu3STQVFRSrpvMen9Xx3EPC3\nG9flHueTa71bU65Xe8ZmEmFhGeFYHY0GrNPAFhq9RThPRY0IPyCZe0Th8uGejkek\njQjm0FHPOqs5jc8CD8eJs4jSEFt9lasFLVDcAhx0FkacLKQjGHvKAnnbRwhN/dF3\nxt4oL8Z4JGPCLau056gKnYaEyviN7PgO+IFIVOVIdKEBu2ASGE8/+QJB5bcHefNj\n04hEkDW0UYJbSfPpVbGAR0gFI/QpycKnAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFFMXvvjoaGGUcul8GA3FT05DLbZcMA4GA1UdDwEB/wQEAwIB\nhjANBgkqhkiG9w0BAQwFAAOCAgEAQLwFhd2JKn4K/6salLyIA4mP58qbA/9BTB/r\nD9l0bEwDlVPSdY7R3gZCe6v7SWLfA9RjE5tdWDrQMi5IU6W2OVrVsZS/yGJfwnwe\na/9iUAYprA5QYKDg37h12XhVsDKlYCekHdC+qa5WwB1SL3YUprDLPWeaIQdg+Uh2\n+LxvpZGoxoEbca0fc7flwq9ke/3sXt/3V4wJDyY6AL2YNdjFzC+FtYjHHx8rYxHs\naesP7yunuN17KcfOZBBnSFRrx96k+Xm95VReTEEpwiBqAECqEpMbd+R0mFAayMb1\ncE77GaK5yeC2f67NLYGpkpIoPbO9p9rzoXLE5GpSizMjimnz6QCbXPFAFBDfSzim\nu6azp40kEUO6kWd7rBhqRwLc43D3TtNWQYxMve5mTRG4Od+eMKwYZmQz89BQCeqm\naZiJP9y9uwJw4p/A5V3lYHTDQqzmbOyhGUk6OdpdE8HXs/1ep1xTT20QDYOx3Ekt\nr4mmNYfH/8v9nHNRlYJOqFhmoh1i85IUl5IHhg6OT5ZTTwsGTSxvgQQXrmmHVrgZ\nrZIqyBKllCgVeB9sMEsntn4bGLig7CS/N1y2mYdW/745yCLZv2gj0NXhPqgEIdVV\nf9DhFD4ohE1C63XP0kOQee+LYg/MY5vH8swpCSWxQgX5icv5jVDz8YTdCKgUc5u8\nrM2p0kk=\n-----END CERTIFICATE-----\n" + ]; + } +}); + +// node_modules/aws-ssl-profiles/lib/profiles/ca/proxies.js +var require_proxies = __commonJS({ + "node_modules/aws-ssl-profiles/lib/profiles/ca/proxies.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.proxies = void 0; + exports2.proxies = [ + "-----BEGIN CERTIFICATE-----\nMIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj\nca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM\n9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw\nIFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6\nVOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L\n93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm\njgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA\nA4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI\nU5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs\nN+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv\no/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU\n5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy\nrqXRfboQnoZsG4q5WTP468SQvvG5\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK\ngXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ\nW0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg\n1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K\n8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r\n2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me\nz/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR\n8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj\nmUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz\n7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6\n+XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI\n0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB\nAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm\nUjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2\nLIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY\n+gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS\nk5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl\n7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm\nbtmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl\nurR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+\nfUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63\nn749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE\n76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H\n9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT\n4PsJYGw=\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5\nMQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\nUm9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\nA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\nQ0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl\nui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j\nQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr\nttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr\nBqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM\nYyRIHN8wfdVoOw==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5\nMQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\nUm9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\nA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\nQ0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi\n9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk\nM6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB\n/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB\nMAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw\nCkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW\n1KyLa2tJElMzrdfkviT8tQp21KW8EA==\n-----END CERTIFICATE-----\n", + "-----BEGIN CERTIFICATE-----\nMIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx\nEDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT\nHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs\nZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5\nMDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD\nVQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy\nZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy\ndmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p\nOsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2\n8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K\nTs9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe\nhRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk\n6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw\nDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q\nAdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI\nbw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB\nve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z\nqwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd\niEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn\n0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN\nsSi6\n-----END CERTIFICATE-----\n" + ]; + } +}); + +// node_modules/aws-ssl-profiles/lib/index.js +var require_lib4 = __commonJS({ + "node_modules/aws-ssl-profiles/lib/index.js"(exports2, module2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var defaults_js_1 = require_defaults(); + var proxies_js_1 = require_proxies(); + var proxyBundle = { + ca: proxies_js_1.proxies + }; + var profiles = { + ca: [...defaults_js_1.defaults, ...proxies_js_1.proxies] + }; + module2.exports = profiles; + module2.exports.proxyBundle = proxyBundle; + module2.exports.default = profiles; + } +}); + +// node_modules/mysql2/lib/constants/ssl_profiles.js +var require_ssl_profiles = __commonJS({ + "node_modules/mysql2/lib/constants/ssl_profiles.js"(exports2) { + "use strict"; + var awsCaBundle = require_lib4(); + exports2["Amazon RDS"] = { + ca: awsCaBundle.ca + }; + } +}); + +// node_modules/mysql2/lib/connection_config.js +var require_connection_config = __commonJS({ + "node_modules/mysql2/lib/connection_config.js"(exports2, module2) { + "use strict"; + var { URL: URL2 } = require("url"); + var ClientConstants = require_client(); + var Charsets = require_charsets(); + var { version } = require_package(); + var SSLProfiles = null; + var validOptions = { + authPlugins: 1, + authSwitchHandler: 1, + bigNumberStrings: 1, + charset: 1, + charsetNumber: 1, + compress: 1, + connectAttributes: 1, + connectTimeout: 1, + database: 1, + dateStrings: 1, + debug: 1, + decimalNumbers: 1, + enableKeepAlive: 1, + flags: 1, + host: 1, + insecureAuth: 1, + infileStreamFactory: 1, + isServer: 1, + keepAliveInitialDelay: 1, + localAddress: 1, + maxPreparedStatements: 1, + multipleStatements: 1, + namedPlaceholders: 1, + nestTables: 1, + password: 1, + // with multi-factor authentication, the main password (used for the first + // authentication factor) can be provided via password1 + password1: 1, + password2: 1, + password3: 1, + passwordSha1: 1, + pool: 1, + port: 1, + queryFormat: 1, + rowsAsArray: 1, + socketPath: 1, + ssl: 1, + stream: 1, + stringifyObjects: 1, + supportBigNumbers: 1, + timezone: 1, + trace: 1, + typeCast: 1, + uri: 1, + user: 1, + disableEval: 1, + enableCleartextPlugin: 1, + // These options are used for Pool + connectionLimit: 1, + maxIdle: 1, + idleTimeout: 1, + Promise: 1, + queueLimit: 1, + resetOnRelease: 1, + waitForConnections: 1, + jsonStrings: 1, + gracefulEnd: 1 + }; + var ConnectionConfig = class _ConnectionConfig { + constructor(options) { + if (typeof options === "string") { + options = _ConnectionConfig.parseUrl(options); + } else if (options && options.uri) { + const uriOptions = _ConnectionConfig.parseUrl(options.uri); + for (const key in uriOptions) { + if (!Object.prototype.hasOwnProperty.call(uriOptions, key)) continue; + if (options[key]) continue; + options[key] = uriOptions[key]; + } + } + for (const key in options) { + if (!Object.prototype.hasOwnProperty.call(options, key)) continue; + if (validOptions[key] !== 1) { + console.error( + `Ignoring invalid configuration option passed to Connection: ${key}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection` + ); + } + } + this.isServer = options.isServer; + this.stream = options.stream; + this.host = options.host || "localhost"; + this.port = (typeof options.port === "string" ? parseInt(options.port, 10) : options.port) || 3306; + this.localAddress = options.localAddress; + this.socketPath = options.socketPath; + this.user = options.user || void 0; + this.password = options.password || options.password1 || void 0; + this.password2 = options.password2 || void 0; + this.password3 = options.password3 || void 0; + this.passwordSha1 = options.passwordSha1 || void 0; + this.database = options.database; + this.connectTimeout = isNaN(options.connectTimeout) ? 10 * 1e3 : options.connectTimeout; + this.insecureAuth = options.insecureAuth || false; + this.infileStreamFactory = options.infileStreamFactory || void 0; + this.supportBigNumbers = options.supportBigNumbers || false; + this.bigNumberStrings = options.bigNumberStrings || false; + this.decimalNumbers = options.decimalNumbers || false; + this.dateStrings = options.dateStrings || false; + this.debug = options.debug; + this.trace = options.trace !== false; + this.stringifyObjects = options.stringifyObjects || false; + this.enableKeepAlive = options.enableKeepAlive !== false; + this.keepAliveInitialDelay = options.keepAliveInitialDelay; + if (options.timezone && !/^(?:local|Z|[ +-]\d\d:\d\d)$/.test(options.timezone)) { + console.error( + `Ignoring invalid timezone passed to Connection: ${options.timezone}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection` + ); + this.timezone = "Z"; + } else { + this.timezone = options.timezone || "local"; + } + this.queryFormat = options.queryFormat; + this.pool = options.pool || void 0; + this.ssl = typeof options.ssl === "string" ? _ConnectionConfig.getSSLProfile(options.ssl) : options.ssl || false; + this.multipleStatements = options.multipleStatements || false; + this.rowsAsArray = options.rowsAsArray || false; + this.namedPlaceholders = options.namedPlaceholders || false; + this.nestTables = options.nestTables === void 0 ? void 0 : options.nestTables; + this.typeCast = options.typeCast === void 0 ? true : options.typeCast; + this.disableEval = Boolean(options.disableEval); + this.enableCleartextPlugin = Boolean(options.enableCleartextPlugin); + if (this.timezone[0] === " ") { + this.timezone = `+${this.timezone.slice(1)}`; + } + if (this.ssl) { + if (typeof this.ssl !== "object") { + throw new TypeError( + `SSL profile must be an object, instead it's a ${typeof this.ssl}` + ); + } + this.ssl.rejectUnauthorized = this.ssl.rejectUnauthorized !== false; + } + this.maxPacketSize = 0; + this.charsetNumber = options.charset ? _ConnectionConfig.getCharsetNumber(options.charset) : options.charsetNumber || Charsets.UTF8MB4_UNICODE_CI; + this.compress = options.compress || false; + this.authPlugins = options.authPlugins; + this.authSwitchHandler = options.authSwitchHandler; + this.clientFlags = _ConnectionConfig.mergeFlags( + _ConnectionConfig.getDefaultFlags(options), + options.flags || "" + ); + const defaultConnectAttributes = { + _client_name: "Node-MySQL-2", + _client_version: version + }; + this.connectAttributes = { + ...defaultConnectAttributes, + ...options.connectAttributes || {} + }; + this.maxPreparedStatements = options.maxPreparedStatements || 16e3; + this.jsonStrings = options.jsonStrings || false; + this.gracefulEnd = options.gracefulEnd || false; + } + // Same result as Object.assign({}, config, overrides), built from a + // fixed-shape literal: one allocation instead of a transition per option, + // and every later options read stays a monomorphic in-object load. The + // key list mirrors the constructor above; test/unit/connection/ + // test-query-options.test.mts fails when the two drift apart. + static queryOptions(config, overrides) { + if (!(config instanceof _ConnectionConfig)) { + return Object.assign({}, config, overrides); + } + const options = { + isServer: config.isServer, + stream: config.stream, + host: config.host, + port: config.port, + localAddress: config.localAddress, + socketPath: config.socketPath, + user: config.user, + password: config.password, + password2: config.password2, + password3: config.password3, + passwordSha1: config.passwordSha1, + database: config.database, + connectTimeout: config.connectTimeout, + insecureAuth: config.insecureAuth, + infileStreamFactory: config.infileStreamFactory, + supportBigNumbers: config.supportBigNumbers, + bigNumberStrings: config.bigNumberStrings, + decimalNumbers: config.decimalNumbers, + dateStrings: config.dateStrings, + debug: config.debug, + trace: config.trace, + stringifyObjects: config.stringifyObjects, + enableKeepAlive: config.enableKeepAlive, + keepAliveInitialDelay: config.keepAliveInitialDelay, + timezone: config.timezone, + queryFormat: config.queryFormat, + pool: config.pool, + ssl: config.ssl, + multipleStatements: config.multipleStatements, + rowsAsArray: config.rowsAsArray, + namedPlaceholders: config.namedPlaceholders, + nestTables: config.nestTables, + typeCast: config.typeCast, + disableEval: config.disableEval, + enableCleartextPlugin: config.enableCleartextPlugin, + maxPacketSize: config.maxPacketSize, + charsetNumber: config.charsetNumber, + compress: config.compress, + authPlugins: config.authPlugins, + authSwitchHandler: config.authSwitchHandler, + clientFlags: config.clientFlags, + connectAttributes: config.connectAttributes, + maxPreparedStatements: config.maxPreparedStatements, + jsonStrings: config.jsonStrings, + gracefulEnd: config.gracefulEnd + }; + return Object.assign(options, overrides); + } + static mergeFlags(default_flags, user_flags) { + let flags = 0, i; + if (!Array.isArray(user_flags)) { + user_flags = String(user_flags || "").toUpperCase().split(/\s*,+\s*/); + } + for (i in default_flags) { + if (user_flags.indexOf(`-${default_flags[i]}`) >= 0) { + continue; + } + flags |= ClientConstants[default_flags[i]] || 0; + } + for (i in user_flags) { + if (user_flags[i][0] === "-") { + continue; + } + if (default_flags.indexOf(user_flags[i]) >= 0) { + continue; + } + flags |= ClientConstants[user_flags[i]] || 0; + } + return flags; + } + static getDefaultFlags(options) { + const defaultFlags = [ + "LONG_PASSWORD", + "FOUND_ROWS", + "LONG_FLAG", + "CONNECT_WITH_DB", + "ODBC", + "LOCAL_FILES", + "IGNORE_SPACE", + "PROTOCOL_41", + "IGNORE_SIGPIPE", + "TRANSACTIONS", + "RESERVED", + "SECURE_CONNECTION", + "MULTI_RESULTS", + "TRANSACTIONS", + "SESSION_TRACK", + "CONNECT_ATTRS", + "CLIENT_QUERY_ATTRIBUTES" + ]; + if (options && options.multipleStatements) { + defaultFlags.push("MULTI_STATEMENTS"); + } + defaultFlags.push("PLUGIN_AUTH"); + defaultFlags.push("PLUGIN_AUTH_LENENC_CLIENT_DATA"); + return defaultFlags; + } + static getCharsetNumber(charset) { + const num = Charsets[charset.toUpperCase()]; + if (num === void 0) { + throw new TypeError(`Unknown charset '${charset}'`); + } + return num; + } + static getSSLProfile(name) { + if (!SSLProfiles) { + SSLProfiles = require_ssl_profiles(); + } + const ssl = SSLProfiles[name]; + if (ssl === void 0) { + throw new TypeError(`Unknown SSL profile '${name}'`); + } + return ssl; + } + static parseUrl(url) { + const parsedUrl = new URL2(url); + const { hostname } = parsedUrl; + const options = { + host: decodeURIComponent( + hostname.startsWith("[") ? hostname.slice(1, -1) : hostname + ), + port: parseInt(parsedUrl.port, 10), + database: decodeURIComponent(parsedUrl.pathname.slice(1)), + user: decodeURIComponent(parsedUrl.username), + password: decodeURIComponent(parsedUrl.password) + }; + for (const [key, value] of parsedUrl.searchParams) { + if (key in options) { + continue; + } + try { + options[key] = JSON.parse(value); + } catch { + options[key] = value; + } + } + return options; + } + }; + module2.exports = ConnectionConfig; + } +}); + +// node_modules/mysql2/lib/commands/query.js +var require_query2 = __commonJS({ + "node_modules/mysql2/lib/commands/query.js"(exports2, module2) { + "use strict"; + var process2 = require("process"); + var Timers = require("timers"); + var Readable = require("stream").Readable; + var Command = require_command(); + var Packets = require_packets(); + var getTextParser = require_text_parser(); + var staticParser = require_static_text_parser(); + var ServerStatus = require_server_status(); + var ConnectionConfig = require_connection_config(); + var createEmptyPacket = () => new Packets.Packet(0, Buffer.allocUnsafe(4), 0, 4); + var Query = class _Query extends Command { + constructor(options, callback) { + super(); + this.sql = options.sql; + this.values = options.values; + this._queryOptions = options; + this.namedPlaceholders = Object.prototype.hasOwnProperty.call( + options, + "namedPlaceholders" + ) ? options.namedPlaceholders : void 0; + this.onResult = callback; + this.timeout = options.timeout; + this.queryTimeout = null; + this._fieldCount = 0; + this._rowParser = null; + this._fields = []; + this._rows = []; + this._currentRows = null; + this._currentFields = null; + this._receivedFieldsCount = 0; + this._resultIndex = 0; + this._localStream = null; + this._unpipeStream = function() { + }; + this._streamFactory = options.infileStreamFactory; + this._connection = null; + } + then() { + const err = "You have tried to call .then(), .catch(), or invoked await on the result of query that is not a promise, which is a programming error. Try calling con.promise().query(), or require('mysql2/promise') instead of 'mysql2' for a promise-compatible version of the query interface. To learn how to use async/await or Promises check out documentation at https://sidorares.github.io/node-mysql2/docs#using-promise-wrapper, or the mysql2 documentation at https://sidorares.github.io/node-mysql2/docs/documentation/promise-wrapper"; + console.log(err); + throw new Error(err); + } + start(_packet, connection) { + if (connection.config.debug) { + console.log(" Sending query command: %s", this.sql); + } + this._connection = connection; + this.options = ConnectionConfig.queryOptions( + connection.config, + this._queryOptions + ); + this._setTimeout(); + const clientFlags = connection.config.clientFlags & (connection.serverCapabilityFlags || 0); + const cmdPacket = new Packets.Query( + this.sql, + connection.config.charsetNumber, + this._queryOptions.attributes, + clientFlags + ); + connection.writePacket(cmdPacket.toPacket(1)); + return _Query.prototype.resultsetHeader; + } + done() { + this._unpipeStream(); + if (this.timeout && !this.queryTimeout) { + return null; + } + if (this.queryTimeout) { + Timers.clearTimeout(this.queryTimeout); + this.queryTimeout = null; + } + if (this.onResult) { + let rows, fields; + if (this._resultIndex === 0) { + rows = this._rows[0]; + fields = this._fields[0]; + } else { + rows = this._rows; + fields = this._fields; + } + if (fields) { + process2.nextTick(() => { + this.onResult(null, rows, fields); + }); + } else { + process2.nextTick(() => { + this.onResult(null, rows); + }); + } + } + return null; + } + doneInsert(rs) { + if (this._localStreamError) { + if (this.onResult) { + this.onResult(this._localStreamError, rs); + } else { + this.emit("error", this._localStreamError); + } + return null; + } + this._rows.push(rs); + this._fields.push(void 0); + this.emit("fields", void 0); + this.emit("result", rs); + if (rs.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) { + this._resultIndex++; + return this.resultsetHeader; + } + return this.done(); + } + resultsetHeader(packet, connection) { + const rs = new Packets.ResultSetHeader(packet, connection); + this._fieldCount = rs.fieldCount; + if (connection.config.debug) { + console.log( + ` Resultset header received, expecting ${rs.fieldCount} column definition packets` + ); + } + if (this._fieldCount === 0) { + return this.doneInsert(rs); + } + if (this._fieldCount === null) { + return this._streamLocalInfile(connection, rs.infileName); + } + this._receivedFieldsCount = 0; + this._currentRows = []; + this._currentFields = []; + this._rows.push(this._currentRows); + this._fields.push(this._currentFields); + return this.readField; + } + _streamLocalInfile(connection, path) { + if (this._streamFactory) { + this._localStream = this._streamFactory(path); + } else { + this._localStreamError = new Error( + `As a result of LOCAL INFILE command server wants to read ${path} file, but as of v2.0 you must provide streamFactory option returning ReadStream.` + ); + connection.writePacket(createEmptyPacket()); + return this.infileOk; + } + const onConnectionError = () => { + this._unpipeStream(); + }; + const onDrain = () => { + this._localStream.resume(); + }; + const onPause = () => { + this._localStream.pause(); + }; + const onData = function(data) { + const dataWithHeader = Buffer.allocUnsafe(data.length + 4); + data.copy(dataWithHeader, 4); + connection.writePacket( + new Packets.Packet(0, dataWithHeader, 0, dataWithHeader.length) + ); + }; + const onEnd = () => { + connection.removeListener("error", onConnectionError); + connection.writePacket(createEmptyPacket()); + }; + const onError = (err) => { + this._localStreamError = err; + connection.removeListener("error", onConnectionError); + connection.writePacket(createEmptyPacket()); + }; + this._unpipeStream = () => { + connection.stream.removeListener("pause", onPause); + connection.stream.removeListener("drain", onDrain); + this._localStream.removeListener("data", onData); + this._localStream.removeListener("end", onEnd); + this._localStream.removeListener("error", onError); + }; + connection.stream.on("pause", onPause); + connection.stream.on("drain", onDrain); + this._localStream.on("data", onData); + this._localStream.on("end", onEnd); + this._localStream.on("error", onError); + connection.once("error", onConnectionError); + return this.infileOk; + } + readField(packet, connection) { + this._receivedFieldsCount++; + if (this._fields[this._resultIndex].length !== this._fieldCount) { + const field = new Packets.ColumnDefinition( + packet, + connection.clientEncoding, + connection._mariadbExtendedMetadata + ); + this._fields[this._resultIndex].push(field); + if (connection.config.debug) { + console.log(" Column definition:"); + console.log(` name: ${field.name}`); + console.log(` type: ${field.columnType}`); + console.log(` flags: ${field.flags}`); + } + } + if (this._receivedFieldsCount === this._fieldCount) { + const fields = this._fields[this._resultIndex]; + this.emit("fields", fields); + if (this.options.disableEval) { + this._rowParser = staticParser(fields, this.options, connection.config); + } else { + this._rowParser = new (getTextParser( + fields, + this.options, + connection.config + ))(fields); + } + return _Query.prototype.fieldsEOF; + } + return _Query.prototype.readField; + } + fieldsEOF(packet, connection) { + if (!packet.isEOF()) { + return connection.protocolError("Expected EOF packet"); + } + return this.row; + } + row(packet, _connection) { + if (packet.isEOF()) { + const status = packet.eofStatusFlags(); + const moreResults = status & ServerStatus.SERVER_MORE_RESULTS_EXISTS; + if (moreResults) { + this._resultIndex++; + return _Query.prototype.resultsetHeader; + } + return this.done(); + } + let row; + try { + row = this._rowParser.next(packet, this._currentFields, this.options); + } catch (err) { + this._localStreamError = err; + return this.doneInsert(null); + } + if (this.onResult) { + this._currentRows.push(row); + } else { + this.emit("result", row, this._resultIndex); + } + return _Query.prototype.row; + } + infileOk(packet, connection) { + const rs = new Packets.ResultSetHeader(packet, connection); + return this.doneInsert(rs); + } + stream(options) { + options = options || /* @__PURE__ */ Object.create(null); + options.objectMode = true; + const stream = new Readable({ + ...options, + emitClose: true, + autoDestroy: true, + read: () => { + this._connection && this._connection.resume(); + } + }); + stream.once("close", () => { + if (!stream.readableEnded) { + stream.emit("end"); + } + }); + const onResult = (row, index) => { + if (stream.destroyed) return; + if (!stream.push(row)) { + this._connection && this._connection.pause(); + } + stream.emit("result", row, index); + }; + const onFields = (fields) => { + if (stream.destroyed) return; + stream.emit("fields", fields); + }; + const onEnd = () => { + if (stream.destroyed) return; + stream.push(null); + }; + const onError = (err) => { + stream.destroy(err); + }; + stream._destroy = (err, cb) => { + this._connection && this._connection.resume(); + this.removeListener("result", onResult); + this.removeListener("fields", onFields); + this.removeListener("end", onEnd); + this.removeListener("error", onError); + cb(err); + }; + this.on("result", onResult); + this.on("fields", onFields); + this.on("end", onEnd); + this.on("error", onError); + return stream; + } + _setTimeout() { + if (this.timeout) { + const timeoutHandler = this._handleTimeoutError.bind(this); + this.queryTimeout = Timers.setTimeout(timeoutHandler, this.timeout); + } + } + _handleTimeoutError() { + if (this.queryTimeout) { + Timers.clearTimeout(this.queryTimeout); + this.queryTimeout = null; + } + const err = new Error("Query inactivity timeout"); + err.errorno = "PROTOCOL_SEQUENCE_TIMEOUT"; + err.code = "PROTOCOL_SEQUENCE_TIMEOUT"; + err.syscall = "query"; + if (this.onResult) { + this.onResult(err); + } else { + this.emit("error", err); + } + } + }; + Query.prototype.catch = Query.prototype.then; + module2.exports = Query; + } +}); + +// node_modules/mysql2/lib/commands/close_statement.js +var require_close_statement2 = __commonJS({ + "node_modules/mysql2/lib/commands/close_statement.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var CloseStatement = class extends Command { + constructor(id) { + super(); + this.id = id; + } + start(packet, connection) { + connection.writePacket(new Packets.CloseStatement(this.id).toPacket(1)); + return null; + } + }; + module2.exports = CloseStatement; + } +}); + +// node_modules/mysql2/lib/parsers/binary_parser.js +var require_binary_parser = __commonJS({ + "node_modules/mysql2/lib/parsers/binary_parser.js"(exports2, module2) { + "use strict"; + var FieldFlags = require_field_flags(); + var Charsets = require_charsets(); + var Types = require_types(); + var helpers = require_helpers(); + var genFunc = require_generate_function(); + var parserCache = require_parser_cache(); + var LocalDate = require_local_date(); + var typeNames = []; + for (const t in Types) { + typeNames[Types[t]] = t; + } + function readCodeFor(field, config, options, fieldNum) { + const supportBigNumbers = Boolean( + options.supportBigNumbers || config.supportBigNumbers + ); + const bigNumberStrings = Boolean( + options.bigNumberStrings || config.bigNumberStrings + ); + const timezone = options.timezone || config.timezone; + const dateStrings = options.dateStrings || config.dateStrings; + const unsigned = field.flags & FieldFlags.UNSIGNED; + if (field.extendedFormat === "json") { + return config.jsonStrings ? `packet.readLengthCodedString(fields[${fieldNum}].encoding)` : `packet.parseJson(fields[${fieldNum}].encoding, ${supportBigNumbers});`; + } + switch (field.columnType) { + case Types.TINY: + return unsigned ? "packet.readInt8();" : "packet.readSInt8();"; + case Types.SHORT: + return unsigned ? "packet.readInt16();" : "packet.readSInt16();"; + case Types.LONG: + case Types.INT24: + return unsigned ? "packet.readInt32();" : "packet.readSInt32();"; + case Types.YEAR: + return "packet.readInt16()"; + case Types.FLOAT: + return "packet.readFloat();"; + case Types.DOUBLE: + return "packet.readDouble();"; + case Types.NULL: + return "null;"; + case Types.DATE: + case Types.DATETIME: + case Types.TIMESTAMP: + case Types.NEWDATE: + if (helpers.typeMatch(field.columnType, dateStrings, Types)) { + return `packet.readDateTimeString(${parseInt(field.decimals, 10)}, ${null}, ${field.columnType});`; + } + return `packet.readDateTime(${helpers.srcEscape(timezone)});`; + case Types.TIME: + return "packet.readTimeString()"; + case Types.DECIMAL: + case Types.NEWDECIMAL: + if (config.decimalNumbers) { + return "packet.parseLengthCodedFloat();"; + } + return 'packet.readLengthCodedString("ascii");'; + case Types.GEOMETRY: + return "packet.parseGeometryValue();"; + case Types.VECTOR: + return "packet.parseVector()"; + case Types.JSON: + return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : `packet.parseJson("utf8", ${supportBigNumbers});`; + case Types.LONGLONG: + if (!supportBigNumbers) { + return unsigned ? "packet.readInt64JSNumber();" : "packet.readSInt64JSNumber();"; + } + if (bigNumberStrings) { + return unsigned ? "packet.readInt64String();" : "packet.readSInt64String();"; + } + return unsigned ? "packet.readInt64();" : "packet.readSInt64();"; + default: + if (field.characterSet === Charsets.BINARY) { + return "packet.readLengthCodedBuffer();"; + } + return `packet.readLengthCodedString(fields[${fieldNum}].encoding)`; + } + } + function compile(fields, options, config) { + const parserFn = genFunc(); + const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8); + function fieldMetadata(field) { + return { + type: typeNames[field.columnType], + extendedTypeName: field.extendedTypeName, + extendedFormat: field.extendedFormat, + length: field.columnLength, + db: field.schema, + table: field.table, + name: field.name + }; + } + function wrap(field, packet) { + return { + ...fieldMetadata(field), + string: function(encoding = field.encoding) { + if (field.columnType === Types.JSON && encoding === field.encoding) { + console.warn( + `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\`` + ); + } + if ([Types.DATETIME, Types.NEWDATE, Types.TIMESTAMP, Types.DATE].includes( + field.columnType + )) { + return packet.readDateTimeString( + parseInt(field.decimals, 10), + " ", + field.columnType + ); + } + if (field.columnType === Types.TINY) { + const unsigned = field.flags & FieldFlags.UNSIGNED; + return String(unsigned ? packet.readInt8() : packet.readSInt8()); + } + if (field.columnType === Types.TIME) { + return packet.readTimeString(); + } + return packet.readLengthCodedString(encoding); + }, + buffer: function() { + return packet.readLengthCodedBuffer(); + }, + geometry: function() { + return packet.parseGeometryValue(); + } + }; + } + function wrapNull(field) { + return { + ...fieldMetadata(field), + string: function() { + return null; + }, + buffer: function() { + return null; + }, + geometry: function() { + return null; + } + }; + } + parserFn("(function(){"); + parserFn("return class BinaryRow {"); + parserFn("constructor() {"); + if (fields.some((field) => LocalDate.usesLocalDate(field, options, config))) { + parserFn("LocalDate.checkTimezone();"); + } + parserFn("}"); + parserFn("next(packet, fields, options) {"); + if (options.rowsAsArray) { + parserFn(`const result = new Array(${fields.length});`); + } else { + parserFn("const result = {};"); + } + if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") { + options.typeCast = config.typeCast; + } + parserFn("packet.readInt8();"); + for (let i = 0; i < nullBitmapLength; ++i) { + parserFn(`const nullBitmaskByte${i} = packet.readInt8();`); + } + let lvalue = ""; + let currentFieldNullBit = 4; + let nullByteIndex = 0; + let fieldName = ""; + let tableName = ""; + for (let i = 0; i < fields.length; i++) { + fieldName = helpers.fieldEscape(fields[i].name); + if (typeof options.nestTables === "string") { + lvalue = `result[${helpers.fieldEscape(fields[i].table + options.nestTables + fields[i].name)}]`; + } else if (options.nestTables === true) { + tableName = helpers.fieldEscape(fields[i].table); + parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`); + lvalue = `result[${tableName}][${fieldName}]`; + } else if (options.rowsAsArray) { + lvalue = `result[${i.toString(10)}]`; + } else { + lvalue = `result[${fieldName}]`; + } + parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit}) {`); + if (typeof options.typeCast === "function") { + const nullWrapperVar = `nullWrapper${i}`; + parserFn(`const ${nullWrapperVar} = wrapNull(fields[${i}]);`); + parserFn( + `${lvalue} = options.typeCast(${nullWrapperVar}, function() { return null; });` + ); + } else { + parserFn(`${lvalue} = null;`); + } + parserFn("} else {"); + if (options.typeCast === false) { + parserFn(`${lvalue} = packet.readLengthCodedBuffer();`); + } else { + const readCode = readCodeFor(fields[i], config, options, i); + if (typeof options.typeCast === "function") { + const fieldWrapperVar = `fieldWrapper${i}`; + parserFn(`const ${fieldWrapperVar} = wrap(fields[${i}], packet);`); + parserFn( + `${lvalue} = options.typeCast(${fieldWrapperVar}, function() { return ${readCode} });` + ); + } else { + parserFn(`${lvalue} = ${readCode};`); + } + } + parserFn("}"); + currentFieldNullBit *= 2; + if (currentFieldNullBit === 256) { + currentFieldNullBit = 1; + nullByteIndex++; + } + } + parserFn("return result;"); + parserFn("}"); + parserFn("};")("})()"); + if (config.debug) { + helpers.printDebugWithCode( + "Compiled binary protocol row parser", + parserFn.toString() + ); + } + return parserFn.toFunction({ wrap, wrapNull, LocalDate }); + } + function getBinaryParser(fields, options, config) { + return parserCache.getParser("binary", fields, options, config, compile); + } + module2.exports = getBinaryParser; + } +}); + +// node_modules/mysql2/lib/parsers/static_binary_parser.js +var require_static_binary_parser = __commonJS({ + "node_modules/mysql2/lib/parsers/static_binary_parser.js"(exports2, module2) { + "use strict"; + var FieldFlags = require_field_flags(); + var Charsets = require_charsets(); + var Types = require_types(); + var helpers = require_helpers(); + var LocalDate = require_local_date(); + var typeNames = []; + for (const t in Types) { + typeNames[Types[t]] = t; + } + function getBinaryParser(fields, queryOptions, config) { + if (fields.some((field) => LocalDate.usesLocalDate(field, queryOptions, config))) { + LocalDate.checkTimezone(); + } + function readCode(field, config2, options, fieldNum, packet) { + const supportBigNumbers = Boolean( + options.supportBigNumbers || config2.supportBigNumbers + ); + const bigNumberStrings = Boolean( + options.bigNumberStrings || config2.bigNumberStrings + ); + const timezone = options.timezone || config2.timezone; + const dateStrings = options.dateStrings || config2.dateStrings; + const unsigned = field.flags & FieldFlags.UNSIGNED; + if (field.extendedFormat === "json") { + return config2.jsonStrings ? packet.readLengthCodedString(field.encoding) : packet.parseJson(field.encoding, supportBigNumbers); + } + switch (field.columnType) { + case Types.TINY: + return unsigned ? packet.readInt8() : packet.readSInt8(); + case Types.SHORT: + return unsigned ? packet.readInt16() : packet.readSInt16(); + case Types.LONG: + case Types.INT24: + return unsigned ? packet.readInt32() : packet.readSInt32(); + case Types.YEAR: + return packet.readInt16(); + case Types.FLOAT: + return packet.readFloat(); + case Types.DOUBLE: + return packet.readDouble(); + case Types.NULL: + return null; + case Types.DATE: + case Types.DATETIME: + case Types.TIMESTAMP: + case Types.NEWDATE: + return helpers.typeMatch(field.columnType, dateStrings, Types) ? packet.readDateTimeString( + parseInt(field.decimals, 10), + null, + field.columnType + ) : packet.readDateTime(timezone); + case Types.TIME: + return packet.readTimeString(); + case Types.DECIMAL: + case Types.NEWDECIMAL: + return config2.decimalNumbers ? packet.parseLengthCodedFloat() : packet.readLengthCodedString("ascii"); + case Types.GEOMETRY: + return packet.parseGeometryValue(); + case Types.VECTOR: + return packet.parseVector(); + case Types.JSON: + return config2.jsonStrings ? packet.readLengthCodedString("utf8") : packet.parseJson("utf8", supportBigNumbers); + case Types.LONGLONG: + if (!supportBigNumbers) + return unsigned ? packet.readInt64JSNumber() : packet.readSInt64JSNumber(); + return bigNumberStrings ? unsigned ? packet.readInt64String() : packet.readSInt64String() : unsigned ? packet.readInt64() : packet.readSInt64(); + default: + return field.characterSet === Charsets.BINARY ? packet.readLengthCodedBuffer() : packet.readLengthCodedString(fields[fieldNum].encoding); + } + } + function wrapNull(field) { + return { + type: typeNames[field.columnType], + extendedTypeName: field.extendedTypeName, + extendedFormat: field.extendedFormat, + length: field.columnLength, + db: field.schema, + table: field.table, + name: field.name, + string: function() { + return null; + }, + buffer: function() { + return null; + }, + geometry: function() { + return null; + } + }; + } + return class BinaryRow { + constructor() { + } + next(packet, fields2, options) { + packet.readInt8(); + const nullBitmapLength = Math.floor((fields2.length + 7 + 2) / 8); + const nullBitmaskBytes = new Array(nullBitmapLength); + for (let i = 0; i < nullBitmapLength; i++) { + nullBitmaskBytes[i] = packet.readInt8(); + } + const result = options.rowsAsArray ? new Array(fields2.length) : {}; + let currentFieldNullBit = 4; + let nullByteIndex = 0; + for (let i = 0; i < fields2.length; i++) { + const field = fields2[i]; + const typeCast = options.typeCast !== void 0 ? options.typeCast : config.typeCast; + let value; + if (nullBitmaskBytes[nullByteIndex] & currentFieldNullBit) { + value = typeof typeCast === "function" ? typeCast(wrapNull(field), () => null) : null; + } else if (options.typeCast === false) { + value = packet.readLengthCodedBuffer(); + } else { + const next = () => readCode(field, config, options, i, packet); + value = typeof typeCast === "function" ? typeCast( + { + type: typeNames[field.columnType], + extendedTypeName: field.extendedTypeName, + extendedFormat: field.extendedFormat, + length: field.columnLength, + db: field.schema, + table: field.table, + name: field.name, + string: function(encoding = field.encoding) { + if (field.columnType === Types.JSON && encoding === field.encoding) { + console.warn( + `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\`` + ); + } + if ([ + Types.DATETIME, + Types.NEWDATE, + Types.TIMESTAMP, + Types.DATE + ].includes(field.columnType)) { + return packet.readDateTimeString( + parseInt(field.decimals, 10), + " ", + field.columnType + ); + } + if (field.columnType === Types.TINY) { + const unsigned = field.flags & FieldFlags.UNSIGNED; + return String( + unsigned ? packet.readInt8() : packet.readSInt8() + ); + } + if (field.columnType === Types.TIME) { + return packet.readTimeString(); + } + return packet.readLengthCodedString(encoding); + }, + buffer: function() { + return packet.readLengthCodedBuffer(); + }, + geometry: function() { + return packet.parseGeometryValue(); + } + }, + next + ) : next(); + } + if (options.rowsAsArray) { + result[i] = value; + } else if (typeof options.nestTables === "string") { + const key = helpers.fieldEscape( + field.table + options.nestTables + field.name, + false + ); + result[key] = value; + } else if (options.nestTables === true) { + const tableName = helpers.fieldEscape(field.table, false); + if (!result[tableName]) { + result[tableName] = {}; + } + const fieldName = helpers.fieldEscape(field.name, false); + result[tableName][fieldName] = value; + } else { + const key = helpers.fieldEscape(field.name, false); + result[key] = value; + } + currentFieldNullBit *= 2; + if (currentFieldNullBit === 256) { + currentFieldNullBit = 1; + nullByteIndex++; + } + } + return result; + } + }; + } + module2.exports = getBinaryParser; + } +}); + +// node_modules/mysql2/lib/commands/execute.js +var require_execute2 = __commonJS({ + "node_modules/mysql2/lib/commands/execute.js"(exports2, module2) { + "use strict"; + var Timers = require("timers"); + var Command = require_command(); + var Query = require_query2(); + var Packets = require_packets(); + var ConnectionConfig = require_connection_config(); + var getBinaryParser = require_binary_parser(); + var getStaticBinaryParser = require_static_binary_parser(); + var Execute = class _Execute extends Command { + constructor(options, callback) { + super(); + this.statement = options.statement; + this.sql = options.sql; + this.values = options.values; + this.onResult = callback; + this.parameters = options.values; + this.insertId = 0; + this.timeout = options.timeout; + this.queryTimeout = null; + this._rows = []; + this._fields = []; + this._currentRows = null; + this._currentFields = null; + this._result = []; + this._fieldCount = 0; + this._rowParser = null; + this._executeOptions = options; + this._resultIndex = 0; + this._localStream = null; + this._unpipeStream = function() { + }; + this._streamFactory = options.infileStreamFactory; + this._connection = null; + } + buildParserFromFields(fields, connection) { + if (this.options.disableEval) { + return getStaticBinaryParser(fields, this.options, connection.config); + } + return getBinaryParser(fields, this.options, connection.config); + } + start(packet, connection) { + this._connection = connection; + this.options = ConnectionConfig.queryOptions( + connection.config, + this._executeOptions + ); + this._setTimeout(); + const clientFlags = connection.config.clientFlags & (connection.serverCapabilityFlags || 0); + const executePacket = new Packets.Execute( + this.statement.id, + this.parameters, + connection.config.charsetNumber, + connection.config.timezone, + this._executeOptions.attributes, + clientFlags, + connection._isMariaDB, + this.statement.parameters + ); + try { + connection.writePacket(executePacket.toPacket(1)); + } catch (error) { + if (this.queryTimeout) { + Timers.clearTimeout(this.queryTimeout); + this.queryTimeout = null; + } + if (this.onResult) { + this.onResult(error); + } else { + this.emit("error", error); + } + return null; + } + return _Execute.prototype.resultsetHeader; + } + readField(packet, connection) { + let fields; + const field = new Packets.ColumnDefinition( + packet, + connection.clientEncoding, + connection._mariadbExtendedMetadata + ); + this._receivedFieldsCount++; + this._fields[this._resultIndex].push(field); + if (this._receivedFieldsCount === this._fieldCount) { + fields = this._fields[this._resultIndex]; + this.emit("fields", fields, this._resultIndex); + return _Execute.prototype.fieldsEOF; + } + return _Execute.prototype.readField; + } + fieldsEOF(packet, connection) { + if (!packet.isEOF()) { + return connection.protocolError("Expected EOF packet"); + } + this._rowParser = new (this.buildParserFromFields( + this._fields[this._resultIndex], + connection + ))(); + return _Execute.prototype.row; + } + }; + Execute.prototype.done = Query.prototype.done; + Execute.prototype.doneInsert = Query.prototype.doneInsert; + Execute.prototype.resultsetHeader = Query.prototype.resultsetHeader; + Execute.prototype._findOrCreateReadStream = Query.prototype._findOrCreateReadStream; + Execute.prototype._streamLocalInfile = Query.prototype._streamLocalInfile; + Execute.prototype._setTimeout = Query.prototype._setTimeout; + Execute.prototype._handleTimeoutError = Query.prototype._handleTimeoutError; + Execute.prototype.row = Query.prototype.row; + Execute.prototype.stream = Query.prototype.stream; + module2.exports = Execute; + } +}); + +// node_modules/mysql2/lib/commands/prepare.js +var require_prepare = __commonJS({ + "node_modules/mysql2/lib/commands/prepare.js"(exports2, module2) { + "use strict"; + var Packets = require_packets(); + var Command = require_command(); + var CloseStatement = require_close_statement2(); + var Execute = require_execute2(); + var PreparedStatementInfo = class { + constructor(query, id, columns, parameters, connection) { + this.query = query; + this.id = id; + this.columns = columns; + this.parameters = parameters; + this.rowParser = null; + this._connection = connection; + } + close() { + return this._connection.addCommand(new CloseStatement(this.id)); + } + execute(parameters, callback) { + if (typeof parameters === "function") { + callback = parameters; + parameters = []; + } + return this._connection.addCommand( + new Execute({ statement: this, values: parameters }, callback) + ); + } + }; + var Prepare = class _Prepare extends Command { + constructor(options, callback) { + super(); + this.query = options.sql; + this.onResult = callback; + this.id = 0; + this.fieldCount = 0; + this.parameterCount = 0; + this.fields = []; + this.parameterDefinitions = []; + this.options = options; + } + start(packet, connection) { + const Connection = connection.constructor; + this.key = Connection.statementKey(this.options); + const statement = connection._statements.get(this.key); + if (statement) { + if (this.onResult) { + this.onResult(null, statement); + } + return null; + } + const cmdPacket = new Packets.PrepareStatement( + this.query, + connection.config.charsetNumber, + this.options.values + ); + connection.writePacket(cmdPacket.toPacket(1)); + return _Prepare.prototype.prepareHeader; + } + prepareHeader(packet, connection) { + const header = new Packets.PreparedStatementHeader(packet); + this.id = header.id; + this.fieldCount = header.fieldCount; + this.parameterCount = header.parameterCount; + if (this.parameterCount > 0) { + return _Prepare.prototype.readParameter; + } + if (this.fieldCount > 0) { + return _Prepare.prototype.readField; + } + return this.prepareDone(connection); + } + readParameter(packet, connection) { + if (packet.isEOF()) { + if (this.fieldCount > 0) { + return _Prepare.prototype.readField; + } + return this.prepareDone(connection); + } + const def = new Packets.ColumnDefinition( + packet, + connection.clientEncoding, + connection._mariadbExtendedMetadata + ); + this.parameterDefinitions.push(def); + if (this.parameterDefinitions.length === this.parameterCount) { + return _Prepare.prototype.parametersEOF; + } + return this.readParameter; + } + readField(packet, connection) { + if (packet.isEOF()) { + return this.prepareDone(connection); + } + const def = new Packets.ColumnDefinition( + packet, + connection.clientEncoding, + connection._mariadbExtendedMetadata + ); + this.fields.push(def); + if (this.fields.length === this.fieldCount) { + return _Prepare.prototype.fieldsEOF; + } + return _Prepare.prototype.readField; + } + parametersEOF(packet, connection) { + if (!packet.isEOF()) { + return connection.protocolError("Expected EOF packet after parameters"); + } + if (this.fieldCount > 0) { + return _Prepare.prototype.readField; + } + return this.prepareDone(connection); + } + fieldsEOF(packet, connection) { + if (!packet.isEOF()) { + return connection.protocolError("Expected EOF packet after fields"); + } + return this.prepareDone(connection); + } + prepareDone(connection) { + const statement = new PreparedStatementInfo( + this.query, + this.id, + this.fields, + this.parameterDefinitions, + connection + ); + connection._statements.set(this.key, statement); + if (this.onResult) { + this.onResult(null, statement); + } + return null; + } + }; + module2.exports = Prepare; + } +}); + +// node_modules/mysql2/lib/commands/ping.js +var require_ping = __commonJS({ + "node_modules/mysql2/lib/commands/ping.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var CommandCode = require_commands(); + var Packet = require_packet(); + var Ping = class _Ping extends Command { + constructor(callback) { + super(); + this.onResult = callback; + } + start(packet, connection) { + const ping = new Packet( + 0, + Buffer.from([1, 0, 0, 0, CommandCode.PING]), + 0, + 5 + ); + connection.writePacket(ping); + return _Ping.prototype.pingResponse; + } + pingResponse() { + if (this.onResult) { + process.nextTick(this.onResult.bind(this)); + } + return null; + } + }; + module2.exports = Ping; + } +}); + +// node_modules/mysql2/lib/commands/register_slave.js +var require_register_slave2 = __commonJS({ + "node_modules/mysql2/lib/commands/register_slave.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var RegisterSlave = class _RegisterSlave extends Command { + constructor(opts, callback) { + super(); + this.onResult = callback; + this.opts = opts; + } + start(packet, connection) { + const newPacket = new Packets.RegisterSlave(this.opts); + connection.writePacket(newPacket.toPacket(1)); + return _RegisterSlave.prototype.registerResponse; + } + registerResponse() { + if (this.onResult) { + process.nextTick(this.onResult.bind(this)); + } + return null; + } + }; + module2.exports = RegisterSlave; + } +}); + +// node_modules/mysql2/lib/packets/binlog_query_statusvars.js +var require_binlog_query_statusvars = __commonJS({ + "node_modules/mysql2/lib/packets/binlog_query_statusvars.js"(exports2, module2) { + "use strict"; + var keys = { + FLAGS2: 0, + SQL_MODE: 1, + CATALOG: 2, + AUTO_INCREMENT: 3, + CHARSET: 4, + TIME_ZONE: 5, + CATALOG_NZ: 6, + LC_TIME_NAMES: 7, + CHARSET_DATABASE: 8, + TABLE_MAP_FOR_UPDATE: 9, + MASTER_DATA_WRITTEN: 10, + INVOKERS: 11, + UPDATED_DB_NAMES: 12, + MICROSECONDS: 3 + }; + module2.exports = function parseStatusVars(buffer) { + const result = {}; + let offset = 0; + let key, length, prevOffset; + while (offset < buffer.length) { + key = buffer[offset++]; + switch (key) { + case keys.FLAGS2: + result.flags = buffer.readUInt32LE(offset); + offset += 4; + break; + case keys.SQL_MODE: + result.sqlMode = buffer.readUInt32LE(offset); + offset += 8; + break; + case keys.CATALOG: + length = buffer[offset++]; + result.catalog = buffer.toString("utf8", offset, offset + length); + offset += length + 1; + break; + case keys.CHARSET: + result.clientCharset = buffer.readUInt16LE(offset); + result.connectionCollation = buffer.readUInt16LE(offset + 2); + result.serverCharset = buffer.readUInt16LE(offset + 4); + offset += 6; + break; + case keys.TIME_ZONE: + length = buffer[offset++]; + result.timeZone = buffer.toString("utf8", offset, offset + length); + offset += length; + break; + case keys.CATALOG_NZ: + length = buffer[offset++]; + result.catalogNz = buffer.toString("utf8", offset, offset + length); + offset += length; + break; + case keys.LC_TIME_NAMES: + result.lcTimeNames = buffer.readUInt16LE(offset); + offset += 2; + break; + case keys.CHARSET_DATABASE: + result.schemaCharset = buffer.readUInt16LE(offset); + offset += 2; + break; + case keys.TABLE_MAP_FOR_UPDATE: + result.mapForUpdate1 = buffer.readUInt32LE(offset); + result.mapForUpdate2 = buffer.readUInt32LE(offset + 4); + offset += 8; + break; + case keys.MASTER_DATA_WRITTEN: + result.masterDataWritten = buffer.readUInt32LE(offset); + offset += 4; + break; + case keys.INVOKERS: + length = buffer[offset++]; + result.invokerUsername = buffer.toString( + "utf8", + offset, + offset + length + ); + offset += length; + length = buffer[offset++]; + result.invokerHostname = buffer.toString( + "utf8", + offset, + offset + length + ); + offset += length; + break; + case keys.UPDATED_DB_NAMES: + length = buffer[offset++]; + result.updatedDBs = []; + for (; length; --length) { + prevOffset = offset; + while (buffer[offset++] && offset < buffer.length) { + } + result.updatedDBs.push( + buffer.toString("utf8", prevOffset, offset - 1) + ); + } + break; + case keys.MICROSECONDS: + result.microseconds = // REVIEW: INVALID UNKNOWN VARIABLE! + buffer.readInt16LE(offset) + (buffer[offset + 2] << 16); + offset += 3; + } + } + return result; + }; + } +}); + +// node_modules/mysql2/lib/commands/binlog_dump.js +var require_binlog_dump2 = __commonJS({ + "node_modules/mysql2/lib/commands/binlog_dump.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var eventParsers = []; + var BinlogEventHeader = class { + constructor(packet) { + this.timestamp = packet.readInt32(); + this.eventType = packet.readInt8(); + this.serverId = packet.readInt32(); + this.eventSize = packet.readInt32(); + this.logPos = packet.readInt32(); + this.flags = packet.readInt16(); + } + }; + var BinlogDump = class _BinlogDump extends Command { + constructor(opts) { + super(); + this.opts = opts; + } + start(packet, connection) { + const newPacket = new Packets.BinlogDump(this.opts); + connection.writePacket(newPacket.toPacket(1)); + return _BinlogDump.prototype.binlogData; + } + binlogData(packet) { + if (packet.isEOF()) { + this.emit("eof"); + return null; + } + packet.readInt8(); + const header = new BinlogEventHeader(packet); + const EventParser = eventParsers[header.eventType]; + let event; + if (EventParser) { + event = new EventParser(packet); + } else { + event = { + name: "UNKNOWN" + }; + } + event.header = header; + this.emit("event", event); + return _BinlogDump.prototype.binlogData; + } + }; + var RotateEvent = class { + constructor(packet) { + this.pposition = packet.readInt32(); + packet.readInt32(); + this.nextBinlog = packet.readString(); + this.name = "RotateEvent"; + } + }; + var FormatDescriptionEvent = class { + constructor(packet) { + this.binlogVersion = packet.readInt16(); + this.serverVersion = packet.readString(50).replace(/\u0000.*/, ""); + this.createTimestamp = packet.readInt32(); + this.eventHeaderLength = packet.readInt8(); + this.eventsLength = packet.readBuffer(); + this.name = "FormatDescriptionEvent"; + } + }; + var QueryEvent = class { + constructor(packet) { + const parseStatusVars = require_binlog_query_statusvars(); + this.slaveProxyId = packet.readInt32(); + this.executionTime = packet.readInt32(); + const schemaLength = packet.readInt8(); + this.errorCode = packet.readInt16(); + const statusVarsLength = packet.readInt16(); + const statusVars = packet.readBuffer(statusVarsLength); + this.schema = packet.readString(schemaLength); + packet.readInt8(); + this.statusVars = parseStatusVars(statusVars); + this.query = packet.readString(); + this.name = "QueryEvent"; + } + }; + var XidEvent = class { + constructor(packet) { + this.binlogVersion = packet.readInt16(); + this.xid = packet.readInt64(); + this.name = "XidEvent"; + } + }; + eventParsers[2] = QueryEvent; + eventParsers[4] = RotateEvent; + eventParsers[15] = FormatDescriptionEvent; + eventParsers[16] = XidEvent; + module2.exports = BinlogDump; + } +}); + +// node_modules/mysql2/lib/commands/change_user.js +var require_change_user2 = __commonJS({ + "node_modules/mysql2/lib/commands/change_user.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var ClientConstants = require_client(); + var ClientHandshake = require_client_handshake(); + var CharsetToEncoding = require_charset_encodings(); + var ChangeUser = class _ChangeUser extends Command { + constructor(options, callback) { + super(); + this.onResult = callback; + this.user = options.user; + this.password = options.password; + this.password1 = options.password; + this.password2 = options.password2; + this.password3 = options.password3; + this.database = options.database; + this.passwordSha1 = options.passwordSha1; + this.charsetNumber = options.charsetNumber; + this.currentConfig = options.currentConfig; + this.authenticationFactor = 0; + } + start(packet, connection) { + const newPacket = new Packets.ChangeUser({ + flags: connection.config.clientFlags, + user: this.user, + database: this.database, + charsetNumber: this.charsetNumber, + password: this.password, + passwordSha1: this.passwordSha1, + authPluginData1: connection._handshakePacket.authPluginData1, + authPluginData2: connection._handshakePacket.authPluginData2 + }); + this.currentConfig.user = this.user; + this.currentConfig.password = this.password; + this.currentConfig.database = this.database; + this.currentConfig.charsetNumber = this.charsetNumber; + connection.clientEncoding = CharsetToEncoding[this.charsetNumber]; + connection._statements.clear(); + connection.writePacket(newPacket.toPacket()); + const multiFactorAuthentication = connection.serverCapabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION; + if (multiFactorAuthentication) { + this.authenticationFactor = 1; + } + return _ChangeUser.prototype.handshakeResult; + } + }; + ChangeUser.prototype.handshakeResult = ClientHandshake.prototype.handshakeResult; + ChangeUser.prototype.calculateNativePasswordAuthToken = ClientHandshake.prototype.calculateNativePasswordAuthToken; + module2.exports = ChangeUser; + } +}); + +// node_modules/mysql2/lib/commands/reset_connection.js +var require_reset_connection2 = __commonJS({ + "node_modules/mysql2/lib/commands/reset_connection.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var Packets = require_packets(); + var ResetConnection = class _ResetConnection extends Command { + constructor(callback) { + super(); + this.onResult = callback; + } + start(packet, connection) { + const req = new Packets.ResetConnection(); + connection.writePacket(req.toPacket()); + return _ResetConnection.prototype.resetConnectionResponse; + } + resetConnectionResponse(packet, connection) { + if (connection._statements) { + connection._statements.clear(); + } + if (this.onResult) { + process.nextTick(this.onResult.bind(this, null)); + } + return null; + } + }; + module2.exports = ResetConnection; + } +}); + +// node_modules/mysql2/lib/commands/quit.js +var require_quit = __commonJS({ + "node_modules/mysql2/lib/commands/quit.js"(exports2, module2) { + "use strict"; + var Command = require_command(); + var CommandCode = require_commands(); + var Packet = require_packet(); + var Quit = class extends Command { + constructor(callback) { + super(); + this.onResult = callback; + } + start(packet, connection) { + connection._closing = true; + const quit = new Packet( + 0, + Buffer.from([1, 0, 0, 0, CommandCode.QUIT]), + 0, + 5 + ); + if (this.onResult) { + this.onResult(); + } + connection.writePacket(quit); + return null; + } + }; + module2.exports = Quit; + } +}); + +// node_modules/mysql2/lib/commands/index.js +var require_commands2 = __commonJS({ + "node_modules/mysql2/lib/commands/index.js"(exports2, module2) { + "use strict"; + var ClientHandshake = require_client_handshake(); + var ServerHandshake = require_server_handshake(); + var Query = require_query2(); + var Prepare = require_prepare(); + var CloseStatement = require_close_statement2(); + var Execute = require_execute2(); + var Ping = require_ping(); + var RegisterSlave = require_register_slave2(); + var BinlogDump = require_binlog_dump2(); + var ChangeUser = require_change_user2(); + var ResetConnection = require_reset_connection2(); + var Quit = require_quit(); + module2.exports = { + ClientHandshake, + ServerHandshake, + Query, + Prepare, + CloseStatement, + Execute, + Ping, + RegisterSlave, + BinlogDump, + ChangeUser, + ResetConnection, + Quit + }; + } +}); + +// node_modules/mysql2/lib/tls_session_cache.js +var require_tls_session_cache = __commonJS({ + "node_modules/mysql2/lib/tls_session_cache.js"(exports2, module2) { + "use strict"; + var { createLRU } = require_lib2(); + var MAX_PEERS_PER_SSL_CONFIG = 100; + var caches = /* @__PURE__ */ new WeakMap(); + function snapshotMaterial(ssl) { + return { + ca: ssl.ca, + cert: ssl.cert, + ciphers: ssl.ciphers, + key: ssl.key, + passphrase: ssl.passphrase, + minVersion: ssl.minVersion, + maxVersion: ssl.maxVersion + }; + } + function sameMaterial(a, b) { + return a.ca === b.ca && a.cert === b.cert && a.ciphers === b.ciphers && a.key === b.key && a.passphrase === b.passphrase && a.minVersion === b.minVersion && a.maxVersion === b.maxVersion; + } + var TlsSessionSlot = class { + constructor(ssl, host, port, rejectUnauthorized, verifyIdentity) { + this.ssl = ssl; + this.material = snapshotMaterial(ssl); + this.key = `${host}:${port}:${Boolean(rejectUnauthorized)}:${Boolean(verifyIdentity)}`; + } + _sessions() { + const cache = caches.get(this.ssl); + if (cache !== void 0 && sameMaterial(cache.material, this.material)) { + return cache.sessions; + } + return void 0; + } + get() { + const sessions = this._sessions(); + return sessions === void 0 ? void 0 : sessions.get(this.key); + } + set(session) { + let sessions = this._sessions(); + if (sessions === void 0) { + if (!sameMaterial(this.material, snapshotMaterial(this.ssl))) { + return; + } + sessions = createLRU({ max: MAX_PEERS_PER_SSL_CONFIG }); + caches.set(this.ssl, { material: this.material, sessions }); + } + sessions.set(this.key, session); + } + delete() { + const sessions = this._sessions(); + if (sessions !== void 0) { + sessions.delete(this.key); + } + } + }; + module2.exports = TlsSessionSlot; + } +}); + +// node_modules/mysql2/lib/tracing.js +var require_tracing = __commonJS({ + "node_modules/mysql2/lib/tracing.js"(exports2, module2) { + "use strict"; + var process2 = require("process"); + var dc = (() => { + try { + return "getBuiltinModule" in process2 ? process2.getBuiltinModule("node:diagnostics_channel") : require("node:diagnostics_channel"); + } catch { + return void 0; + } + })(); + var hasTracingChannel = typeof dc?.tracingChannel === "function"; + var queryChannel = hasTracingChannel ? dc.tracingChannel("mysql2:query") : void 0; + var executeChannel = hasTracingChannel ? dc.tracingChannel("mysql2:execute") : void 0; + var connectChannel = hasTracingChannel ? dc.tracingChannel("mysql2:connect") : void 0; + var poolConnectChannel = hasTracingChannel ? dc.tracingChannel("mysql2:pool:connect") : void 0; + function getServerContext(config) { + if (config.socketPath) { + return { serverAddress: config.socketPath, serverPort: void 0 }; + } + return { + serverAddress: config.host || "localhost", + serverPort: config.port || 3306 + }; + } + function shouldTrace(channel) { + if (channel === void 0 || channel === null) { + return false; + } + return channel.hasSubscribers ?? channel.start?.hasSubscribers ?? false; + } + function traceCallback(channel, fn, position, context, thisArg, ...args) { + if (shouldTrace(channel)) { + return channel.traceCallback(fn, position, context(), thisArg, ...args); + } + return fn.apply(thisArg, args); + } + function tracePromise(channel, fn, contextFactory) { + if (shouldTrace(channel)) { + return channel.tracePromise(fn, contextFactory()); + } + return fn(); + } + module2.exports = { + dc, + hasTracingChannel, + shouldTrace, + queryChannel, + executeChannel, + connectChannel, + poolConnectChannel, + getServerContext, + traceCallback, + tracePromise + }; + } +}); + +// node_modules/named-placeholders/index.js +var require_named_placeholders = __commonJS({ + "node_modules/named-placeholders/index.js"(exports2, module2) { + "use strict"; + var RE_PARAM = /(?:\?)|(?::(\d+|(?:[a-zA-Z][a-zA-Z0-9_]*)))/g; + var DQUOTE = 34; + var SQUOTE = 39; + var BSLASH = 92; + function parse(query) { + let ppos = RE_PARAM.exec(query); + let curpos = 0; + let start = 0; + let end; + const parts = []; + let inQuote = false; + let escape = false; + let qchr; + const tokens = []; + let qcnt = 0; + let lastTokenEndPos = 0; + let i; + if (ppos) { + do { + for (i = curpos, end = ppos.index; i < end; ++i) { + const chr = query.charCodeAt(i); + if (chr === BSLASH) escape = !escape; + else { + if (escape) { + escape = false; + continue; + } + if (inQuote && chr === qchr) { + if (query.charCodeAt(i + 1) === qchr) { + ++i; + continue; + } + inQuote = false; + } else if (!inQuote && (chr === DQUOTE || chr === SQUOTE)) { + inQuote = true; + qchr = chr; + } + } + } + if (!inQuote) { + parts.push(query.substring(start, end)); + tokens.push(ppos[0].length === 1 ? qcnt++ : ppos[1]); + start = end + ppos[0].length; + lastTokenEndPos = start; + } + curpos = end + ppos[0].length; + } while (ppos = RE_PARAM.exec(query)); + if (tokens.length) { + if (curpos < query.length) { + parts.push(query.substring(lastTokenEndPos)); + } + return [parts, tokens]; + } + } + return [query]; + } + function createCompiler(config) { + if (!config) config = {}; + if (!config.placeholder) { + config.placeholder = "?"; + } + let ncache = 100; + let cache; + if (typeof config.cache === "number") { + ncache = config.cache; + } + if (typeof config.cache === "object") { + cache = config.cache; + } + if (config.cache !== false && !cache) { + cache = require_lib2().createLRU({ max: ncache }); + } + function toArrayParams(tree, params) { + const arr = []; + if (tree.length === 1) { + return [tree[0], []]; + } + if (typeof params === "undefined") + throw new Error( + "Named query contains placeholders, but parameters object is undefined" + ); + const tokens = tree[1]; + for (let i = 0; i < tokens.length; ++i) { + arr.push(params[tokens[i]]); + } + return [tree[0], arr]; + } + function noTailingSemicolon(s) { + if (s.slice(-1) === ":") { + return s.slice(0, -1); + } + return s; + } + function join(tree) { + if (tree.length === 1) { + return tree; + } + let unnamed = noTailingSemicolon(tree[0][0]); + for (let i = 1; i < tree[0].length; ++i) { + if (tree[0][i - 1].slice(-1) === ":") { + unnamed += config.placeholder; + } + unnamed += config.placeholder; + unnamed += noTailingSemicolon(tree[0][i]); + } + const last = tree[0][tree[0].length - 1]; + if (tree[0].length === tree[1].length) { + if (last.slice(-1) === ":") { + unnamed += config.placeholder; + } + unnamed += config.placeholder; + } + return [unnamed, tree[1]]; + } + function compile(query, paramsObj) { + let tree; + if (cache && (tree = cache.get(query))) { + return toArrayParams(tree, paramsObj); + } + tree = join(parse(query)); + if (cache) { + cache.set(query, tree); + } + return toArrayParams(tree, paramsObj); + } + compile.parse = parse; + return compile; + } + function toNumbered(q, params) { + const tree = parse(q); + const paramsArr = []; + if (tree.length === 1) { + return [tree[0], paramsArr]; + } + const pIndexes = {}; + let pLastIndex = 0; + let qs = ""; + let varIndex; + const varNames = []; + for (let i = 0; i < tree[0].length; ++i) { + varIndex = pIndexes[tree[1][i]]; + if (!varIndex) { + varIndex = ++pLastIndex; + pIndexes[tree[1][i]] = varIndex; + } + if (tree[1][i]) { + varNames[varIndex - 1] = tree[1][i]; + qs += `${tree[0][i]}$${varIndex}`; + } else { + qs += tree[0][i]; + } + } + return [qs, varNames.map((n) => params[n])]; + } + module2.exports = createCompiler; + module2.exports.toNumbered = toNumbered; + } +}); + +// node_modules/mysql2/lib/base/connection.js +var require_connection = __commonJS({ + "node_modules/mysql2/lib/base/connection.js"(exports2, module2) { + "use strict"; + var Net = require("net"); + var Tls = require("tls"); + var Timers = require("timers"); + var EventEmitter = require("events").EventEmitter; + var Readable = require("stream").Readable; + var Queue = require_ring_queue(); + var SqlString = require_lib(); + var { createLRU } = require_lib2(); + var PacketParser = require_packet_parser(); + var Packets = require_packets(); + var Commands = require_commands2(); + var ConnectionConfig = require_connection_config(); + var TlsSessionSlot = require_tls_session_cache(); + var CharsetToEncoding = require_charset_encodings(); + var { + traceCallback, + tracePromise, + getServerContext, + shouldTrace, + queryChannel, + executeChannel, + connectChannel + } = require_tracing(); + var _connectionId = 0; + var convertNamedPlaceholders = null; + var secureContexts = /* @__PURE__ */ new WeakMap(); + function getSecureContext(ssl) { + const cached = secureContexts.get(ssl); + if (cached !== void 0 && cached.ca === ssl.ca && cached.cert === ssl.cert && cached.ciphers === ssl.ciphers && cached.key === ssl.key && cached.passphrase === ssl.passphrase && cached.minVersion === ssl.minVersion && cached.maxVersion === ssl.maxVersion) { + return cached.secureContext; + } + const secureContext = Tls.createSecureContext({ + ca: ssl.ca, + cert: ssl.cert, + ciphers: ssl.ciphers, + key: ssl.key, + passphrase: ssl.passphrase, + minVersion: ssl.minVersion, + maxVersion: ssl.maxVersion + }); + secureContexts.set(ssl, { + secureContext, + ca: ssl.ca, + cert: ssl.cert, + ciphers: ssl.ciphers, + key: ssl.key, + passphrase: ssl.passphrase, + minVersion: ssl.minVersion, + maxVersion: ssl.maxVersion + }); + return secureContext; + } + var BaseConnection = class _BaseConnection extends EventEmitter { + constructor(opts) { + super(); + this.config = opts.config; + if (!opts.config.stream) { + if (opts.config.socketPath) { + this.stream = Net.connect(opts.config.socketPath); + } else { + this.stream = Net.connect(opts.config.port, opts.config.host); + if (this.config.enableKeepAlive) { + this.stream.on("connect", () => { + this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay); + }); + } + this.stream.setNoDelay(true); + } + } else if (typeof opts.config.stream === "function") { + this.stream = opts.config.stream(opts); + } else { + this.stream = opts.config.stream; + } + this._internalId = _connectionId++; + this._commands = new Queue(); + this._command = null; + this._paused = false; + this._paused_packets = new Queue(); + this._statements = createLRU({ + max: this.config.maxPreparedStatements, + onEviction: function(_, statement) { + statement.close(); + } + }); + this.serverCapabilityFlags = 0; + this._isMariaDB = false; + this._mariadbExtendedMetadata = false; + this.authorized = false; + this.sequenceId = 0; + this.compressedSequenceId = 0; + this.threadId = null; + this._handshakePacket = null; + this._fatalError = null; + this._protocolError = null; + this._outOfOrderPackets = []; + this.clientEncoding = CharsetToEncoding[this.config.charsetNumber]; + this.stream.on("error", this._handleNetworkError.bind(this)); + this.packetParser = new PacketParser((p) => { + this.handlePacket(p); + }); + this.stream.on("data", (data) => { + if (this.connectTimeout && this.config.isServer) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + this.packetParser.execute(data); + }); + this.stream.on("end", () => { + this.emit("end"); + }); + this.stream.on("close", () => { + if (this._closing) { + return; + } + if (!this._protocolError) { + this._protocolError = new Error( + "Connection lost: The server closed the connection." + ); + this._protocolError.fatal = true; + this._protocolError.code = "PROTOCOL_CONNECTION_LOST"; + } + this._notifyError(this._protocolError); + }); + let handshakeCommand; + if (!this.config.isServer) { + handshakeCommand = new Commands.ClientHandshake(this.config.clientFlags); + handshakeCommand.on("end", () => { + if (this.connectTimeout) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + if (!handshakeCommand.handshake || this._fatalError || this._protocolError) { + return; + } + this._handshakePacket = handshakeCommand.handshake; + this.threadId = handshakeCommand.handshake.connectionId; + this.emit("connect", handshakeCommand.handshake); + }); + handshakeCommand.on("error", (err) => { + this._closing = true; + this._notifyError(err); + }); + this.addCommand(handshakeCommand); + if (shouldTrace(connectChannel)) { + const config = this.config; + tracePromise( + connectChannel, + () => new Promise((resolve, reject) => { + let onConnect, onError; + onConnect = (param) => { + this.removeListener("error", onError); + resolve(param); + }; + onError = (err) => { + this.removeListener("connect", onConnect); + reject(err); + }; + this.once("connect", onConnect); + this.once("error", onError); + }), + () => { + const server = getServerContext(config); + return { + database: config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort, + user: config.user || "" + }; + } + ).catch(() => { + }); + } + } + this.serverEncoding = "utf8"; + if (this.config.connectTimeout) { + const timeoutHandler = this._handleTimeoutError.bind(this); + this.connectTimeout = Timers.setTimeout( + timeoutHandler, + this.config.connectTimeout + ); + } + } + _addCommandClosedState(cmd) { + const err = new Error( + "Can't add new command when connection is in closed state" + ); + err.fatal = true; + if (cmd.onResult) { + cmd.onResult(err); + } else { + this.emit("error", err); + } + } + _handleFatalError(err) { + err.fatal = true; + this.stream.removeAllListeners("data"); + this.addCommand = this._addCommandClosedState; + this.write = () => { + this.emit("error", new Error("Can't write in closed state")); + }; + this._notifyError(err); + this._fatalError = err; + } + _handleNetworkError(err) { + if (this.connectTimeout) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + if (err.code === "ECONNRESET" && this._closing) { + return; + } + this._handleFatalError(err); + } + _handleTimeoutError() { + if (this.connectTimeout) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + this.stream.destroy && this.stream.destroy(); + const err = new Error("connect ETIMEDOUT"); + err.errorno = "ETIMEDOUT"; + err.code = "ETIMEDOUT"; + err.syscall = "connect"; + this._handleNetworkError(err); + } + // notify all commands in the queue and bubble error as connection "error" + // called on stream error or unexpected termination + _notifyError(err) { + if (this.connectTimeout) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + if (this._fatalError) { + return; + } + let command; + let bubbleErrorToConnection = !this._command; + if (this._command && this._command.onResult) { + this._command.onResult(err); + this._command = null; + } else if (!(this._command && this._command.constructor === Commands.ClientHandshake && this._commands.length > 0)) { + bubbleErrorToConnection = true; + } + while (command = this._commands.shift()) { + if (command.onResult) { + command.onResult(err); + } else { + bubbleErrorToConnection = true; + } + } + if (bubbleErrorToConnection || this._pool) { + this.emit("error", err); + } + if (err.fatal) { + this.close(); + } + } + write(buffer) { + const result = this.stream.write(buffer, (err) => { + if (err) { + this._handleNetworkError(err); + } + }); + if (!result) { + this.stream.emit("pause"); + } + } + // http://dev.mysql.com/doc/internals/en/sequence-id.html + // + // The sequence-id is incremented with each packet and may wrap around. + // It starts at 0 and is reset to 0 when a new command + // begins in the Command Phase. + // http://dev.mysql.com/doc/internals/en/example-several-mysql-packets.html + _resetSequenceId() { + this.sequenceId = 0; + this.compressedSequenceId = 0; + } + _bumpCompressedSequenceId(numPackets) { + this.compressedSequenceId += numPackets; + this.compressedSequenceId %= 256; + } + _bumpSequenceId(numPackets) { + this.sequenceId += numPackets; + this.sequenceId %= 256; + } + writePacket(packet) { + const MAX_PACKET_LENGTH = 16777215; + const length = packet.length(); + let chunk, offset, header; + if (length < MAX_PACKET_LENGTH) { + packet.writeHeader(this.sequenceId); + if (this.config.debug) { + console.log( + `${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[this.sequenceId, packet._name, packet.length()].join(",")})` + ); + console.log( + `${this._internalId} ${this.connectionId} <== ${packet.buffer.toString("hex")}` + ); + } + this._bumpSequenceId(1); + this.write(packet.buffer); + } else { + if (this.config.debug) { + console.log( + `${this._internalId} ${this.connectionId} <== Writing large packet, raw content not written:` + ); + console.log( + `${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[this.sequenceId, packet._name, packet.length()].join(",")})` + ); + } + for (offset = 4; offset < 4 + length; offset += MAX_PACKET_LENGTH) { + chunk = packet.buffer.slice(offset, offset + MAX_PACKET_LENGTH); + if (chunk.length === MAX_PACKET_LENGTH) { + header = Buffer.from([255, 255, 255, this.sequenceId]); + } else { + header = Buffer.from([ + chunk.length & 255, + chunk.length >> 8 & 255, + chunk.length >> 16 & 255, + this.sequenceId + ]); + } + this._bumpSequenceId(1); + this.write(header); + this.write(chunk); + } + } + } + // 0.11+ environment + startTLS(onSecure) { + if (this.config.debug) { + console.log("Upgrading connection to TLS"); + } + const secureContext = getSecureContext(this.config.ssl); + const rejectUnauthorized = this.config.ssl.rejectUnauthorized; + const verifyIdentity = this.config.ssl.verifyIdentity; + const servername = Net.isIP(this.config.host) ? void 0 : this.config.host; + const sessionSlot = new TlsSessionSlot( + this.config.ssl, + this.config.host, + this.config.port, + rejectUnauthorized, + verifyIdentity + ); + let secureEstablished = false; + let peerAccepted = false; + let issuedSession = null; + this.stream.removeAllListeners("data"); + const secureSocket = Tls.connect( + { + rejectUnauthorized, + requestCert: rejectUnauthorized, + checkServerIdentity: verifyIdentity ? Tls.checkServerIdentity : function() { + return void 0; + }, + secureContext, + session: sessionSlot.get(), + isServer: false, + socket: this.stream, + servername + }, + () => { + secureEstablished = true; + if (rejectUnauthorized && !secureSocket.isSessionReused()) { + if (typeof servername === "string" && verifyIdentity) { + const cert = secureSocket.getPeerCertificate(true); + const serverIdentityCheckError = Tls.checkServerIdentity( + servername, + cert + ); + if (serverIdentityCheckError) { + sessionSlot.delete(); + onSecure(serverIdentityCheckError); + return; + } + } + } + peerAccepted = true; + if (issuedSession !== null) { + sessionSlot.set(issuedSession); + } + onSecure(); + } + ); + secureSocket.on("session", (session) => { + if (peerAccepted) { + sessionSlot.set(session); + } else { + issuedSession = session; + } + }); + secureSocket.on("error", (err) => { + if (secureEstablished) { + this._handleNetworkError(err); + } else { + sessionSlot.delete(); + onSecure(err); + } + }); + secureSocket.on("data", (data) => { + this.packetParser.execute(data); + }); + this.stream = secureSocket; + } + protocolError(message, code) { + if (this._closing) { + return; + } + const err = new Error(message); + err.fatal = true; + err.code = code || "PROTOCOL_ERROR"; + this.emit("error", err); + } + get state() { + if (this._fatalError || this._protocolError) { + return "error"; + } + if (this._closing || this.stream && this.stream.destroyed) { + return "disconnected"; + } + if (this.authorized) { + return "authenticated"; + } + if (this._handshakePacket) { + return "connected"; + } + if (this.stream && !this.stream.destroyed) { + return "protocol_handshake"; + } + return "disconnected"; + } + get fatalError() { + return this._fatalError; + } + handlePacket(packet) { + if (this._paused) { + this._paused_packets.push(packet ? packet.clone() : packet); + return; + } + if (this.config.debug) { + if (packet) { + console.log( + ` raw: ${packet.buffer.slice(packet.offset, packet.offset + packet.length()).toString("hex")}` + ); + console.trace(); + const commandName = this._command ? this._command._commandName : "(no command)"; + const stateName = this._command ? this._command.stateName() : "(no command)"; + console.log( + `${this._internalId} ${this.connectionId} ==> ${commandName}#${stateName}(${[packet.sequenceId, packet.type(), packet.length()].join(",")})` + ); + } + } + if (!this._command) { + const marker = packet.peekByte(); + if (marker === 255) { + const error = Packets.Error.fromPacket(packet); + this.protocolError(error.message, error.code); + } else { + this.protocolError( + "Unexpected packet while no commands in the queue", + "PROTOCOL_UNEXPECTED_PACKET" + ); + } + this.close(); + return; + } + if (packet) { + if (this.sequenceId !== packet.sequenceId) { + const err = new Error( + `Warning: got packets out of order. Expected ${this.sequenceId} but received ${packet.sequenceId}` + ); + err.expected = this.sequenceId; + err.received = packet.sequenceId; + this.emit("warn", err); + console.error(err.message); + } + this._bumpSequenceId(packet.numPackets); + } + try { + if (this._fatalError) { + return; + } + const done = this._command.execute(packet, this); + if (done) { + this._command = this._commands.shift(); + if (this._command) { + this.sequenceId = 0; + this.compressedSequenceId = 0; + this.handlePacket(); + } + } + } catch (err) { + this._handleFatalError(err); + this.stream.destroy(); + } + } + addCommand(cmd) { + if (this.config.debug) { + const commandName = cmd.constructor.name; + console.log(`Add command: ${commandName}`); + cmd._commandName = commandName; + } + if (!this._command) { + this._command = cmd; + this.handlePacket(); + } else { + this._commands.push(cmd); + } + return cmd; + } + format(sql, values, namedPlaceholders) { + if (typeof this.config.queryFormat === "function") { + return this.config.queryFormat.call( + this, + sql, + values, + this.config.timezone + ); + } + const opts = { + sql, + values + }; + if (typeof namedPlaceholders !== "undefined") { + opts.namedPlaceholders = namedPlaceholders; + } + this._resolveNamedPlaceholders(opts); + return SqlString.format( + opts.sql, + opts.values, + this.config.stringifyObjects, + this.config.timezone + ); + } + escape(value) { + return SqlString.escape(value, false, this.config.timezone); + } + escapeId(value) { + return SqlString.escapeId(value, false); + } + raw(sql) { + return SqlString.raw(sql); + } + _resolveNamedPlaceholders(options) { + let unnamed; + if (typeof options.namedPlaceholders === "undefined") { + options.namedPlaceholders = this.config.namedPlaceholders; + } + if (options.namedPlaceholders) { + if (Array.isArray(options.values)) { + return; + } + if (convertNamedPlaceholders === null) { + convertNamedPlaceholders = require_named_placeholders()(); + } + unnamed = convertNamedPlaceholders(options.sql, options.values); + options.sql = unnamed[0]; + options.values = unnamed[1]; + } + } + query(sql, values, cb) { + let cmdQuery; + if (sql.constructor === Commands.Query) { + cmdQuery = sql; + } else { + cmdQuery = _BaseConnection.createQuery(sql, values, cb, this.config); + } + this._resolveNamedPlaceholders(cmdQuery); + const rawSql = this.format( + cmdQuery.sql, + cmdQuery.values !== void 0 ? cmdQuery.values : [], + cmdQuery.namedPlaceholders + ); + cmdQuery.sql = rawSql; + if (cmdQuery.onResult) { + traceCallback( + queryChannel, + (wrappedCb) => { + cmdQuery.onResult = wrappedCb; + this.addCommand(cmdQuery); + }, + 0, + () => { + const server = getServerContext(this.config); + return { + query: cmdQuery.sql, + values: cmdQuery.values, + database: this.config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort + }; + }, + null, + cmdQuery.onResult + ); + } else if (shouldTrace(queryChannel)) { + tracePromise( + queryChannel, + () => new Promise((resolve, reject) => { + cmdQuery.once("error", reject); + cmdQuery.once("end", () => resolve()); + this.addCommand(cmdQuery); + }), + () => { + const server = getServerContext(this.config); + return { + query: cmdQuery.sql, + values: cmdQuery.values, + database: this.config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort + }; + } + ).catch(() => { + }); + } else { + this.addCommand(cmdQuery); + } + return cmdQuery; + } + pause() { + this._paused = true; + this.stream.pause(); + } + resume() { + let packet; + this._paused = false; + while (packet = this._paused_packets.shift()) { + this.handlePacket(packet); + if (this._paused) { + return; + } + } + this.stream.resume(); + } + // TODO: named placeholders support + prepare(options, cb) { + if (typeof options === "string") { + options = { sql: options }; + } + return this.addCommand(new Commands.Prepare(options, cb)); + } + unprepare(sql) { + let options = {}; + if (typeof sql === "object") { + options = sql; + } else { + options.sql = sql; + } + const key = _BaseConnection.statementKey(options); + const stmt = this._statements.get(key); + if (stmt) { + this._statements.delete(key); + stmt.close(); + } + return stmt; + } + execute(sql, values, cb) { + let options = { + infileStreamFactory: this.config.infileStreamFactory + }; + if (typeof sql === "object") { + options = { + ...options, + ...sql, + sql: sql.sql, + values: sql.values + }; + if (typeof values === "function") { + cb = values; + } else { + options.values = options.values || values; + } + } else if (typeof values === "function") { + cb = values; + options.sql = sql; + options.values = void 0; + } else { + options.sql = sql; + options.values = values; + } + this._resolveNamedPlaceholders(options); + if (options.values) { + if (!Array.isArray(options.values)) { + throw new TypeError( + "Bind parameters must be array if namedPlaceholders parameter is not enabled" + ); + } + options.values.forEach((val) => { + if (!Array.isArray(options.values)) { + throw new TypeError( + "Bind parameters must be array if namedPlaceholders parameter is not enabled" + ); + } + if (val === void 0) { + throw new TypeError( + "Bind parameters must not contain undefined. To pass SQL NULL specify JS null" + ); + } + if (typeof val === "function") { + throw new TypeError( + "Bind parameters must not contain function(s). To pass the body of a function as a string call .toString() first" + ); + } + }); + } + const executeCommand = new Commands.Execute(options, cb); + const prepareAndExecute = (errorCb) => { + const prepareCommand = new Commands.Prepare(options, (err, stmt) => { + if (err) { + executeCommand.start = function() { + return null; + }; + errorCb(err); + executeCommand.emit("end"); + return; + } + executeCommand.statement = stmt; + }); + this.addCommand(prepareCommand); + this.addCommand(executeCommand); + }; + if (executeCommand.onResult) { + const origExecCb = executeCommand.onResult; + traceCallback( + executeChannel, + (wrappedCb) => { + executeCommand.onResult = wrappedCb; + prepareAndExecute(wrappedCb); + }, + 0, + () => { + const server = getServerContext(this.config); + return { + query: options.sql, + values: options.values, + database: this.config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort + }; + }, + null, + origExecCb + ); + } else if (shouldTrace(executeChannel)) { + tracePromise( + executeChannel, + () => new Promise((resolve, reject) => { + prepareAndExecute((err) => { + executeCommand.emit("error", err); + }); + executeCommand.once("error", reject); + executeCommand.once("end", () => resolve()); + }), + () => { + const server = getServerContext(this.config); + return { + query: options.sql, + values: options.values, + database: this.config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort + }; + } + ).catch(() => { + }); + } else { + prepareAndExecute((err) => { + executeCommand.emit("error", err); + }); + } + return executeCommand; + } + changeUser(options, callback) { + if (!callback && typeof options === "function") { + callback = options; + options = {}; + } + const charsetNumber = options.charset ? ConnectionConfig.getCharsetNumber(options.charset) : this.config.charsetNumber; + return this.addCommand( + new Commands.ChangeUser( + { + user: options.user || this.config.user, + // for the purpose of multi-factor authentication, or not, the main + // password (used for the 1st authentication factor) can also be + // provided via the "password1" option + password: options.password || options.password1 || this.config.password || this.config.password1, + password2: options.password2 || this.config.password2, + password3: options.password3 || this.config.password3, + passwordSha1: options.passwordSha1 || this.config.passwordSha1, + database: options.database || this.config.database, + timeout: options.timeout, + charsetNumber, + currentConfig: this.config + }, + (err) => { + if (err) { + err.fatal = true; + } + if (callback) { + callback(err); + } + } + ) + ); + } + // transaction helpers + beginTransaction(cb) { + return this.query("START TRANSACTION", cb); + } + commit(cb) { + return this.query("COMMIT", cb); + } + rollback(cb) { + return this.query("ROLLBACK", cb); + } + ping(cb) { + return this.addCommand(new Commands.Ping(cb)); + } + reset(cb) { + return this.addCommand(new Commands.ResetConnection(cb)); + } + _registerSlave(opts, cb) { + return this.addCommand(new Commands.RegisterSlave(opts, cb)); + } + _binlogDump(opts, cb) { + return this.addCommand(new Commands.BinlogDump(opts, cb)); + } + // currently just alias to close + destroy() { + this.close(); + } + close() { + if (this.connectTimeout) { + Timers.clearTimeout(this.connectTimeout); + this.connectTimeout = null; + } + this._closing = true; + this.stream.end(); + this.addCommand = this._addCommandClosedState; + } + createBinlogStream(opts) { + let test = 1; + const stream = new Readable({ objectMode: true }); + stream._read = function() { + return { + data: test++ + }; + }; + this._registerSlave(opts, () => { + const dumpCmd = this._binlogDump(opts); + dumpCmd.on("event", (ev) => { + stream.push(ev); + }); + dumpCmd.on("eof", () => { + stream.push(null); + if (opts.flags && opts.flags & 1) { + this.close(); + } + }); + }); + return stream; + } + connect(cb) { + if (!cb) { + return; + } + if (this._fatalError || this._protocolError) { + return cb(this._fatalError || this._protocolError); + } + if (this._handshakePacket) { + return cb(null, this); + } + let onError, onConnect; + onError = (param) => { + this.removeListener("connect", onConnect); + cb(param); + }; + onConnect = (param) => { + this.removeListener("error", onError); + cb(null, param); + }; + this.once("error", onError); + this.once("connect", onConnect); + } + // =================================== + // outgoing server connection methods + // =================================== + writeColumns(columns) { + this.writePacket(Packets.ResultSetHeader.toPacket(columns.length)); + columns.forEach((column) => { + this.writePacket( + Packets.ColumnDefinition.toPacket(column, this.serverConfig.encoding) + ); + }); + this.writeEof(); + } + // row is array of columns, not hash + writeTextRow(column) { + this.writePacket( + Packets.TextRow.toPacket(column, this.serverConfig.encoding) + ); + } + writeBinaryRow(column) { + this.writePacket( + Packets.BinaryRow.toPacket(column, this.serverConfig.encoding) + ); + } + writeTextResult(rows, columns, binary = false) { + this.writeColumns(columns); + rows.forEach((row) => { + const arrayRow = new Array(columns.length); + columns.forEach((column) => { + arrayRow.push(row[column.name]); + }); + if (binary) { + this.writeBinaryRow(arrayRow); + } else this.writeTextRow(arrayRow); + }); + this.writeEof(); + } + writeEof(warnings, statusFlags) { + this.writePacket(Packets.EOF.toPacket(warnings, statusFlags)); + } + writeOk(args) { + if (!args) { + args = { affectedRows: 0 }; + } + this.writePacket(Packets.OK.toPacket(args, this.serverConfig.encoding)); + } + writeError(args) { + const encoding = this.serverConfig ? this.serverConfig.encoding : "cesu8"; + this.writePacket(Packets.Error.toPacket(args, encoding)); + } + serverHandshake(args) { + this.serverConfig = args; + this.serverConfig.encoding = CharsetToEncoding[this.serverConfig.characterSet]; + return this.addCommand(new Commands.ServerHandshake(args)); + } + [Symbol.dispose]() { + if (!this._closing) { + this.end(); + } + } + // =============================================================== + end(callback) { + if (this.config.isServer) { + this._closing = true; + const quitCmd2 = new EventEmitter(); + setImmediate(() => { + this.stream.end(); + quitCmd2.emit("end"); + }); + return quitCmd2; + } + const quitCmd = this.addCommand(new Commands.Quit(callback)); + this.addCommand = this._addCommandClosedState; + return quitCmd; + } + static createQuery(sql, values, cb, config) { + let options = { + rowsAsArray: config.rowsAsArray, + infileStreamFactory: config.infileStreamFactory + }; + if (typeof sql === "object") { + options = { + ...options, + ...sql, + sql: sql.sql, + values: sql.values + }; + if (typeof values === "function") { + cb = values; + } else if (values !== void 0) { + options.values = values; + } + } else if (typeof values === "function") { + cb = values; + options.sql = sql; + options.values = void 0; + } else { + options.sql = sql; + options.values = values; + } + return new Commands.Query(options, cb); + } + static statementKey(options) { + return `${typeof options.nestTables}/${options.nestTables}/${options.rowsAsArray}${options.sql}`; + } + }; + module2.exports = BaseConnection; + } +}); + +// node_modules/mysql2/lib/promise/capture_local_err.js +var require_capture_local_err = __commonJS({ + "node_modules/mysql2/lib/promise/capture_local_err.js"(exports2, module2) { + "use strict"; + function captureStackHolder(constructorOpt) { + const holder = {}; + Error.captureStackTrace(holder, constructorOpt); + return holder; + } + function applyCapturedStack(err, holder) { + const stack = holder && holder.stack; + if (typeof stack !== "string" || !stack) return; + const lines = stack.split("\n"); + lines[0] = `${err.name}: ${err.message}`; + err.stack = lines.join("\n"); + } + module2.exports = { captureStackHolder, applyCapturedStack }; + } +}); + +// node_modules/mysql2/lib/promise/make_done_cb.js +var require_make_done_cb = __commonJS({ + "node_modules/mysql2/lib/promise/make_done_cb.js"(exports2, module2) { + "use strict"; + var { applyCapturedStack } = require_capture_local_err(); + function makeDoneCb(resolve, reject, stackHolder) { + return function(err, rows, fields) { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve([rows, fields]); + } + }; + } + module2.exports = makeDoneCb; + } +}); + +// node_modules/mysql2/lib/promise/prepared_statement_info.js +var require_prepared_statement_info = __commonJS({ + "node_modules/mysql2/lib/promise/prepared_statement_info.js"(exports2, module2) { + "use strict"; + var { captureStackHolder } = require_capture_local_err(); + var makeDoneCb = require_make_done_cb(); + var PromisePreparedStatementInfo = class _PromisePreparedStatementInfo { + constructor(statement, promiseImpl) { + this.statement = statement; + this.Promise = promiseImpl; + } + execute(parameters) { + const s = this.statement; + const stackHolder = s._connection.config.trace ? captureStackHolder(_PromisePreparedStatementInfo.prototype.execute) : void 0; + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + if (parameters) { + s.execute(parameters, done); + } else { + s.execute(done); + } + }); + } + close() { + return new this.Promise((resolve) => { + this.statement.close(); + resolve(); + }); + } + }; + module2.exports = PromisePreparedStatementInfo; + } +}); + +// node_modules/mysql2/lib/promise/inherit_events.js +var require_inherit_events = __commonJS({ + "node_modules/mysql2/lib/promise/inherit_events.js"(exports2, module2) { + "use strict"; + function inheritEvents(source, target, events) { + const listeners = {}; + target.on("newListener", (eventName) => { + if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) { + source.on( + eventName, + listeners[eventName] = function() { + const args = [].slice.call(arguments); + args.unshift(eventName); + target.emit.apply(target, args); + } + ); + } + }).on("removeListener", (eventName) => { + if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) { + source.removeListener(eventName, listeners[eventName]); + delete listeners[eventName]; + } + }); + } + module2.exports = inheritEvents; + } +}); + +// node_modules/mysql2/lib/promise/connection.js +var require_connection2 = __commonJS({ + "node_modules/mysql2/lib/promise/connection.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var PromisePreparedStatementInfo = require_prepared_statement_info(); + var { + captureStackHolder, + applyCapturedStack + } = require_capture_local_err(); + var makeDoneCb = require_make_done_cb(); + var inheritEvents = require_inherit_events(); + var BaseConnection = require_connection(); + var PromiseConnection = class _PromiseConnection extends EventEmitter { + constructor(connection, promiseImpl) { + super(); + this.connection = connection; + this.Promise = promiseImpl || Promise; + inheritEvents(connection, this, [ + "error", + "drain", + "connect", + "end", + "enqueue" + ]); + } + release() { + this.connection.release(); + } + query(query, params) { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.query) : void 0; + if (typeof params === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + if (params !== void 0) { + c.query(query, params, done); + } else { + c.query(query, done); + } + }); + } + execute(query, params) { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.execute) : void 0; + if (typeof params === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + if (params !== void 0) { + c.execute(query, params, done); + } else { + c.execute(query, done); + } + }); + } + end() { + return new this.Promise((resolve) => { + this.connection.end(resolve); + }); + } + async [Symbol.asyncDispose]() { + if (!this.connection._closing) { + await this.end(); + } + } + beginTransaction() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.beginTransaction) : void 0; + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + c.beginTransaction(done); + }); + } + commit() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.commit) : void 0; + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + c.commit(done); + }); + } + rollback() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.rollback) : void 0; + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + c.rollback(done); + }); + } + ping() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.ping) : void 0; + return new this.Promise((resolve, reject) => { + c.ping((err) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(true); + } + }); + }); + } + reset() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.reset) : void 0; + return new this.Promise((resolve, reject) => { + c.reset((err) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(); + } + }); + }); + } + connect() { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.connect) : void 0; + return new this.Promise((resolve, reject) => { + c.connect((err, param) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(param); + } + }); + }); + } + prepare(options) { + const c = this.connection; + const promiseImpl = this.Promise; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.prepare) : void 0; + return new this.Promise((resolve, reject) => { + c.prepare(options, (err, statement) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + const wrappedStatement = new PromisePreparedStatementInfo( + statement, + promiseImpl + ); + resolve(wrappedStatement); + } + }); + }); + } + changeUser(options) { + const c = this.connection; + const stackHolder = c.config.trace ? captureStackHolder(_PromiseConnection.prototype.changeUser) : void 0; + return new this.Promise((resolve, reject) => { + c.changeUser(options, (err) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(); + } + }); + }); + } + get config() { + return this.connection.config; + } + get threadId() { + return this.connection.threadId; + } + }; + (function(functionsToWrap) { + for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) { + const func = functionsToWrap[i]; + if (typeof BaseConnection.prototype[func] === "function" && PromiseConnection.prototype[func] === void 0) { + PromiseConnection.prototype[func] = /* @__PURE__ */ (function factory(funcName) { + return function() { + return BaseConnection.prototype[funcName].apply( + this.connection, + arguments + ); + }; + })(func); + } + } + })([ + // synchronous functions + "close", + "createBinlogStream", + "destroy", + "escape", + "escapeId", + "format", + "pause", + "pipe", + "resume", + "unprepare" + ]); + module2.exports = PromiseConnection; + } +}); + +// node_modules/mysql2/lib/connection.js +var require_connection3 = __commonJS({ + "node_modules/mysql2/lib/connection.js"(exports2, module2) { + "use strict"; + var BaseConnection = require_connection(); + var Connection = class extends BaseConnection { + promise(promiseImpl) { + const PromiseConnection = require_connection2(); + return new PromiseConnection(this, promiseImpl); + } + }; + module2.exports = Connection; + } +}); + +// node_modules/mysql2/lib/promise/pool_connection.js +var require_pool_connection = __commonJS({ + "node_modules/mysql2/lib/promise/pool_connection.js"(exports2, module2) { + "use strict"; + var PromiseConnection = require_connection2(); + var PromisePoolConnection = class extends PromiseConnection { + constructor(connection, promiseImpl) { + super(connection, promiseImpl); + } + destroy() { + return this.connection.destroy(); + } + async [Symbol.asyncDispose]() { + this.release(); + } + }; + module2.exports = PromisePoolConnection; + } +}); + +// node_modules/mysql2/lib/pool_connection.js +var require_pool_connection2 = __commonJS({ + "node_modules/mysql2/lib/pool_connection.js"(exports2, module2) { + "use strict"; + var Connection = require_connection3(); + var PoolConnection = class extends Connection { + constructor(pool, options) { + super(options); + this._pool = pool; + this._released = false; + this.lastActiveTime = Date.now(); + this.once("end", () => { + this._removeFromPool(); + }); + this.once("error", () => { + this._removeFromPool(); + }); + } + release() { + if (this._released) { + return; + } + if (!this._pool || this._pool._closed) { + return; + } + this._released = true; + this.lastActiveTime = Date.now(); + this._pool.releaseConnection(this); + } + [Symbol.dispose]() { + this.release(); + } + end(callback) { + if (this.config.gracefulEnd) { + this._removeFromPool(); + super.end(callback); + return; + } + const err = new Error( + "Calling conn.end() to release a pooled connection is deprecated. In next version calling conn.end() will be restored to default conn.end() behavior. Use conn.release() instead." + ); + this.emit("warn", err); + console.warn(err.message); + this.release(); + if (typeof callback === "function") { + callback(); + } + } + destroy() { + this._removeFromPool(); + super.destroy(); + } + _removeFromPool() { + if (!this._pool || this._pool._closed) { + return; + } + const pool = this._pool; + this._pool = null; + pool._removeConnection(this); + } + promise(promiseImpl) { + const PromisePoolConnection = require_pool_connection(); + return new PromisePoolConnection(this, promiseImpl); + } + }; + PoolConnection.statementKey = Connection.statementKey; + module2.exports = PoolConnection; + PoolConnection.prototype._realEnd = Connection.prototype.end; + } +}); + +// node_modules/mysql2/lib/base/pool.js +var require_pool = __commonJS({ + "node_modules/mysql2/lib/base/pool.js"(exports2, module2) { + "use strict"; + var process2 = require("process"); + var SqlString = require_lib(); + var EventEmitter = require("events").EventEmitter; + var PoolConnection = require_pool_connection2(); + var Queue = require_ring_queue(); + var BaseConnection = require_connection(); + var Errors = require_errors(); + var { + traceCallback, + getServerContext, + poolConnectChannel + } = require_tracing(); + function isReadOnlyError(err) { + if (!err || !err.errno) { + return false; + } + return err.errno === Errors.ER_OPTION_PREVENTS_STATEMENT || err.errno === Errors.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION || err.errno === Errors.ER_READ_ONLY_MODE; + } + function spliceConnection(queue, connection) { + const len = queue.length; + for (let i = 0; i < len; i++) { + if (queue.get(i) === connection) { + queue.removeOne(i); + break; + } + } + } + var BasePool = class extends EventEmitter { + constructor(options) { + super(); + this.config = options.config; + this.config.connectionConfig.pool = this; + this._allConnections = new Queue(); + this._freeConnections = new Queue(); + this._connectionQueue = new Queue(); + this._closed = false; + if (this.config.maxIdle < this.config.connectionLimit) { + this._removeIdleTimeoutConnections(); + } + } + /** + * Creates a per-connection copy of the pool connection config. + * + * Commands like `changeUser` mutate `connection.config` in place. Sharing a + * single config object between every pooled connection made those mutations + * leak into connections created later. The prototype is preserved so the + * copy is still a `ConnectionConfig`. + */ + _createConnectionConfig() { + const { connectionConfig } = this.config; + return Object.create( + Object.getPrototypeOf(connectionConfig), + Object.getOwnPropertyDescriptors(connectionConfig) + ); + } + getConnection(cb) { + const _getConnection = (cb2) => { + if (this._closed) { + return process2.nextTick(() => cb2(new Error("Pool is closed."))); + } + let connection; + if (this._freeConnections.length > 0) { + connection = this._freeConnections.pop(); + this.emit("acquire", connection); + return process2.nextTick(() => { + connection._released = false; + cb2(null, connection); + }); + } + if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) { + connection = new PoolConnection(this, { + config: this._createConnectionConfig() + }); + this._allConnections.push(connection); + return connection.connect((err) => { + if (this._closed) { + return cb2(new Error("Pool is closed.")); + } + if (err) { + return cb2(err); + } + this.emit("connection", connection); + this.emit("acquire", connection); + return cb2(null, connection); + }); + } + if (!this.config.waitForConnections) { + return process2.nextTick( + () => cb2(new Error("No connections available.")) + ); + } + if (this.config.queueLimit && this._connectionQueue.length >= this.config.queueLimit) { + return cb2(new Error("Queue limit reached.")); + } + this.emit("enqueue"); + return this._connectionQueue.push(cb2); + }; + const config = this.config.connectionConfig; + traceCallback( + poolConnectChannel, + _getConnection, + 0, + () => { + const server = getServerContext(config); + return { + database: config.database || "", + serverAddress: server.serverAddress, + serverPort: server.serverPort + }; + }, + null, + cb + ); + } + releaseConnection(connection) { + let cb; + if (!connection._pool) { + if (this._connectionQueue.length) { + cb = this._connectionQueue.shift(); + process2.nextTick(this.getConnection.bind(this, cb)); + } + return; + } + if (this.config.resetOnRelease && connection.reset) { + connection.reset((err) => { + if (err) { + connection._pool = null; + spliceConnection(this._allConnections, connection); + connection.destroy(); + if (this._connectionQueue.length) { + cb = this._connectionQueue.shift(); + process2.nextTick(this.getConnection.bind(this, cb)); + } + return; + } + this._handleSuccessfulRelease(connection); + }); + } else { + this._handleSuccessfulRelease(connection); + } + } + _handleSuccessfulRelease(connection) { + let cb; + if (this._connectionQueue.length) { + cb = this._connectionQueue.shift(); + process2.nextTick(() => { + connection._released = false; + cb(null, connection); + }); + } else { + this._freeConnections.push(connection); + this.emit("release", connection); + } + } + [Symbol.dispose]() { + if (!this._closed) { + this.end(); + } + } + end(cb) { + this._closed = true; + clearTimeout(this._removeIdleTimeoutConnectionsTimer); + if (typeof cb !== "function") { + cb = function(err) { + if (err) { + throw err; + } + }; + } + while (this._connectionQueue.length > 0) { + const queuedCallback = this._connectionQueue.shift(); + process2.nextTick(() => queuedCallback(new Error("Pool is closed."))); + } + let calledBack = false; + let closedConnections = 0; + let connection; + const endCB = function(err) { + if (calledBack) { + return; + } + if (err || ++closedConnections >= this._allConnections.length) { + calledBack = true; + cb(err); + return; + } + }.bind(this); + if (this._allConnections.length === 0) { + endCB(); + return; + } + for (let i = 0; i < this._allConnections.length; i++) { + connection = this._allConnections.get(i); + connection._realEnd(endCB); + } + } + query(sql, values, cb) { + const cmdQuery = BaseConnection.createQuery( + sql, + values, + cb, + this.config.connectionConfig + ); + if (typeof cmdQuery.namedPlaceholders === "undefined") { + cmdQuery.namedPlaceholders = this.config.connectionConfig.namedPlaceholders; + } + this.getConnection((err, conn) => { + if (err) { + if (typeof cmdQuery.onResult === "function") { + cmdQuery.onResult(err); + } else { + cmdQuery.emit("error", err); + } + return; + } + try { + let queryError = null; + const origOnResult = cmdQuery.onResult; + if (origOnResult) { + cmdQuery.onResult = function(err2, rows, fields) { + queryError = err2 || null; + origOnResult(err2, rows, fields); + }; + } else { + cmdQuery.once("error", (err2) => { + queryError = err2; + }); + } + conn.query(cmdQuery).once("end", () => { + if (isReadOnlyError(queryError)) { + conn.destroy(); + } else { + conn.release(); + } + }); + } catch (e) { + conn.release(); + if (typeof cmdQuery.onResult === "function") { + cmdQuery.onResult(e); + } else { + cmdQuery.emit("error", e); + } + } + }); + return cmdQuery; + } + execute(sql, values, cb) { + if (typeof values === "function") { + cb = values; + values = []; + } + this.getConnection((err, conn) => { + if (err) { + return cb(err); + } + try { + conn.execute(sql, values, (err2, rows, fields) => { + if (isReadOnlyError(err2)) { + conn.destroy(); + } + cb(err2, rows, fields); + }).once("end", () => { + conn.release(); + }); + } catch (e) { + conn.release(); + return cb(e); + } + }); + } + _removeConnection(connection) { + spliceConnection(this._allConnections, connection); + spliceConnection(this._freeConnections, connection); + this.releaseConnection(connection); + } + _removeIdleTimeoutConnections() { + if (this._removeIdleTimeoutConnectionsTimer) { + clearTimeout(this._removeIdleTimeoutConnectionsTimer); + } + this._removeIdleTimeoutConnectionsTimer = setTimeout(() => { + try { + while (this._freeConnections.length > this.config.maxIdle || this._freeConnections.length > 0 && Date.now() - this._freeConnections.get(0).lastActiveTime > this.config.idleTimeout) { + if (this.config.connectionConfig.gracefulEnd) { + this._freeConnections.get(0).end(); + } else { + this._freeConnections.get(0).destroy(); + } + } + } finally { + this._removeIdleTimeoutConnections(); + } + }, 1e3); + } + format(sql, values) { + return SqlString.format( + sql, + values, + this.config.connectionConfig.stringifyObjects, + this.config.connectionConfig.timezone + ); + } + escape(value) { + return SqlString.escape( + value, + this.config.connectionConfig.stringifyObjects, + this.config.connectionConfig.timezone + ); + } + escapeId(value) { + return SqlString.escapeId(value, false); + } + }; + module2.exports = BasePool; + } +}); + +// node_modules/mysql2/lib/promise/pool.js +var require_pool2 = __commonJS({ + "node_modules/mysql2/lib/promise/pool.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var { + captureStackHolder, + applyCapturedStack + } = require_capture_local_err(); + var makeDoneCb = require_make_done_cb(); + var PromisePoolConnection = require_pool_connection(); + var inheritEvents = require_inherit_events(); + var BasePool = require_pool(); + var PromisePool = class _PromisePool extends EventEmitter { + constructor(pool, thePromise) { + super(); + this.pool = pool; + this.Promise = thePromise || Promise; + inheritEvents(pool, this, ["acquire", "connection", "enqueue", "release"]); + } + getConnection() { + const corePool = this.pool; + return new this.Promise((resolve, reject) => { + corePool.getConnection((err, coreConnection) => { + if (err) { + reject(err); + } else { + resolve(new PromisePoolConnection(coreConnection, this.Promise)); + } + }); + }); + } + releaseConnection(connection) { + if (connection instanceof PromisePoolConnection) connection.release(); + } + query(sql, args) { + const corePool = this.pool; + const stackHolder = corePool.config.connectionConfig.trace ? captureStackHolder(_PromisePool.prototype.query) : void 0; + if (typeof args === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + if (args !== void 0) { + corePool.query(sql, args, done); + } else { + corePool.query(sql, done); + } + }); + } + execute(sql, args) { + const corePool = this.pool; + const stackHolder = corePool.config.connectionConfig.trace ? captureStackHolder(_PromisePool.prototype.execute) : void 0; + if (typeof args === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + if (args) { + corePool.execute(sql, args, done); + } else { + corePool.execute(sql, done); + } + }); + } + end() { + const corePool = this.pool; + const stackHolder = corePool.config.connectionConfig.trace ? captureStackHolder(_PromisePool.prototype.end) : void 0; + return new this.Promise((resolve, reject) => { + corePool.end((err) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(); + } + }); + }); + } + async [Symbol.asyncDispose]() { + if (!this.pool._closed) { + await this.end(); + } + } + }; + (function(functionsToWrap) { + for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) { + const func = functionsToWrap[i]; + if (typeof BasePool.prototype[func] === "function" && PromisePool.prototype[func] === void 0) { + PromisePool.prototype[func] = /* @__PURE__ */ (function factory(funcName) { + return function() { + return BasePool.prototype[funcName].apply(this.pool, arguments); + }; + })(func); + } + } + })([ + // synchronous functions + "escape", + "escapeId", + "format" + ]); + module2.exports = PromisePool; + } +}); + +// node_modules/mysql2/lib/pool.js +var require_pool3 = __commonJS({ + "node_modules/mysql2/lib/pool.js"(exports2, module2) { + "use strict"; + var BasePool = require_pool(); + var Pool = class extends BasePool { + promise(promiseImpl) { + const PromisePool = require_pool2(); + return new PromisePool(this, promiseImpl); + } + }; + module2.exports = Pool; + } +}); + +// node_modules/mysql2/lib/pool_config.js +var require_pool_config = __commonJS({ + "node_modules/mysql2/lib/pool_config.js"(exports2, module2) { + "use strict"; + var ConnectionConfig = require_connection_config(); + var PoolConfig = class { + constructor(options) { + if (typeof options === "string") { + options = ConnectionConfig.parseUrl(options); + } + this.connectionConfig = new ConnectionConfig(options); + this.waitForConnections = options.waitForConnections === void 0 ? true : Boolean(options.waitForConnections); + this.connectionLimit = isNaN(options.connectionLimit) ? 10 : Number(options.connectionLimit); + this.maxIdle = isNaN(options.maxIdle) ? this.connectionLimit : Number(options.maxIdle); + this.idleTimeout = isNaN(options.idleTimeout) ? 6e4 : Number(options.idleTimeout); + this.queueLimit = isNaN(options.queueLimit) ? 0 : Number(options.queueLimit); + this.resetOnRelease = options.resetOnRelease === void 0 ? false : Boolean(options.resetOnRelease); + } + }; + module2.exports = PoolConfig; + } +}); + +// node_modules/mysql2/lib/pool_cluster.js +var require_pool_cluster = __commonJS({ + "node_modules/mysql2/lib/pool_cluster.js"(exports2, module2) { + "use strict"; + var process2 = require("process"); + var Pool = require_pool3(); + var PoolConfig = require_pool_config(); + var Connection = require_connection3(); + var EventEmitter = require("events").EventEmitter; + var makeSelector = { + RR() { + let index = 0; + return (clusterIds) => clusterIds[index++ % clusterIds.length]; + }, + RANDOM() { + return (clusterIds) => clusterIds[Math.floor(Math.random() * clusterIds.length)]; + }, + ORDER() { + return (clusterIds) => clusterIds[0]; + } + }; + var getMonotonicMilliseconds = function() { + let ms; + if (typeof process2.hrtime === "function") { + ms = process2.hrtime(); + ms = ms[0] * 1e3 + ms[1] * 1e-6; + } else { + ms = process2.uptime() * 1e3; + } + return Math.floor(ms); + }; + var patternRegExp = function(pattern) { + if (pattern instanceof RegExp) { + return pattern; + } + const source = pattern.replace(/([.+?^=!:${}()|[\]/\\])/g, "\\$1").replace(/\*/g, ".*"); + return new RegExp(`^${source}$`); + }; + var PoolNamespace = class { + constructor(cluster, pattern, selector) { + this._cluster = cluster; + this._pattern = pattern; + this._selector = makeSelector[selector](); + } + getConnection(cb) { + const clusterNode = this._getClusterNode(); + if (clusterNode === null) { + let err = new Error("Pool does Not exist."); + err.code = "POOL_NOEXIST"; + if (this._cluster._findNodeIds(this._pattern, true).length !== 0) { + err = new Error("Pool does Not have online node."); + err.code = "POOL_NONEONLINE"; + } + return cb(err); + } + return this._cluster._getConnection(clusterNode, (err, connection) => { + if (err) { + if (this._cluster._canRetry && this._cluster._findNodeIds(this._pattern).length !== 0) { + this._cluster.emit("warn", err); + return this.getConnection(cb); + } + return cb(err); + } + return cb(null, connection); + }); + } + /** + * pool cluster query + * @param {*} sql + * @param {*} values + * @param {*} cb + * @returns query + */ + query(sql, values, cb) { + const query = Connection.createQuery(sql, values, cb, {}); + this.getConnection((err, conn) => { + if (err) { + if (typeof query.onResult === "function") { + query.onResult(err); + } else { + query.emit("error", err); + } + return; + } + try { + conn.query(query).once("end", () => { + conn.release(); + }); + } catch (e) { + conn.release(); + throw e; + } + }); + return query; + } + /** + * pool cluster execute + * @param {*} sql + * @param {*} values + * @param {*} cb + */ + execute(sql, values, cb) { + if (typeof values === "function") { + cb = values; + values = []; + } + this.getConnection((err, conn) => { + if (err) { + return cb(err); + } + try { + conn.execute(sql, values, cb).once("end", () => { + conn.release(); + }); + } catch (e) { + conn.release(); + throw e; + } + }); + } + get trace() { + const nodeIds = this._cluster._findNodeIds(this._pattern, true); + for (let i = 0; i < nodeIds.length; i++) { + const node = this._cluster._getNode(nodeIds[i]); + if (node?.pool.config.connectionConfig.trace) { + return true; + } + } + return nodeIds.length === 0; + } + _getClusterNode() { + const foundNodeIds = this._cluster._findNodeIds(this._pattern); + if (foundNodeIds.length === 0) { + return null; + } + const nodeId = foundNodeIds.length === 1 ? foundNodeIds[0] : this._selector(foundNodeIds); + return this._cluster._getNode(nodeId); + } + }; + var PoolCluster = class extends EventEmitter { + constructor(config) { + super(); + config = config || {}; + this._canRetry = typeof config.canRetry === "undefined" ? true : config.canRetry; + this._removeNodeErrorCount = config.removeNodeErrorCount || 5; + this._restoreNodeTimeout = config.restoreNodeTimeout || 0; + this._defaultSelector = config.defaultSelector || "RR"; + this._closed = false; + this._lastId = 0; + this._nodes = {}; + this._serviceableNodeIds = []; + this._namespaces = {}; + this._findCaches = {}; + } + of(pattern, selector) { + pattern = pattern || "*"; + selector = selector || this._defaultSelector; + selector = selector.toUpperCase(); + if (!makeSelector[selector] === "undefined") { + selector = this._defaultSelector; + } + const key = pattern + selector; + if (typeof this._namespaces[key] === "undefined") { + this._namespaces[key] = new PoolNamespace(this, pattern, selector); + } + return this._namespaces[key]; + } + add(id, config) { + if (typeof id === "object") { + config = id; + id = `CLUSTER::${++this._lastId}`; + } + if (typeof this._nodes[id] === "undefined") { + this._nodes[id] = { + id, + errorCount: 0, + pool: new Pool({ config: new PoolConfig(config) }), + _offlineUntil: 0 + }; + this._serviceableNodeIds.push(id); + this._clearFindCaches(); + } + } + remove(pattern) { + const foundNodeIds = this._findNodeIds(pattern, true); + for (let i = 0; i < foundNodeIds.length; i++) { + const node = this._getNode(foundNodeIds[i]); + if (node) { + this._removeNode(node); + } + } + } + getConnection(pattern, selector, cb) { + let namespace; + if (typeof pattern === "function") { + cb = pattern; + namespace = this.of(); + } else { + if (typeof selector === "function") { + cb = selector; + selector = this._defaultSelector; + } + namespace = this.of(pattern, selector); + } + namespace.getConnection(cb); + } + [Symbol.dispose]() { + if (!this._closed) { + this.end(); + } + } + end(callback) { + const cb = callback !== void 0 ? callback : (err) => { + if (err) { + throw err; + } + }; + if (this._closed) { + process2.nextTick(cb); + return; + } + this._closed = true; + let calledBack = false; + let waitingClose = 0; + const onEnd = (err) => { + if (!calledBack && (err || --waitingClose <= 0)) { + calledBack = true; + return cb(err); + } + }; + for (const id in this._nodes) { + waitingClose++; + this._nodes[id].pool.end(onEnd); + } + if (waitingClose === 0) { + process2.nextTick(onEnd); + } + } + _findNodeIds(pattern, includeOffline) { + let currentTime = 0; + let foundNodeIds = this._findCaches[pattern]; + if (foundNodeIds === void 0) { + const expression = patternRegExp(pattern); + foundNodeIds = this._serviceableNodeIds.filter( + (id) => id.match(expression) + ); + } + this._findCaches[pattern] = foundNodeIds; + if (includeOffline) { + return foundNodeIds; + } + return foundNodeIds.filter((nodeId) => { + const node = this._getNode(nodeId); + if (!node._offlineUntil) { + return true; + } + if (!currentTime) { + currentTime = getMonotonicMilliseconds(); + } + return node._offlineUntil <= currentTime; + }); + } + _getNode(id) { + return this._nodes[id] || null; + } + _increaseErrorCount(node) { + const errorCount = ++node.errorCount; + if (this._removeNodeErrorCount > errorCount) { + return; + } + if (this._restoreNodeTimeout > 0) { + node._offlineUntil = getMonotonicMilliseconds() + this._restoreNodeTimeout; + this.emit("offline", node.id); + return; + } + this._removeNode(node); + this.emit("remove", node.id); + } + _decreaseErrorCount(node) { + let errorCount = node.errorCount; + if (errorCount > this._removeNodeErrorCount) { + errorCount = this._removeNodeErrorCount; + } + if (errorCount < 1) { + errorCount = 1; + } + node.errorCount = errorCount - 1; + if (node._offlineUntil) { + node._offlineUntil = 0; + this.emit("online", node.id); + } + } + _getConnection(node, cb) { + node.pool.getConnection((err, connection) => { + if (err) { + this._increaseErrorCount(node); + return cb(err); + } + this._decreaseErrorCount(node); + connection._clusterId = node.id; + return cb(null, connection); + }); + } + _removeNode(node) { + const index = this._serviceableNodeIds.indexOf(node.id); + if (index !== -1) { + this._serviceableNodeIds.splice(index, 1); + delete this._nodes[node.id]; + this._clearFindCaches(); + node.pool.end(); + } + } + _clearFindCaches() { + this._findCaches = {}; + } + }; + module2.exports = PoolCluster; + } +}); + +// node_modules/mysql2/lib/create_connection.js +var require_create_connection = __commonJS({ + "node_modules/mysql2/lib/create_connection.js"(exports2, module2) { + "use strict"; + var Connection = require_connection3(); + var ConnectionConfig = require_connection_config(); + function createConnection(opts) { + return new Connection({ config: new ConnectionConfig(opts) }); + } + module2.exports = createConnection; + } +}); + +// node_modules/mysql2/lib/create_pool.js +var require_create_pool = __commonJS({ + "node_modules/mysql2/lib/create_pool.js"(exports2, module2) { + "use strict"; + var Pool = require_pool3(); + var PoolConfig = require_pool_config(); + function createPool(config) { + return new Pool({ config: new PoolConfig(config) }); + } + module2.exports = createPool; + } +}); + +// node_modules/mysql2/lib/create_pool_cluster.js +var require_create_pool_cluster = __commonJS({ + "node_modules/mysql2/lib/create_pool_cluster.js"(exports2, module2) { + "use strict"; + var PoolCluster = require_pool_cluster(); + function createPoolCluster(config) { + return new PoolCluster(config); + } + module2.exports = createPoolCluster; + } +}); + +// node_modules/mysql2/lib/promise/pool_cluster.js +var require_pool_cluster2 = __commonJS({ + "node_modules/mysql2/lib/promise/pool_cluster.js"(exports2, module2) { + "use strict"; + var { captureStackHolder } = require_capture_local_err(); + var PromisePoolConnection = require_pool_connection(); + var makeDoneCb = require_make_done_cb(); + var PromisePoolNamespace = class _PromisePoolNamespace { + constructor(poolNamespace, thePromise) { + this.poolNamespace = poolNamespace; + this.Promise = thePromise || Promise; + } + getConnection() { + const corePoolNamespace = this.poolNamespace; + return new this.Promise((resolve, reject) => { + corePoolNamespace.getConnection((err, coreConnection) => { + if (err) { + reject(err); + } else { + resolve(new PromisePoolConnection(coreConnection, this.Promise)); + } + }); + }); + } + query(sql, values) { + const corePoolNamespace = this.poolNamespace; + const stackHolder = corePoolNamespace.trace ? captureStackHolder(_PromisePoolNamespace.prototype.query) : void 0; + if (typeof values === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + corePoolNamespace.query(sql, values, done); + }); + } + execute(sql, values) { + const corePoolNamespace = this.poolNamespace; + const stackHolder = corePoolNamespace.trace ? captureStackHolder(_PromisePoolNamespace.prototype.execute) : void 0; + if (typeof values === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + corePoolNamespace.execute(sql, values, done); + }); + } + }; + module2.exports = PromisePoolNamespace; + } +}); + +// node_modules/mysql2/promise.js +var require_promise = __commonJS({ + "node_modules/mysql2/promise.js"(exports2) { + "use strict"; + var SqlString = require_lib(); + var EventEmitter = require("events").EventEmitter; + var parserCache = require_parser_cache(); + var PoolCluster = require_pool_cluster(); + var createConnection = require_create_connection(); + var createPool = require_create_pool(); + var createPoolCluster = require_create_pool_cluster(); + var PromiseConnection = require_connection2(); + var PromisePool = require_pool2(); + var { + captureStackHolder, + applyCapturedStack + } = require_capture_local_err(); + var makeDoneCb = require_make_done_cb(); + var PromisePoolConnection = require_pool_connection(); + var inheritEvents = require_inherit_events(); + var PromisePoolNamespace = require_pool_cluster2(); + function createConnectionPromise(opts) { + const coreConnection = createConnection(opts); + const stackHolder = captureStackHolder(createConnectionPromise); + const thePromise = opts.Promise || Promise; + if (!thePromise) { + throw new Error( + "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }" + ); + } + return new thePromise((resolve, reject) => { + coreConnection.once("connect", () => { + resolve(new PromiseConnection(coreConnection, thePromise)); + }); + coreConnection.once("error", (err) => { + applyCapturedStack(err, stackHolder); + reject(err); + }); + }); + } + function createPromisePool(opts) { + const corePool = createPool(opts); + const thePromise = opts.Promise || Promise; + if (!thePromise) { + throw new Error( + "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }" + ); + } + return new PromisePool(corePool, thePromise); + } + var PromisePoolCluster = class _PromisePoolCluster extends EventEmitter { + constructor(poolCluster, thePromise) { + super(); + this.poolCluster = poolCluster; + this.Promise = thePromise || Promise; + inheritEvents(poolCluster, this, ["warn", "remove", "online", "offline"]); + } + getConnection(pattern, selector) { + const corePoolCluster = this.poolCluster; + return new this.Promise((resolve, reject) => { + corePoolCluster.getConnection( + pattern, + selector, + (err, coreConnection) => { + if (err) { + reject(err); + } else { + resolve(new PromisePoolConnection(coreConnection, this.Promise)); + } + } + ); + }); + } + query(sql, args) { + const corePoolCluster = this.poolCluster; + const stackHolder = captureStackHolder(_PromisePoolCluster.prototype.query); + if (typeof args === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + corePoolCluster.query(sql, args, done); + }); + } + execute(sql, args) { + const corePoolCluster = this.poolCluster; + const stackHolder = captureStackHolder( + _PromisePoolCluster.prototype.execute + ); + if (typeof args === "function") { + throw new Error( + "Callback function is not available with promise clients." + ); + } + return new this.Promise((resolve, reject) => { + const done = makeDoneCb(resolve, reject, stackHolder); + corePoolCluster.execute(sql, args, done); + }); + } + of(pattern, selector) { + return new PromisePoolNamespace( + this.poolCluster.of(pattern, selector), + this.Promise + ); + } + end() { + const corePoolCluster = this.poolCluster; + const stackHolder = captureStackHolder(_PromisePoolCluster.prototype.end); + return new this.Promise((resolve, reject) => { + corePoolCluster.end((err) => { + if (err) { + applyCapturedStack(err, stackHolder); + reject(err); + } else { + resolve(); + } + }); + }); + } + async [Symbol.asyncDispose]() { + if (!this.poolCluster._closed) { + await this.end(); + } + } + }; + (function(functionsToWrap) { + for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) { + const func = functionsToWrap[i]; + if (typeof PoolCluster.prototype[func] === "function" && PromisePoolCluster.prototype[func] === void 0) { + PromisePoolCluster.prototype[func] = /* @__PURE__ */ (function factory(funcName) { + return function() { + return PoolCluster.prototype[funcName].apply( + this.poolCluster, + arguments + ); + }; + })(func); + } + } + })(["add", "remove"]); + function createPromisePoolCluster(opts) { + const corePoolCluster = createPoolCluster(opts); + const thePromise = opts && opts.Promise || Promise; + if (!thePromise) { + throw new Error( + "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }" + ); + } + return new PromisePoolCluster(corePoolCluster, thePromise); + } + exports2.createConnection = createConnectionPromise; + exports2.createPool = createPromisePool; + exports2.createPoolCluster = createPromisePoolCluster; + exports2.escape = SqlString.escape; + exports2.escapeId = SqlString.escapeId; + exports2.format = SqlString.format; + exports2.raw = SqlString.raw; + exports2.Connection = PromiseConnection; + exports2.PoolConnection = PromisePoolConnection; + exports2.PromisePool = PromisePool; + exports2.PromiseConnection = PromiseConnection; + exports2.PromisePoolConnection = PromisePoolConnection; + exports2.__defineGetter__("Types", () => require_types()); + exports2.__defineGetter__( + "TypedParameter", + () => require_typed_parameter().types + ); + exports2.__defineGetter__( + "Charsets", + () => require_charsets() + ); + exports2.__defineGetter__( + "CharsetToEncoding", + () => require_charset_encodings() + ); + exports2.setMaxParserCache = function(max) { + parserCache.setMaxCache(max); + }; + exports2.clearParserCache = function() { + parserCache.clearCache(); + }; + } +}); + +// node_modules/postgres-array/index.js +var require_postgres_array = __commonJS({ + "node_modules/postgres-array/index.js"(exports2) { + "use strict"; + exports2.parse = function(source, transform) { + return new ArrayParser(source, transform).parse(); + }; + var ArrayParser = class _ArrayParser { + constructor(source, transform) { + this.source = source; + this.transform = transform || identity; + this.position = 0; + this.entries = []; + this.recorded = []; + this.dimension = 0; + } + isEof() { + return this.position >= this.source.length; + } + nextCharacter() { + var character = this.source[this.position++]; + if (character === "\\") { + return { + value: this.source[this.position++], + escaped: true + }; + } + return { + value: character, + escaped: false + }; + } + record(character) { + this.recorded.push(character); + } + newEntry(includeEmpty) { + var entry; + if (this.recorded.length > 0 || includeEmpty) { + entry = this.recorded.join(""); + if (entry === "NULL" && !includeEmpty) { + entry = null; + } + if (entry !== null) entry = this.transform(entry); + this.entries.push(entry); + this.recorded = []; + } + } + consumeDimensions() { + if (this.source[0] === "[") { + while (!this.isEof()) { + var char = this.nextCharacter(); + if (char.value === "=") break; + } + } + } + parse(nested) { + var character, parser, quote; + this.consumeDimensions(); + while (!this.isEof()) { + character = this.nextCharacter(); + if (character.value === "{" && !quote) { + this.dimension++; + if (this.dimension > 1) { + parser = new _ArrayParser(this.source.substr(this.position - 1), this.transform); + this.entries.push(parser.parse(true)); + this.position += parser.position - 2; + } + } else if (character.value === "}" && !quote) { + this.dimension--; + if (!this.dimension) { + this.newEntry(); + if (nested) return this.entries; + } + } else if (character.value === '"' && !character.escaped) { + if (quote) this.newEntry(true); + quote = !quote; + } else if (character.value === "," && !quote) { + this.newEntry(); + } else { + this.record(character.value); + } + } + if (this.dimension !== 0) { + throw new Error("array dimension not balanced"); + } + return this.entries; + } + }; + function identity(value) { + return value; + } + } +}); + +// node_modules/pg-types/lib/arrayParser.js +var require_arrayParser = __commonJS({ + "node_modules/pg-types/lib/arrayParser.js"(exports2, module2) { + var array = require_postgres_array(); + module2.exports = { + create: function(source, transform) { + return { + parse: function() { + return array.parse(source, transform); + } + }; + } + }; + } +}); + +// node_modules/postgres-date/index.js +var require_postgres_date = __commonJS({ + "node_modules/postgres-date/index.js"(exports2, module2) { + "use strict"; + var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/; + var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/; + var TIME_ZONE = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/; + var INFINITY = /^-?infinity$/; + module2.exports = function parseDate(isoDate) { + if (INFINITY.test(isoDate)) { + return Number(isoDate.replace("i", "I")); + } + var matches = DATE_TIME.exec(isoDate); + if (!matches) { + return getDate(isoDate) || null; + } + var isBC = !!matches[8]; + var year = parseInt(matches[1], 10); + if (isBC) { + year = bcYearToNegativeYear(year); + } + var month = parseInt(matches[2], 10) - 1; + var day = matches[3]; + var hour = parseInt(matches[4], 10); + var minute = parseInt(matches[5], 10); + var second = parseInt(matches[6], 10); + var ms = matches[7]; + ms = ms ? 1e3 * parseFloat(ms) : 0; + var date; + var offset = timeZoneOffset(isoDate); + if (offset != null) { + date = new Date(Date.UTC(year, month, day, hour, minute, second, ms)); + if (is0To99(year)) { + date.setUTCFullYear(year); + } + if (offset !== 0) { + date.setTime(date.getTime() - offset); + } + } else { + date = new Date(year, month, day, hour, minute, second, ms); + if (is0To99(year)) { + date.setFullYear(year); + } + } + return date; + }; + function getDate(isoDate) { + var matches = DATE.exec(isoDate); + if (!matches) { + return; + } + var year = parseInt(matches[1], 10); + var isBC = !!matches[4]; + if (isBC) { + year = bcYearToNegativeYear(year); + } + var month = parseInt(matches[2], 10) - 1; + var day = matches[3]; + var date = new Date(year, month, day); + if (is0To99(year)) { + date.setFullYear(year); + } + return date; + } + function timeZoneOffset(isoDate) { + if (isoDate.endsWith("+00")) { + return 0; + } + var zone = TIME_ZONE.exec(isoDate.split(" ")[1]); + if (!zone) return; + var type = zone[1]; + if (type === "Z") { + return 0; + } + var sign = type === "-" ? -1 : 1; + var offset = parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10); + return offset * sign * 1e3; + } + function bcYearToNegativeYear(year) { + return -(year - 1); + } + function is0To99(num) { + return num >= 0 && num < 100; + } + } +}); + +// node_modules/xtend/mutable.js +var require_mutable = __commonJS({ + "node_modules/xtend/mutable.js"(exports2, module2) { + module2.exports = extend; + var hasOwnProperty = Object.prototype.hasOwnProperty; + function extend(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + } + } +}); + +// node_modules/postgres-interval/index.js +var require_postgres_interval = __commonJS({ + "node_modules/postgres-interval/index.js"(exports2, module2) { + "use strict"; + var extend = require_mutable(); + module2.exports = PostgresInterval; + function PostgresInterval(raw) { + if (!(this instanceof PostgresInterval)) { + return new PostgresInterval(raw); + } + extend(this, parse(raw)); + } + var properties = ["seconds", "minutes", "hours", "days", "months", "years"]; + PostgresInterval.prototype.toPostgres = function() { + var filtered = properties.filter(this.hasOwnProperty, this); + if (this.milliseconds && filtered.indexOf("seconds") < 0) { + filtered.push("seconds"); + } + if (filtered.length === 0) return "0"; + return filtered.map(function(property) { + var value = this[property] || 0; + if (property === "seconds" && this.milliseconds) { + value = (value + this.milliseconds / 1e3).toFixed(6).replace(/\.?0+$/, ""); + } + return value + " " + property; + }, this).join(" "); + }; + var propertiesISOEquivalent = { + years: "Y", + months: "M", + days: "D", + hours: "H", + minutes: "M", + seconds: "S" + }; + var dateProperties = ["years", "months", "days"]; + var timeProperties = ["hours", "minutes", "seconds"]; + PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function() { + var datePart = dateProperties.map(buildProperty, this).join(""); + var timePart = timeProperties.map(buildProperty, this).join(""); + return "P" + datePart + "T" + timePart; + function buildProperty(property) { + var value = this[property] || 0; + if (property === "seconds" && this.milliseconds) { + value = (value + this.milliseconds / 1e3).toFixed(6).replace(/0+$/, ""); + } + return value + propertiesISOEquivalent[property]; + } + }; + var NUMBER = "([+-]?\\d+)"; + var YEAR = NUMBER + "\\s+years?"; + var MONTH = NUMBER + "\\s+mons?"; + var DAY = NUMBER + "\\s+days?"; + var TIME = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?"; + var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function(regexString) { + return "(" + regexString + ")?"; + }).join("\\s*")); + var positions = { + years: 2, + months: 4, + days: 6, + hours: 9, + minutes: 10, + seconds: 11, + milliseconds: 12 + }; + var negatives = ["hours", "minutes", "seconds", "milliseconds"]; + function parseMilliseconds(fraction) { + var microseconds = fraction + "000000".slice(fraction.length); + return parseInt(microseconds, 10) / 1e3; + } + function parse(interval) { + if (!interval) return {}; + var matches = INTERVAL.exec(interval); + var isNegative = matches[8] === "-"; + return Object.keys(positions).reduce(function(parsed, property) { + var position = positions[property]; + var value = matches[position]; + if (!value) return parsed; + value = property === "milliseconds" ? parseMilliseconds(value) : parseInt(value, 10); + if (!value) return parsed; + if (isNegative && ~negatives.indexOf(property)) { + value *= -1; + } + parsed[property] = value; + return parsed; + }, {}); + } + } +}); + +// node_modules/postgres-bytea/index.js +var require_postgres_bytea = __commonJS({ + "node_modules/postgres-bytea/index.js"(exports2, module2) { + "use strict"; + var bufferFrom = Buffer.from || Buffer; + module2.exports = function parseBytea(input) { + if (/^\\x/.test(input)) { + return bufferFrom(input.substr(2), "hex"); + } + var output = ""; + var i = 0; + while (i < input.length) { + if (input[i] !== "\\") { + output += input[i]; + ++i; + } else { + if (/[0-7]{3}/.test(input.substr(i + 1, 3))) { + output += String.fromCharCode(parseInt(input.substr(i + 1, 3), 8)); + i += 4; + } else { + var backslashes = 1; + while (i + backslashes < input.length && input[i + backslashes] === "\\") { + backslashes++; + } + for (var k = 0; k < Math.floor(backslashes / 2); ++k) { + output += "\\"; + } + i += Math.floor(backslashes / 2) * 2; + } + } + } + return bufferFrom(output, "binary"); + }; + } +}); + +// node_modules/pg-types/lib/textParsers.js +var require_textParsers = __commonJS({ + "node_modules/pg-types/lib/textParsers.js"(exports2, module2) { + var array = require_postgres_array(); + var arrayParser = require_arrayParser(); + var parseDate = require_postgres_date(); + var parseInterval = require_postgres_interval(); + var parseByteA = require_postgres_bytea(); + function allowNull(fn) { + return function nullAllowed(value) { + if (value === null) return value; + return fn(value); + }; + } + function parseBool(value) { + if (value === null) return value; + return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1"; + } + function parseBoolArray(value) { + if (!value) return null; + return array.parse(value, parseBool); + } + function parseBaseTenInt(string) { + return parseInt(string, 10); + } + function parseIntegerArray(value) { + if (!value) return null; + return array.parse(value, allowNull(parseBaseTenInt)); + } + function parseBigIntegerArray(value) { + if (!value) return null; + return array.parse(value, allowNull(function(entry) { + return parseBigInteger(entry).trim(); + })); + } + var parsePointArray = function(value) { + if (!value) { + return null; + } + var p = arrayParser.create(value, function(entry) { + if (entry !== null) { + entry = parsePoint(entry); + } + return entry; + }); + return p.parse(); + }; + var parseFloatArray = function(value) { + if (!value) { + return null; + } + var p = arrayParser.create(value, function(entry) { + if (entry !== null) { + entry = parseFloat(entry); + } + return entry; + }); + return p.parse(); + }; + var parseStringArray = function(value) { + if (!value) { + return null; + } + var p = arrayParser.create(value); + return p.parse(); + }; + var parseDateArray = function(value) { + if (!value) { + return null; + } + var p = arrayParser.create(value, function(entry) { + if (entry !== null) { + entry = parseDate(entry); + } + return entry; + }); + return p.parse(); + }; + var parseIntervalArray = function(value) { + if (!value) { + return null; + } + var p = arrayParser.create(value, function(entry) { + if (entry !== null) { + entry = parseInterval(entry); + } + return entry; + }); + return p.parse(); + }; + var parseByteAArray = function(value) { + if (!value) { + return null; + } + return array.parse(value, allowNull(parseByteA)); + }; + var parseInteger = function(value) { + return parseInt(value, 10); + }; + var parseBigInteger = function(value) { + var valStr = String(value); + if (/^\d+$/.test(valStr)) { + return valStr; + } + return value; + }; + var parseJsonArray = function(value) { + if (!value) { + return null; + } + return array.parse(value, allowNull(JSON.parse)); + }; + var parsePoint = function(value) { + if (value[0] !== "(") { + return null; + } + value = value.substring(1, value.length - 1).split(","); + return { + x: parseFloat(value[0]), + y: parseFloat(value[1]) + }; + }; + var parseCircle = function(value) { + if (value[0] !== "<" && value[1] !== "(") { + return null; + } + var point = "("; + var radius = ""; + var pointParsed = false; + for (var i = 2; i < value.length - 1; i++) { + if (!pointParsed) { + point += value[i]; + } + if (value[i] === ")") { + pointParsed = true; + continue; + } else if (!pointParsed) { + continue; + } + if (value[i] === ",") { + continue; + } + radius += value[i]; + } + var result = parsePoint(point); + result.radius = parseFloat(radius); + return result; + }; + var init = function(register) { + register(20, parseBigInteger); + register(21, parseInteger); + register(23, parseInteger); + register(26, parseInteger); + register(700, parseFloat); + register(701, parseFloat); + register(16, parseBool); + register(1082, parseDate); + register(1114, parseDate); + register(1184, parseDate); + register(600, parsePoint); + register(651, parseStringArray); + register(718, parseCircle); + register(1e3, parseBoolArray); + register(1001, parseByteAArray); + register(1005, parseIntegerArray); + register(1007, parseIntegerArray); + register(1028, parseIntegerArray); + register(1016, parseBigIntegerArray); + register(1017, parsePointArray); + register(1021, parseFloatArray); + register(1022, parseFloatArray); + register(1231, parseFloatArray); + register(1014, parseStringArray); + register(1015, parseStringArray); + register(1008, parseStringArray); + register(1009, parseStringArray); + register(1040, parseStringArray); + register(1041, parseStringArray); + register(1115, parseDateArray); + register(1182, parseDateArray); + register(1185, parseDateArray); + register(1186, parseInterval); + register(1187, parseIntervalArray); + register(17, parseByteA); + register(114, JSON.parse.bind(JSON)); + register(3802, JSON.parse.bind(JSON)); + register(199, parseJsonArray); + register(3807, parseJsonArray); + register(3907, parseStringArray); + register(2951, parseStringArray); + register(791, parseStringArray); + register(1183, parseStringArray); + register(1270, parseStringArray); + }; + module2.exports = { + init + }; + } +}); + +// node_modules/pg-int8/index.js +var require_pg_int8 = __commonJS({ + "node_modules/pg-int8/index.js"(exports2, module2) { + "use strict"; + var BASE = 1e6; + function readInt8(buffer) { + var high = buffer.readInt32BE(0); + var low = buffer.readUInt32BE(4); + var sign = ""; + if (high < 0) { + high = ~high + (low === 0); + low = ~low + 1 >>> 0; + sign = "-"; + } + var result = ""; + var carry; + var t; + var digits; + var pad; + var l; + var i; + { + carry = high % BASE; + high = high / BASE >>> 0; + t = 4294967296 * carry + low; + low = t / BASE >>> 0; + digits = "" + (t - BASE * low); + if (low === 0 && high === 0) { + return sign + digits + result; + } + pad = ""; + l = 6 - digits.length; + for (i = 0; i < l; i++) { + pad += "0"; + } + result = pad + digits + result; + } + { + carry = high % BASE; + high = high / BASE >>> 0; + t = 4294967296 * carry + low; + low = t / BASE >>> 0; + digits = "" + (t - BASE * low); + if (low === 0 && high === 0) { + return sign + digits + result; + } + pad = ""; + l = 6 - digits.length; + for (i = 0; i < l; i++) { + pad += "0"; + } + result = pad + digits + result; + } + { + carry = high % BASE; + high = high / BASE >>> 0; + t = 4294967296 * carry + low; + low = t / BASE >>> 0; + digits = "" + (t - BASE * low); + if (low === 0 && high === 0) { + return sign + digits + result; + } + pad = ""; + l = 6 - digits.length; + for (i = 0; i < l; i++) { + pad += "0"; + } + result = pad + digits + result; + } + { + carry = high % BASE; + t = 4294967296 * carry + low; + digits = "" + t % BASE; + return sign + digits + result; + } + } + module2.exports = readInt8; + } +}); + +// node_modules/pg-types/lib/binaryParsers.js +var require_binaryParsers = __commonJS({ + "node_modules/pg-types/lib/binaryParsers.js"(exports2, module2) { + var parseInt64 = require_pg_int8(); + var parseBits = function(data, bits, offset, invert, callback) { + offset = offset || 0; + invert = invert || false; + callback = callback || function(lastValue, newValue, bits2) { + return lastValue * Math.pow(2, bits2) + newValue; + }; + var offsetBytes = offset >> 3; + var inv = function(value) { + if (invert) { + return ~value & 255; + } + return value; + }; + var mask = 255; + var firstBits = 8 - offset % 8; + if (bits < firstBits) { + mask = 255 << 8 - bits & 255; + firstBits = bits; + } + if (offset) { + mask = mask >> offset % 8; + } + var result = 0; + if (offset % 8 + bits >= 8) { + result = callback(0, inv(data[offsetBytes]) & mask, firstBits); + } + var bytes = bits + offset >> 3; + for (var i = offsetBytes + 1; i < bytes; i++) { + result = callback(result, inv(data[i]), 8); + } + var lastBits = (bits + offset) % 8; + if (lastBits > 0) { + result = callback(result, inv(data[bytes]) >> 8 - lastBits, lastBits); + } + return result; + }; + var parseFloatFromBits = function(data, precisionBits, exponentBits) { + var bias = Math.pow(2, exponentBits - 1) - 1; + var sign = parseBits(data, 1); + var exponent = parseBits(data, exponentBits, 1); + if (exponent === 0) { + return 0; + } + var precisionBitsCounter = 1; + var parsePrecisionBits = function(lastValue, newValue, bits) { + if (lastValue === 0) { + lastValue = 1; + } + for (var i = 1; i <= bits; i++) { + precisionBitsCounter /= 2; + if ((newValue & 1 << bits - i) > 0) { + lastValue += precisionBitsCounter; + } + } + return lastValue; + }; + var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits); + if (exponent == Math.pow(2, exponentBits + 1) - 1) { + if (mantissa === 0) { + return sign === 0 ? Infinity : -Infinity; + } + return NaN; + } + return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa; + }; + var parseInt16 = function(value) { + if (parseBits(value, 1) == 1) { + return -1 * (parseBits(value, 15, 1, true) + 1); + } + return parseBits(value, 15, 1); + }; + var parseInt32 = function(value) { + if (parseBits(value, 1) == 1) { + return -1 * (parseBits(value, 31, 1, true) + 1); + } + return parseBits(value, 31, 1); + }; + var parseFloat32 = function(value) { + return parseFloatFromBits(value, 23, 8); + }; + var parseFloat64 = function(value) { + return parseFloatFromBits(value, 52, 11); + }; + var parseNumeric = function(value) { + var sign = parseBits(value, 16, 32); + if (sign == 49152) { + return NaN; + } + var weight = Math.pow(1e4, parseBits(value, 16, 16)); + var result = 0; + var digits = []; + var ndigits = parseBits(value, 16); + for (var i = 0; i < ndigits; i++) { + result += parseBits(value, 16, 64 + 16 * i) * weight; + weight /= 1e4; + } + var scale = Math.pow(10, parseBits(value, 16, 48)); + return (sign === 0 ? 1 : -1) * Math.round(result * scale) / scale; + }; + var parseDate = function(isUTC, value) { + var sign = parseBits(value, 1); + var rawValue = parseBits(value, 63, 1); + var result = new Date((sign === 0 ? 1 : -1) * rawValue / 1e3 + 9466848e5); + if (!isUTC) { + result.setTime(result.getTime() + result.getTimezoneOffset() * 6e4); + } + result.usec = rawValue % 1e3; + result.getMicroSeconds = function() { + return this.usec; + }; + result.setMicroSeconds = function(value2) { + this.usec = value2; + }; + result.getUTCMicroSeconds = function() { + return this.usec; + }; + return result; + }; + var parseArray = function(value) { + var dim = parseBits(value, 32); + var flags = parseBits(value, 32, 32); + var elementType = parseBits(value, 32, 64); + var offset = 96; + var dims = []; + for (var i = 0; i < dim; i++) { + dims[i] = parseBits(value, 32, offset); + offset += 32; + offset += 32; + } + var parseElement = function(elementType2) { + var length = parseBits(value, 32, offset); + offset += 32; + if (length == 4294967295) { + return null; + } + var result; + if (elementType2 == 23 || elementType2 == 20) { + result = parseBits(value, length * 8, offset); + offset += length * 8; + return result; + } else if (elementType2 == 25) { + result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3); + return result; + } else { + console.log("ERROR: ElementType not implemented: " + elementType2); + } + }; + var parse = function(dimension, elementType2) { + var array = []; + var i2; + if (dimension.length > 1) { + var count = dimension.shift(); + for (i2 = 0; i2 < count; i2++) { + array[i2] = parse(dimension, elementType2); + } + dimension.unshift(count); + } else { + for (i2 = 0; i2 < dimension[0]; i2++) { + array[i2] = parseElement(elementType2); + } + } + return array; + }; + return parse(dims, elementType); + }; + var parseText = function(value) { + return value.toString("utf8"); + }; + var parseBool = function(value) { + if (value === null) return null; + return parseBits(value, 8) > 0; + }; + var init = function(register) { + register(20, parseInt64); + register(21, parseInt16); + register(23, parseInt32); + register(26, parseInt32); + register(1700, parseNumeric); + register(700, parseFloat32); + register(701, parseFloat64); + register(16, parseBool); + register(1114, parseDate.bind(null, false)); + register(1184, parseDate.bind(null, true)); + register(1e3, parseArray); + register(1007, parseArray); + register(1016, parseArray); + register(1008, parseArray); + register(1009, parseArray); + register(25, parseText); + }; + module2.exports = { + init + }; + } +}); + +// node_modules/pg-types/lib/builtins.js +var require_builtins = __commonJS({ + "node_modules/pg-types/lib/builtins.js"(exports2, module2) { + module2.exports = { + BOOL: 16, + BYTEA: 17, + CHAR: 18, + INT8: 20, + INT2: 21, + INT4: 23, + REGPROC: 24, + TEXT: 25, + OID: 26, + TID: 27, + XID: 28, + CID: 29, + JSON: 114, + XML: 142, + PG_NODE_TREE: 194, + SMGR: 210, + PATH: 602, + POLYGON: 604, + CIDR: 650, + FLOAT4: 700, + FLOAT8: 701, + ABSTIME: 702, + RELTIME: 703, + TINTERVAL: 704, + CIRCLE: 718, + MACADDR8: 774, + MONEY: 790, + MACADDR: 829, + INET: 869, + ACLITEM: 1033, + BPCHAR: 1042, + VARCHAR: 1043, + DATE: 1082, + TIME: 1083, + TIMESTAMP: 1114, + TIMESTAMPTZ: 1184, + INTERVAL: 1186, + TIMETZ: 1266, + BIT: 1560, + VARBIT: 1562, + NUMERIC: 1700, + REFCURSOR: 1790, + REGPROCEDURE: 2202, + REGOPER: 2203, + REGOPERATOR: 2204, + REGCLASS: 2205, + REGTYPE: 2206, + UUID: 2950, + TXID_SNAPSHOT: 2970, + PG_LSN: 3220, + PG_NDISTINCT: 3361, + PG_DEPENDENCIES: 3402, + TSVECTOR: 3614, + TSQUERY: 3615, + GTSVECTOR: 3642, + REGCONFIG: 3734, + REGDICTIONARY: 3769, + JSONB: 3802, + REGNAMESPACE: 4089, + REGROLE: 4096 + }; + } +}); + +// node_modules/pg-types/index.js +var require_pg_types = __commonJS({ + "node_modules/pg-types/index.js"(exports2) { + var textParsers = require_textParsers(); + var binaryParsers = require_binaryParsers(); + var arrayParser = require_arrayParser(); + var builtinTypes = require_builtins(); + exports2.getTypeParser = getTypeParser; + exports2.setTypeParser = setTypeParser; + exports2.arrayParser = arrayParser; + exports2.builtins = builtinTypes; + var typeParsers = { + text: {}, + binary: {} + }; + function noParse(val) { + return String(val); + } + function getTypeParser(oid, format) { + format = format || "text"; + if (!typeParsers[format]) { + return noParse; + } + return typeParsers[format][oid] || noParse; + } + function setTypeParser(oid, format, parseFn) { + if (typeof format == "function") { + parseFn = format; + format = "text"; + } + typeParsers[format][oid] = parseFn; + } + textParsers.init(function(oid, converter) { + typeParsers.text[oid] = converter; + }); + binaryParsers.init(function(oid, converter) { + typeParsers.binary[oid] = converter; + }); + } +}); + +// node_modules/pg/lib/defaults.js +var require_defaults2 = __commonJS({ + "node_modules/pg/lib/defaults.js"(exports2, module2) { + "use strict"; + var user; + try { + user = process.platform === "win32" ? process.env.USERNAME : process.env.USER; + } catch { + } + module2.exports = { + // database host. defaults to localhost + host: "localhost", + // database user's name + user, + // name of database to connect + database: void 0, + // database user's password + password: null, + // a Postgres connection string to be used instead of setting individual connection items + // NOTE: Setting this value will cause it to override any other value (such as database or user) defined + // in the defaults object. + connectionString: void 0, + // database port + port: 5432, + // number of rows to return at a time from a prepared statement's + // portal. 0 will return all rows at once + rows: 0, + // binary result mode + binary: false, + // Connection pool options - see https://github.com/brianc/node-pg-pool + // number of connections to use in connection pool + // 0 will disable connection pooling + max: 10, + // max milliseconds a client can go unused before it is removed + // from the pool and destroyed + idleTimeoutMillis: 3e4, + client_encoding: "", + ssl: false, + // SSL negotiation style: 'postgres' (traditional SSLRequest) or 'direct' + sslnegotiation: void 0, + application_name: void 0, + fallback_application_name: void 0, + options: void 0, + parseInputDatesAsUTC: false, + // max milliseconds any query using this connection will execute for before timing out in error. + // false=unlimited + statement_timeout: false, + // Abort any statement that waits longer than the specified duration in milliseconds while attempting to acquire a lock. + // false=unlimited + lock_timeout: false, + // Terminate any session with an open transaction that has been idle for longer than the specified duration in milliseconds + // false=unlimited + idle_in_transaction_session_timeout: false, + // max milliseconds to wait for query to complete (client side) + query_timeout: false, + connect_timeout: 0, + keepalives: 1, + keepalives_idle: 0 + }; + var pgTypes = require_pg_types(); + var parseBigInteger = pgTypes.getTypeParser(20, "text"); + var parseBigIntegerArray = pgTypes.getTypeParser(1016, "text"); + module2.exports.__defineSetter__("parseInt8", function(val) { + pgTypes.setTypeParser(20, "text", val ? pgTypes.getTypeParser(23, "text") : parseBigInteger); + pgTypes.setTypeParser(1016, "text", val ? pgTypes.getTypeParser(1007, "text") : parseBigIntegerArray); + }); + } +}); + +// node_modules/pg/lib/utils.js +var require_utils = __commonJS({ + "node_modules/pg/lib/utils.js"(exports2, module2) { + "use strict"; + var defaults = require_defaults2(); + var nodeUtils = require("util"); + var { isDate } = require("util/types"); + var invalidDateDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Sending an invalid date to Postgres is deprecated and will throw an error in the next major version of pg. Ensure any Date object passed as a query parameter is valid.", + "PG_INVALID_DATE" + ); + function escapeElement(elementRepresentation) { + const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, '\\"'); + return '"' + escaped + '"'; + } + function arrayString(val) { + let result = "{"; + for (let i = 0; i < val.length; i++) { + if (i > 0) { + result += ","; + } + let item = val[i]; + if (item == null) { + result += "NULL"; + } else if (Array.isArray(item)) { + result += arrayString(item); + } else if (ArrayBuffer.isView(item)) { + if (!(item instanceof Buffer)) { + item = Buffer.from(item.buffer, item.byteOffset, item.byteLength); + } + result += "\\\\x" + item.toString("hex"); + } else { + result += escapeElement(prepareValue(item)); + } + } + result += "}"; + return result; + } + var prepareValue = function(val, seen) { + if (val == null) { + return null; + } + if (typeof val === "object") { + if (val instanceof Buffer) { + return val; + } + if (ArrayBuffer.isView(val)) { + return Buffer.from(val.buffer, val.byteOffset, val.byteLength); + } + if (isDate(val)) { + if (isNaN(val.getTime())) { + invalidDateDeprecationNotice(); + } + if (defaults.parseInputDatesAsUTC) { + return dateToStringUTC(val); + } else { + return dateToString(val); + } + } + if (Array.isArray(val)) { + return arrayString(val); + } + return prepareObject(val, seen); + } + return val.toString(); + }; + function prepareObject(val, seen) { + if (val && typeof val.toPostgres === "function") { + seen = seen || []; + if (seen.indexOf(val) !== -1) { + throw new Error('circular reference detected while preparing "' + val + '" for query'); + } + seen.push(val); + return prepareValue(val.toPostgres(prepareValue), seen); + } + return JSON.stringify(val); + } + function dateToString(date) { + let offset = -date.getTimezoneOffset(); + let year = date.getFullYear(); + const isBCYear = year < 1; + if (isBCYear) year = Math.abs(year) + 1; + let ret = String(year).padStart(4, "0") + "-" + String(date.getMonth() + 1).padStart(2, "0") + "-" + String(date.getDate()).padStart(2, "0") + "T" + String(date.getHours()).padStart(2, "0") + ":" + String(date.getMinutes()).padStart(2, "0") + ":" + String(date.getSeconds()).padStart(2, "0") + "." + String(date.getMilliseconds()).padStart(3, "0"); + if (offset < 0) { + ret += "-"; + offset *= -1; + } else { + ret += "+"; + } + ret += String(Math.floor(offset / 60)).padStart(2, "0") + ":" + String(offset % 60).padStart(2, "0"); + if (isBCYear) ret += " BC"; + return ret; + } + function dateToStringUTC(date) { + let year = date.getUTCFullYear(); + const isBCYear = year < 1; + if (isBCYear) year = Math.abs(year) + 1; + let ret = String(year).padStart(4, "0") + "-" + String(date.getUTCMonth() + 1).padStart(2, "0") + "-" + String(date.getUTCDate()).padStart(2, "0") + "T" + String(date.getUTCHours()).padStart(2, "0") + ":" + String(date.getUTCMinutes()).padStart(2, "0") + ":" + String(date.getUTCSeconds()).padStart(2, "0") + "." + String(date.getUTCMilliseconds()).padStart(3, "0"); + ret += "+00:00"; + if (isBCYear) ret += " BC"; + return ret; + } + function normalizeQueryConfig(config, values, callback) { + config = typeof config === "string" ? { text: config } : cloneQueryConfig(config); + if (values) { + if (typeof values === "function") { + config.callback = values; + } else { + config.values = values; + } + } + if (callback) { + config.callback = callback; + } + return config; + } + function cloneQueryConfig(config) { + if (config == null) { + return config; + } + return Object.defineProperties(Object.create(Object.getPrototypeOf(config)), Object.getOwnPropertyDescriptors(config)); + } + var escapeIdentifier = function(str) { + return '"' + str.replace(/"/g, '""') + '"'; + }; + var escapeLiteral = function(str) { + let hasBackslash = false; + let escaped = "'"; + if (str == null) { + return "''"; + } + if (typeof str !== "string") { + return "''"; + } + for (let i = 0; i < str.length; i++) { + const c = str[i]; + if (c === "'") { + escaped += c + c; + } else if (c === "\\") { + escaped += c + c; + hasBackslash = true; + } else { + escaped += c; + } + } + escaped += "'"; + if (hasBackslash === true) { + escaped = " E" + escaped; + } + return escaped; + }; + module2.exports = { + prepareValue: function prepareValueWrapper(value) { + return prepareValue(value); + }, + normalizeQueryConfig, + escapeIdentifier, + escapeLiteral + }; + } +}); + +// node_modules/pg/lib/crypto/utils.js +var require_utils2 = __commonJS({ + "node_modules/pg/lib/crypto/utils.js"(exports2, module2) { + var nodeCrypto = require("crypto"); + module2.exports = { + postgresMd5PasswordHash, + randomBytes, + deriveKey, + sha256, + hashByName, + hmacSha256, + md5 + }; + var webCrypto = nodeCrypto.webcrypto || globalThis.crypto; + var subtleCrypto = webCrypto.subtle; + var textEncoder = new TextEncoder(); + function randomBytes(length) { + return webCrypto.getRandomValues(Buffer.alloc(length)); + } + async function md5(string) { + try { + return nodeCrypto.createHash("md5").update(string, "utf-8").digest("hex"); + } catch (e) { + const data = typeof string === "string" ? textEncoder.encode(string) : string; + const hash = await subtleCrypto.digest("MD5", data); + return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join(""); + } + } + async function postgresMd5PasswordHash(user, password, salt) { + const inner = await md5(password + user); + const outer = await md5(Buffer.concat([Buffer.from(inner), salt])); + return "md5" + outer; + } + async function sha256(text) { + return await subtleCrypto.digest("SHA-256", text); + } + async function hashByName(hashName, text) { + return await subtleCrypto.digest(hashName, text); + } + async function hmacSha256(keyBuffer, msg) { + const key = await subtleCrypto.importKey("raw", keyBuffer, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]); + return await subtleCrypto.sign("HMAC", key, textEncoder.encode(msg)); + } + async function deriveKey(password, salt, iterations) { + const key = await subtleCrypto.importKey("raw", textEncoder.encode(password), "PBKDF2", false, ["deriveBits"]); + const params = { name: "PBKDF2", hash: "SHA-256", salt, iterations }; + return await subtleCrypto.deriveBits(params, key, 32 * 8, ["deriveBits"]); + } + } +}); + +// node_modules/pg/lib/crypto/cert-signatures.js +var require_cert_signatures = __commonJS({ + "node_modules/pg/lib/crypto/cert-signatures.js"(exports2, module2) { + function x509Error(msg, cert) { + return new Error("SASL channel binding: " + msg + " when parsing public certificate " + cert.toString("base64")); + } + function readASN1Length(data, index) { + let length = data[index++]; + if (length < 128) return { length, index }; + const lengthBytes = length & 127; + if (lengthBytes > 4) throw x509Error("bad length", data); + length = 0; + for (let i = 0; i < lengthBytes; i++) { + length = length << 8 | data[index++]; + } + return { length, index }; + } + function readASN1OID(data, index) { + if (data[index++] !== 6) throw x509Error("non-OID data", data); + const { length: OIDLength, index: indexAfterOIDLength } = readASN1Length(data, index); + index = indexAfterOIDLength; + const lastIndex = index + OIDLength; + const byte1 = data[index++]; + let oid = (byte1 / 40 >> 0) + "." + byte1 % 40; + while (index < lastIndex) { + let value = 0; + while (index < lastIndex) { + const nextByte = data[index++]; + value = value << 7 | nextByte & 127; + if (nextByte < 128) break; + } + oid += "." + value; + } + return { oid, index }; + } + function expectASN1Seq(data, index) { + if (data[index++] !== 48) throw x509Error("non-sequence data", data); + return readASN1Length(data, index); + } + function signatureAlgorithmHashFromCertificate(data, index) { + if (index === void 0) index = 0; + index = expectASN1Seq(data, index).index; + const { length: certInfoLength, index: indexAfterCertInfoLength } = expectASN1Seq(data, index); + index = indexAfterCertInfoLength + certInfoLength; + index = expectASN1Seq(data, index).index; + const { oid, index: indexAfterOID } = readASN1OID(data, index); + switch (oid) { + // RSA + case "1.2.840.113549.1.1.4": + return "MD5"; + case "1.2.840.113549.1.1.5": + return "SHA-1"; + case "1.2.840.113549.1.1.11": + return "SHA-256"; + case "1.2.840.113549.1.1.12": + return "SHA-384"; + case "1.2.840.113549.1.1.13": + return "SHA-512"; + case "1.2.840.113549.1.1.14": + return "SHA-224"; + case "1.2.840.113549.1.1.15": + return "SHA512-224"; + case "1.2.840.113549.1.1.16": + return "SHA512-256"; + // ECDSA + case "1.2.840.10045.4.1": + return "SHA-1"; + case "1.2.840.10045.4.3.1": + return "SHA-224"; + case "1.2.840.10045.4.3.2": + return "SHA-256"; + case "1.2.840.10045.4.3.3": + return "SHA-384"; + case "1.2.840.10045.4.3.4": + return "SHA-512"; + // RSASSA-PSS: hash is indicated separately + case "1.2.840.113549.1.1.10": { + index = indexAfterOID; + index = expectASN1Seq(data, index).index; + if (data[index++] !== 160) throw x509Error("non-tag data", data); + index = readASN1Length(data, index).index; + index = expectASN1Seq(data, index).index; + const { oid: hashOID } = readASN1OID(data, index); + switch (hashOID) { + // standalone hash OIDs + case "1.2.840.113549.2.5": + return "MD5"; + case "1.3.14.3.2.26": + return "SHA-1"; + case "2.16.840.1.101.3.4.2.1": + return "SHA-256"; + case "2.16.840.1.101.3.4.2.2": + return "SHA-384"; + case "2.16.840.1.101.3.4.2.3": + return "SHA-512"; + } + throw x509Error("unknown hash OID " + hashOID, data); + } + // Ed25519 -- see https://github.com/openssl/openssl/issues/15477 + case "1.3.101.110": + case "1.3.101.112": + return "SHA-512"; + // Ed448 -- still not in pg 17.2 (if supported, digest would be SHAKE256 x 64 bytes) + case "1.3.101.111": + case "1.3.101.113": + throw x509Error("Ed448 certificate channel binding is not currently supported by Postgres"); + } + throw x509Error("unknown OID " + oid, data); + } + module2.exports = { signatureAlgorithmHashFromCertificate }; + } +}); + +// node_modules/pg/lib/crypto/sasl.js +var require_sasl = __commonJS({ + "node_modules/pg/lib/crypto/sasl.js"(exports2, module2) { + "use strict"; + var crypto = require_utils2(); + var { signatureAlgorithmHashFromCertificate } = require_cert_signatures(); + function saslprep(password) { + const nonAsciiSpace = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g; + const mappedToNothing = /[\u00AD\u034F\u1806\u180B\u180C\u180D\u200C\u200D\u2060\uFE00-\uFE0F\uFEFF]/g; + return password.replace(nonAsciiSpace, " ").replace(mappedToNothing, "").normalize("NFKC"); + } + var DEFAULT_MAX_SCRAM_ITERATIONS = 1e5; + function startSession(mechanisms, stream, scramMaxIterations = DEFAULT_MAX_SCRAM_ITERATIONS) { + const candidates = ["SCRAM-SHA-256"]; + if (stream) candidates.unshift("SCRAM-SHA-256-PLUS"); + const mechanism = candidates.find((candidate) => mechanisms.includes(candidate)); + if (!mechanism) { + throw new Error("SASL: Only mechanism(s) " + candidates.join(" and ") + " are supported"); + } + if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream.getPeerCertificate !== "function") { + throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate"); + } + const clientNonce = crypto.randomBytes(18).toString("base64"); + const gs2Header = mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream ? "y" : "n"; + return { + mechanism, + clientNonce, + response: gs2Header + ",,n=*,r=" + clientNonce, + message: "SASLInitialResponse", + scramMaxIterations + }; + } + async function continueSession(session, password, serverData, stream) { + if (session.message !== "SASLInitialResponse") { + throw new Error("SASL: Last message was not SASLInitialResponse"); + } + if (typeof password !== "string") { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string"); + } + if (password === "") { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a non-empty string"); + } + if (typeof serverData !== "string") { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string"); + } + const sv = parseServerFirstMessage(serverData); + if (!sv.nonce.startsWith(session.clientNonce)) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce"); + } else if (sv.nonce.length === session.clientNonce.length) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short"); + } + const scramMaxIterations = typeof session.scramMaxIterations === "number" ? session.scramMaxIterations : DEFAULT_MAX_SCRAM_ITERATIONS; + if (scramMaxIterations !== 0 && sv.iteration > scramMaxIterations) { + throw new Error( + "SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration count " + sv.iteration + " exceeds scramMaxIterations of " + scramMaxIterations + ); + } + const clientFirstMessageBare = "n=*,r=" + session.clientNonce; + const serverFirstMessage = "r=" + sv.nonce + ",s=" + sv.salt + ",i=" + sv.iteration; + let channelBinding = stream ? "eSws" : "biws"; + if (session.mechanism === "SCRAM-SHA-256-PLUS") { + const peerCert = stream.getPeerCertificate().raw; + let hashName = signatureAlgorithmHashFromCertificate(peerCert); + if (hashName === "MD5" || hashName === "SHA-1") hashName = "SHA-256"; + const certHash = await crypto.hashByName(hashName, peerCert); + const bindingData = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]); + channelBinding = bindingData.toString("base64"); + } + const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce; + const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof; + const saltBytes = Buffer.from(sv.salt, "base64"); + const saltedPassword = await crypto.deriveKey(saslprep(password), saltBytes, sv.iteration); + const clientKey = await crypto.hmacSha256(saltedPassword, "Client Key"); + const storedKey = await crypto.sha256(clientKey); + const clientSignature = await crypto.hmacSha256(storedKey, authMessage); + const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64"); + const serverKey = await crypto.hmacSha256(saltedPassword, "Server Key"); + const serverSignatureBytes = await crypto.hmacSha256(serverKey, authMessage); + session.message = "SASLResponse"; + session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64"); + session.response = clientFinalMessageWithoutProof + ",p=" + clientProof; + } + function finalizeSession(session, serverData) { + if (session.message !== "SASLResponse") { + throw new Error("SASL: Last message was not SASLResponse"); + } + if (typeof serverData !== "string") { + throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string"); + } + const { serverSignature } = parseServerFinalMessage(serverData); + if (serverSignature !== session.serverSignature) { + throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match"); + } + } + function isPrintableChars(text) { + if (typeof text !== "string") { + throw new TypeError("SASL: text must be a string"); + } + return text.split("").map((_, i) => text.charCodeAt(i)).every((c) => c >= 33 && c <= 43 || c >= 45 && c <= 126); + } + function isBase64(text) { + return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(text); + } + function parseAttributePairs(text) { + if (typeof text !== "string") { + throw new TypeError("SASL: attribute pairs text must be a string"); + } + return new Map( + text.split(",").map((attrValue) => { + if (!/^.=/.test(attrValue)) { + throw new Error("SASL: Invalid attribute pair entry"); + } + const name = attrValue[0]; + const value = attrValue.substring(2); + return [name, value]; + }) + ); + } + function parseServerFirstMessage(data) { + const attrPairs = parseAttributePairs(data); + const nonce = attrPairs.get("r"); + if (!nonce) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing"); + } else if (!isPrintableChars(nonce)) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters"); + } + const salt = attrPairs.get("s"); + if (!salt) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing"); + } else if (!isBase64(salt)) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64"); + } + const iterationText = attrPairs.get("i"); + if (!iterationText) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing"); + } else if (!/^[1-9][0-9]*$/.test(iterationText)) { + throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count"); + } + const iteration = parseInt(iterationText, 10); + return { + nonce, + salt, + iteration + }; + } + function parseServerFinalMessage(serverData) { + const attrPairs = parseAttributePairs(serverData); + const error = attrPairs.get("e"); + const serverSignature = attrPairs.get("v"); + if (error) { + throw new Error(`SASL: SCRAM-SERVER-FINAL-MESSAGE: server returned error: "${error}"`); + } + if (!serverSignature) { + throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing"); + } else if (!isBase64(serverSignature)) { + throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64"); + } + return { + serverSignature + }; + } + function xorBuffers(a, b) { + if (!Buffer.isBuffer(a)) { + throw new TypeError("first argument must be a Buffer"); + } + if (!Buffer.isBuffer(b)) { + throw new TypeError("second argument must be a Buffer"); + } + if (a.length !== b.length) { + throw new Error("Buffer lengths must match"); + } + if (a.length === 0) { + throw new Error("Buffers cannot be empty"); + } + return Buffer.from(a.map((_, i) => a[i] ^ b[i])); + } + module2.exports = { + startSession, + continueSession, + finalizeSession, + DEFAULT_MAX_SCRAM_ITERATIONS + }; + } +}); + +// node_modules/pg/lib/type-overrides.js +var require_type_overrides = __commonJS({ + "node_modules/pg/lib/type-overrides.js"(exports2, module2) { + "use strict"; + var types = require_pg_types(); + function TypeOverrides(userTypes) { + this._types = userTypes || types; + this.text = {}; + this.binary = {}; + } + TypeOverrides.prototype.getOverrides = function(format) { + switch (format) { + case "text": + return this.text; + case "binary": + return this.binary; + default: + return {}; + } + }; + TypeOverrides.prototype.setTypeParser = function(oid, format, parseFn) { + if (typeof format === "function") { + parseFn = format; + format = "text"; + } + this.getOverrides(format)[oid] = parseFn; + }; + TypeOverrides.prototype.getTypeParser = function(oid, format) { + format = format || "text"; + return this.getOverrides(format)[oid] || this._types.getTypeParser(oid, format); + }; + module2.exports = TypeOverrides; + } +}); + +// node_modules/pg-connection-string/index.js +var require_pg_connection_string = __commonJS({ + "node_modules/pg-connection-string/index.js"(exports2, module2) { + "use strict"; + function parse(str, options = {}) { + if (str.charAt(0) === "/") { + const config2 = str.split(" "); + return { host: config2[0], database: config2[1] }; + } + const config = /* @__PURE__ */ Object.create(null); + let result; + let dummyHost = false; + if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) { + str = encodeURI(str).replace(/%25(\d\d)/g, "%$1"); + } + try { + try { + result = new URL(str, "postgres://base"); + } catch (e) { + result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base"); + dummyHost = true; + } + } catch (err) { + err.input && (err.input = "*****REDACTED*****"); + throw err; + } + for (const entry of result.searchParams.entries()) { + config[entry[0]] = entry[1]; + } + config.user = config.user || decodeURIComponent(result.username); + config.password = config.password || decodeURIComponent(result.password); + if (result.protocol == "socket:") { + config.host = decodeURI(result.pathname); + config.database = result.searchParams.get("db"); + config.client_encoding = result.searchParams.get("encoding"); + return config; + } + const hostname = (dummyHost ? "" : result.hostname).replace(/^\[(.+)\]$/, "$1"); + if (!config.host) { + config.host = decodeURIComponent(hostname); + } else if (hostname && /^%2f/i.test(hostname)) { + result.pathname = hostname + result.pathname; + } + if (!config.port) { + config.port = result.port; + } + const pathname = result.pathname.slice(1) || null; + config.database = pathname ? decodeURI(pathname) : null; + if (config.ssl === "true" || config.ssl === "1") { + config.ssl = true; + } + if (config.ssl === "0") { + config.ssl = false; + } + if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) { + config.ssl = {}; + } + if (config.sslnegotiation === "direct" && config.ssl === void 0) { + config.ssl = true; + } + const fs = config.sslcert || config.sslkey || config.sslrootcert ? require("fs") : null; + if (config.sslcert) { + config.ssl.cert = fs.readFileSync(config.sslcert).toString(); + } + if (config.sslkey) { + config.ssl.key = fs.readFileSync(config.sslkey).toString(); + } + if (config.sslrootcert) { + config.ssl.ca = fs.readFileSync(config.sslrootcert).toString(); + } + if (options.useLibpqCompat && config.uselibpqcompat) { + throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them."); + } + if (config.uselibpqcompat === "true" || options.useLibpqCompat) { + switch (config.sslmode) { + case "disable": { + config.ssl = false; + break; + } + case "prefer": { + config.ssl.rejectUnauthorized = false; + break; + } + case "require": { + if (config.sslrootcert) { + config.ssl.checkServerIdentity = function() { + }; + } else { + config.ssl.rejectUnauthorized = false; + } + break; + } + case "verify-ca": { + if (!config.ssl.ca) { + throw new Error( + "SECURITY WARNING: Using sslmode=verify-ca requires specifying a CA with sslrootcert. If a public CA is used, verify-ca allows connections to a server that somebody else may have registered with the CA, making you vulnerable to Man-in-the-Middle attacks. Either specify a custom CA certificate with sslrootcert parameter or use sslmode=verify-full for proper security." + ); + } + config.ssl.checkServerIdentity = function() { + }; + break; + } + case "verify-full": { + break; + } + } + } else { + switch (config.sslmode) { + case "disable": { + config.ssl = false; + break; + } + case "prefer": + case "require": + case "verify-ca": + case "verify-full": { + if (config.sslmode !== "verify-full") { + deprecatedSslModeWarning(config.sslmode); + } + break; + } + case "no-verify": { + config.ssl.rejectUnauthorized = false; + break; + } + } + } + return config; + } + function toConnectionOptions(sslConfig) { + const connectionOptions = Object.entries(sslConfig).reduce((c, [key, value]) => { + if (value !== void 0 && value !== null) { + c[key] = value; + } + return c; + }, /* @__PURE__ */ Object.create(null)); + return connectionOptions; + } + function toClientConfig(config) { + const poolConfig = Object.entries(config).reduce((c, [key, value]) => { + if (key === "ssl") { + const sslConfig = value; + if (typeof sslConfig === "boolean") { + c[key] = sslConfig; + } + if (typeof sslConfig === "object") { + c[key] = toConnectionOptions(sslConfig); + } + } else if (value !== void 0 && value !== null) { + if (key === "port") { + if (value !== "") { + const v = parseInt(value, 10); + if (isNaN(v)) { + throw new Error(`Invalid ${key}: ${value}`); + } + c[key] = v; + } + } else { + c[key] = value; + } + } + return c; + }, /* @__PURE__ */ Object.create(null)); + return poolConfig; + } + function parseIntoClientConfig(str) { + return toClientConfig(parse(str)); + } + function deprecatedSslModeWarning(sslmode) { + if (!deprecatedSslModeWarning.warned && typeof process !== "undefined" && process.emitWarning) { + deprecatedSslModeWarning.warned = true; + process.emitWarning(`SECURITY WARNING: The SSL modes 'prefer', 'require', and 'verify-ca' are treated as aliases for 'verify-full'. +In the next major version (pg-connection-string v3.0.0 and pg v9.0.0), these modes will adopt standard libpq semantics, which have weaker security guarantees. + +To prepare for this change: +- If you want the current behavior, explicitly use 'sslmode=verify-full' +- If you want libpq compatibility now, use 'uselibpqcompat=true&sslmode=${sslmode}' + +See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode definitions.`); + } + } + module2.exports = parse; + parse.parse = parse; + parse.toClientConfig = toClientConfig; + parse.parseIntoClientConfig = parseIntoClientConfig; + } +}); + +// node_modules/pg/lib/connection-parameters.js +var require_connection_parameters = __commonJS({ + "node_modules/pg/lib/connection-parameters.js"(exports2, module2) { + "use strict"; + var dns = require("dns"); + var defaults = require_defaults2(); + var parse = require_pg_connection_string().parse; + var val = function(key, config, envVar) { + if (config[key]) { + return config[key]; + } + if (envVar === void 0) { + envVar = process.env["PG" + key.toUpperCase()]; + } else if (envVar === false) { + } else { + envVar = process.env[envVar]; + } + return envVar || defaults[key]; + }; + var readSSLConfigFromEnvironment = function() { + switch (process.env.PGSSLMODE) { + case "disable": + return false; + case "prefer": + case "require": + case "verify-ca": + case "verify-full": + return true; + case "no-verify": + return { rejectUnauthorized: false }; + } + return defaults.ssl; + }; + var quoteParamValue = function(value) { + return "'" + ("" + value).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'"; + }; + var add = function(params, config, paramName) { + const value = config[paramName]; + if (value !== void 0 && value !== null) { + params.push(paramName + "=" + quoteParamValue(value)); + } + }; + var ConnectionParameters = class { + constructor(config) { + config = typeof config === "string" ? parse(config) : config || {}; + if (config.connectionString) { + config = Object.assign({}, config, parse(config.connectionString)); + } + this.user = val("user", config); + this.database = val("database", config); + if (this.database === void 0) { + this.database = this.user; + } + this.port = parseInt(val("port", config), 10); + this.host = val("host", config); + Object.defineProperty(this, "password", { + configurable: true, + enumerable: false, + writable: true, + value: val("password", config) + }); + this.binary = val("binary", config); + this.options = val("options", config); + this.ssl = typeof config.ssl === "undefined" ? readSSLConfigFromEnvironment() : config.ssl; + if (typeof this.ssl === "string") { + if (this.ssl === "true") { + this.ssl = true; + } + } + if (this.ssl === "no-verify") { + this.ssl = { rejectUnauthorized: false }; + } + if (this.ssl && this.ssl.key) { + Object.defineProperty(this.ssl, "key", { + enumerable: false + }); + } + this.sslnegotiation = val("sslnegotiation", config, "PGSSLNEGOTIATION"); + if (this.sslnegotiation !== void 0 && this.sslnegotiation !== "postgres" && this.sslnegotiation !== "direct") { + throw new Error( + `Invalid sslnegotiation value: "${this.sslnegotiation}". Valid values are "postgres" and "direct".` + ); + } + if (this.sslnegotiation === "direct" && !this.ssl) { + throw new Error("sslnegotiation=direct requires SSL to be enabled"); + } + this.client_encoding = val("client_encoding", config); + this.replication = val("replication", config); + this.isDomainSocket = !(this.host || "").indexOf("/"); + this.application_name = val("application_name", config, "PGAPPNAME"); + this.fallback_application_name = val("fallback_application_name", config, false); + this.statement_timeout = val("statement_timeout", config, false); + this.lock_timeout = val("lock_timeout", config, false); + this.idle_in_transaction_session_timeout = val("idle_in_transaction_session_timeout", config, false); + this.query_timeout = val("query_timeout", config, false); + if (config.connectionTimeoutMillis === void 0) { + this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0; + } else { + this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1e3); + } + if (config.keepAlive === false) { + this.keepalives = 0; + } else if (config.keepAlive === true) { + this.keepalives = 1; + } + if (typeof config.keepAliveInitialDelayMillis === "number") { + this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1e3); + } + } + getLibpqConnectionString(cb) { + const params = []; + add(params, this, "user"); + add(params, this, "password"); + add(params, this, "port"); + add(params, this, "application_name"); + add(params, this, "fallback_application_name"); + add(params, this, "connect_timeout"); + add(params, this, "options"); + const ssl = typeof this.ssl === "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {}; + add(params, ssl, "sslmode"); + add(params, ssl, "sslca"); + add(params, ssl, "sslkey"); + add(params, ssl, "sslcert"); + add(params, ssl, "sslrootcert"); + add(params, this, "sslnegotiation"); + if (this.database) { + params.push("dbname=" + quoteParamValue(this.database)); + } + if (this.replication) { + params.push("replication=" + quoteParamValue(this.replication)); + } + if (this.host) { + params.push("host=" + quoteParamValue(this.host)); + } + if (this.isDomainSocket) { + return cb(null, params.join(" ")); + } + if (this.client_encoding) { + params.push("client_encoding=" + quoteParamValue(this.client_encoding)); + } + dns.lookup(this.host, function(err, address) { + if (err) return cb(err, null); + params.push("hostaddr=" + quoteParamValue(address)); + return cb(null, params.join(" ")); + }); + } + }; + module2.exports = ConnectionParameters; + } +}); + +// node_modules/pg/lib/result.js +var require_result = __commonJS({ + "node_modules/pg/lib/result.js"(exports2, module2) { + "use strict"; + var types = require_pg_types(); + var matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/; + var Result = class { + constructor(rowMode, types2) { + this.command = null; + this.rowCount = null; + this.oid = null; + this.rows = []; + this.fields = []; + this._parsers = void 0; + this._types = types2; + this.RowCtor = null; + this.rowAsArray = rowMode === "array"; + if (this.rowAsArray) { + this.parseRow = this._parseRowAsArray; + } + this._prebuiltEmptyResultObject = null; + } + // adds a command complete message + addCommandComplete(msg) { + let match; + if (msg.text) { + match = matchRegexp.exec(msg.text); + } else { + match = matchRegexp.exec(msg.command); + } + if (match) { + this.command = match[1]; + if (match[3]) { + this.oid = parseInt(match[2], 10); + this.rowCount = parseInt(match[3], 10); + } else if (match[2]) { + this.rowCount = parseInt(match[2], 10); + } + } + } + _parseRowAsArray(rowData) { + const row = new Array(rowData.length); + for (let i = 0, len = rowData.length; i < len; i++) { + const rawValue = rowData[i]; + if (rawValue !== null) { + row[i] = this._parsers[i](rawValue); + } else { + row[i] = null; + } + } + return row; + } + parseRow(rowData) { + const row = { ...this._prebuiltEmptyResultObject }; + for (let i = 0, len = rowData.length; i < len; i++) { + const rawValue = rowData[i]; + const field = this.fields[i].name; + if (rawValue !== null) { + const v = this.fields[i].format === "binary" ? Buffer.from(rawValue) : rawValue; + row[field] = this._parsers[i](v); + } else { + row[field] = null; + } + } + return row; + } + addRow(row) { + this.rows.push(row); + } + addFields(fieldDescriptions) { + this.fields = fieldDescriptions; + if (this.fields.length) { + this._parsers = new Array(fieldDescriptions.length); + } + const row = /* @__PURE__ */ Object.create(null); + for (let i = 0; i < fieldDescriptions.length; i++) { + const desc = fieldDescriptions[i]; + row[desc.name] = null; + if (this._types) { + this._parsers[i] = this._types.getTypeParser(desc.dataTypeID, desc.format || "text"); + } else { + this._parsers[i] = types.getTypeParser(desc.dataTypeID, desc.format || "text"); + } + } + this._prebuiltEmptyResultObject = { ...row }; + } + }; + module2.exports = Result; + } +}); + +// node_modules/pg/lib/query.js +var require_query3 = __commonJS({ + "node_modules/pg/lib/query.js"(exports2, module2) { + "use strict"; + var { EventEmitter } = require("events"); + var Result = require_result(); + var utils = require_utils(); + var Query = class extends EventEmitter { + constructor(config, values, callback) { + super(); + config = utils.normalizeQueryConfig(config, values, callback); + this.text = config.text; + this.values = config.values; + this.rows = config.rows; + this.types = config.types; + this.name = config.name; + this.queryMode = config.queryMode; + this.binary = config.binary; + this.portal = config.portal || ""; + this.callback = config.callback; + this._rowMode = config.rowMode; + if (process.domain && config.callback) { + this.callback = process.domain.bind(config.callback); + } + this._result = new Result(this._rowMode, this.types); + this._results = this._result; + this._canceledDueToError = false; + } + requiresPreparation() { + if (this.queryMode === "extended") { + return true; + } + if (this.name) { + return true; + } + if (this.rows) { + return true; + } + if (!this.text) { + return false; + } + if (!this.values) { + return false; + } + return this.values.length > 0; + } + _checkForMultirow() { + if (this._result.command) { + if (!Array.isArray(this._results)) { + this._results = [this._result]; + } + this._result = new Result(this._rowMode, this._result._types); + this._results.push(this._result); + } + } + // associates row metadata from the supplied + // message with this query object + // metadata used when parsing row results + handleRowDescription(msg) { + this._checkForMultirow(); + this._result.addFields(msg.fields); + this._accumulateRows = this.callback || !this.listeners("row").length; + } + handleDataRow(msg) { + let row; + if (this._canceledDueToError) { + return; + } + try { + row = this._result.parseRow(msg.fields); + } catch (err) { + this._canceledDueToError = err; + return; + } + this.emit("row", row, this._result); + if (this._accumulateRows) { + this._result.addRow(row); + } + } + handleCommandComplete(msg, connection) { + this._checkForMultirow(); + this._result.addCommandComplete(msg); + if (this.rows) { + connection.sync(); + } + } + // if a named prepared statement is created with empty query text + // the backend will send an emptyQuery message but *not* a command complete message + // since we pipeline sync immediately after execute we don't need to do anything here + // unless we have rows specified, in which case we did not pipeline the initial sync call + handleEmptyQuery(connection) { + if (this.rows) { + connection.sync(); + } + } + handleError(err, connection) { + if (this._canceledDueToError) { + err = this._canceledDueToError; + this._canceledDueToError = false; + } + if (this.callback) { + return this.callback(err); + } + this.emit("error", err); + } + handleReadyForQuery(con) { + if (this._canceledDueToError) { + return this.handleError(this._canceledDueToError, con); + } + if (this.callback) { + try { + this.callback(null, this._results); + } catch (err) { + process.nextTick(() => { + throw err; + }); + } + } + this.emit("end", this._results); + } + submit(connection) { + if (typeof this.text !== "string" && typeof this.name !== "string") { + return new Error("A query must have either text or a name. Supplying neither is unsupported."); + } + const previous = connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name]; + if (this.text && previous && this.text !== previous) { + return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`); + } + if (this.values && !Array.isArray(this.values)) { + return new Error("Query values must be an array"); + } + if (this.requiresPreparation()) { + connection.stream.cork && connection.stream.cork(); + try { + this.prepare(connection); + } finally { + connection.stream.uncork && connection.stream.uncork(); + } + } else { + connection.query(this.text); + } + return null; + } + hasBeenParsed(connection) { + return this.name && (connection.parsedStatements[this.name] !== void 0 || connection.submittedNamedStatements[this.name] !== void 0); + } + handlePortalSuspended(connection) { + this._getRows(connection, this.rows); + } + _getRows(connection, rows) { + connection.execute({ + portal: this.portal, + rows + }); + if (!rows) { + connection.sync(); + } else { + connection.flush(); + } + } + // http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY + prepare(connection) { + if (!this.hasBeenParsed(connection)) { + connection.parse({ + text: this.text, + name: this.name, + types: this.types + }); + if (this.name) { + connection.submittedNamedStatements[this.name] = this.text; + } + } + try { + connection.bind({ + portal: this.portal, + statement: this.name, + values: this.values, + binary: this.binary, + valueMapper: utils.prepareValue + }); + } catch (err) { + connection.close({ type: "S", name: this.name }); + connection.sync(); + this.handleError(err, connection); + return; + } + connection.describe({ + type: "P", + name: this.portal || "" + }); + this._getRows(connection, this.rows); + } + handleCopyInResponse(connection) { + connection.sendCopyFail("No source stream defined"); + } + handleCopyData(msg, connection) { + } + }; + module2.exports = Query; + } +}); + +// node_modules/pg-protocol/dist/messages.js +var require_messages = __commonJS({ + "node_modules/pg-protocol/dist/messages.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.NoticeMessage = exports2.DataRowMessage = exports2.CommandCompleteMessage = exports2.ReadyForQueryMessage = exports2.NotificationResponseMessage = exports2.BackendKeyDataMessage = exports2.AuthenticationMD5Password = exports2.ParameterStatusMessage = exports2.ParameterDescriptionMessage = exports2.RowDescriptionMessage = exports2.Field = exports2.CopyResponse = exports2.CopyDataMessage = exports2.DatabaseError = exports2.copyDone = exports2.emptyQuery = exports2.replicationStart = exports2.portalSuspended = exports2.noData = exports2.closeComplete = exports2.bindComplete = exports2.parseComplete = void 0; + exports2.parseComplete = { + name: "parseComplete", + length: 5 + }; + exports2.bindComplete = { + name: "bindComplete", + length: 5 + }; + exports2.closeComplete = { + name: "closeComplete", + length: 5 + }; + exports2.noData = { + name: "noData", + length: 5 + }; + exports2.portalSuspended = { + name: "portalSuspended", + length: 5 + }; + exports2.replicationStart = { + name: "replicationStart", + length: 4 + }; + exports2.emptyQuery = { + name: "emptyQuery", + length: 4 + }; + exports2.copyDone = { + name: "copyDone", + length: 4 + }; + var DatabaseError = class extends Error { + constructor(message, length, name) { + super(message); + this.length = length; + this.name = name; + } + }; + exports2.DatabaseError = DatabaseError; + var CopyDataMessage = class { + constructor(length, chunk) { + this.length = length; + this.chunk = chunk; + this.name = "copyData"; + } + }; + exports2.CopyDataMessage = CopyDataMessage; + var CopyResponse = class { + constructor(length, name, binary, columnCount) { + this.length = length; + this.name = name; + this.binary = binary; + this.columnTypes = new Array(columnCount); + } + }; + exports2.CopyResponse = CopyResponse; + var Field = class { + constructor(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, format) { + this.name = name; + this.tableID = tableID; + this.columnID = columnID; + this.dataTypeID = dataTypeID; + this.dataTypeSize = dataTypeSize; + this.dataTypeModifier = dataTypeModifier; + this.format = format; + } + }; + exports2.Field = Field; + var RowDescriptionMessage = class { + constructor(length, fieldCount) { + this.length = length; + this.fieldCount = fieldCount; + this.name = "rowDescription"; + this.fields = new Array(this.fieldCount); + } + }; + exports2.RowDescriptionMessage = RowDescriptionMessage; + var ParameterDescriptionMessage = class { + constructor(length, parameterCount) { + this.length = length; + this.parameterCount = parameterCount; + this.name = "parameterDescription"; + this.dataTypeIDs = new Array(this.parameterCount); + } + }; + exports2.ParameterDescriptionMessage = ParameterDescriptionMessage; + var ParameterStatusMessage = class { + constructor(length, parameterName, parameterValue) { + this.length = length; + this.parameterName = parameterName; + this.parameterValue = parameterValue; + this.name = "parameterStatus"; + } + }; + exports2.ParameterStatusMessage = ParameterStatusMessage; + var AuthenticationMD5Password = class { + constructor(length, salt) { + this.length = length; + this.salt = salt; + this.name = "authenticationMD5Password"; + } + }; + exports2.AuthenticationMD5Password = AuthenticationMD5Password; + var BackendKeyDataMessage = class { + constructor(length, processID, secretKey) { + this.length = length; + this.processID = processID; + this.secretKey = secretKey; + this.name = "backendKeyData"; + } + }; + exports2.BackendKeyDataMessage = BackendKeyDataMessage; + var NotificationResponseMessage = class { + constructor(length, processId, channel, payload) { + this.length = length; + this.processId = processId; + this.channel = channel; + this.payload = payload; + this.name = "notification"; + } + }; + exports2.NotificationResponseMessage = NotificationResponseMessage; + var ReadyForQueryMessage = class { + constructor(length, status) { + this.length = length; + this.status = status; + this.name = "readyForQuery"; + } + }; + exports2.ReadyForQueryMessage = ReadyForQueryMessage; + var CommandCompleteMessage = class { + constructor(length, text) { + this.length = length; + this.text = text; + this.name = "commandComplete"; + } + }; + exports2.CommandCompleteMessage = CommandCompleteMessage; + var DataRowMessage = class { + constructor(length, fields) { + this.length = length; + this.fields = fields; + this.name = "dataRow"; + this.fieldCount = fields.length; + } + }; + exports2.DataRowMessage = DataRowMessage; + var NoticeMessage = class { + constructor(length, message) { + this.length = length; + this.message = message; + this.name = "notice"; + } + }; + exports2.NoticeMessage = NoticeMessage; + } +}); + +// node_modules/pg-protocol/dist/buffer-writer.js +var require_buffer_writer = __commonJS({ + "node_modules/pg-protocol/dist/buffer-writer.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Writer = void 0; + var Writer = class { + constructor(size = 256) { + this.size = size; + this.offset = 5; + this.headerPosition = 0; + this.buffer = Buffer.allocUnsafe(size); + } + ensure(size) { + const remaining = this.buffer.length - this.offset; + if (remaining < size) { + const oldBuffer = this.buffer; + const newSize = oldBuffer.length + (oldBuffer.length >> 1) + size; + this.buffer = Buffer.allocUnsafe(newSize); + oldBuffer.copy(this.buffer, 0, 0, this.offset); + } + } + addInt32(num) { + this.ensure(4); + this.buffer[this.offset++] = num >>> 24 & 255; + this.buffer[this.offset++] = num >>> 16 & 255; + this.buffer[this.offset++] = num >>> 8 & 255; + this.buffer[this.offset++] = num >>> 0 & 255; + return this; + } + addInt16(num) { + this.ensure(2); + this.buffer[this.offset++] = num >>> 8 & 255; + this.buffer[this.offset++] = num >>> 0 & 255; + return this; + } + addCString(string) { + if (!string) { + this.ensure(1); + } else { + const len = Buffer.byteLength(string); + this.ensure(len + 1); + this.buffer.write(string, this.offset, "utf-8"); + this.offset += len; + } + this.buffer[this.offset++] = 0; + return this; + } + addString(string = "") { + const len = Buffer.byteLength(string); + this.ensure(len); + this.buffer.write(string, this.offset); + this.offset += len; + return this; + } + // Write an Int32 byte-length prefix immediately followed by the string's UTF-8 + // bytes. Postgres' Bind wire format prefixes every parameter with its length, + // and doing it in one method computes Buffer.byteLength ONCE — the previous + // `addInt32(Buffer.byteLength(s)).addString(s)` pairing scanned the string + // three times (byteLength for the prefix, byteLength again inside addString, + // then the encode), which is costly for large text parameters. + addInt32PrefixedString(string) { + const len = Buffer.byteLength(string); + this.ensure(4 + len); + const buffer = this.buffer; + let offset = this.offset; + buffer[offset++] = len >>> 24 & 255; + buffer[offset++] = len >>> 16 & 255; + buffer[offset++] = len >>> 8 & 255; + buffer[offset++] = len >>> 0 & 255; + buffer.write(string, offset, "utf-8"); + this.offset = offset + len; + return this; + } + add(otherBuffer) { + this.ensure(otherBuffer.length); + otherBuffer.copy(this.buffer, this.offset); + this.offset += otherBuffer.length; + return this; + } + /** + * Appends an uninitialized block of {@link size} bytes to the buffer and returns its offset. + */ + reserveUnsafe(size) { + const offset = this.offset; + this.ensure(size); + this.offset += size; + return offset; + } + join(code) { + if (code) { + this.buffer[this.headerPosition] = code; + const length = this.offset - (this.headerPosition + 1); + this.buffer.writeInt32BE(length, this.headerPosition + 1); + } + return this.buffer.slice(code ? 0 : 5, this.offset); + } + flush(code) { + const result = this.join(code); + this.offset = 5; + this.headerPosition = 0; + this.buffer = Buffer.allocUnsafe(this.size); + return result; + } + clear() { + this.offset = 5; + this.headerPosition = 0; + } + }; + exports2.Writer = Writer; + } +}); + +// node_modules/pg-protocol/dist/serializer.js +var require_serializer = __commonJS({ + "node_modules/pg-protocol/dist/serializer.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.serialize = void 0; + var buffer_writer_1 = require_buffer_writer(); + var writer = new buffer_writer_1.Writer(); + var startup = (opts) => { + writer.addInt16(3).addInt16(0); + for (const key of Object.keys(opts)) { + writer.addCString(key).addCString(opts[key]); + } + writer.addCString("client_encoding").addCString("UTF8"); + const bodyBuffer = writer.addCString("").flush(); + const length = bodyBuffer.length + 4; + return new buffer_writer_1.Writer().addInt32(length).add(bodyBuffer).flush(); + }; + var requestSsl = () => { + const response = Buffer.allocUnsafe(8); + response.writeInt32BE(8, 0); + response.writeInt32BE(80877103, 4); + return response; + }; + var password = (password2) => { + return writer.addCString(password2).flush( + 112 + /* code.startup */ + ); + }; + var sendSASLInitialResponseMessage = function(mechanism, initialResponse) { + writer.addCString(mechanism).addInt32PrefixedString(initialResponse); + return writer.flush( + 112 + /* code.startup */ + ); + }; + var sendSCRAMClientFinalMessage = function(additionalData) { + return writer.addString(additionalData).flush( + 112 + /* code.startup */ + ); + }; + var query = (text) => { + return writer.addCString(text).flush( + 81 + /* code.query */ + ); + }; + var emptyArray = []; + var parse = (query2) => { + const name = query2.name || ""; + if (name.length > 63) { + console.error("Warning! Postgres only supports 63 characters for query names."); + console.error("You supplied %s (%s)", name, name.length); + console.error("This can cause conflicts and silent errors executing queries"); + } + const types = query2.types || emptyArray; + const len = types.length; + const buffer = writer.addCString(name).addCString(query2.text).addInt16(len); + for (let i = 0; i < len; i++) { + buffer.addInt32(types[i]); + } + return writer.flush( + 80 + /* code.parse */ + ); + }; + var writeValues = function(values, valueMapper, formatsOffset) { + const len = values.length; + for (let i = 0; i < len; i++) { + const mappedVal = valueMapper ? valueMapper(values[i], i) : values[i]; + let formatByte = 0; + if (mappedVal == null) { + writer.addInt32(-1); + } else if (mappedVal instanceof Buffer) { + formatByte = 1; + writer.addInt32(mappedVal.length); + writer.add(mappedVal); + } else { + writer.addInt32PrefixedString(mappedVal); + } + const buf = writer.buffer; + buf[formatsOffset++] = 0; + buf[formatsOffset++] = formatByte; + } + }; + var bind = (config = {}) => { + const portal = config.portal || ""; + const statement = config.statement || ""; + const binary = config.binary || false; + const values = config.values || emptyArray; + const len = values.length; + writer.addCString(portal).addCString(statement); + writer.addInt16(len); + const formatsOffset = writer.reserveUnsafe(len * 2); + writer.addInt16(len); + try { + writeValues(values, config.valueMapper, formatsOffset); + } catch (err) { + writer.clear(); + throw err; + } + writer.addInt16(1); + writer.addInt16( + binary ? 1 : 0 + /* ParamType.STRING */ + ); + return writer.flush( + 66 + /* code.bind */ + ); + }; + var emptyExecute = Buffer.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]); + var execute = (config) => { + if (!config || !config.portal && !config.rows) { + return emptyExecute; + } + const portal = config.portal || ""; + const rows = config.rows || 0; + const portalLength = Buffer.byteLength(portal); + const len = 4 + portalLength + 1 + 4; + const buff = Buffer.allocUnsafe(1 + len); + buff[0] = 69; + buff.writeInt32BE(len, 1); + buff.write(portal, 5, "utf-8"); + buff[portalLength + 5] = 0; + buff.writeUInt32BE(rows, buff.length - 4); + return buff; + }; + var cancel = (processID, secretKey) => { + const buffer = Buffer.allocUnsafe(16); + buffer.writeInt32BE(16, 0); + buffer.writeInt16BE(1234, 4); + buffer.writeInt16BE(5678, 6); + buffer.writeInt32BE(processID, 8); + buffer.writeInt32BE(secretKey, 12); + return buffer; + }; + var cstringMessage = (code, string) => { + const stringLen = Buffer.byteLength(string); + const len = 4 + stringLen + 1; + const buffer = Buffer.allocUnsafe(1 + len); + buffer[0] = code; + buffer.writeInt32BE(len, 1); + buffer.write(string, 5, "utf-8"); + buffer[len] = 0; + return buffer; + }; + var emptyDescribePortal = writer.addCString("P").flush( + 68 + /* code.describe */ + ); + var emptyDescribeStatement = writer.addCString("S").flush( + 68 + /* code.describe */ + ); + var describe = (msg) => { + return msg.name ? cstringMessage(68, `${msg.type}${msg.name || ""}`) : msg.type === "P" ? emptyDescribePortal : emptyDescribeStatement; + }; + var close = (msg) => { + const text = `${msg.type}${msg.name || ""}`; + return cstringMessage(67, text); + }; + var copyData = (chunk) => { + return writer.add(chunk).flush( + 100 + /* code.copyFromChunk */ + ); + }; + var copyFail = (message) => { + return cstringMessage(102, message); + }; + var codeOnlyBuffer = (code) => Buffer.from([code, 0, 0, 0, 4]); + var flushBuffer = codeOnlyBuffer( + 72 + /* code.flush */ + ); + var syncBuffer = codeOnlyBuffer( + 83 + /* code.sync */ + ); + var endBuffer = codeOnlyBuffer( + 88 + /* code.end */ + ); + var copyDoneBuffer = codeOnlyBuffer( + 99 + /* code.copyDone */ + ); + var serialize = { + startup, + password, + requestSsl, + sendSASLInitialResponseMessage, + sendSCRAMClientFinalMessage, + query, + parse, + bind, + execute, + describe, + close, + flush: () => flushBuffer, + sync: () => syncBuffer, + end: () => endBuffer, + copyData, + copyDone: () => copyDoneBuffer, + copyFail, + cancel + }; + exports2.serialize = serialize; + } +}); + +// node_modules/pg-protocol/dist/buffer-reader.js +var require_buffer_reader = __commonJS({ + "node_modules/pg-protocol/dist/buffer-reader.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.BufferReader = void 0; + var BufferReader = class { + constructor(offset = 0) { + this.offset = offset; + this.buffer = Buffer.allocUnsafe(0); + this.encoding = "utf-8"; + } + setBuffer(offset, buffer) { + this.offset = offset; + this.buffer = buffer; + } + int16() { + const result = this.buffer.readInt16BE(this.offset); + this.offset += 2; + return result; + } + byte() { + const result = this.buffer[this.offset]; + this.offset++; + return result; + } + int32() { + const result = this.buffer.readInt32BE(this.offset); + this.offset += 4; + return result; + } + uint32() { + const result = this.buffer.readUInt32BE(this.offset); + this.offset += 4; + return result; + } + string(length) { + const result = this.buffer.toString(this.encoding, this.offset, this.offset + length); + this.offset += length; + return result; + } + cstring() { + const start = this.offset; + let end = start; + while (this.buffer[end++]) { + } + this.offset = end; + return this.buffer.toString(this.encoding, start, end - 1); + } + bytes(length) { + const result = this.buffer.slice(this.offset, this.offset + length); + this.offset += length; + return result; + } + }; + exports2.BufferReader = BufferReader; + } +}); + +// node_modules/pg-protocol/dist/parser.js +var require_parser = __commonJS({ + "node_modules/pg-protocol/dist/parser.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Parser = void 0; + var messages_1 = require_messages(); + var buffer_reader_1 = require_buffer_reader(); + var CODE_LENGTH = 1; + var LEN_LENGTH = 4; + var HEADER_LENGTH = CODE_LENGTH + LEN_LENGTH; + var LATEINIT_LENGTH = -1; + var emptyBuffer = Buffer.allocUnsafe(0); + var Parser = class { + constructor(opts) { + this.buffer = emptyBuffer; + this.bufferLength = 0; + this.bufferOffset = 0; + this.reader = new buffer_reader_1.BufferReader(); + if ((opts === null || opts === void 0 ? void 0 : opts.mode) === "binary") { + throw new Error("Binary mode not supported yet"); + } + this.mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || "text"; + } + parse(buffer, callback) { + this.mergeBuffer(buffer); + const bufferFullLength = this.bufferOffset + this.bufferLength; + let offset = this.bufferOffset; + while (offset + HEADER_LENGTH <= bufferFullLength) { + const code = this.buffer[offset]; + const length = this.buffer.readUInt32BE(offset + CODE_LENGTH); + const fullMessageLength = CODE_LENGTH + length; + if (fullMessageLength + offset <= bufferFullLength) { + const message = this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer); + callback(message); + offset += fullMessageLength; + } else { + break; + } + } + if (offset === bufferFullLength) { + this.buffer = emptyBuffer; + this.bufferLength = 0; + this.bufferOffset = 0; + } else { + this.bufferLength = bufferFullLength - offset; + this.bufferOffset = offset; + } + } + mergeBuffer(buffer) { + if (this.bufferLength > 0) { + const newLength = this.bufferLength + buffer.byteLength; + const newFullLength = newLength + this.bufferOffset; + if (newFullLength > this.buffer.byteLength) { + let newBuffer; + if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) { + newBuffer = this.buffer; + } else { + let newBufferLength = this.buffer.byteLength * 2; + while (newLength >= newBufferLength) { + newBufferLength *= 2; + } + newBuffer = Buffer.allocUnsafe(newBufferLength); + } + this.buffer.copy(newBuffer, 0, this.bufferOffset, this.bufferOffset + this.bufferLength); + this.buffer = newBuffer; + this.bufferOffset = 0; + } + buffer.copy(this.buffer, this.bufferOffset + this.bufferLength); + this.bufferLength = newLength; + } else { + this.buffer = buffer; + this.bufferOffset = 0; + this.bufferLength = buffer.byteLength; + } + } + handlePacket(offset, code, length, bytes) { + const { reader } = this; + reader.setBuffer(offset, bytes); + let message; + switch (code) { + case 50: + message = messages_1.bindComplete; + break; + case 49: + message = messages_1.parseComplete; + break; + case 51: + message = messages_1.closeComplete; + break; + case 110: + message = messages_1.noData; + break; + case 115: + message = messages_1.portalSuspended; + break; + case 99: + message = messages_1.copyDone; + break; + case 87: + message = messages_1.replicationStart; + break; + case 73: + message = messages_1.emptyQuery; + break; + case 68: + message = parseDataRowMessage(reader); + break; + case 67: + message = parseCommandCompleteMessage(reader); + break; + case 90: + message = parseReadyForQueryMessage(reader); + break; + case 65: + message = parseNotificationMessage(reader); + break; + case 82: + message = parseAuthenticationResponse(reader, length); + break; + case 83: + message = parseParameterStatusMessage(reader); + break; + case 75: + message = parseBackendKeyData(reader); + break; + case 69: + message = parseErrorMessage(reader, "error"); + break; + case 78: + message = parseErrorMessage(reader, "notice"); + break; + case 84: + message = parseRowDescriptionMessage(reader); + break; + case 116: + message = parseParameterDescriptionMessage(reader); + break; + case 71: + message = parseCopyInMessage(reader); + break; + case 72: + message = parseCopyOutMessage(reader); + break; + case 100: + message = parseCopyData(reader, length); + break; + default: + return new messages_1.DatabaseError("received invalid response: " + code.toString(16), length, "error"); + } + reader.setBuffer(0, emptyBuffer); + message.length = length; + return message; + } + }; + exports2.Parser = Parser; + var parseReadyForQueryMessage = (reader) => { + const status = reader.string(1); + return new messages_1.ReadyForQueryMessage(LATEINIT_LENGTH, status); + }; + var parseCommandCompleteMessage = (reader) => { + const text = reader.cstring(); + return new messages_1.CommandCompleteMessage(LATEINIT_LENGTH, text); + }; + var parseCopyData = (reader, length) => { + const chunk = reader.bytes(length - 4); + return new messages_1.CopyDataMessage(LATEINIT_LENGTH, chunk); + }; + var parseCopyInMessage = (reader) => parseCopyMessage(reader, "copyInResponse"); + var parseCopyOutMessage = (reader) => parseCopyMessage(reader, "copyOutResponse"); + var parseCopyMessage = (reader, messageName) => { + const isBinary = reader.byte() !== 0; + const columnCount = reader.int16(); + const message = new messages_1.CopyResponse(LATEINIT_LENGTH, messageName, isBinary, columnCount); + for (let i = 0; i < columnCount; i++) { + message.columnTypes[i] = reader.int16(); + } + return message; + }; + var parseNotificationMessage = (reader) => { + const processId = reader.int32(); + const channel = reader.cstring(); + const payload = reader.cstring(); + return new messages_1.NotificationResponseMessage(LATEINIT_LENGTH, processId, channel, payload); + }; + var parseRowDescriptionMessage = (reader) => { + const fieldCount = reader.int16(); + const message = new messages_1.RowDescriptionMessage(LATEINIT_LENGTH, fieldCount); + for (let i = 0; i < fieldCount; i++) { + message.fields[i] = parseField(reader); + } + return message; + }; + var parseField = (reader) => { + const name = reader.cstring(); + const tableID = reader.uint32(); + const columnID = reader.int16(); + const dataTypeID = reader.uint32(); + const dataTypeSize = reader.int16(); + const dataTypeModifier = reader.int32(); + const mode = reader.int16() === 0 ? "text" : "binary"; + return new messages_1.Field(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode); + }; + var parseParameterDescriptionMessage = (reader) => { + const parameterCount = reader.int16(); + const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount); + for (let i = 0; i < parameterCount; i++) { + message.dataTypeIDs[i] = reader.uint32(); + } + return message; + }; + var parseDataRowMessage = (reader) => { + const fieldCount = reader.int16(); + const fields = new Array(fieldCount); + for (let i = 0; i < fieldCount; i++) { + const len = reader.int32(); + fields[i] = len === -1 ? null : reader.string(len); + } + return new messages_1.DataRowMessage(LATEINIT_LENGTH, fields); + }; + var parseParameterStatusMessage = (reader) => { + const name = reader.cstring(); + const value = reader.cstring(); + return new messages_1.ParameterStatusMessage(LATEINIT_LENGTH, name, value); + }; + var parseBackendKeyData = (reader) => { + const processID = reader.int32(); + const secretKey = reader.int32(); + return new messages_1.BackendKeyDataMessage(LATEINIT_LENGTH, processID, secretKey); + }; + var parseAuthenticationResponse = (reader, length) => { + const code = reader.int32(); + const message = { + name: "authenticationOk", + length + }; + switch (code) { + case 0: + break; + case 3: + if (message.length === 8) { + message.name = "authenticationCleartextPassword"; + } + break; + case 5: + if (message.length === 12) { + message.name = "authenticationMD5Password"; + const salt = reader.bytes(4); + return new messages_1.AuthenticationMD5Password(LATEINIT_LENGTH, salt); + } + break; + case 10: + { + message.name = "authenticationSASL"; + message.mechanisms = []; + let mechanism; + do { + mechanism = reader.cstring(); + if (mechanism) { + message.mechanisms.push(mechanism); + } + } while (mechanism); + } + break; + case 11: + message.name = "authenticationSASLContinue"; + message.data = reader.string(length - 8); + break; + case 12: + message.name = "authenticationSASLFinal"; + message.data = reader.string(length - 8); + break; + default: + throw new Error("Unknown authenticationOk message type " + code); + } + return message; + }; + var parseErrorMessage = (reader, name) => { + const fields = {}; + let fieldType = reader.string(1); + while (fieldType !== "\0") { + fields[fieldType] = reader.cstring(); + fieldType = reader.string(1); + } + const messageValue = fields.M; + const message = name === "notice" ? new messages_1.NoticeMessage(LATEINIT_LENGTH, messageValue) : new messages_1.DatabaseError(messageValue, LATEINIT_LENGTH, name); + message.severity = fields.S; + message.code = fields.C; + message.detail = fields.D; + message.hint = fields.H; + message.position = fields.P; + message.internalPosition = fields.p; + message.internalQuery = fields.q; + message.where = fields.W; + message.schema = fields.s; + message.table = fields.t; + message.column = fields.c; + message.dataType = fields.d; + message.constraint = fields.n; + message.file = fields.F; + message.line = fields.L; + message.routine = fields.R; + return message; + }; + } +}); + +// node_modules/pg-protocol/dist/index.js +var require_dist = __commonJS({ + "node_modules/pg-protocol/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DatabaseError = exports2.serialize = void 0; + exports2.parse = parse; + var messages_1 = require_messages(); + Object.defineProperty(exports2, "DatabaseError", { enumerable: true, get: function() { + return messages_1.DatabaseError; + } }); + var serializer_1 = require_serializer(); + Object.defineProperty(exports2, "serialize", { enumerable: true, get: function() { + return serializer_1.serialize; + } }); + var parser_1 = require_parser(); + function parse(stream, callback) { + const parser = new parser_1.Parser(); + stream.on("data", (buffer) => parser.parse(buffer, callback)); + return new Promise((resolve) => stream.on("end", () => resolve())); + } + } +}); + +// node_modules/pg-cloudflare/dist/empty.js +var require_empty = __commonJS({ + "node_modules/pg-cloudflare/dist/empty.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.default = {}; + } +}); + +// node_modules/pg/lib/stream.js +var require_stream = __commonJS({ + "node_modules/pg/lib/stream.js"(exports2, module2) { + var { getStream, getSecureStream } = getStreamFuncs(); + module2.exports = { + /** + * Get a socket stream compatible with the current runtime environment. + * @returns {Duplex} + */ + getStream, + /** + * Get a TLS secured socket, compatible with the current environment, + * using the socket and other settings given in `options`. + * @returns {Duplex} + */ + getSecureStream + }; + function getNodejsStreamFuncs() { + function getStream2(ssl) { + const net = require("net"); + return new net.Socket(); + } + function getSecureStream2(options) { + const tls = require("tls"); + return tls.connect(options); + } + return { + getStream: getStream2, + getSecureStream: getSecureStream2 + }; + } + function getCloudflareStreamFuncs() { + function getStream2(ssl) { + const { CloudflareSocket } = require_empty(); + return new CloudflareSocket(ssl); + } + function getSecureStream2(options) { + options.socket.startTls(options); + return options.socket; + } + return { + getStream: getStream2, + getSecureStream: getSecureStream2 + }; + } + function isCloudflareRuntime() { + if (typeof navigator === "object" && navigator !== null && typeof navigator.userAgent === "string") { + return navigator.userAgent === "Cloudflare-Workers"; + } + if (typeof Response === "function") { + const resp = new Response(null, { cf: { thing: true } }); + if (typeof resp.cf === "object" && resp.cf !== null && resp.cf.thing) { + return true; + } + } + return false; + } + function getStreamFuncs() { + if (isCloudflareRuntime()) { + return getCloudflareStreamFuncs(); + } + return getNodejsStreamFuncs(); + } + } +}); + +// node_modules/pg/lib/connection.js +var require_connection4 = __commonJS({ + "node_modules/pg/lib/connection.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var { parse, serialize } = require_dist(); + var stream = require_stream(); + var { getStream } = stream; + var flushBuffer = serialize.flush(); + var syncBuffer = serialize.sync(); + var endBuffer = serialize.end(); + var Connection = class extends EventEmitter { + constructor(config) { + super(); + config = config || {}; + this.stream = config.stream || getStream(config.ssl); + if (typeof this.stream === "function") { + this.stream = this.stream(config); + } + this._keepAlive = config.keepAlive; + this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis; + this.parsedStatements = {}; + this.submittedNamedStatements = {}; + this.ssl = config.ssl || false; + this.sslNegotiation = config.sslNegotiation || "postgres"; + this._ending = false; + this._emitMessage = false; + const self2 = this; + this.on("newListener", function(eventName) { + if (eventName === "message") { + self2._emitMessage = true; + } + }); + } + connect(port, host) { + const self2 = this; + this._connecting = true; + this.stream.setNoDelay(true); + this.stream.connect(port, host); + this.stream.once("connect", function() { + if (self2._keepAlive) { + self2.stream.setKeepAlive(true, self2._keepAliveInitialDelayMillis); + } + self2.emit("connect"); + }); + const reportStreamError = function(error) { + if (self2._ending && (error.code === "ECONNRESET" || error.code === "EPIPE")) { + return; + } + self2.emit("error", error); + }; + this.stream.on("error", reportStreamError); + this.stream.on("close", function() { + self2.emit("end"); + }); + if (!this.ssl) { + return this.attachListeners(this.stream); + } + if (this.sslNegotiation === "direct") { + return this.stream.once("connect", function() { + self2.upgradeToSSL(host, reportStreamError); + }); + } + this.stream.once("data", function(buffer) { + const responseCode = buffer.toString("utf8"); + switch (responseCode) { + case "S": + break; + case "N": + self2.stream.end(); + return self2.emit("error", new Error("The server does not support SSL connections")); + default: + self2.stream.end(); + return self2.emit("error", new Error("There was an error establishing an SSL connection")); + } + self2.upgradeToSSL(host, reportStreamError); + }); + } + upgradeToSSL(host, reportStreamError) { + const self2 = this; + const options = { + socket: self2.stream, + // tls.connect checks the server identity against `servername`, falling + // back to `host` and then to 'localhost'. `servername` must stay unset + // for IP addresses (see below), so `host` is needed to keep certificate + // validation working when connecting to an IP address. + host + }; + if (self2.ssl !== true) { + Object.assign(options, self2.ssl); + if ("key" in self2.ssl) { + options.key = self2.ssl.key; + } + } + if (self2.sslNegotiation === "direct") { + options.ALPNProtocols = ["postgresql"]; + } + const net = require("net"); + if (net.isIP && net.isIP(host) === 0) { + options.servername = host; + } + try { + self2.stream = stream.getSecureStream(options); + } catch (err) { + return self2.emit("error", err); + } + self2.attachListeners(self2.stream); + self2.stream.on("error", reportStreamError); + self2.emit("sslconnect"); + } + attachListeners(stream2) { + parse(stream2, (msg) => { + const eventName = msg.name === "error" ? "errorMessage" : msg.name; + if (this._emitMessage) { + this.emit("message", msg); + } + this.emit(eventName, msg); + }); + } + requestSsl() { + this.stream.write(serialize.requestSsl()); + } + startup(config) { + this.stream.write(serialize.startup(config)); + } + cancel(processID, secretKey) { + this._send(serialize.cancel(processID, secretKey)); + } + password(password) { + this._send(serialize.password(password)); + } + sendSASLInitialResponseMessage(mechanism, initialResponse) { + this._send(serialize.sendSASLInitialResponseMessage(mechanism, initialResponse)); + } + sendSCRAMClientFinalMessage(additionalData) { + this._send(serialize.sendSCRAMClientFinalMessage(additionalData)); + } + _send(buffer) { + if (!this.stream.writable) { + return false; + } + return this.stream.write(buffer); + } + query(text) { + this._send(serialize.query(text)); + } + // send parse message + parse(query) { + this._send(serialize.parse(query)); + } + // send bind message + bind(config) { + this._send(serialize.bind(config)); + } + // send execute message + execute(config) { + this._send(serialize.execute(config)); + } + flush() { + if (this.stream.writable) { + this.stream.write(flushBuffer); + } + } + sync() { + this._send(syncBuffer); + } + ref() { + this.stream.ref(); + } + unref() { + this.stream.unref(); + } + end() { + this._ending = true; + if (!this._connecting || !this.stream.writable) { + this.stream.end(); + return; + } + return this.stream.write(endBuffer, () => { + this.stream.end(); + }); + } + close(msg) { + this._send(serialize.close(msg)); + } + describe(msg) { + this._send(serialize.describe(msg)); + } + sendCopyFromChunk(chunk) { + this._send(serialize.copyData(chunk)); + } + endCopyFrom() { + this._send(serialize.copyDone()); + } + sendCopyFail(msg) { + this._send(serialize.copyFail(msg)); + } + }; + module2.exports = Connection; + } +}); + +// node_modules/split2/index.js +var require_split2 = __commonJS({ + "node_modules/split2/index.js"(exports2, module2) { + "use strict"; + var { Transform } = require("stream"); + var { StringDecoder } = require("string_decoder"); + var kLast = /* @__PURE__ */ Symbol("last"); + var kDecoder = /* @__PURE__ */ Symbol("decoder"); + function transform(chunk, enc, cb) { + let list; + if (this.overflow) { + const buf = this[kDecoder].write(chunk); + list = buf.split(this.matcher); + if (list.length === 1) return cb(); + list.shift(); + this.overflow = false; + } else { + this[kLast] += this[kDecoder].write(chunk); + list = this[kLast].split(this.matcher); + } + this[kLast] = list.pop(); + for (let i = 0; i < list.length; i++) { + try { + push(this, this.mapper(list[i])); + } catch (error) { + return cb(error); + } + } + this.overflow = this[kLast].length > this.maxLength; + if (this.overflow && !this.skipOverflow) { + cb(new Error("maximum buffer reached")); + return; + } + cb(); + } + function flush(cb) { + this[kLast] += this[kDecoder].end(); + if (this[kLast]) { + try { + push(this, this.mapper(this[kLast])); + } catch (error) { + return cb(error); + } + } + cb(); + } + function push(self2, val) { + if (val !== void 0) { + self2.push(val); + } + } + function noop(incoming) { + return incoming; + } + function split(matcher, mapper, options) { + matcher = matcher || /\r?\n/; + mapper = mapper || noop; + options = options || {}; + switch (arguments.length) { + case 1: + if (typeof matcher === "function") { + mapper = matcher; + matcher = /\r?\n/; + } else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) { + options = matcher; + matcher = /\r?\n/; + } + break; + case 2: + if (typeof matcher === "function") { + options = mapper; + mapper = matcher; + matcher = /\r?\n/; + } else if (typeof mapper === "object") { + options = mapper; + mapper = noop; + } + } + options = Object.assign({}, options); + options.autoDestroy = true; + options.transform = transform; + options.flush = flush; + options.readableObjectMode = true; + const stream = new Transform(options); + stream[kLast] = ""; + stream[kDecoder] = new StringDecoder("utf8"); + stream.matcher = matcher; + stream.mapper = mapper; + stream.maxLength = options.maxLength; + stream.skipOverflow = options.skipOverflow || false; + stream.overflow = false; + stream._destroy = function(err, cb) { + this._writableState.errorEmitted = false; + cb(err); + }; + return stream; + } + module2.exports = split; + } +}); + +// node_modules/pgpass/lib/helper.js +var require_helper = __commonJS({ + "node_modules/pgpass/lib/helper.js"(exports2, module2) { + "use strict"; + var path = require("path"); + var Stream = require("stream").Stream; + var split = require_split2(); + var util = require("util"); + var defaultPort = 5432; + var isWin = process.platform === "win32"; + var warnStream = process.stderr; + var S_IRWXG = 56; + var S_IRWXO = 7; + var S_IFMT = 61440; + var S_IFREG = 32768; + function isRegFile(mode) { + return (mode & S_IFMT) == S_IFREG; + } + var fieldNames = ["host", "port", "database", "user", "password"]; + var nrOfFields = fieldNames.length; + var passKey = fieldNames[nrOfFields - 1]; + function warn() { + var isWritable = warnStream instanceof Stream && true === warnStream.writable; + if (isWritable) { + var args = Array.prototype.slice.call(arguments).concat("\n"); + warnStream.write(util.format.apply(util, args)); + } + } + Object.defineProperty(module2.exports, "isWin", { + get: function() { + return isWin; + }, + set: function(val) { + isWin = val; + } + }); + module2.exports.warnTo = function(stream) { + var old = warnStream; + warnStream = stream; + return old; + }; + module2.exports.getFileName = function(rawEnv) { + var env = rawEnv || process.env; + var file = env.PGPASSFILE || (isWin ? path.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path.join(env.HOME || "./", ".pgpass")); + return file; + }; + module2.exports.usePgPass = function(stats, fname) { + if (Object.prototype.hasOwnProperty.call(process.env, "PGPASSWORD")) { + return false; + } + if (isWin) { + return true; + } + fname = fname || ""; + if (!isRegFile(stats.mode)) { + warn('WARNING: password file "%s" is not a plain file', fname); + return false; + } + if (stats.mode & (S_IRWXG | S_IRWXO)) { + warn('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', fname); + return false; + } + return true; + }; + var matcher = module2.exports.match = function(connInfo, entry) { + return fieldNames.slice(0, -1).reduce(function(prev, field, idx) { + if (idx == 1) { + if (Number(connInfo[field] || defaultPort) === Number(entry[field])) { + return prev && true; + } + } + return prev && (entry[field] === "*" || entry[field] === connInfo[field]); + }, true); + }; + module2.exports.getPassword = function(connInfo, stream, cb) { + var pass; + var lineStream = stream.pipe(split()); + function onLine(line) { + var entry = parseLine(line); + if (entry && isValidEntry(entry) && matcher(connInfo, entry)) { + pass = entry[passKey]; + lineStream.end(); + } + } + var onEnd = function() { + stream.destroy(); + cb(pass); + }; + var onErr = function(err) { + stream.destroy(); + warn("WARNING: error on reading file: %s", err); + cb(void 0); + }; + stream.on("error", onErr); + lineStream.on("data", onLine).on("end", onEnd).on("error", onErr); + }; + var parseLine = module2.exports.parseLine = function(line) { + if (line.length < 11 || line.match(/^\s+#/)) { + return null; + } + var curChar = ""; + var prevChar = ""; + var fieldIdx = 0; + var startIdx = 0; + var endIdx = 0; + var obj = {}; + var isLastField = false; + var addToObj = function(idx, i0, i1) { + var field = line.substring(i0, i1); + if (!Object.hasOwnProperty.call(process.env, "PGPASS_NO_DEESCAPE")) { + field = field.replace(/\\([:\\])/g, "$1"); + } + obj[fieldNames[idx]] = field; + }; + for (var i = 0; i < line.length - 1; i += 1) { + curChar = line.charAt(i + 1); + prevChar = line.charAt(i); + isLastField = fieldIdx == nrOfFields - 1; + if (isLastField) { + addToObj(fieldIdx, startIdx); + break; + } + if (i >= 0 && curChar == ":" && prevChar !== "\\") { + addToObj(fieldIdx, startIdx, i + 1); + startIdx = i + 2; + fieldIdx += 1; + } + } + obj = Object.keys(obj).length === nrOfFields ? obj : null; + return obj; + }; + var isValidEntry = module2.exports.isValidEntry = function(entry) { + var rules = { + // host + 0: function(x) { + return x.length > 0; + }, + // port + 1: function(x) { + if (x === "*") { + return true; + } + x = Number(x); + return isFinite(x) && x > 0 && x < 9007199254740992 && Math.floor(x) === x; + }, + // database + 2: function(x) { + return x.length > 0; + }, + // username + 3: function(x) { + return x.length > 0; + }, + // password + 4: function(x) { + return x.length > 0; + } + }; + for (var idx = 0; idx < fieldNames.length; idx += 1) { + var rule = rules[idx]; + var value = entry[fieldNames[idx]] || ""; + var res = rule(value); + if (!res) { + return false; + } + } + return true; + }; + } +}); + +// node_modules/pgpass/lib/index.js +var require_lib5 = __commonJS({ + "node_modules/pgpass/lib/index.js"(exports2, module2) { + "use strict"; + var path = require("path"); + var fs = require("fs"); + var helper = require_helper(); + module2.exports = function(connInfo, cb) { + var file = helper.getFileName(); + fs.stat(file, function(err, stat) { + if (err || !helper.usePgPass(stat, file)) { + return cb(void 0); + } + var st = fs.createReadStream(file); + helper.getPassword(connInfo, st, cb); + }); + }; + module2.exports.warnTo = helper.warnTo; + } +}); + +// node_modules/pg/lib/client.js +var require_client2 = __commonJS({ + "node_modules/pg/lib/client.js"(exports2, module2) { + var EventEmitter = require("events").EventEmitter; + var utils = require_utils(); + var nodeUtils = require("util"); + var sasl = require_sasl(); + var TypeOverrides = require_type_overrides(); + var ConnectionParameters = require_connection_parameters(); + var Query = require_query3(); + var defaults = require_defaults2(); + var Connection = require_connection4(); + var crypto = require_utils2(); + var activeQueryDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Client.activeQuery is deprecated and will be removed in pg@9.0" + ); + var queryQueueDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Client.queryQueue is deprecated and will be removed in pg@9.0." + ); + var pgPassDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "pgpass support is deprecated and will be removed in pg@9.0. You can provide an async function as the password property to the Client/Pool constructor that returns a password instead. Within this function you can call the pgpass module in your own code." + ); + var byoPromiseDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Passing a custom Promise implementation to the Client/Pool constructor is deprecated and will be removed in pg@9.0." + ); + var queryQueueLengthDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead." + ); + function coerceNumberOrDefault(value, defaultValue) { + if (typeof value === "number") { + return Number.isFinite(value) ? value : defaultValue; + } + if (typeof value === "string" && value.trim() !== "") { + const n = Number(value); + return Number.isFinite(n) ? n : defaultValue; + } + return defaultValue; + } + var Client = class extends EventEmitter { + constructor(config) { + super(); + this.connectionParameters = new ConnectionParameters(config); + this.user = this.connectionParameters.user; + this.database = this.connectionParameters.database; + this.port = this.connectionParameters.port; + this.host = this.connectionParameters.host; + Object.defineProperty(this, "password", { + configurable: true, + enumerable: false, + writable: true, + value: this.connectionParameters.password + }); + this.replication = this.connectionParameters.replication; + const c = config || {}; + if (c.Promise) { + byoPromiseDeprecationNotice(); + } + this._Promise = c.Promise || global.Promise; + this._types = new TypeOverrides(c.types); + this._ending = false; + this._ended = false; + this._connecting = false; + this._connected = false; + this._connectionError = false; + this._queryable = true; + this._activeQuery = null; + this._txStatus = null; + this.enableChannelBinding = Boolean(c.enableChannelBinding); + this.scramMaxIterations = coerceNumberOrDefault(c.scramMaxIterations, sasl.DEFAULT_MAX_SCRAM_ITERATIONS); + this.connection = c.connection || new Connection({ + stream: c.stream, + ssl: this.connectionParameters.ssl, + sslNegotiation: this.connectionParameters.sslnegotiation, + keepAlive: c.keepAlive || false, + keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0, + encoding: this.connectionParameters.client_encoding || "utf8" + }); + this._queryQueue = []; + this._sentQueryQueue = []; + this.pipeline = Boolean(c.pipeline); + this.binary = c.binary || defaults.binary; + this.processID = null; + this.secretKey = null; + this.ssl = this.connectionParameters.ssl || false; + this.sslNegotiation = this.connectionParameters.sslnegotiation || "postgres"; + if (this.ssl && this.ssl.key) { + Object.defineProperty(this.ssl, "key", { + enumerable: false + }); + } + this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0; + } + get activeQuery() { + activeQueryDeprecationNotice(); + return this._activeQuery; + } + set activeQuery(val) { + activeQueryDeprecationNotice(); + this._activeQuery = val; + } + _getActiveQuery() { + return this._activeQuery; + } + _errorAllQueries(err) { + const enqueueError = (query) => { + process.nextTick(() => { + query.handleError(err, this.connection); + }); + }; + const activeQuery = this._getActiveQuery(); + if (activeQuery) { + enqueueError(activeQuery); + this._activeQuery = null; + } + this._sentQueryQueue.forEach(enqueueError); + this._sentQueryQueue.length = 0; + this._queryQueue.forEach(enqueueError); + this._queryQueue.length = 0; + } + _connect(callback) { + const self2 = this; + const con = this.connection; + this._connectionCallback = callback; + if (this._connecting || this._connected) { + const err = new Error("Client has already been connected. You cannot reuse a client."); + process.nextTick(() => { + callback(err); + }); + return; + } + this._connecting = true; + if (this._connectionTimeoutMillis > 0) { + this.connectionTimeoutHandle = setTimeout(() => { + con._ending = true; + con.stream.destroy(new Error("timeout expired")); + }, this._connectionTimeoutMillis); + if (this.connectionTimeoutHandle.unref) { + this.connectionTimeoutHandle.unref(); + } + } + if (this.host && this.host.indexOf("/") === 0) { + con.connect(this.host + "/.s.PGSQL." + this.port); + } else { + con.connect(this.port, this.host); + } + con.on("connect", function() { + if (self2.ssl) { + if (self2.sslNegotiation !== "direct") { + con.requestSsl(); + } + } else { + con.startup(self2.getStartupConf()); + } + }); + con.on("sslconnect", function() { + con.startup(self2.getStartupConf()); + }); + this._attachListeners(con); + con.once("end", () => { + const error = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly"); + clearTimeout(this.connectionTimeoutHandle); + this._errorAllQueries(error); + this._ended = true; + if (!this._ending) { + if (this._connecting && !this._connectionError) { + if (this._connectionCallback) { + this._connectionCallback(error); + } else { + this._handleErrorEvent(error); + } + } else if (!this._connectionError) { + this._handleErrorEvent(error); + } + } + process.nextTick(() => { + this.emit("end"); + }); + }); + } + connect(callback) { + if (callback) { + this._connect(callback); + return; + } + return new this._Promise((resolve, reject) => { + this._connect((error) => { + if (error) { + reject(error); + } else { + resolve(this); + } + }); + }); + } + _attachListeners(con) { + con.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this)); + con.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this)); + con.on("authenticationSASL", this._handleAuthSASL.bind(this)); + con.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this)); + con.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this)); + con.on("backendKeyData", this._handleBackendKeyData.bind(this)); + con.on("error", this._handleErrorEvent.bind(this)); + con.on("errorMessage", this._handleErrorMessage.bind(this)); + con.on("readyForQuery", this._handleReadyForQuery.bind(this)); + con.on("notice", this._handleNotice.bind(this)); + con.on("rowDescription", this._handleRowDescription.bind(this)); + con.on("dataRow", this._handleDataRow.bind(this)); + con.on("portalSuspended", this._handlePortalSuspended.bind(this)); + con.on("emptyQuery", this._handleEmptyQuery.bind(this)); + con.on("commandComplete", this._handleCommandComplete.bind(this)); + con.on("parseComplete", this._handleParseComplete.bind(this)); + con.on("copyInResponse", this._handleCopyInResponse.bind(this)); + con.on("copyData", this._handleCopyData.bind(this)); + con.on("notification", this._handleNotification.bind(this)); + } + _getPassword(cb) { + const con = this.connection; + if (typeof this.password === "function") { + this._Promise.resolve().then(() => this.password(this.connectionParameters)).then((pass) => { + if (pass !== void 0) { + if (typeof pass !== "string") { + con.emit("error", new TypeError("Password must be a string")); + return; + } + this.connectionParameters.password = this.password = pass; + } else { + this.connectionParameters.password = this.password = null; + } + cb(); + }).catch((err) => { + con.emit("error", err); + }); + } else if (this.password !== null) { + cb(); + } else { + try { + const pgPass = require_lib5(); + pgPass(this.connectionParameters, (pass) => { + if (void 0 !== pass) { + pgPassDeprecationNotice(); + this.connectionParameters.password = this.password = pass; + } + cb(); + }); + } catch (e) { + this.emit("error", e); + } + } + } + _handleAuthCleartextPassword(msg) { + this._getPassword(() => { + this.connection.password(this.password); + }); + } + _handleAuthMD5Password(msg) { + this._getPassword(async () => { + try { + const hashedPassword = await crypto.postgresMd5PasswordHash(this.user, this.password, msg.salt); + this.connection.password(hashedPassword); + } catch (e) { + this.emit("error", e); + } + }); + } + _handleAuthSASL(msg) { + this._getPassword(() => { + try { + this.saslSession = sasl.startSession( + msg.mechanisms, + this.enableChannelBinding && this.connection.stream, + this.scramMaxIterations + ); + this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response); + } catch (err) { + this.connection.emit("error", err); + } + }); + } + async _handleAuthSASLContinue(msg) { + try { + await sasl.continueSession( + this.saslSession, + this.password, + msg.data, + this.enableChannelBinding && this.connection.stream + ); + this.connection.sendSCRAMClientFinalMessage(this.saslSession.response); + } catch (err) { + this.connection.emit("error", err); + } + } + _handleAuthSASLFinal(msg) { + try { + sasl.finalizeSession(this.saslSession, msg.data); + this.saslSession = null; + } catch (err) { + this.connection.emit("error", err); + } + } + _handleBackendKeyData(msg) { + this.processID = msg.processID; + this.secretKey = msg.secretKey; + } + _handleReadyForQuery(msg) { + if (this._connecting) { + this._connecting = false; + this._connected = true; + clearTimeout(this.connectionTimeoutHandle); + if (this._connectionCallback) { + this._connectionCallback(null, this); + this._connectionCallback = null; + } + this.emit("connect"); + } + const activeQuery = this._getActiveQuery(); + this._activeQuery = null; + this._txStatus = msg?.status ?? null; + this.readyForQuery = true; + if (activeQuery) { + activeQuery.handleReadyForQuery(this.connection); + } + this._pulseQueryQueue(); + } + // if we receive an error event or error message + // during the connection process we handle it here + _handleErrorWhileConnecting(err) { + if (this._connectionError) { + return; + } + this._connectionError = true; + clearTimeout(this.connectionTimeoutHandle); + if (this._connectionCallback) { + return this._connectionCallback(err); + } + this.emit("error", err); + } + // if we're connected and we receive an error event from the connection + // this means the socket is dead - do a hard abort of all queries and emit + // the socket error on the client as well + _handleErrorEvent(err) { + if (this._connecting) { + return this._handleErrorWhileConnecting(err); + } + this._queryable = false; + this._errorAllQueries(err); + this.emit("error", err); + } + // handle error messages from the postgres backend + _handleErrorMessage(msg) { + if (this._connecting) { + return this._handleErrorWhileConnecting(msg); + } + const activeQuery = this._getActiveQuery(); + if (!activeQuery) { + this._handleErrorEvent(msg); + return; + } + this._activeQuery = null; + if (activeQuery.name) { + delete this.connection.submittedNamedStatements[activeQuery.name]; + } + activeQuery.handleError(msg, this.connection); + } + _handleRowDescription(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected rowDescription message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleRowDescription(msg); + } + _handleDataRow(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected dataRow message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleDataRow(msg); + } + _handlePortalSuspended(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected portalSuspended message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handlePortalSuspended(this.connection); + } + _handleEmptyQuery(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected emptyQuery message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleEmptyQuery(this.connection); + } + _handleCommandComplete(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected commandComplete message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleCommandComplete(msg, this.connection); + } + _handleParseComplete() { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected parseComplete message from backend."); + this._handleErrorEvent(error); + return; + } + if (activeQuery.name) { + this.connection.parsedStatements[activeQuery.name] = activeQuery.text; + delete this.connection.submittedNamedStatements[activeQuery.name]; + } + } + _handleCopyInResponse(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected copyInResponse message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleCopyInResponse(this.connection); + } + _handleCopyData(msg) { + const activeQuery = this._getActiveQuery(); + if (activeQuery == null) { + const error = new Error("Received unexpected copyData message from backend."); + this._handleErrorEvent(error); + return; + } + activeQuery.handleCopyData(msg, this.connection); + } + _handleNotification(msg) { + this.emit("notification", msg); + } + _handleNotice(msg) { + this.emit("notice", msg); + } + getStartupConf() { + const params = this.connectionParameters; + const data = { + user: params.user, + database: params.database + }; + const appName = params.application_name || params.fallback_application_name; + if (appName) { + data.application_name = appName; + } + if (params.replication) { + data.replication = "" + params.replication; + } + if (params.statement_timeout) { + data.statement_timeout = String(parseInt(params.statement_timeout, 10)); + } + if (params.lock_timeout) { + data.lock_timeout = String(parseInt(params.lock_timeout, 10)); + } + if (params.idle_in_transaction_session_timeout) { + data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10)); + } + if (params.options) { + data.options = params.options; + } + return data; + } + cancel(client, query) { + if (client.activeQuery === query) { + const con = this.connection; + if (this.host && this.host.indexOf("/") === 0) { + con.connect(this.host + "/.s.PGSQL." + this.port); + } else { + con.connect(this.port, this.host); + } + con.on("connect", function() { + con.cancel(client.processID, client.secretKey); + }); + } else if (client._queryQueue.indexOf(query) !== -1) { + client._queryQueue.splice(client._queryQueue.indexOf(query), 1); + } else if (client._sentQueryQueue.indexOf(query) !== -1) { + query.callback = () => { + }; + } + } + setTypeParser(oid, format, parseFn) { + return this._types.setTypeParser(oid, format, parseFn); + } + getTypeParser(oid, format) { + return this._types.getTypeParser(oid, format); + } + // escapeIdentifier and escapeLiteral moved to utility functions & exported + // on PG + // re-exported here for backwards compatibility + escapeIdentifier(str) { + return utils.escapeIdentifier(str); + } + escapeLiteral(str) { + return utils.escapeLiteral(str); + } + _pulseQueryQueue() { + if (this.pipeline) { + this._pulsePipelinedQueryQueue(); + return; + } + if (this.readyForQuery === true) { + this._activeQuery = this._queryQueue.shift(); + const activeQuery = this._getActiveQuery(); + if (activeQuery) { + this.readyForQuery = false; + this.hasExecuted = true; + const queryError = activeQuery.submit(this.connection); + if (queryError) { + process.nextTick(() => { + activeQuery.handleError(queryError, this.connection); + this.readyForQuery = true; + this._pulseQueryQueue(); + }); + } + } else if (this.hasExecuted) { + this._activeQuery = null; + this.emit("drain"); + } + } + } + _pulsePipelinedQueryQueue() { + if (!this._connected || !this._queryable) { + return; + } + while (this._queryQueue.length > 0) { + const query = this._queryQueue.shift(); + this.hasExecuted = true; + const queryError = query.submit(this.connection); + if (queryError) { + process.nextTick(() => { + query.handleError(queryError, this.connection); + }); + continue; + } + this._sentQueryQueue.push(query); + } + if (this.readyForQuery && !this._activeQuery && this._sentQueryQueue.length > 0) { + this._activeQuery = this._sentQueryQueue.shift(); + this.readyForQuery = false; + } + if (!this._activeQuery && this._sentQueryQueue.length === 0 && this._queryQueue.length === 0 && this.hasExecuted) { + this.emit("drain"); + } + } + query(config, values, callback) { + let query; + let result; + if (config == null) { + throw new TypeError("Client was passed a null or undefined query"); + } + if (typeof config.submit === "function") { + result = query = config; + if (!query.callback) { + if (typeof values === "function") { + query.callback = values; + } else if (callback) { + query.callback = callback; + } + } + } else { + query = new Query(config, values, callback); + if (!query.callback) { + result = new this._Promise((resolve, reject) => { + query.callback = (err, res) => err ? reject(err) : resolve(res); + }).catch((err) => { + Error.captureStackTrace(err); + throw err; + }); + } else if (typeof query.callback !== "function") { + throw new TypeError("callback is not a function"); + } + } + const readTimeout = config.query_timeout || this.connectionParameters.query_timeout; + if (readTimeout) { + const queryCallback = query.callback || (() => { + }); + const readTimeoutTimer = setTimeout(() => { + const error = new Error("Query read timeout"); + process.nextTick(() => { + query.handleError(error, this.connection); + }); + queryCallback(error); + query.callback = () => { + }; + const index = this._queryQueue.indexOf(query); + if (index > -1) { + this._queryQueue.splice(index, 1); + } else if (this.pipeline) { + this.connection.stream.destroy(); + return; + } + this._pulseQueryQueue(); + }, readTimeout); + query.callback = (err, res) => { + clearTimeout(readTimeoutTimer); + queryCallback(err, res); + }; + } + if (this.binary && !query.binary) { + query.binary = true; + } + if (query._result && !query._result._types) { + query._result._types = this._types; + } + if (this.pipeline) { + const portalQuery = typeof config.submit === "function" && !(query instanceof Query) ? "Custom query classes such as pg-cursor and pg-query-stream are" : query.rows ? "The `rows` option is" : null; + if (portalQuery) { + process.nextTick(() => { + query.handleError(new Error(`${portalQuery} not supported in pipeline mode`), this.connection); + }); + return result; + } + } + if (!this._queryable) { + process.nextTick(() => { + query.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection); + }); + return result; + } + if (this._ending) { + process.nextTick(() => { + query.handleError(new Error("Client was closed and is not queryable"), this.connection); + }); + return result; + } + if (this._queryQueue.length > 0 && !this.pipeline) { + queryQueueLengthDeprecationNotice(); + } + this._queryQueue.push(query); + this._pulseQueryQueue(); + return result; + } + ref() { + this.connection.ref(); + } + unref() { + this.connection.unref(); + } + getTransactionStatus() { + return this._txStatus; + } + end(cb) { + this._ending = true; + if (!this.connection._connecting || this._ended) { + if (cb) { + cb(); + return; + } else { + return this._Promise.resolve(); + } + } + if (!this._queryable) { + this.connection.stream.destroy(); + } else if (this.pipeline && (this._getActiveQuery() || this._sentQueryQueue.length > 0 || this._queryQueue.length > 0)) { + this.once("drain", () => this.connection.end()); + } else if (this._getActiveQuery()) { + this.connection.stream.destroy(); + } else { + this.connection.end(); + } + if (cb) { + this.connection.once("end", cb); + } else { + return new this._Promise((resolve) => { + this.connection.once("end", resolve); + }); + } + } + get queryQueue() { + queryQueueDeprecationNotice(); + return this._queryQueue; + } + }; + Client.Query = Query; + module2.exports = Client; + } +}); + +// node_modules/pg-pool/index.js +var require_pg_pool = __commonJS({ + "node_modules/pg-pool/index.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var NOOP = function() { + }; + var removeWhere = (list, predicate) => { + const i = list.findIndex(predicate); + return i === -1 ? void 0 : list.splice(i, 1)[0]; + }; + var IdleItem = class { + constructor(client, idleListener, timeoutId) { + this.client = client; + this.idleListener = idleListener; + this.timeoutId = timeoutId; + } + }; + var PendingItem = class { + constructor(callback) { + this.callback = callback; + } + }; + function throwOnDoubleRelease() { + throw new Error("Release called on client which has already been released to the pool."); + } + function promisify(Promise2, callback) { + if (callback) { + return { callback, result: void 0 }; + } + let rej; + let res; + const cb = function(err, client) { + err ? rej(err) : res(client); + }; + const result = new Promise2(function(resolve, reject) { + res = resolve; + rej = reject; + }).catch((err) => { + Error.captureStackTrace(err); + throw err; + }); + return { callback: cb, result }; + } + function makeIdleListener(pool, client) { + return function idleListener(err) { + err.client = client; + client.removeListener("error", idleListener); + client.on("error", () => { + pool.log("additional client error after disconnection due to error", err); + }); + pool._remove(client); + pool.emit("error", err, client); + }; + } + var Pool = class extends EventEmitter { + constructor(options, Client) { + super(); + this.options = Object.assign({}, options); + if (options != null && "password" in options) { + Object.defineProperty(this.options, "password", { + configurable: true, + enumerable: false, + writable: true, + value: options.password + }); + } + if (options != null && options.ssl && options.ssl.key) { + Object.defineProperty(this.options.ssl, "key", { + enumerable: false + }); + } + this.options.max = this.options.max || this.options.poolSize || 10; + this.options.min = this.options.min || 0; + this.options.maxUses = this.options.maxUses || Infinity; + this.options.allowExitOnIdle = this.options.allowExitOnIdle || false; + this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0; + this.log = this.options.log || function() { + }; + this.Client = this.options.Client || Client || require_lib6().Client; + this.Promise = this.options.Promise || global.Promise; + if (typeof this.options.idleTimeoutMillis === "undefined") { + this.options.idleTimeoutMillis = 1e4; + } + this._clients = []; + this._idle = []; + this._expired = /* @__PURE__ */ new WeakSet(); + this._pendingQueue = []; + this._endCallback = void 0; + this.ending = false; + this.ended = false; + } + _promiseTry(f) { + const Promise2 = this.Promise; + if (typeof Promise2.try === "function") { + return Promise2.try(f); + } + return new Promise2((resolve) => resolve(f())); + } + _isFull() { + return this._clients.length >= this.options.max; + } + _isAboveMin() { + return this._clients.length > this.options.min; + } + _pulseQueue() { + this.log("pulse queue"); + if (this.ended) { + this.log("pulse queue ended"); + return; + } + if (this.ending) { + this.log("pulse queue on ending"); + if (this._idle.length) { + this._idle.slice().map((item) => { + this._remove(item.client); + }); + } + if (!this._clients.length) { + this.ended = true; + this._endCallback(); + } + return; + } + if (!this._pendingQueue.length) { + this.log("no queued requests"); + return; + } + if (!this._idle.length && this._isFull()) { + return; + } + const pendingItem = this._pendingQueue.shift(); + if (this._idle.length) { + const idleItem = this._idle.pop(); + clearTimeout(idleItem.timeoutId); + const client = idleItem.client; + client.ref && client.ref(); + const idleListener = idleItem.idleListener; + return this._acquireClient(client, pendingItem, idleListener, false); + } + if (!this._isFull()) { + return this.newClient(pendingItem); + } + throw new Error("unexpected condition"); + } + _remove(client, callback) { + const removed = removeWhere(this._idle, (item) => item.client === client); + if (removed !== void 0) { + clearTimeout(removed.timeoutId); + } + this._clients = this._clients.filter((c) => c !== client); + const context = this; + client.end(() => { + context.emit("remove", client); + if (typeof callback === "function") { + callback(); + } + }); + } + connect(cb) { + if (this.ending) { + const err = new Error("Cannot use a pool after calling end on the pool"); + return cb ? cb(err) : this.Promise.reject(err); + } + const response = promisify(this.Promise, cb); + const result = response.result; + if (this._isFull() || this._idle.length) { + if (this._idle.length) { + process.nextTick(() => this._pulseQueue()); + } + if (!this.options.connectionTimeoutMillis) { + this._pendingQueue.push(new PendingItem(response.callback)); + return result; + } + const queueCallback = (err, res, done) => { + clearTimeout(tid); + response.callback(err, res, done); + }; + const pendingItem = new PendingItem(queueCallback); + const tid = setTimeout(() => { + removeWhere(this._pendingQueue, (i) => i.callback === queueCallback); + pendingItem.timedOut = true; + response.callback(new Error("timeout exceeded when trying to connect")); + }, this.options.connectionTimeoutMillis); + if (tid.unref) { + tid.unref(); + } + this._pendingQueue.push(pendingItem); + return result; + } + this.newClient(new PendingItem(response.callback)); + return result; + } + newClient(pendingItem) { + const client = new this.Client(this.options); + this._clients.push(client); + const idleListener = makeIdleListener(this, client); + this.log("checking client timeout"); + let tid; + let timeoutHit = false; + if (this.options.connectionTimeoutMillis) { + tid = setTimeout(() => { + if (client.connection) { + this.log("ending client due to timeout"); + timeoutHit = true; + client.connection.stream.destroy(); + } else if (!client.isConnected()) { + this.log("ending client due to timeout"); + timeoutHit = true; + client.end(); + } + }, this.options.connectionTimeoutMillis); + } + this.log("connecting new client"); + client.connect((err) => { + if (tid) { + clearTimeout(tid); + } + client.on("error", idleListener); + if (err) { + this.log("client failed to connect", err); + this._clients = this._clients.filter((c) => c !== client); + if (timeoutHit) { + err = new Error("Connection terminated due to connection timeout", { cause: err }); + } + this._pulseQueue(); + if (!pendingItem.timedOut) { + pendingItem.callback(err, void 0, NOOP); + } + } else { + this.log("new client connected"); + if (this.options.onConnect) { + this._promiseTry(() => this.options.onConnect(client)).then( + () => { + this._afterConnect(client, pendingItem, idleListener); + }, + (hookErr) => { + this._clients = this._clients.filter((c) => c !== client); + client.end(() => { + this._pulseQueue(); + if (!pendingItem.timedOut) { + pendingItem.callback(hookErr, void 0, NOOP); + } + }); + } + ); + return; + } + return this._afterConnect(client, pendingItem, idleListener); + } + }); + } + _afterConnect(client, pendingItem, idleListener) { + if (this.options.maxLifetimeSeconds !== 0) { + const maxLifetimeTimeout = setTimeout(() => { + this.log("ending client due to expired lifetime"); + this._expired.add(client); + const idleIndex = this._idle.findIndex((idleItem) => idleItem.client === client); + if (idleIndex !== -1) { + this._acquireClient( + client, + new PendingItem((err, client2, clientRelease) => clientRelease()), + idleListener, + false + ); + } + }, this.options.maxLifetimeSeconds * 1e3); + maxLifetimeTimeout.unref(); + client.once("end", () => clearTimeout(maxLifetimeTimeout)); + } + return this._acquireClient(client, pendingItem, idleListener, true); + } + // acquire a client for a pending work item + _acquireClient(client, pendingItem, idleListener, isNew) { + if (isNew) { + this.emit("connect", client); + } + this.emit("acquire", client); + client.release = this._releaseOnce(client, idleListener); + client.removeListener("error", idleListener); + if (!pendingItem.timedOut) { + if (isNew && this.options.verify) { + this.options.verify(client, (err) => { + if (err) { + client.release(err); + return pendingItem.callback(err, void 0, NOOP); + } + pendingItem.callback(void 0, client, client.release); + }); + } else { + pendingItem.callback(void 0, client, client.release); + } + } else { + if (isNew && this.options.verify) { + this.options.verify(client, client.release); + } else { + client.release(); + } + } + } + // returns a function that wraps _release and throws if called more than once + _releaseOnce(client, idleListener) { + let released = false; + return (err) => { + if (released) { + throwOnDoubleRelease(); + } + released = true; + this._release(client, idleListener, err); + }; + } + // release a client back to the poll, include an error + // to remove it from the pool + _release(client, idleListener, err) { + client.on("error", idleListener); + client._poolUseCount = (client._poolUseCount || 0) + 1; + this.emit("release", err, client); + if (err || this.ending || !client._queryable || client._ending || client._poolUseCount >= this.options.maxUses) { + if (client._poolUseCount >= this.options.maxUses) { + this.log("remove expended client"); + } + return this._remove(client, this._pulseQueue.bind(this)); + } + const isExpired = this._expired.has(client); + if (isExpired) { + this.log("remove expired client"); + this._expired.delete(client); + return this._remove(client, this._pulseQueue.bind(this)); + } + let tid; + if (this.options.idleTimeoutMillis && this._isAboveMin()) { + tid = setTimeout(() => { + if (this._isAboveMin()) { + this.log("remove idle client"); + this._remove(client, this._pulseQueue.bind(this)); + } + }, this.options.idleTimeoutMillis); + if (this.options.allowExitOnIdle) { + tid.unref(); + } + } + if (this.options.allowExitOnIdle) { + client.unref(); + } + this._idle.push(new IdleItem(client, idleListener, tid)); + this._pulseQueue(); + } + query(text, values, cb) { + if (typeof text === "function") { + const response2 = promisify(this.Promise, text); + setImmediate(function() { + return response2.callback(new Error("Passing a function as the first parameter to pool.query is not supported")); + }); + return response2.result; + } + if (typeof values === "function") { + cb = values; + values = void 0; + } + const response = promisify(this.Promise, cb); + cb = response.callback; + this.connect((err, client) => { + if (err) { + return cb(err); + } + let clientReleased = false; + const onError = (err2) => { + if (clientReleased) { + return; + } + clientReleased = true; + client.release(err2); + cb(err2); + }; + client.once("error", onError); + this.log("dispatching query"); + try { + client.query(text, values, (err2, res) => { + this.log("query dispatched"); + client.removeListener("error", onError); + if (clientReleased) { + return; + } + clientReleased = true; + client.release(err2); + if (err2) { + return cb(err2); + } + return cb(void 0, res); + }); + } catch (err2) { + client.release(err2); + return cb(err2); + } + }); + return response.result; + } + end(cb) { + this.log("ending"); + if (this.ending) { + const err = new Error("Called end on pool more than once"); + return cb ? cb(err) : this.Promise.reject(err); + } + this.ending = true; + const promised = promisify(this.Promise, cb); + this._endCallback = promised.callback; + this._pulseQueue(); + return promised.result; + } + get waitingCount() { + return this._pendingQueue.length; + } + get idleCount() { + return this._idle.length; + } + get expiredCount() { + return this._clients.reduce((acc, client) => acc + (this._expired.has(client) ? 1 : 0), 0); + } + get totalCount() { + return this._clients.length; + } + }; + module2.exports = Pool; + } +}); + +// node_modules/pg/lib/native/query.js +var require_query4 = __commonJS({ + "node_modules/pg/lib/native/query.js"(exports2, module2) { + "use strict"; + var EventEmitter = require("events").EventEmitter; + var util = require("util"); + var utils = require_utils(); + var NativeQuery = module2.exports = function(config, values, callback) { + EventEmitter.call(this); + config = utils.normalizeQueryConfig(config, values, callback); + this.text = config.text; + this.values = config.values; + this.name = config.name; + this.queryMode = config.queryMode; + this.callback = config.callback; + this.state = "new"; + this._arrayMode = config.rowMode === "array"; + this._emitRowEvents = false; + this.on( + "newListener", + function(event) { + if (event === "row") this._emitRowEvents = true; + }.bind(this) + ); + }; + util.inherits(NativeQuery, EventEmitter); + var errorFieldMap = { + sqlState: "code", + statementPosition: "position", + messagePrimary: "message", + messageDetail: "detail", + messageHint: "hint", + context: "where", + schemaName: "schema", + tableName: "table", + columnName: "column", + dataTypeName: "dataType", + constraintName: "constraint", + sourceFile: "file", + sourceLine: "line", + sourceFunction: "routine" + }; + NativeQuery.prototype.handleError = function(err) { + const fields = this.native && this.native.pq.resultErrorFields(); + if (fields) { + for (const key in fields) { + const normalizedFieldName = errorFieldMap[key] || key; + err[normalizedFieldName] = fields[key]; + } + } + if (this.callback) { + this.callback(err); + } else { + this.emit("error", err); + } + this.state = "error"; + }; + NativeQuery.prototype.then = function(onSuccess, onFailure) { + return this._getPromise().then(onSuccess, onFailure); + }; + NativeQuery.prototype.catch = function(callback) { + return this._getPromise().catch(callback); + }; + NativeQuery.prototype._getPromise = function() { + if (this._promise) return this._promise; + this._promise = new Promise( + function(resolve, reject) { + this._once("end", resolve); + this._once("error", reject); + }.bind(this) + ); + return this._promise; + }; + NativeQuery.prototype.submit = function(client) { + this.state = "running"; + const self2 = this; + this.native = client.native; + client.native.arrayMode = this._arrayMode; + let after = function(err, rows, results) { + client.native.arrayMode = false; + setImmediate(function() { + self2.emit("_done"); + }); + if (err) { + return self2.handleError(err); + } + if (self2._emitRowEvents) { + if (results.length > 1) { + rows.forEach((rowOfRows, i) => { + rowOfRows.forEach((row) => { + self2.emit("row", row, results[i]); + }); + }); + } else { + rows.forEach(function(row) { + self2.emit("row", row, results); + }); + } + } + self2.state = "end"; + self2.emit("end", results); + if (self2.callback) { + self2.callback(null, results); + } + }; + if (process.domain) { + after = process.domain.bind(after); + } + if (this.name) { + if (this.name.length > 63) { + console.error("Warning! Postgres only supports 63 characters for query names."); + console.error("You supplied %s (%s)", this.name, this.name.length); + console.error("This can cause conflicts and silent errors executing queries"); + } + const values = (this.values || []).map(utils.prepareValue); + if (client.namedQueries[this.name] !== void 0) { + if (this.text && client.namedQueries[this.name] !== this.text) { + const err = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`); + return after(err); + } + return client.native.execute(this.name, values, after); + } + return client.native.prepare(this.name, this.text, values.length, function(err) { + if (err) return after(err); + client.namedQueries[self2.name] = self2.text; + return self2.native.execute(self2.name, values, after); + }); + } else if (this.values) { + if (!Array.isArray(this.values)) { + const err = new Error("Query values must be an array"); + return after(err); + } + const vals = this.values.map(utils.prepareValue); + client.native.query(this.text, vals, after); + } else if (this.queryMode === "extended") { + client.native.query(this.text, [], after); + } else { + client.native.query(this.text, after); + } + }; + } +}); + +// node_modules/pg/lib/native/client.js +var require_client3 = __commonJS({ + "node_modules/pg/lib/native/client.js"(exports2, module2) { + var nodeUtils = require("util"); + var Native; + try { + Native = require("pg-native"); + } catch (e) { + throw e; + } + var TypeOverrides = require_type_overrides(); + var EventEmitter = require("events").EventEmitter; + var util = require("util"); + var ConnectionParameters = require_connection_parameters(); + var NativeQuery = require_query4(); + var queryQueueLengthDeprecationNotice = nodeUtils.deprecate( + () => { + }, + "Calling client.query() when the client is already executing a query is deprecated and will be removed in pg@9.0. Use async/await or an external async flow control mechanism instead." + ); + var Client = module2.exports = function(config) { + EventEmitter.call(this); + config = config || {}; + this._Promise = config.Promise || global.Promise; + this._types = new TypeOverrides(config.types); + this.native = new Native({ + types: this._types + }); + this._queryQueue = []; + this._ending = false; + this._connecting = false; + this._connected = false; + this._queryable = true; + this.pipeline = Boolean(config.pipeline); + this._pipelineInFlight = false; + const cp = this.connectionParameters = new ConnectionParameters(config); + if (config.nativeConnectionString) cp.nativeConnectionString = config.nativeConnectionString; + this.user = cp.user; + Object.defineProperty(this, "password", { + configurable: true, + enumerable: false, + writable: true, + value: cp.password + }); + this.database = cp.database; + this.host = cp.host; + this.port = cp.port; + this.namedQueries = {}; + }; + Client.Query = NativeQuery; + util.inherits(Client, EventEmitter); + Client.prototype._errorAllQueries = function(err) { + const enqueueError = (query) => { + process.nextTick(() => { + query.native = this.native; + query.handleError(err); + }); + }; + if (this._hasActiveQuery()) { + enqueueError(this._activeQuery); + this._activeQuery = null; + } + this._queryQueue.forEach(enqueueError); + this._queryQueue.length = 0; + }; + Client.prototype._connect = function(cb) { + const self2 = this; + if (this._connecting) { + process.nextTick(() => cb(new Error("Client has already been connected. You cannot reuse a client."))); + return; + } + this._connecting = true; + this.connectionParameters.getLibpqConnectionString(function(err, conString) { + if (self2.connectionParameters.nativeConnectionString) conString = self2.connectionParameters.nativeConnectionString; + if (err) return cb(err); + self2.native.connect(conString, function(err2) { + if (err2) { + self2.native.end(); + return cb(err2); + } + self2._connected = true; + self2.native.on("error", function(err3) { + self2._queryable = false; + self2._errorAllQueries(err3); + self2.emit("error", err3); + }); + self2.native.on("notification", function(msg) { + self2.emit("notification", { + channel: msg.relname, + payload: msg.extra + }); + }); + self2.emit("connect"); + self2._pulseQueryQueue(true); + cb(null, this); + }); + }); + }; + Client.prototype.connect = function(callback) { + if (callback) { + this._connect(callback); + return; + } + return new this._Promise((resolve, reject) => { + this._connect((error) => { + if (error) { + reject(error); + } else { + resolve(this); + } + }); + }); + }; + Client.prototype.query = function(config, values, callback) { + let query; + let result; + let readTimeout; + let readTimeoutTimer; + let queryCallback; + if (config === null || config === void 0) { + throw new TypeError("Client was passed a null or undefined query"); + } else if (typeof config.submit === "function") { + readTimeout = config.query_timeout || this.connectionParameters.query_timeout; + result = query = config; + if (typeof values === "function") { + config.callback = values; + } + } else { + readTimeout = config.query_timeout || this.connectionParameters.query_timeout; + query = new NativeQuery(config, values, callback); + if (!query.callback) { + let resolveOut, rejectOut; + result = new this._Promise((resolve, reject) => { + resolveOut = resolve; + rejectOut = reject; + }).catch((err) => { + Error.captureStackTrace(err); + throw err; + }); + query.callback = (err, res) => err ? rejectOut(err) : resolveOut(res); + } + } + if (readTimeout) { + queryCallback = query.callback || (() => { + }); + readTimeoutTimer = setTimeout(() => { + const error = new Error("Query read timeout"); + process.nextTick(() => { + query.handleError(error, this.connection); + }); + queryCallback(error); + query.callback = () => { + }; + const index = this._queryQueue.indexOf(query); + if (index > -1) { + this._queryQueue.splice(index, 1); + } + this._pulseQueryQueue(); + }, readTimeout); + query.callback = (err, res) => { + clearTimeout(readTimeoutTimer); + queryCallback(err, res); + }; + } + if (!this._queryable) { + query.native = this.native; + process.nextTick(() => { + query.handleError(new Error("Client has encountered a connection error and is not queryable")); + }); + return result; + } + if (this._ending) { + query.native = this.native; + process.nextTick(() => { + query.handleError(new Error("Client was closed and is not queryable")); + }); + return result; + } + if (this._queryQueue.length > 0 && !this.pipeline) { + queryQueueLengthDeprecationNotice(); + } + this._queryQueue.push(query); + this._pulseQueryQueue(); + return result; + }; + Client.prototype.end = function(cb) { + const self2 = this; + this._ending = true; + if (this._connecting && !this._connected) { + this.once("connect", () => { + this.end(() => { + }); + }); + } + let result; + if (!cb) { + result = new this._Promise(function(resolve, reject) { + cb = (err) => err ? reject(err) : resolve(); + }); + } + const doEnd = function() { + self2.native.end(function() { + self2._connected = false; + self2._errorAllQueries(new Error("Connection terminated")); + process.nextTick(() => { + self2.emit("end"); + if (cb) cb(); + }); + }); + }; + if (this.pipeline && (this._pipelineInFlight || this._queryQueue.length > 0)) { + this.once("drain", doEnd); + } else { + doEnd(); + } + return result; + }; + Client.prototype._hasActiveQuery = function() { + return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end"; + }; + Client.prototype._pulseQueryQueue = function(initialConnection) { + if (!this._connected) { + return; + } + if (this.pipeline && !initialConnection) { + return this._pulsePipelinedQueryQueue(); + } + if (this._hasActiveQuery()) { + return; + } + const query = this._queryQueue.shift(); + if (!query) { + if (!initialConnection) { + this.emit("drain"); + } + return; + } + this._activeQuery = query; + query.submit(this); + const self2 = this; + query.once("_done", function() { + self2._pulseQueryQueue(); + }); + }; + Client.prototype._pulsePipelinedQueryQueue = function() { + if (!this._connected || this._pipelineInFlight) { + return; + } + if (this._queryQueue.length === 0) { + if (this.hasExecuted) { + this.emit("drain"); + } + return; + } + this._pipelineInFlight = true; + const self2 = this; + const queries = []; + const nativeQueries = []; + const utils = require_utils(); + while (this._queryQueue.length > 0) { + const query = this._queryQueue.shift(); + this.hasExecuted = true; + nativeQueries.push(query); + const values = query.values ? query.values.map(utils.prepareValue) : null; + const pipelineEntry = { text: query.text, name: query.name, arrayMode: query._arrayMode }; + if (values) { + pipelineEntry.values = values; + } + if (query.name && this.namedQueries[query.name]) { + pipelineEntry._alreadyPrepared = true; + } + queries.push(pipelineEntry); + } + this.native.pipeline(queries, function(err, results) { + self2._pipelineInFlight = false; + if (err) { + self2._connected = false; + self2._queryable = false; + for (let i = 0; i < nativeQueries.length; i++) { + const q = nativeQueries[i]; + q.native = self2.native; + q.handleError(err); + } + self2._errorAllQueries(err); + self2.emit("error", err); + self2.emit("end"); + return; + } + for (let i = 0; i < nativeQueries.length; i++) { + const q = nativeQueries[i]; + const r = results[i]; + q.native = self2.native; + if (r.err) { + q.handleError(r.err); + } else { + if (q.name) { + self2.namedQueries[q.name] = q.text; + } + q.state = "end"; + q.emit("end", r.result); + if (q.callback) { + q.callback(null, r.result); + } + } + setImmediate(function() { + q.emit("_done"); + }); + } + self2._pulsePipelinedQueryQueue(); + }); + }; + Client.prototype.cancel = function(query) { + if (this._activeQuery === query) { + this.native.cancel(function() { + }); + } else if (this._queryQueue.indexOf(query) !== -1) { + this._queryQueue.splice(this._queryQueue.indexOf(query), 1); + } + }; + Client.prototype.ref = function() { + }; + Client.prototype.unref = function() { + }; + Client.prototype.setTypeParser = function(oid, format, parseFn) { + return this._types.setTypeParser(oid, format, parseFn); + }; + Client.prototype.getTypeParser = function(oid, format) { + return this._types.getTypeParser(oid, format); + }; + Client.prototype.isConnected = function() { + return this._connected; + }; + Client.prototype.getTransactionStatus = function() { + return this.native.getTransactionStatus(); + }; + } +}); + +// node_modules/pg/lib/native/index.js +var require_native = __commonJS({ + "node_modules/pg/lib/native/index.js"(exports2, module2) { + "use strict"; + module2.exports = require_client3(); + } +}); + +// node_modules/pg/lib/index.js +var require_lib6 = __commonJS({ + "node_modules/pg/lib/index.js"(exports2, module2) { + "use strict"; + var Client = require_client2(); + var defaults = require_defaults2(); + var Connection = require_connection4(); + var Result = require_result(); + var utils = require_utils(); + var Pool = require_pg_pool(); + var TypeOverrides = require_type_overrides(); + var { DatabaseError } = require_dist(); + var { escapeIdentifier, escapeLiteral } = require_utils(); + var poolFactory = (Client2) => { + return class BoundPool extends Pool { + constructor(options) { + super(options, Client2); + } + }; + }; + var PG = function(clientConstructor2) { + this.defaults = defaults; + this.Client = clientConstructor2; + this.Query = this.Client.Query; + this.Pool = poolFactory(this.Client); + this._pools = []; + this.Connection = Connection; + this.types = require_pg_types(); + this.DatabaseError = DatabaseError; + this.TypeOverrides = TypeOverrides; + this.escapeIdentifier = escapeIdentifier; + this.escapeLiteral = escapeLiteral; + this.Result = Result; + this.utils = utils; + }; + var clientConstructor = Client; + var forceNative = false; + try { + forceNative = !!process.env.NODE_PG_FORCE_NATIVE; + } catch { + } + if (forceNative) { + clientConstructor = require_native(); + } + module2.exports = new PG(clientConstructor); + Object.defineProperty(module2.exports, "native", { + configurable: true, + enumerable: false, + get() { + let native = null; + try { + native = new PG(require_native()); + } catch (err) { + if (err.code !== "MODULE_NOT_FOUND") { + throw err; + } + } + Object.defineProperty(module2.exports, "native", { + value: native + }); + return native; + } + }); + } +}); + +// node_modules/bson/lib/bson.cjs +var require_bson = __commonJS({ + "node_modules/bson/lib/bson.cjs"(exports2) { + "use strict"; + var TypedArrayPrototypeGetSymbolToStringTag = (() => { + const g = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get; + return (value) => g.call(value); + })(); + function isUint8Array(value) { + return TypedArrayPrototypeGetSymbolToStringTag(value) === "Uint8Array"; + } + function isAnyArrayBuffer(value) { + return typeof value === "object" && value != null && Symbol.toStringTag in value && (value[Symbol.toStringTag] === "ArrayBuffer" || value[Symbol.toStringTag] === "SharedArrayBuffer"); + } + function isRegExp(regexp2) { + return regexp2 instanceof RegExp || Object.prototype.toString.call(regexp2) === "[object RegExp]"; + } + function isMap(value) { + return typeof value === "object" && value != null && Symbol.toStringTag in value && value[Symbol.toStringTag] === "Map"; + } + function isDate(date) { + return date instanceof Date || Object.prototype.toString.call(date) === "[object Date]"; + } + function defaultInspect(x, _options) { + return JSON.stringify(x, (k, v) => { + if (typeof v === "bigint") { + return { $numberLong: `${v}` }; + } else if (isMap(v)) { + return Object.fromEntries(v); + } + return v; + }); + } + function getStylizeFunction(options) { + const stylizeExists = options != null && typeof options === "object" && "stylize" in options && typeof options.stylize === "function"; + if (stylizeExists) { + return options.stylize; + } + } + var BSON_MAJOR_VERSION = 6; + var BSON_VERSION_SYMBOL = /* @__PURE__ */ Symbol.for("@@mdb.bson.version"); + var BSON_INT32_MAX = 2147483647; + var BSON_INT32_MIN = -2147483648; + var BSON_INT64_MAX = Math.pow(2, 63) - 1; + var BSON_INT64_MIN = -Math.pow(2, 63); + var JS_INT_MAX = Math.pow(2, 53); + var JS_INT_MIN = -Math.pow(2, 53); + var BSON_DATA_NUMBER = 1; + var BSON_DATA_STRING = 2; + var BSON_DATA_OBJECT = 3; + var BSON_DATA_ARRAY = 4; + var BSON_DATA_BINARY = 5; + var BSON_DATA_UNDEFINED = 6; + var BSON_DATA_OID = 7; + var BSON_DATA_BOOLEAN = 8; + var BSON_DATA_DATE = 9; + var BSON_DATA_NULL = 10; + var BSON_DATA_REGEXP = 11; + var BSON_DATA_DBPOINTER = 12; + var BSON_DATA_CODE = 13; + var BSON_DATA_SYMBOL = 14; + var BSON_DATA_CODE_W_SCOPE = 15; + var BSON_DATA_INT = 16; + var BSON_DATA_TIMESTAMP = 17; + var BSON_DATA_LONG = 18; + var BSON_DATA_DECIMAL128 = 19; + var BSON_DATA_MIN_KEY = 255; + var BSON_DATA_MAX_KEY = 127; + var BSON_BINARY_SUBTYPE_DEFAULT = 0; + var BSON_BINARY_SUBTYPE_UUID_NEW = 4; + var BSONType = Object.freeze({ + double: 1, + string: 2, + object: 3, + array: 4, + binData: 5, + undefined: 6, + objectId: 7, + bool: 8, + date: 9, + null: 10, + regex: 11, + dbPointer: 12, + javascript: 13, + symbol: 14, + javascriptWithScope: 15, + int: 16, + timestamp: 17, + long: 18, + decimal: 19, + minKey: -1, + maxKey: 127 + }); + var BSONError = class extends Error { + get bsonError() { + return true; + } + get name() { + return "BSONError"; + } + constructor(message, options) { + super(message, options); + } + static isBSONError(value) { + return value != null && typeof value === "object" && "bsonError" in value && value.bsonError === true && "name" in value && "message" in value && "stack" in value; + } + }; + var BSONVersionError = class extends BSONError { + get name() { + return "BSONVersionError"; + } + constructor() { + super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`); + } + }; + var BSONRuntimeError = class extends BSONError { + get name() { + return "BSONRuntimeError"; + } + constructor(message) { + super(message); + } + }; + var BSONOffsetError = class extends BSONError { + get name() { + return "BSONOffsetError"; + } + constructor(message, offset, options) { + super(`${message}. offset: ${offset}`, options); + this.offset = offset; + } + }; + var TextDecoderFatal; + var TextDecoderNonFatal; + function parseUtf8(buffer2, start, end, fatal) { + if (fatal) { + TextDecoderFatal ??= new TextDecoder("utf8", { fatal: true }); + try { + return TextDecoderFatal.decode(buffer2.subarray(start, end)); + } catch (cause) { + throw new BSONError("Invalid UTF-8 string in BSON document", { cause }); + } + } + TextDecoderNonFatal ??= new TextDecoder("utf8", { fatal: false }); + return TextDecoderNonFatal.decode(buffer2.subarray(start, end)); + } + function tryReadBasicLatin(uint8array, start, end) { + if (uint8array.length === 0) { + return ""; + } + const stringByteLength = end - start; + if (stringByteLength === 0) { + return ""; + } + if (stringByteLength > 20) { + return null; + } + if (stringByteLength === 1 && uint8array[start] < 128) { + return String.fromCharCode(uint8array[start]); + } + if (stringByteLength === 2 && uint8array[start] < 128 && uint8array[start + 1] < 128) { + return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]); + } + if (stringByteLength === 3 && uint8array[start] < 128 && uint8array[start + 1] < 128 && uint8array[start + 2] < 128) { + return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]) + String.fromCharCode(uint8array[start + 2]); + } + const latinBytes = []; + for (let i = start; i < end; i++) { + const byte = uint8array[i]; + if (byte > 127) { + return null; + } + latinBytes.push(byte); + } + return String.fromCharCode(...latinBytes); + } + function tryWriteBasicLatin(destination, source, offset) { + if (source.length === 0) + return 0; + if (source.length > 25) + return null; + if (destination.length - offset < source.length) + return null; + for (let charOffset = 0, destinationOffset = offset; charOffset < source.length; charOffset++, destinationOffset++) { + const char = source.charCodeAt(charOffset); + if (char > 127) + return null; + destination[destinationOffset] = char; + } + return source.length; + } + function nodejsMathRandomBytes(byteLength) { + return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))); + } + var nodejsRandomBytes = (() => { + try { + return require("crypto").randomBytes; + } catch { + return nodejsMathRandomBytes; + } + })(); + var nodeJsByteUtils = { + toLocalBufferType(potentialBuffer) { + if (Buffer.isBuffer(potentialBuffer)) { + return potentialBuffer; + } + if (ArrayBuffer.isView(potentialBuffer)) { + return Buffer.from(potentialBuffer.buffer, potentialBuffer.byteOffset, potentialBuffer.byteLength); + } + const stringTag = potentialBuffer?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialBuffer); + if (stringTag === "ArrayBuffer" || stringTag === "SharedArrayBuffer" || stringTag === "[object ArrayBuffer]" || stringTag === "[object SharedArrayBuffer]") { + return Buffer.from(potentialBuffer); + } + throw new BSONError(`Cannot create Buffer from the passed potentialBuffer.`); + }, + allocate(size) { + return Buffer.alloc(size); + }, + allocateUnsafe(size) { + return Buffer.allocUnsafe(size); + }, + equals(a, b) { + return nodeJsByteUtils.toLocalBufferType(a).equals(b); + }, + fromNumberArray(array) { + return Buffer.from(array); + }, + fromBase64(base64) { + return Buffer.from(base64, "base64"); + }, + toBase64(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("base64"); + }, + fromISO88591(codePoints) { + return Buffer.from(codePoints, "binary"); + }, + toISO88591(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("binary"); + }, + fromHex(hex) { + return Buffer.from(hex, "hex"); + }, + toHex(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).toString("hex"); + }, + toUTF8(buffer2, start, end, fatal) { + const basicLatin = end - start <= 20 ? tryReadBasicLatin(buffer2, start, end) : null; + if (basicLatin != null) { + return basicLatin; + } + const string = nodeJsByteUtils.toLocalBufferType(buffer2).toString("utf8", start, end); + if (fatal) { + for (let i = 0; i < string.length; i++) { + if (string.charCodeAt(i) === 65533) { + parseUtf8(buffer2, start, end, true); + break; + } + } + } + return string; + }, + utf8ByteLength(input) { + return Buffer.byteLength(input, "utf8"); + }, + encodeUTF8Into(buffer2, source, byteOffset) { + const latinBytesWritten = tryWriteBasicLatin(buffer2, source, byteOffset); + if (latinBytesWritten != null) { + return latinBytesWritten; + } + return nodeJsByteUtils.toLocalBufferType(buffer2).write(source, byteOffset, void 0, "utf8"); + }, + randomBytes: nodejsRandomBytes, + swap32(buffer2) { + return nodeJsByteUtils.toLocalBufferType(buffer2).swap32(); + } + }; + function isReactNative() { + const { navigator: navigator2 } = globalThis; + return typeof navigator2 === "object" && navigator2.product === "ReactNative"; + } + function webMathRandomBytes(byteLength) { + if (byteLength < 0) { + throw new RangeError(`The argument 'byteLength' is invalid. Received ${byteLength}`); + } + return webByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256))); + } + var webRandomBytes = (() => { + const { crypto } = globalThis; + if (crypto != null && typeof crypto.getRandomValues === "function") { + return (byteLength) => { + return crypto.getRandomValues(webByteUtils.allocate(byteLength)); + }; + } else { + if (isReactNative()) { + const { console: console2 } = globalThis; + console2?.warn?.("BSON: For React Native please polyfill crypto.getRandomValues, e.g. using: https://www.npmjs.com/package/react-native-get-random-values."); + } + return webMathRandomBytes; + } + })(); + var HEX_DIGIT = /(\d|[a-f])/i; + var webByteUtils = { + toLocalBufferType(potentialUint8array) { + const stringTag = potentialUint8array?.[Symbol.toStringTag] ?? Object.prototype.toString.call(potentialUint8array); + if (stringTag === "Uint8Array") { + return potentialUint8array; + } + if (ArrayBuffer.isView(potentialUint8array)) { + return new Uint8Array(potentialUint8array.buffer.slice(potentialUint8array.byteOffset, potentialUint8array.byteOffset + potentialUint8array.byteLength)); + } + if (stringTag === "ArrayBuffer" || stringTag === "SharedArrayBuffer" || stringTag === "[object ArrayBuffer]" || stringTag === "[object SharedArrayBuffer]") { + return new Uint8Array(potentialUint8array); + } + throw new BSONError(`Cannot make a Uint8Array from passed potentialBuffer.`); + }, + allocate(size) { + if (typeof size !== "number") { + throw new TypeError(`The "size" argument must be of type number. Received ${String(size)}`); + } + return new Uint8Array(size); + }, + allocateUnsafe(size) { + return webByteUtils.allocate(size); + }, + equals(a, b) { + if (a.byteLength !== b.byteLength) { + return false; + } + for (let i = 0; i < a.byteLength; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + }, + fromNumberArray(array) { + return Uint8Array.from(array); + }, + fromBase64(base64) { + return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)); + }, + toBase64(uint8array) { + return btoa(webByteUtils.toISO88591(uint8array)); + }, + fromISO88591(codePoints) { + return Uint8Array.from(codePoints, (c) => c.charCodeAt(0) & 255); + }, + toISO88591(uint8array) { + return Array.from(Uint16Array.from(uint8array), (b) => String.fromCharCode(b)).join(""); + }, + fromHex(hex) { + const evenLengthHex = hex.length % 2 === 0 ? hex : hex.slice(0, hex.length - 1); + const buffer2 = []; + for (let i = 0; i < evenLengthHex.length; i += 2) { + const firstDigit = evenLengthHex[i]; + const secondDigit = evenLengthHex[i + 1]; + if (!HEX_DIGIT.test(firstDigit)) { + break; + } + if (!HEX_DIGIT.test(secondDigit)) { + break; + } + const hexDigit = Number.parseInt(`${firstDigit}${secondDigit}`, 16); + buffer2.push(hexDigit); + } + return Uint8Array.from(buffer2); + }, + toHex(uint8array) { + return Array.from(uint8array, (byte) => byte.toString(16).padStart(2, "0")).join(""); + }, + toUTF8(uint8array, start, end, fatal) { + const basicLatin = end - start <= 20 ? tryReadBasicLatin(uint8array, start, end) : null; + if (basicLatin != null) { + return basicLatin; + } + return parseUtf8(uint8array, start, end, fatal); + }, + utf8ByteLength(input) { + return new TextEncoder().encode(input).byteLength; + }, + encodeUTF8Into(uint8array, source, byteOffset) { + const bytes = new TextEncoder().encode(source); + uint8array.set(bytes, byteOffset); + return bytes.byteLength; + }, + randomBytes: webRandomBytes, + swap32(buffer2) { + if (buffer2.length % 4 !== 0) { + throw new RangeError("Buffer size must be a multiple of 32-bits"); + } + for (let i = 0; i < buffer2.length; i += 4) { + const byte0 = buffer2[i]; + const byte1 = buffer2[i + 1]; + const byte2 = buffer2[i + 2]; + const byte3 = buffer2[i + 3]; + buffer2[i] = byte3; + buffer2[i + 1] = byte2; + buffer2[i + 2] = byte1; + buffer2[i + 3] = byte0; + } + return buffer2; + } + }; + var hasGlobalBuffer = typeof Buffer === "function" && Buffer.prototype?._isBuffer !== true; + var ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils; + var BSONValue = class { + get [BSON_VERSION_SYMBOL]() { + return BSON_MAJOR_VERSION; + } + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")](depth, options, inspect) { + return this.inspect(depth, options, inspect); + } + }; + var FLOAT = new Float64Array(1); + var FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8); + FLOAT[0] = -1; + var isBigEndian = FLOAT_BYTES[7] === 0; + var NumberUtils = { + isBigEndian, + getNonnegativeInt32LE(source, offset) { + if (source[offset + 3] > 127) { + throw new RangeError(`Size cannot be negative at offset: ${offset}`); + } + return source[offset] | source[offset + 1] << 8 | source[offset + 2] << 16 | source[offset + 3] << 24; + }, + getInt32LE(source, offset) { + return source[offset] | source[offset + 1] << 8 | source[offset + 2] << 16 | source[offset + 3] << 24; + }, + getUint32LE(source, offset) { + return source[offset] + source[offset + 1] * 256 + source[offset + 2] * 65536 + source[offset + 3] * 16777216; + }, + getUint32BE(source, offset) { + return source[offset + 3] + source[offset + 2] * 256 + source[offset + 1] * 65536 + source[offset] * 16777216; + }, + getBigInt64LE(source, offset) { + const hi = BigInt(source[offset + 4] + source[offset + 5] * 256 + source[offset + 6] * 65536 + (source[offset + 7] << 24)); + const lo = BigInt(source[offset] + source[offset + 1] * 256 + source[offset + 2] * 65536 + source[offset + 3] * 16777216); + return (hi << BigInt(32)) + lo; + }, + getFloat64LE: isBigEndian ? (source, offset) => { + FLOAT_BYTES[7] = source[offset]; + FLOAT_BYTES[6] = source[offset + 1]; + FLOAT_BYTES[5] = source[offset + 2]; + FLOAT_BYTES[4] = source[offset + 3]; + FLOAT_BYTES[3] = source[offset + 4]; + FLOAT_BYTES[2] = source[offset + 5]; + FLOAT_BYTES[1] = source[offset + 6]; + FLOAT_BYTES[0] = source[offset + 7]; + return FLOAT[0]; + } : (source, offset) => { + FLOAT_BYTES[0] = source[offset]; + FLOAT_BYTES[1] = source[offset + 1]; + FLOAT_BYTES[2] = source[offset + 2]; + FLOAT_BYTES[3] = source[offset + 3]; + FLOAT_BYTES[4] = source[offset + 4]; + FLOAT_BYTES[5] = source[offset + 5]; + FLOAT_BYTES[6] = source[offset + 6]; + FLOAT_BYTES[7] = source[offset + 7]; + return FLOAT[0]; + }, + setInt32BE(destination, offset, value) { + destination[offset + 3] = value; + value >>>= 8; + destination[offset + 2] = value; + value >>>= 8; + destination[offset + 1] = value; + value >>>= 8; + destination[offset] = value; + return 4; + }, + setInt32LE(destination, offset, value) { + destination[offset] = value; + value >>>= 8; + destination[offset + 1] = value; + value >>>= 8; + destination[offset + 2] = value; + value >>>= 8; + destination[offset + 3] = value; + return 4; + }, + setBigInt64LE(destination, offset, value) { + const mask32bits = BigInt(4294967295); + let lo = Number(value & mask32bits); + destination[offset] = lo; + lo >>= 8; + destination[offset + 1] = lo; + lo >>= 8; + destination[offset + 2] = lo; + lo >>= 8; + destination[offset + 3] = lo; + let hi = Number(value >> BigInt(32) & mask32bits); + destination[offset + 4] = hi; + hi >>= 8; + destination[offset + 5] = hi; + hi >>= 8; + destination[offset + 6] = hi; + hi >>= 8; + destination[offset + 7] = hi; + return 8; + }, + setFloat64LE: isBigEndian ? (destination, offset, value) => { + FLOAT[0] = value; + destination[offset] = FLOAT_BYTES[7]; + destination[offset + 1] = FLOAT_BYTES[6]; + destination[offset + 2] = FLOAT_BYTES[5]; + destination[offset + 3] = FLOAT_BYTES[4]; + destination[offset + 4] = FLOAT_BYTES[3]; + destination[offset + 5] = FLOAT_BYTES[2]; + destination[offset + 6] = FLOAT_BYTES[1]; + destination[offset + 7] = FLOAT_BYTES[0]; + return 8; + } : (destination, offset, value) => { + FLOAT[0] = value; + destination[offset] = FLOAT_BYTES[0]; + destination[offset + 1] = FLOAT_BYTES[1]; + destination[offset + 2] = FLOAT_BYTES[2]; + destination[offset + 3] = FLOAT_BYTES[3]; + destination[offset + 4] = FLOAT_BYTES[4]; + destination[offset + 5] = FLOAT_BYTES[5]; + destination[offset + 6] = FLOAT_BYTES[6]; + destination[offset + 7] = FLOAT_BYTES[7]; + return 8; + } + }; + var Binary = class _Binary extends BSONValue { + get _bsontype() { + return "Binary"; + } + constructor(buffer2, subType) { + super(); + if (!(buffer2 == null) && typeof buffer2 === "string" && !ArrayBuffer.isView(buffer2) && !isAnyArrayBuffer(buffer2) && !Array.isArray(buffer2)) { + throw new BSONError("Binary can only be constructed from Uint8Array or number[]"); + } + this.sub_type = subType ?? _Binary.BSON_BINARY_SUBTYPE_DEFAULT; + if (buffer2 == null) { + this.buffer = ByteUtils.allocate(_Binary.BUFFER_SIZE); + this.position = 0; + } else { + this.buffer = Array.isArray(buffer2) ? ByteUtils.fromNumberArray(buffer2) : ByteUtils.toLocalBufferType(buffer2); + this.position = this.buffer.byteLength; + } + } + put(byteValue) { + if (typeof byteValue === "string" && byteValue.length !== 1) { + throw new BSONError("only accepts single character String"); + } else if (typeof byteValue !== "number" && byteValue.length !== 1) + throw new BSONError("only accepts single character Uint8Array or Array"); + let decodedByte; + if (typeof byteValue === "string") { + decodedByte = byteValue.charCodeAt(0); + } else if (typeof byteValue === "number") { + decodedByte = byteValue; + } else { + decodedByte = byteValue[0]; + } + if (decodedByte < 0 || decodedByte > 255) { + throw new BSONError("only accepts number in a valid unsigned byte range 0-255"); + } + if (this.buffer.byteLength > this.position) { + this.buffer[this.position++] = decodedByte; + } else { + const newSpace = ByteUtils.allocate(_Binary.BUFFER_SIZE + this.buffer.length); + newSpace.set(this.buffer, 0); + this.buffer = newSpace; + this.buffer[this.position++] = decodedByte; + } + } + write(sequence, offset) { + offset = typeof offset === "number" ? offset : this.position; + if (this.buffer.byteLength < offset + sequence.length) { + const newSpace = ByteUtils.allocate(this.buffer.byteLength + sequence.length); + newSpace.set(this.buffer, 0); + this.buffer = newSpace; + } + if (ArrayBuffer.isView(sequence)) { + this.buffer.set(ByteUtils.toLocalBufferType(sequence), offset); + this.position = offset + sequence.byteLength > this.position ? offset + sequence.length : this.position; + } else if (typeof sequence === "string") { + throw new BSONError("input cannot be string"); + } + } + read(position, length) { + length = length && length > 0 ? length : this.position; + const end = position + length; + return this.buffer.subarray(position, end > this.position ? this.position : end); + } + value() { + return this.buffer.length === this.position ? this.buffer : this.buffer.subarray(0, this.position); + } + length() { + return this.position; + } + toJSON() { + return ByteUtils.toBase64(this.buffer.subarray(0, this.position)); + } + toString(encoding) { + if (encoding === "hex") + return ByteUtils.toHex(this.buffer.subarray(0, this.position)); + if (encoding === "base64") + return ByteUtils.toBase64(this.buffer.subarray(0, this.position)); + if (encoding === "utf8" || encoding === "utf-8") + return ByteUtils.toUTF8(this.buffer, 0, this.position, false); + return ByteUtils.toUTF8(this.buffer, 0, this.position, false); + } + toExtendedJSON(options) { + options = options || {}; + if (this.sub_type === _Binary.SUBTYPE_VECTOR) { + validateBinaryVector(this); + } + const base64String = ByteUtils.toBase64(this.buffer); + const subType = Number(this.sub_type).toString(16); + if (options.legacy) { + return { + $binary: base64String, + $type: subType.length === 1 ? "0" + subType : subType + }; + } + return { + $binary: { + base64: base64String, + subType: subType.length === 1 ? "0" + subType : subType + } + }; + } + toUUID() { + if (this.sub_type === _Binary.SUBTYPE_UUID) { + return new UUID(this.buffer.subarray(0, this.position)); + } + throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${_Binary.SUBTYPE_UUID}" is currently supported.`); + } + static createFromHexString(hex, subType) { + return new _Binary(ByteUtils.fromHex(hex), subType); + } + static createFromBase64(base64, subType) { + return new _Binary(ByteUtils.fromBase64(base64), subType); + } + static fromExtendedJSON(doc, options) { + options = options || {}; + let data; + let type; + if ("$binary" in doc) { + if (options.legacy && typeof doc.$binary === "string" && "$type" in doc) { + type = doc.$type ? parseInt(doc.$type, 16) : 0; + data = ByteUtils.fromBase64(doc.$binary); + } else { + if (typeof doc.$binary !== "string") { + type = doc.$binary.subType ? parseInt(doc.$binary.subType, 16) : 0; + data = ByteUtils.fromBase64(doc.$binary.base64); + } + } + } else if ("$uuid" in doc) { + type = 4; + data = UUID.bytesFromString(doc.$uuid); + } + if (!data) { + throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`); + } + return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new _Binary(data, type); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position)); + const base64Arg = inspect(base64, options); + const subTypeArg = inspect(this.sub_type, options); + return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`; + } + toInt8Array() { + if (this.sub_type !== _Binary.SUBTYPE_VECTOR) { + throw new BSONError("Binary sub_type is not Vector"); + } + if (this.buffer[0] !== _Binary.VECTOR_TYPE.Int8) { + throw new BSONError("Binary datatype field is not Int8"); + } + validateBinaryVector(this); + return new Int8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)); + } + toFloat32Array() { + if (this.sub_type !== _Binary.SUBTYPE_VECTOR) { + throw new BSONError("Binary sub_type is not Vector"); + } + if (this.buffer[0] !== _Binary.VECTOR_TYPE.Float32) { + throw new BSONError("Binary datatype field is not Float32"); + } + validateBinaryVector(this); + const floatBytes = new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)); + if (NumberUtils.isBigEndian) + ByteUtils.swap32(floatBytes); + return new Float32Array(floatBytes.buffer); + } + toPackedBits() { + if (this.sub_type !== _Binary.SUBTYPE_VECTOR) { + throw new BSONError("Binary sub_type is not Vector"); + } + if (this.buffer[0] !== _Binary.VECTOR_TYPE.PackedBit) { + throw new BSONError("Binary datatype field is not packed bit"); + } + validateBinaryVector(this); + return new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position)); + } + toBits() { + if (this.sub_type !== _Binary.SUBTYPE_VECTOR) { + throw new BSONError("Binary sub_type is not Vector"); + } + if (this.buffer[0] !== _Binary.VECTOR_TYPE.PackedBit) { + throw new BSONError("Binary datatype field is not packed bit"); + } + validateBinaryVector(this); + const byteCount = this.length() - 2; + const bitCount = byteCount * 8 - this.buffer[1]; + const bits = new Int8Array(bitCount); + for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) { + const byteOffset = bitOffset / 8 | 0; + const byte = this.buffer[byteOffset + 2]; + const shift = 7 - bitOffset % 8; + const bit = byte >> shift & 1; + bits[bitOffset] = bit; + } + return bits; + } + static fromInt8Array(array) { + const buffer2 = ByteUtils.allocate(array.byteLength + 2); + buffer2[0] = _Binary.VECTOR_TYPE.Int8; + buffer2[1] = 0; + const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); + buffer2.set(intBytes, 2); + const bin = new this(buffer2, this.SUBTYPE_VECTOR); + validateBinaryVector(bin); + return bin; + } + static fromFloat32Array(array) { + const binaryBytes = ByteUtils.allocate(array.byteLength + 2); + binaryBytes[0] = _Binary.VECTOR_TYPE.Float32; + binaryBytes[1] = 0; + const floatBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); + binaryBytes.set(floatBytes, 2); + if (NumberUtils.isBigEndian) + ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2)); + const bin = new this(binaryBytes, this.SUBTYPE_VECTOR); + validateBinaryVector(bin); + return bin; + } + static fromPackedBits(array, padding = 0) { + const buffer2 = ByteUtils.allocate(array.byteLength + 2); + buffer2[0] = _Binary.VECTOR_TYPE.PackedBit; + buffer2[1] = padding; + buffer2.set(array, 2); + const bin = new this(buffer2, this.SUBTYPE_VECTOR); + validateBinaryVector(bin); + return bin; + } + static fromBits(bits) { + const byteLength = bits.length + 7 >>> 3; + const bytes = new Uint8Array(byteLength + 2); + bytes[0] = _Binary.VECTOR_TYPE.PackedBit; + const remainder = bits.length % 8; + bytes[1] = remainder === 0 ? 0 : 8 - remainder; + for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) { + const byteOffset = bitOffset >>> 3; + const bit = bits[bitOffset]; + if (bit !== 0 && bit !== 1) { + throw new BSONError(`Invalid bit value at ${bitOffset}: must be 0 or 1, found ${bits[bitOffset]}`); + } + if (bit === 0) + continue; + const shift = 7 - bitOffset % 8; + bytes[byteOffset + 2] |= bit << shift; + } + return new this(bytes, _Binary.SUBTYPE_VECTOR); + } + }; + Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0; + Binary.BUFFER_SIZE = 256; + Binary.SUBTYPE_DEFAULT = 0; + Binary.SUBTYPE_FUNCTION = 1; + Binary.SUBTYPE_BYTE_ARRAY = 2; + Binary.SUBTYPE_UUID_OLD = 3; + Binary.SUBTYPE_UUID = 4; + Binary.SUBTYPE_MD5 = 5; + Binary.SUBTYPE_ENCRYPTED = 6; + Binary.SUBTYPE_COLUMN = 7; + Binary.SUBTYPE_SENSITIVE = 8; + Binary.SUBTYPE_VECTOR = 9; + Binary.SUBTYPE_USER_DEFINED = 128; + Binary.VECTOR_TYPE = Object.freeze({ + Int8: 3, + Float32: 39, + PackedBit: 16 + }); + function validateBinaryVector(vector) { + if (vector.sub_type !== Binary.SUBTYPE_VECTOR) + return; + const size = vector.position; + const datatype = vector.buffer[0]; + const padding = vector.buffer[1]; + if ((datatype === Binary.VECTOR_TYPE.Float32 || datatype === Binary.VECTOR_TYPE.Int8) && padding !== 0) { + throw new BSONError("Invalid Vector: padding must be zero for int8 and float32 vectors"); + } + if (datatype === Binary.VECTOR_TYPE.Float32) { + if (size !== 0 && size - 2 !== 0 && (size - 2) % 4 !== 0) { + throw new BSONError("Invalid Vector: Float32 vector must contain a multiple of 4 bytes"); + } + } + if (datatype === Binary.VECTOR_TYPE.PackedBit && padding !== 0 && size === 2) { + throw new BSONError("Invalid Vector: padding must be zero for packed bit vectors that are empty"); + } + if (datatype === Binary.VECTOR_TYPE.PackedBit && padding > 7) { + throw new BSONError(`Invalid Vector: padding must be a value between 0 and 7. found: ${padding}`); + } + } + var UUID_BYTE_LENGTH = 16; + var UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i; + var UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i; + var UUID = class _UUID extends Binary { + constructor(input) { + let bytes; + if (input == null) { + bytes = _UUID.generate(); + } else if (input instanceof _UUID) { + bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer)); + } else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) { + bytes = ByteUtils.toLocalBufferType(input); + } else if (typeof input === "string") { + bytes = _UUID.bytesFromString(input); + } else { + throw new BSONError("Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)."); + } + super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW); + } + get id() { + return this.buffer; + } + set id(value) { + this.buffer = value; + } + toHexString(includeDashes = true) { + if (includeDashes) { + return [ + ByteUtils.toHex(this.buffer.subarray(0, 4)), + ByteUtils.toHex(this.buffer.subarray(4, 6)), + ByteUtils.toHex(this.buffer.subarray(6, 8)), + ByteUtils.toHex(this.buffer.subarray(8, 10)), + ByteUtils.toHex(this.buffer.subarray(10, 16)) + ].join("-"); + } + return ByteUtils.toHex(this.buffer); + } + toString(encoding) { + if (encoding === "hex") + return ByteUtils.toHex(this.id); + if (encoding === "base64") + return ByteUtils.toBase64(this.id); + return this.toHexString(); + } + toJSON() { + return this.toHexString(); + } + equals(otherId) { + if (!otherId) { + return false; + } + if (otherId instanceof _UUID) { + return ByteUtils.equals(otherId.id, this.id); + } + try { + return ByteUtils.equals(new _UUID(otherId).id, this.id); + } catch { + return false; + } + } + toBinary() { + return new Binary(this.id, Binary.SUBTYPE_UUID); + } + static generate() { + const bytes = ByteUtils.randomBytes(UUID_BYTE_LENGTH); + bytes[6] = bytes[6] & 15 | 64; + bytes[8] = bytes[8] & 63 | 128; + return bytes; + } + static isValid(input) { + if (!input) { + return false; + } + if (typeof input === "string") { + return _UUID.isValidUUIDString(input); + } + if (isUint8Array(input)) { + return input.byteLength === UUID_BYTE_LENGTH; + } + return input._bsontype === "Binary" && input.sub_type === this.SUBTYPE_UUID && input.buffer.byteLength === 16; + } + static createFromHexString(hexString) { + const buffer2 = _UUID.bytesFromString(hexString); + return new _UUID(buffer2); + } + static createFromBase64(base64) { + return new _UUID(ByteUtils.fromBase64(base64)); + } + static bytesFromString(representation) { + if (!_UUID.isValidUUIDString(representation)) { + throw new BSONError("UUID string representation must be 32 hex digits or canonical hyphenated representation"); + } + return ByteUtils.fromHex(representation.replace(/-/g, "")); + } + static isValidUUIDString(representation) { + return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + return `new UUID(${inspect(this.toHexString(), options)})`; + } + }; + var Code = class _Code extends BSONValue { + get _bsontype() { + return "Code"; + } + constructor(code, scope) { + super(); + this.code = code.toString(); + this.scope = scope ?? null; + } + toJSON() { + if (this.scope != null) { + return { code: this.code, scope: this.scope }; + } + return { code: this.code }; + } + toExtendedJSON() { + if (this.scope) { + return { $code: this.code, $scope: this.scope }; + } + return { $code: this.code }; + } + static fromExtendedJSON(doc) { + return new _Code(doc.$code, doc.$scope); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + let parametersString = inspect(this.code, options); + const multiLineFn = parametersString.includes("\n"); + if (this.scope != null) { + parametersString += `,${multiLineFn ? "\n" : " "}${inspect(this.scope, options)}`; + } + const endingNewline = multiLineFn && this.scope === null; + return `new Code(${multiLineFn ? "\n" : ""}${parametersString}${endingNewline ? "\n" : ""})`; + } + }; + function isDBRefLike(value) { + return value != null && typeof value === "object" && "$id" in value && value.$id != null && "$ref" in value && typeof value.$ref === "string" && (!("$db" in value) || "$db" in value && typeof value.$db === "string"); + } + var DBRef = class _DBRef extends BSONValue { + get _bsontype() { + return "DBRef"; + } + constructor(collection, oid, db, fields) { + super(); + const parts = collection.split("."); + if (parts.length === 2) { + db = parts.shift(); + collection = parts.shift(); + } + this.collection = collection; + this.oid = oid; + this.db = db; + this.fields = fields || {}; + } + get namespace() { + return this.collection; + } + set namespace(value) { + this.collection = value; + } + toJSON() { + const o = Object.assign({ + $ref: this.collection, + $id: this.oid + }, this.fields); + if (this.db != null) + o.$db = this.db; + return o; + } + toExtendedJSON(options) { + options = options || {}; + let o = { + $ref: this.collection, + $id: this.oid + }; + if (options.legacy) { + return o; + } + if (this.db) + o.$db = this.db; + o = Object.assign(o, this.fields); + return o; + } + static fromExtendedJSON(doc) { + const copy = Object.assign({}, doc); + delete copy.$ref; + delete copy.$id; + delete copy.$db; + return new _DBRef(doc.$ref, doc.$id, doc.$db, copy); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + const args = [ + inspect(this.namespace, options), + inspect(this.oid, options), + ...this.db ? [inspect(this.db, options)] : [], + ...Object.keys(this.fields).length > 0 ? [inspect(this.fields, options)] : [] + ]; + args[1] = inspect === defaultInspect ? `new ObjectId(${args[1]})` : args[1]; + return `new DBRef(${args.join(", ")})`; + } + }; + function removeLeadingZerosAndExplicitPlus(str) { + if (str === "") { + return str; + } + let startIndex = 0; + const isNegative = str[startIndex] === "-"; + const isExplicitlyPositive = str[startIndex] === "+"; + if (isExplicitlyPositive || isNegative) { + startIndex += 1; + } + let foundInsignificantZero = false; + for (; startIndex < str.length && str[startIndex] === "0"; ++startIndex) { + foundInsignificantZero = true; + } + if (!foundInsignificantZero) { + return isExplicitlyPositive ? str.slice(1) : str; + } + return `${isNegative ? "-" : ""}${str.length === startIndex ? "0" : str.slice(startIndex)}`; + } + function validateStringCharacters(str, radix) { + radix = radix ?? 10; + const validCharacters = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix); + const regex = new RegExp(`[^-+${validCharacters}]`, "i"); + return regex.test(str) ? false : str; + } + var wasm = void 0; + try { + wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11])), {}).exports; + } catch { + } + var TWO_PWR_16_DBL = 1 << 16; + var TWO_PWR_24_DBL = 1 << 24; + var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL; + var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL; + var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2; + var INT_CACHE = {}; + var UINT_CACHE = {}; + var MAX_INT64_STRING_LENGTH = 20; + var DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/; + var Long = class _Long extends BSONValue { + get _bsontype() { + return "Long"; + } + get __isLong__() { + return true; + } + constructor(lowOrValue = 0, highOrUnsigned, unsigned) { + super(); + const unsignedBool = typeof highOrUnsigned === "boolean" ? highOrUnsigned : Boolean(unsigned); + const high = typeof highOrUnsigned === "number" ? highOrUnsigned : 0; + const res = typeof lowOrValue === "string" ? _Long.fromString(lowOrValue, unsignedBool) : typeof lowOrValue === "bigint" ? _Long.fromBigInt(lowOrValue, unsignedBool) : { low: lowOrValue | 0, high: high | 0, unsigned: unsignedBool }; + this.low = res.low; + this.high = res.high; + this.unsigned = res.unsigned; + } + static fromBits(lowBits, highBits, unsigned) { + return new _Long(lowBits, highBits, unsigned); + } + static fromInt(value, unsigned) { + let obj, cachedObj, cache; + if (unsigned) { + value >>>= 0; + if (cache = 0 <= value && value < 256) { + cachedObj = UINT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = _Long.fromBits(value, (value | 0) < 0 ? -1 : 0, true); + if (cache) + UINT_CACHE[value] = obj; + return obj; + } else { + value |= 0; + if (cache = -128 <= value && value < 128) { + cachedObj = INT_CACHE[value]; + if (cachedObj) + return cachedObj; + } + obj = _Long.fromBits(value, value < 0 ? -1 : 0, false); + if (cache) + INT_CACHE[value] = obj; + return obj; + } + } + static fromNumber(value, unsigned) { + if (isNaN(value)) + return unsigned ? _Long.UZERO : _Long.ZERO; + if (unsigned) { + if (value < 0) + return _Long.UZERO; + if (value >= TWO_PWR_64_DBL) + return _Long.MAX_UNSIGNED_VALUE; + } else { + if (value <= -9223372036854776e3) + return _Long.MIN_VALUE; + if (value + 1 >= TWO_PWR_63_DBL) + return _Long.MAX_VALUE; + } + if (value < 0) + return _Long.fromNumber(-value, unsigned).neg(); + return _Long.fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned); + } + static fromBigInt(value, unsigned) { + const FROM_BIGINT_BIT_MASK = BigInt(4294967295); + const FROM_BIGINT_BIT_SHIFT = BigInt(32); + return new _Long(Number(value & FROM_BIGINT_BIT_MASK), Number(value >> FROM_BIGINT_BIT_SHIFT & FROM_BIGINT_BIT_MASK), unsigned); + } + static _fromString(str, unsigned, radix) { + if (str.length === 0) + throw new BSONError("empty string"); + if (radix < 2 || 36 < radix) + throw new BSONError("radix"); + let p; + if ((p = str.indexOf("-")) > 0) + throw new BSONError("interior hyphen"); + else if (p === 0) { + return _Long._fromString(str.substring(1), unsigned, radix).neg(); + } + const radixToPower = _Long.fromNumber(Math.pow(radix, 8)); + let result = _Long.ZERO; + for (let i = 0; i < str.length; i += 8) { + const size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix); + if (size < 8) { + const power = _Long.fromNumber(Math.pow(radix, size)); + result = result.mul(power).add(_Long.fromNumber(value)); + } else { + result = result.mul(radixToPower); + result = result.add(_Long.fromNumber(value)); + } + } + result.unsigned = unsigned; + return result; + } + static fromStringStrict(str, unsignedOrRadix, radix) { + let unsigned = false; + if (typeof unsignedOrRadix === "number") { + radix = unsignedOrRadix, unsignedOrRadix = false; + } else { + unsigned = !!unsignedOrRadix; + } + radix ??= 10; + if (str.trim() !== str) { + throw new BSONError(`Input: '${str}' contains leading and/or trailing whitespace`); + } + if (!validateStringCharacters(str, radix)) { + throw new BSONError(`Input: '${str}' contains invalid characters for radix: ${radix}`); + } + const cleanedStr = removeLeadingZerosAndExplicitPlus(str); + const result = _Long._fromString(cleanedStr, unsigned, radix); + if (result.toString(radix).toLowerCase() !== cleanedStr.toLowerCase()) { + throw new BSONError(`Input: ${str} is not representable as ${result.unsigned ? "an unsigned" : "a signed"} 64-bit Long ${radix != null ? `with radix: ${radix}` : ""}`); + } + return result; + } + static fromString(str, unsignedOrRadix, radix) { + let unsigned = false; + if (typeof unsignedOrRadix === "number") { + radix = unsignedOrRadix, unsignedOrRadix = false; + } else { + unsigned = !!unsignedOrRadix; + } + radix ??= 10; + if (str === "NaN" && radix < 24) { + return _Long.ZERO; + } else if ((str === "Infinity" || str === "+Infinity" || str === "-Infinity") && radix < 35) { + return _Long.ZERO; + } + return _Long._fromString(str, unsigned, radix); + } + static fromBytes(bytes, unsigned, le) { + return le ? _Long.fromBytesLE(bytes, unsigned) : _Long.fromBytesBE(bytes, unsigned); + } + static fromBytesLE(bytes, unsigned) { + return new _Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned); + } + static fromBytesBE(bytes, unsigned) { + return new _Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned); + } + static isLong(value) { + return value != null && typeof value === "object" && "__isLong__" in value && value.__isLong__ === true; + } + static fromValue(val, unsigned) { + if (typeof val === "number") + return _Long.fromNumber(val, unsigned); + if (typeof val === "string") + return _Long.fromString(val, unsigned); + return _Long.fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned); + } + add(addend) { + if (!_Long.isLong(addend)) + addend = _Long.fromValue(addend); + const a48 = this.high >>> 16; + const a32 = this.high & 65535; + const a16 = this.low >>> 16; + const a00 = this.low & 65535; + const b48 = addend.high >>> 16; + const b32 = addend.high & 65535; + const b16 = addend.low >>> 16; + const b00 = addend.low & 65535; + let c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 + b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 + b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 + b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 + b48; + c48 &= 65535; + return _Long.fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); + } + and(other) { + if (!_Long.isLong(other)) + other = _Long.fromValue(other); + return _Long.fromBits(this.low & other.low, this.high & other.high, this.unsigned); + } + compare(other) { + if (!_Long.isLong(other)) + other = _Long.fromValue(other); + if (this.eq(other)) + return 0; + const thisNeg = this.isNegative(), otherNeg = other.isNegative(); + if (thisNeg && !otherNeg) + return -1; + if (!thisNeg && otherNeg) + return 1; + if (!this.unsigned) + return this.sub(other).isNegative() ? -1 : 1; + return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1; + } + comp(other) { + return this.compare(other); + } + divide(divisor) { + if (!_Long.isLong(divisor)) + divisor = _Long.fromValue(divisor); + if (divisor.isZero()) + throw new BSONError("division by zero"); + if (wasm) { + if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) { + return this; + } + const low = (this.unsigned ? wasm.div_u : wasm.div_s)(this.low, this.high, divisor.low, divisor.high); + return _Long.fromBits(low, wasm.get_high(), this.unsigned); + } + if (this.isZero()) + return this.unsigned ? _Long.UZERO : _Long.ZERO; + let approx, rem, res; + if (!this.unsigned) { + if (this.eq(_Long.MIN_VALUE)) { + if (divisor.eq(_Long.ONE) || divisor.eq(_Long.NEG_ONE)) + return _Long.MIN_VALUE; + else if (divisor.eq(_Long.MIN_VALUE)) + return _Long.ONE; + else { + const halfThis = this.shr(1); + approx = halfThis.div(divisor).shl(1); + if (approx.eq(_Long.ZERO)) { + return divisor.isNegative() ? _Long.ONE : _Long.NEG_ONE; + } else { + rem = this.sub(divisor.mul(approx)); + res = approx.add(rem.div(divisor)); + return res; + } + } + } else if (divisor.eq(_Long.MIN_VALUE)) + return this.unsigned ? _Long.UZERO : _Long.ZERO; + if (this.isNegative()) { + if (divisor.isNegative()) + return this.neg().div(divisor.neg()); + return this.neg().div(divisor).neg(); + } else if (divisor.isNegative()) + return this.div(divisor.neg()).neg(); + res = _Long.ZERO; + } else { + if (!divisor.unsigned) + divisor = divisor.toUnsigned(); + if (divisor.gt(this)) + return _Long.UZERO; + if (divisor.gt(this.shru(1))) + return _Long.UONE; + res = _Long.UZERO; + } + rem = this; + while (rem.gte(divisor)) { + approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber())); + const log2 = Math.ceil(Math.log(approx) / Math.LN2); + const delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48); + let approxRes = _Long.fromNumber(approx); + let approxRem = approxRes.mul(divisor); + while (approxRem.isNegative() || approxRem.gt(rem)) { + approx -= delta; + approxRes = _Long.fromNumber(approx, this.unsigned); + approxRem = approxRes.mul(divisor); + } + if (approxRes.isZero()) + approxRes = _Long.ONE; + res = res.add(approxRes); + rem = rem.sub(approxRem); + } + return res; + } + div(divisor) { + return this.divide(divisor); + } + equals(other) { + if (!_Long.isLong(other)) + other = _Long.fromValue(other); + if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1) + return false; + return this.high === other.high && this.low === other.low; + } + eq(other) { + return this.equals(other); + } + getHighBits() { + return this.high; + } + getHighBitsUnsigned() { + return this.high >>> 0; + } + getLowBits() { + return this.low; + } + getLowBitsUnsigned() { + return this.low >>> 0; + } + getNumBitsAbs() { + if (this.isNegative()) { + return this.eq(_Long.MIN_VALUE) ? 64 : this.neg().getNumBitsAbs(); + } + const val = this.high !== 0 ? this.high : this.low; + let bit; + for (bit = 31; bit > 0; bit--) + if ((val & 1 << bit) !== 0) + break; + return this.high !== 0 ? bit + 33 : bit + 1; + } + greaterThan(other) { + return this.comp(other) > 0; + } + gt(other) { + return this.greaterThan(other); + } + greaterThanOrEqual(other) { + return this.comp(other) >= 0; + } + gte(other) { + return this.greaterThanOrEqual(other); + } + ge(other) { + return this.greaterThanOrEqual(other); + } + isEven() { + return (this.low & 1) === 0; + } + isNegative() { + return !this.unsigned && this.high < 0; + } + isOdd() { + return (this.low & 1) === 1; + } + isPositive() { + return this.unsigned || this.high >= 0; + } + isZero() { + return this.high === 0 && this.low === 0; + } + lessThan(other) { + return this.comp(other) < 0; + } + lt(other) { + return this.lessThan(other); + } + lessThanOrEqual(other) { + return this.comp(other) <= 0; + } + lte(other) { + return this.lessThanOrEqual(other); + } + modulo(divisor) { + if (!_Long.isLong(divisor)) + divisor = _Long.fromValue(divisor); + if (wasm) { + const low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(this.low, this.high, divisor.low, divisor.high); + return _Long.fromBits(low, wasm.get_high(), this.unsigned); + } + return this.sub(this.div(divisor).mul(divisor)); + } + mod(divisor) { + return this.modulo(divisor); + } + rem(divisor) { + return this.modulo(divisor); + } + multiply(multiplier) { + if (this.isZero()) + return _Long.ZERO; + if (!_Long.isLong(multiplier)) + multiplier = _Long.fromValue(multiplier); + if (wasm) { + const low = wasm.mul(this.low, this.high, multiplier.low, multiplier.high); + return _Long.fromBits(low, wasm.get_high(), this.unsigned); + } + if (multiplier.isZero()) + return _Long.ZERO; + if (this.eq(_Long.MIN_VALUE)) + return multiplier.isOdd() ? _Long.MIN_VALUE : _Long.ZERO; + if (multiplier.eq(_Long.MIN_VALUE)) + return this.isOdd() ? _Long.MIN_VALUE : _Long.ZERO; + if (this.isNegative()) { + if (multiplier.isNegative()) + return this.neg().mul(multiplier.neg()); + else + return this.neg().mul(multiplier).neg(); + } else if (multiplier.isNegative()) + return this.mul(multiplier.neg()).neg(); + if (this.lt(_Long.TWO_PWR_24) && multiplier.lt(_Long.TWO_PWR_24)) + return _Long.fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned); + const a48 = this.high >>> 16; + const a32 = this.high & 65535; + const a16 = this.low >>> 16; + const a00 = this.low & 65535; + const b48 = multiplier.high >>> 16; + const b32 = multiplier.high & 65535; + const b16 = multiplier.low >>> 16; + const b00 = multiplier.low & 65535; + let c48 = 0, c32 = 0, c16 = 0, c00 = 0; + c00 += a00 * b00; + c16 += c00 >>> 16; + c00 &= 65535; + c16 += a16 * b00; + c32 += c16 >>> 16; + c16 &= 65535; + c16 += a00 * b16; + c32 += c16 >>> 16; + c16 &= 65535; + c32 += a32 * b00; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a16 * b16; + c48 += c32 >>> 16; + c32 &= 65535; + c32 += a00 * b32; + c48 += c32 >>> 16; + c32 &= 65535; + c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48; + c48 &= 65535; + return _Long.fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned); + } + mul(multiplier) { + return this.multiply(multiplier); + } + negate() { + if (!this.unsigned && this.eq(_Long.MIN_VALUE)) + return _Long.MIN_VALUE; + return this.not().add(_Long.ONE); + } + neg() { + return this.negate(); + } + not() { + return _Long.fromBits(~this.low, ~this.high, this.unsigned); + } + notEquals(other) { + return !this.equals(other); + } + neq(other) { + return this.notEquals(other); + } + ne(other) { + return this.notEquals(other); + } + or(other) { + if (!_Long.isLong(other)) + other = _Long.fromValue(other); + return _Long.fromBits(this.low | other.low, this.high | other.high, this.unsigned); + } + shiftLeft(numBits) { + if (_Long.isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return _Long.fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned); + else + return _Long.fromBits(0, this.low << numBits - 32, this.unsigned); + } + shl(numBits) { + return this.shiftLeft(numBits); + } + shiftRight(numBits) { + if (_Long.isLong(numBits)) + numBits = numBits.toInt(); + if ((numBits &= 63) === 0) + return this; + else if (numBits < 32) + return _Long.fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned); + else + return _Long.fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned); + } + shr(numBits) { + return this.shiftRight(numBits); + } + shiftRightUnsigned(numBits) { + if (_Long.isLong(numBits)) + numBits = numBits.toInt(); + numBits &= 63; + if (numBits === 0) + return this; + else { + const high = this.high; + if (numBits < 32) { + const low = this.low; + return _Long.fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits, this.unsigned); + } else if (numBits === 32) + return _Long.fromBits(high, 0, this.unsigned); + else + return _Long.fromBits(high >>> numBits - 32, 0, this.unsigned); + } + } + shr_u(numBits) { + return this.shiftRightUnsigned(numBits); + } + shru(numBits) { + return this.shiftRightUnsigned(numBits); + } + subtract(subtrahend) { + if (!_Long.isLong(subtrahend)) + subtrahend = _Long.fromValue(subtrahend); + return this.add(subtrahend.neg()); + } + sub(subtrahend) { + return this.subtract(subtrahend); + } + toInt() { + return this.unsigned ? this.low >>> 0 : this.low; + } + toNumber() { + if (this.unsigned) + return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0); + return this.high * TWO_PWR_32_DBL + (this.low >>> 0); + } + toBigInt() { + return BigInt(this.toString()); + } + toBytes(le) { + return le ? this.toBytesLE() : this.toBytesBE(); + } + toBytesLE() { + const hi = this.high, lo = this.low; + return [ + lo & 255, + lo >>> 8 & 255, + lo >>> 16 & 255, + lo >>> 24, + hi & 255, + hi >>> 8 & 255, + hi >>> 16 & 255, + hi >>> 24 + ]; + } + toBytesBE() { + const hi = this.high, lo = this.low; + return [ + hi >>> 24, + hi >>> 16 & 255, + hi >>> 8 & 255, + hi & 255, + lo >>> 24, + lo >>> 16 & 255, + lo >>> 8 & 255, + lo & 255 + ]; + } + toSigned() { + if (!this.unsigned) + return this; + return _Long.fromBits(this.low, this.high, false); + } + toString(radix) { + radix = radix || 10; + if (radix < 2 || 36 < radix) + throw new BSONError("radix"); + if (this.isZero()) + return "0"; + if (this.isNegative()) { + if (this.eq(_Long.MIN_VALUE)) { + const radixLong = _Long.fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this); + return div.toString(radix) + rem1.toInt().toString(radix); + } else + return "-" + this.neg().toString(radix); + } + const radixToPower = _Long.fromNumber(Math.pow(radix, 6), this.unsigned); + let rem = this; + let result = ""; + while (true) { + const remDiv = rem.div(radixToPower); + const intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0; + let digits = intval.toString(radix); + rem = remDiv; + if (rem.isZero()) { + return digits + result; + } else { + while (digits.length < 6) + digits = "0" + digits; + result = "" + digits + result; + } + } + } + toUnsigned() { + if (this.unsigned) + return this; + return _Long.fromBits(this.low, this.high, true); + } + xor(other) { + if (!_Long.isLong(other)) + other = _Long.fromValue(other); + return _Long.fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned); + } + eqz() { + return this.isZero(); + } + le(other) { + return this.lessThanOrEqual(other); + } + toExtendedJSON(options) { + if (options && options.relaxed) + return this.toNumber(); + return { $numberLong: this.toString() }; + } + static fromExtendedJSON(doc, options) { + const { useBigInt64 = false, relaxed = true } = { ...options }; + if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) { + throw new BSONError("$numberLong string is too long"); + } + if (!DECIMAL_REG_EX.test(doc.$numberLong)) { + throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`); + } + if (useBigInt64) { + const bigIntResult = BigInt(doc.$numberLong); + return BigInt.asIntN(64, bigIntResult); + } + const longResult = _Long.fromString(doc.$numberLong); + if (relaxed) { + return longResult.toNumber(); + } + return longResult; + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + const longVal = inspect(this.toString(), options); + const unsignedVal = this.unsigned ? `, ${inspect(this.unsigned, options)}` : ""; + return `new Long(${longVal}${unsignedVal})`; + } + }; + Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL); + Long.MAX_UNSIGNED_VALUE = Long.fromBits(4294967295 | 0, 4294967295 | 0, true); + Long.ZERO = Long.fromInt(0); + Long.UZERO = Long.fromInt(0, true); + Long.ONE = Long.fromInt(1); + Long.UONE = Long.fromInt(1, true); + Long.NEG_ONE = Long.fromInt(-1); + Long.MAX_VALUE = Long.fromBits(4294967295 | 0, 2147483647 | 0, false); + Long.MIN_VALUE = Long.fromBits(0, 2147483648 | 0, false); + var PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/; + var PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i; + var PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i; + var EXPONENT_MAX = 6111; + var EXPONENT_MIN = -6176; + var EXPONENT_BIAS = 6176; + var MAX_DIGITS = 34; + var NAN_BUFFER = ByteUtils.fromNumberArray([ + 124, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ].reverse()); + var INF_NEGATIVE_BUFFER = ByteUtils.fromNumberArray([ + 248, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ].reverse()); + var INF_POSITIVE_BUFFER = ByteUtils.fromNumberArray([ + 120, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ].reverse()); + var EXPONENT_REGEX = /^([-+])?(\d+)?$/; + var COMBINATION_MASK = 31; + var EXPONENT_MASK = 16383; + var COMBINATION_INFINITY = 30; + var COMBINATION_NAN = 31; + function isDigit(value) { + return !isNaN(parseInt(value, 10)); + } + function divideu128(value) { + const DIVISOR = Long.fromNumber(1e3 * 1e3 * 1e3); + let _rem = Long.fromNumber(0); + if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) { + return { quotient: value, rem: _rem }; + } + for (let i = 0; i <= 3; i++) { + _rem = _rem.shiftLeft(32); + _rem = _rem.add(new Long(value.parts[i], 0)); + value.parts[i] = _rem.div(DIVISOR).low; + _rem = _rem.modulo(DIVISOR); + } + return { quotient: value, rem: _rem }; + } + function multiply64x2(left, right) { + if (!left && !right) { + return { high: Long.fromNumber(0), low: Long.fromNumber(0) }; + } + const leftHigh = left.shiftRightUnsigned(32); + const leftLow = new Long(left.getLowBits(), 0); + const rightHigh = right.shiftRightUnsigned(32); + const rightLow = new Long(right.getLowBits(), 0); + let productHigh = leftHigh.multiply(rightHigh); + let productMid = leftHigh.multiply(rightLow); + const productMid2 = leftLow.multiply(rightHigh); + let productLow = leftLow.multiply(rightLow); + productHigh = productHigh.add(productMid.shiftRightUnsigned(32)); + productMid = new Long(productMid.getLowBits(), 0).add(productMid2).add(productLow.shiftRightUnsigned(32)); + productHigh = productHigh.add(productMid.shiftRightUnsigned(32)); + productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0)); + return { high: productHigh, low: productLow }; + } + function lessThan(left, right) { + const uhleft = left.high >>> 0; + const uhright = right.high >>> 0; + if (uhleft < uhright) { + return true; + } else if (uhleft === uhright) { + const ulleft = left.low >>> 0; + const ulright = right.low >>> 0; + if (ulleft < ulright) + return true; + } + return false; + } + function invalidErr(string, message) { + throw new BSONError(`"${string}" is not a valid Decimal128 string - ${message}`); + } + var Decimal128 = class _Decimal128 extends BSONValue { + get _bsontype() { + return "Decimal128"; + } + constructor(bytes) { + super(); + if (typeof bytes === "string") { + this.bytes = _Decimal128.fromString(bytes).bytes; + } else if (bytes instanceof Uint8Array || isUint8Array(bytes)) { + if (bytes.byteLength !== 16) { + throw new BSONError("Decimal128 must take a Buffer of 16 bytes"); + } + this.bytes = bytes; + } else { + throw new BSONError("Decimal128 must take a Buffer or string"); + } + } + static fromString(representation) { + return _Decimal128._fromString(representation, { allowRounding: false }); + } + static fromStringWithRounding(representation) { + return _Decimal128._fromString(representation, { allowRounding: true }); + } + static _fromString(representation, options) { + let isNegative = false; + let sawSign = false; + let sawRadix = false; + let foundNonZero = false; + let significantDigits = 0; + let nDigitsRead = 0; + let nDigits = 0; + let radixPosition = 0; + let firstNonZero = 0; + const digits = [0]; + let nDigitsStored = 0; + let digitsInsert = 0; + let lastDigit = 0; + let exponent = 0; + let significandHigh = new Long(0, 0); + let significandLow = new Long(0, 0); + let biasedExponent = 0; + let index = 0; + if (representation.length >= 7e3) { + throw new BSONError("" + representation + " not a valid Decimal128 string"); + } + const stringMatch = representation.match(PARSE_STRING_REGEXP); + const infMatch = representation.match(PARSE_INF_REGEXP); + const nanMatch = representation.match(PARSE_NAN_REGEXP); + if (!stringMatch && !infMatch && !nanMatch || representation.length === 0) { + throw new BSONError("" + representation + " not a valid Decimal128 string"); + } + if (stringMatch) { + const unsignedNumber = stringMatch[2]; + const e = stringMatch[4]; + const expSign = stringMatch[5]; + const expNumber = stringMatch[6]; + if (e && expNumber === void 0) + invalidErr(representation, "missing exponent power"); + if (e && unsignedNumber === void 0) + invalidErr(representation, "missing exponent base"); + if (e === void 0 && (expSign || expNumber)) { + invalidErr(representation, "missing e before exponent"); + } + } + if (representation[index] === "+" || representation[index] === "-") { + sawSign = true; + isNegative = representation[index++] === "-"; + } + if (!isDigit(representation[index]) && representation[index] !== ".") { + if (representation[index] === "i" || representation[index] === "I") { + return new _Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER); + } else if (representation[index] === "N") { + return new _Decimal128(NAN_BUFFER); + } + } + while (isDigit(representation[index]) || representation[index] === ".") { + if (representation[index] === ".") { + if (sawRadix) + invalidErr(representation, "contains multiple periods"); + sawRadix = true; + index = index + 1; + continue; + } + if (nDigitsStored < MAX_DIGITS) { + if (representation[index] !== "0" || foundNonZero) { + if (!foundNonZero) { + firstNonZero = nDigitsRead; + } + foundNonZero = true; + digits[digitsInsert++] = parseInt(representation[index], 10); + nDigitsStored = nDigitsStored + 1; + } + } + if (foundNonZero) + nDigits = nDigits + 1; + if (sawRadix) + radixPosition = radixPosition + 1; + nDigitsRead = nDigitsRead + 1; + index = index + 1; + } + if (sawRadix && !nDigitsRead) + throw new BSONError("" + representation + " not a valid Decimal128 string"); + if (representation[index] === "e" || representation[index] === "E") { + const match = representation.substr(++index).match(EXPONENT_REGEX); + if (!match || !match[2]) + return new _Decimal128(NAN_BUFFER); + exponent = parseInt(match[0], 10); + index = index + match[0].length; + } + if (representation[index]) + return new _Decimal128(NAN_BUFFER); + if (!nDigitsStored) { + digits[0] = 0; + nDigits = 1; + nDigitsStored = 1; + significantDigits = 0; + } else { + lastDigit = nDigitsStored - 1; + significantDigits = nDigits; + if (significantDigits !== 1) { + while (representation[firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)] === "0") { + significantDigits = significantDigits - 1; + } + } + } + if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) { + exponent = EXPONENT_MIN; + } else { + exponent = exponent - radixPosition; + } + while (exponent > EXPONENT_MAX) { + lastDigit = lastDigit + 1; + if (lastDigit >= MAX_DIGITS) { + if (significantDigits === 0) { + exponent = EXPONENT_MAX; + break; + } + invalidErr(representation, "overflow"); + } + exponent = exponent - 1; + } + if (options.allowRounding) { + while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) { + if (lastDigit === 0 && significantDigits < nDigitsStored) { + exponent = EXPONENT_MIN; + significantDigits = 0; + break; + } + if (nDigitsStored < nDigits) { + nDigits = nDigits - 1; + } else { + lastDigit = lastDigit - 1; + } + if (exponent < EXPONENT_MAX) { + exponent = exponent + 1; + } else { + const digitsString = digits.join(""); + if (digitsString.match(/^0+$/)) { + exponent = EXPONENT_MAX; + break; + } + invalidErr(representation, "overflow"); + } + } + if (lastDigit + 1 < significantDigits) { + let endOfString = nDigitsRead; + if (sawRadix) { + firstNonZero = firstNonZero + 1; + endOfString = endOfString + 1; + } + if (sawSign) { + firstNonZero = firstNonZero + 1; + endOfString = endOfString + 1; + } + const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10); + let roundBit = 0; + if (roundDigit >= 5) { + roundBit = 1; + if (roundDigit === 5) { + roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0; + for (let i = firstNonZero + lastDigit + 2; i < endOfString; i++) { + if (parseInt(representation[i], 10)) { + roundBit = 1; + break; + } + } + } + } + if (roundBit) { + let dIdx = lastDigit; + for (; dIdx >= 0; dIdx--) { + if (++digits[dIdx] > 9) { + digits[dIdx] = 0; + if (dIdx === 0) { + if (exponent < EXPONENT_MAX) { + exponent = exponent + 1; + digits[dIdx] = 1; + } else { + return new _Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER); + } + } + } else { + break; + } + } + } + } + } else { + while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) { + if (lastDigit === 0) { + if (significantDigits === 0) { + exponent = EXPONENT_MIN; + break; + } + invalidErr(representation, "exponent underflow"); + } + if (nDigitsStored < nDigits) { + if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== "0" && significantDigits !== 0) { + invalidErr(representation, "inexact rounding"); + } + nDigits = nDigits - 1; + } else { + if (digits[lastDigit] !== 0) { + invalidErr(representation, "inexact rounding"); + } + lastDigit = lastDigit - 1; + } + if (exponent < EXPONENT_MAX) { + exponent = exponent + 1; + } else { + invalidErr(representation, "overflow"); + } + } + if (lastDigit + 1 < significantDigits) { + if (sawRadix) { + firstNonZero = firstNonZero + 1; + } + if (sawSign) { + firstNonZero = firstNonZero + 1; + } + const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10); + if (roundDigit !== 0) { + invalidErr(representation, "inexact rounding"); + } + } + } + significandHigh = Long.fromNumber(0); + significandLow = Long.fromNumber(0); + if (significantDigits === 0) { + significandHigh = Long.fromNumber(0); + significandLow = Long.fromNumber(0); + } else if (lastDigit < 17) { + let dIdx = 0; + significandLow = Long.fromNumber(digits[dIdx++]); + significandHigh = new Long(0, 0); + for (; dIdx <= lastDigit; dIdx++) { + significandLow = significandLow.multiply(Long.fromNumber(10)); + significandLow = significandLow.add(Long.fromNumber(digits[dIdx])); + } + } else { + let dIdx = 0; + significandHigh = Long.fromNumber(digits[dIdx++]); + for (; dIdx <= lastDigit - 17; dIdx++) { + significandHigh = significandHigh.multiply(Long.fromNumber(10)); + significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx])); + } + significandLow = Long.fromNumber(digits[dIdx++]); + for (; dIdx <= lastDigit; dIdx++) { + significandLow = significandLow.multiply(Long.fromNumber(10)); + significandLow = significandLow.add(Long.fromNumber(digits[dIdx])); + } + } + const significand = multiply64x2(significandHigh, Long.fromString("100000000000000000")); + significand.low = significand.low.add(significandLow); + if (lessThan(significand.low, significandLow)) { + significand.high = significand.high.add(Long.fromNumber(1)); + } + biasedExponent = exponent + EXPONENT_BIAS; + const dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) }; + if (significand.high.shiftRightUnsigned(49).and(Long.fromNumber(1)).equals(Long.fromNumber(1))) { + dec.high = dec.high.or(Long.fromNumber(3).shiftLeft(61)); + dec.high = dec.high.or(Long.fromNumber(biasedExponent).and(Long.fromNumber(16383).shiftLeft(47))); + dec.high = dec.high.or(significand.high.and(Long.fromNumber(140737488355327))); + } else { + dec.high = dec.high.or(Long.fromNumber(biasedExponent & 16383).shiftLeft(49)); + dec.high = dec.high.or(significand.high.and(Long.fromNumber(562949953421311))); + } + dec.low = significand.low; + if (isNegative) { + dec.high = dec.high.or(Long.fromString("9223372036854775808")); + } + const buffer2 = ByteUtils.allocateUnsafe(16); + index = 0; + buffer2[index++] = dec.low.low & 255; + buffer2[index++] = dec.low.low >> 8 & 255; + buffer2[index++] = dec.low.low >> 16 & 255; + buffer2[index++] = dec.low.low >> 24 & 255; + buffer2[index++] = dec.low.high & 255; + buffer2[index++] = dec.low.high >> 8 & 255; + buffer2[index++] = dec.low.high >> 16 & 255; + buffer2[index++] = dec.low.high >> 24 & 255; + buffer2[index++] = dec.high.low & 255; + buffer2[index++] = dec.high.low >> 8 & 255; + buffer2[index++] = dec.high.low >> 16 & 255; + buffer2[index++] = dec.high.low >> 24 & 255; + buffer2[index++] = dec.high.high & 255; + buffer2[index++] = dec.high.high >> 8 & 255; + buffer2[index++] = dec.high.high >> 16 & 255; + buffer2[index++] = dec.high.high >> 24 & 255; + return new _Decimal128(buffer2); + } + toString() { + let biased_exponent; + let significand_digits = 0; + const significand = new Array(36); + for (let i = 0; i < significand.length; i++) + significand[i] = 0; + let index = 0; + let is_zero = false; + let significand_msb; + let significand128 = { parts: [0, 0, 0, 0] }; + let j, k; + const string = []; + index = 0; + const buffer2 = this.bytes; + const low = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24; + const midl = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24; + const midh = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24; + const high = buffer2[index++] | buffer2[index++] << 8 | buffer2[index++] << 16 | buffer2[index++] << 24; + index = 0; + const dec = { + low: new Long(low, midl), + high: new Long(midh, high) + }; + if (dec.high.lessThan(Long.ZERO)) { + string.push("-"); + } + const combination = high >> 26 & COMBINATION_MASK; + if (combination >> 3 === 3) { + if (combination === COMBINATION_INFINITY) { + return string.join("") + "Infinity"; + } else if (combination === COMBINATION_NAN) { + return "NaN"; + } else { + biased_exponent = high >> 15 & EXPONENT_MASK; + significand_msb = 8 + (high >> 14 & 1); + } + } else { + significand_msb = high >> 14 & 7; + biased_exponent = high >> 17 & EXPONENT_MASK; + } + const exponent = biased_exponent - EXPONENT_BIAS; + significand128.parts[0] = (high & 16383) + ((significand_msb & 15) << 14); + significand128.parts[1] = midh; + significand128.parts[2] = midl; + significand128.parts[3] = low; + if (significand128.parts[0] === 0 && significand128.parts[1] === 0 && significand128.parts[2] === 0 && significand128.parts[3] === 0) { + is_zero = true; + } else { + for (k = 3; k >= 0; k--) { + let least_digits = 0; + const result = divideu128(significand128); + significand128 = result.quotient; + least_digits = result.rem.low; + if (!least_digits) + continue; + for (j = 8; j >= 0; j--) { + significand[k * 9 + j] = least_digits % 10; + least_digits = Math.floor(least_digits / 10); + } + } + } + if (is_zero) { + significand_digits = 1; + significand[index] = 0; + } else { + significand_digits = 36; + while (!significand[index]) { + significand_digits = significand_digits - 1; + index = index + 1; + } + } + const scientific_exponent = significand_digits - 1 + exponent; + if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) { + if (significand_digits > 34) { + string.push(`${0}`); + if (exponent > 0) + string.push(`E+${exponent}`); + else if (exponent < 0) + string.push(`E${exponent}`); + return string.join(""); + } + string.push(`${significand[index++]}`); + significand_digits = significand_digits - 1; + if (significand_digits) { + string.push("."); + } + for (let i = 0; i < significand_digits; i++) { + string.push(`${significand[index++]}`); + } + string.push("E"); + if (scientific_exponent > 0) { + string.push(`+${scientific_exponent}`); + } else { + string.push(`${scientific_exponent}`); + } + } else { + if (exponent >= 0) { + for (let i = 0; i < significand_digits; i++) { + string.push(`${significand[index++]}`); + } + } else { + let radix_position = significand_digits + exponent; + if (radix_position > 0) { + for (let i = 0; i < radix_position; i++) { + string.push(`${significand[index++]}`); + } + } else { + string.push("0"); + } + string.push("."); + while (radix_position++ < 0) { + string.push("0"); + } + for (let i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) { + string.push(`${significand[index++]}`); + } + } + } + return string.join(""); + } + toJSON() { + return { $numberDecimal: this.toString() }; + } + toExtendedJSON() { + return { $numberDecimal: this.toString() }; + } + static fromExtendedJSON(doc) { + return _Decimal128.fromString(doc.$numberDecimal); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + const d128string = inspect(this.toString(), options); + return `new Decimal128(${d128string})`; + } + }; + var Double = class _Double extends BSONValue { + get _bsontype() { + return "Double"; + } + constructor(value) { + super(); + if (value instanceof Number) { + value = value.valueOf(); + } + this.value = +value; + } + static fromString(value) { + const coercedValue = Number(value); + if (value === "NaN") + return new _Double(NaN); + if (value === "Infinity") + return new _Double(Infinity); + if (value === "-Infinity") + return new _Double(-Infinity); + if (!Number.isFinite(coercedValue)) { + throw new BSONError(`Input: ${value} is not representable as a Double`); + } + if (value.trim() !== value) { + throw new BSONError(`Input: '${value}' contains whitespace`); + } + if (value === "") { + throw new BSONError(`Input is an empty string`); + } + if (/[^-0-9.+eE]/.test(value)) { + throw new BSONError(`Input: '${value}' is not in decimal or exponential notation`); + } + return new _Double(coercedValue); + } + valueOf() { + return this.value; + } + toJSON() { + return this.value; + } + toString(radix) { + return this.value.toString(radix); + } + toExtendedJSON(options) { + if (options && (options.legacy || options.relaxed && isFinite(this.value))) { + return this.value; + } + if (Object.is(Math.sign(this.value), -0)) { + return { $numberDouble: "-0.0" }; + } + return { + $numberDouble: Number.isInteger(this.value) ? this.value.toFixed(1) : this.value.toString() + }; + } + static fromExtendedJSON(doc, options) { + const doubleValue = parseFloat(doc.$numberDouble); + return options && options.relaxed ? doubleValue : new _Double(doubleValue); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + return `new Double(${inspect(this.value, options)})`; + } + }; + var Int32 = class _Int32 extends BSONValue { + get _bsontype() { + return "Int32"; + } + constructor(value) { + super(); + if (value instanceof Number) { + value = value.valueOf(); + } + this.value = +value | 0; + } + static fromString(value) { + const cleanedValue = removeLeadingZerosAndExplicitPlus(value); + const coercedValue = Number(value); + if (BSON_INT32_MAX < coercedValue) { + throw new BSONError(`Input: '${value}' is larger than the maximum value for Int32`); + } else if (BSON_INT32_MIN > coercedValue) { + throw new BSONError(`Input: '${value}' is smaller than the minimum value for Int32`); + } else if (!Number.isSafeInteger(coercedValue)) { + throw new BSONError(`Input: '${value}' is not a safe integer`); + } else if (coercedValue.toString() !== cleanedValue) { + throw new BSONError(`Input: '${value}' is not a valid Int32 string`); + } + return new _Int32(coercedValue); + } + valueOf() { + return this.value; + } + toString(radix) { + return this.value.toString(radix); + } + toJSON() { + return this.value; + } + toExtendedJSON(options) { + if (options && (options.relaxed || options.legacy)) + return this.value; + return { $numberInt: this.value.toString() }; + } + static fromExtendedJSON(doc, options) { + return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new _Int32(doc.$numberInt); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + return `new Int32(${inspect(this.value, options)})`; + } + }; + var MaxKey = class _MaxKey extends BSONValue { + get _bsontype() { + return "MaxKey"; + } + toExtendedJSON() { + return { $maxKey: 1 }; + } + static fromExtendedJSON() { + return new _MaxKey(); + } + inspect() { + return "new MaxKey()"; + } + }; + var MinKey = class _MinKey extends BSONValue { + get _bsontype() { + return "MinKey"; + } + toExtendedJSON() { + return { $minKey: 1 }; + } + static fromExtendedJSON() { + return new _MinKey(); + } + inspect() { + return "new MinKey()"; + } + }; + var PROCESS_UNIQUE = null; + var __idCache = /* @__PURE__ */ new WeakMap(); + var ObjectId = class _ObjectId extends BSONValue { + get _bsontype() { + return "ObjectId"; + } + constructor(inputId) { + super(); + let workingId; + if (typeof inputId === "object" && inputId && "id" in inputId) { + if (typeof inputId.id !== "string" && !ArrayBuffer.isView(inputId.id)) { + throw new BSONError("Argument passed in must have an id that is of type string or Buffer"); + } + if ("toHexString" in inputId && typeof inputId.toHexString === "function") { + workingId = ByteUtils.fromHex(inputId.toHexString()); + } else { + workingId = inputId.id; + } + } else { + workingId = inputId; + } + if (workingId == null || typeof workingId === "number") { + this.buffer = _ObjectId.generate(typeof workingId === "number" ? workingId : void 0); + } else if (ArrayBuffer.isView(workingId) && workingId.byteLength === 12) { + this.buffer = ByteUtils.toLocalBufferType(workingId); + } else if (typeof workingId === "string") { + if (_ObjectId.validateHexString(workingId)) { + this.buffer = ByteUtils.fromHex(workingId); + if (_ObjectId.cacheHexString) { + __idCache.set(this, workingId); + } + } else { + throw new BSONError("input must be a 24 character hex string, 12 byte Uint8Array, or an integer"); + } + } else { + throw new BSONError("Argument passed in does not match the accepted types"); + } + } + get id() { + return this.buffer; + } + set id(value) { + this.buffer = value; + if (_ObjectId.cacheHexString) { + __idCache.set(this, ByteUtils.toHex(value)); + } + } + static validateHexString(string) { + if (string?.length !== 24) + return false; + for (let i = 0; i < 24; i++) { + const char = string.charCodeAt(i); + if (char >= 48 && char <= 57 || char >= 97 && char <= 102 || char >= 65 && char <= 70) { + continue; + } + return false; + } + return true; + } + toHexString() { + if (_ObjectId.cacheHexString) { + const __id = __idCache.get(this); + if (__id) + return __id; + } + const hexString = ByteUtils.toHex(this.id); + if (_ObjectId.cacheHexString) { + __idCache.set(this, hexString); + } + return hexString; + } + static getInc() { + return _ObjectId.index = (_ObjectId.index + 1) % 16777215; + } + static generate(time) { + if ("number" !== typeof time) { + time = Math.floor(Date.now() / 1e3); + } + const inc = _ObjectId.getInc(); + const buffer2 = ByteUtils.allocateUnsafe(12); + NumberUtils.setInt32BE(buffer2, 0, time); + if (PROCESS_UNIQUE === null) { + PROCESS_UNIQUE = ByteUtils.randomBytes(5); + } + buffer2[4] = PROCESS_UNIQUE[0]; + buffer2[5] = PROCESS_UNIQUE[1]; + buffer2[6] = PROCESS_UNIQUE[2]; + buffer2[7] = PROCESS_UNIQUE[3]; + buffer2[8] = PROCESS_UNIQUE[4]; + buffer2[11] = inc & 255; + buffer2[10] = inc >> 8 & 255; + buffer2[9] = inc >> 16 & 255; + return buffer2; + } + toString(encoding) { + if (encoding === "base64") + return ByteUtils.toBase64(this.id); + if (encoding === "hex") + return this.toHexString(); + return this.toHexString(); + } + toJSON() { + return this.toHexString(); + } + static is(variable) { + return variable != null && typeof variable === "object" && "_bsontype" in variable && variable._bsontype === "ObjectId"; + } + equals(otherId) { + if (otherId === void 0 || otherId === null) { + return false; + } + if (_ObjectId.is(otherId)) { + return this.buffer[11] === otherId.buffer[11] && ByteUtils.equals(this.buffer, otherId.buffer); + } + if (typeof otherId === "string") { + return otherId.toLowerCase() === this.toHexString(); + } + if (typeof otherId === "object" && typeof otherId.toHexString === "function") { + const otherIdString = otherId.toHexString(); + const thisIdString = this.toHexString(); + return typeof otherIdString === "string" && otherIdString.toLowerCase() === thisIdString; + } + return false; + } + getTimestamp() { + const timestamp = /* @__PURE__ */ new Date(); + const time = NumberUtils.getUint32BE(this.buffer, 0); + timestamp.setTime(Math.floor(time) * 1e3); + return timestamp; + } + static createPk() { + return new _ObjectId(); + } + serializeInto(uint8array, index) { + uint8array[index] = this.buffer[0]; + uint8array[index + 1] = this.buffer[1]; + uint8array[index + 2] = this.buffer[2]; + uint8array[index + 3] = this.buffer[3]; + uint8array[index + 4] = this.buffer[4]; + uint8array[index + 5] = this.buffer[5]; + uint8array[index + 6] = this.buffer[6]; + uint8array[index + 7] = this.buffer[7]; + uint8array[index + 8] = this.buffer[8]; + uint8array[index + 9] = this.buffer[9]; + uint8array[index + 10] = this.buffer[10]; + uint8array[index + 11] = this.buffer[11]; + return 12; + } + static createFromTime(time) { + const buffer2 = ByteUtils.allocate(12); + for (let i = 11; i >= 4; i--) + buffer2[i] = 0; + NumberUtils.setInt32BE(buffer2, 0, time); + return new _ObjectId(buffer2); + } + static createFromHexString(hexString) { + if (hexString?.length !== 24) { + throw new BSONError("hex string must be 24 characters"); + } + return new _ObjectId(ByteUtils.fromHex(hexString)); + } + static createFromBase64(base64) { + if (base64?.length !== 16) { + throw new BSONError("base64 string must be 16 characters"); + } + return new _ObjectId(ByteUtils.fromBase64(base64)); + } + static isValid(id) { + if (id == null) + return false; + if (typeof id === "string") + return _ObjectId.validateHexString(id); + try { + new _ObjectId(id); + return true; + } catch { + return false; + } + } + toExtendedJSON() { + if (this.toHexString) + return { $oid: this.toHexString() }; + return { $oid: this.toString("hex") }; + } + static fromExtendedJSON(doc) { + return new _ObjectId(doc.$oid); + } + isCached() { + return _ObjectId.cacheHexString && __idCache.has(this); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + return `new ObjectId(${inspect(this.toHexString(), options)})`; + } + }; + ObjectId.index = Math.floor(Math.random() * 16777215); + function internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined) { + let totalLength = 4 + 1; + if (Array.isArray(object)) { + for (let i = 0; i < object.length; i++) { + totalLength += calculateElement(i.toString(), object[i], serializeFunctions, true, ignoreUndefined); + } + } else { + if (typeof object?.toBSON === "function") { + object = object.toBSON(); + } + for (const key of Object.keys(object)) { + totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined); + } + } + return totalLength; + } + function calculateElement(name, value, serializeFunctions = false, isArray = false, ignoreUndefined = false) { + if (typeof value?.toBSON === "function") { + value = value.toBSON(); + } + switch (typeof value) { + case "string": + return 1 + ByteUtils.utf8ByteLength(name) + 1 + 4 + ByteUtils.utf8ByteLength(value) + 1; + case "number": + if (Math.floor(value) === value && value >= JS_INT_MIN && value <= JS_INT_MAX) { + if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (4 + 1); + } else { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1); + } + } else { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1); + } + case "undefined": + if (isArray || !ignoreUndefined) + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1; + return 0; + case "boolean": + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 1); + case "object": + if (value != null && typeof value._bsontype === "string" && value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) { + throw new BSONVersionError(); + } else if (value == null || value._bsontype === "MinKey" || value._bsontype === "MaxKey") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1; + } else if (value._bsontype === "ObjectId") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1); + } else if (value instanceof Date || isDate(value)) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1); + } else if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || isAnyArrayBuffer(value)) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength; + } else if (value._bsontype === "Long" || value._bsontype === "Double" || value._bsontype === "Timestamp") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1); + } else if (value._bsontype === "Decimal128") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1); + } else if (value._bsontype === "Code") { + if (value.scope != null && Object.keys(value.scope).length > 0) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + 4 + 4 + ByteUtils.utf8ByteLength(value.code.toString()) + 1 + internalCalculateObjectSize(value.scope, serializeFunctions, ignoreUndefined); + } else { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + 4 + ByteUtils.utf8ByteLength(value.code.toString()) + 1; + } + } else if (value._bsontype === "Binary") { + const binary = value; + if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1 + 4); + } else { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1); + } + } else if (value._bsontype === "Symbol") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + ByteUtils.utf8ByteLength(value.value) + 4 + 1 + 1; + } else if (value._bsontype === "DBRef") { + const ordered_values = Object.assign({ + $ref: value.collection, + $id: value.oid + }, value.fields); + if (value.db != null) { + ordered_values["$db"] = value.db; + } + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + internalCalculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined); + } else if (value instanceof RegExp || isRegExp(value)) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + ByteUtils.utf8ByteLength(value.source) + 1 + (value.global ? 1 : 0) + (value.ignoreCase ? 1 : 0) + (value.multiline ? 1 : 0) + 1; + } else if (value._bsontype === "BSONRegExp") { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + ByteUtils.utf8ByteLength(value.pattern) + 1 + ByteUtils.utf8ByteLength(value.options) + 1; + } else { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + internalCalculateObjectSize(value, serializeFunctions, ignoreUndefined) + 1; + } + case "function": + if (serializeFunctions) { + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1 + 4 + ByteUtils.utf8ByteLength(value.toString()) + 1; + } + return 0; + case "bigint": + return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1); + case "symbol": + return 0; + default: + throw new BSONError(`Unrecognized JS type: ${typeof value}`); + } + } + function alphabetize(str) { + return str.split("").sort().join(""); + } + var BSONRegExp = class _BSONRegExp extends BSONValue { + get _bsontype() { + return "BSONRegExp"; + } + constructor(pattern, options) { + super(); + this.pattern = pattern; + this.options = alphabetize(options ?? ""); + if (this.pattern.indexOf("\0") !== -1) { + throw new BSONError(`BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`); + } + if (this.options.indexOf("\0") !== -1) { + throw new BSONError(`BSON Regex options cannot contain null bytes, found: ${JSON.stringify(this.options)}`); + } + for (let i = 0; i < this.options.length; i++) { + if (!(this.options[i] === "i" || this.options[i] === "m" || this.options[i] === "x" || this.options[i] === "l" || this.options[i] === "s" || this.options[i] === "u")) { + throw new BSONError(`The regular expression option [${this.options[i]}] is not supported`); + } + } + } + static parseOptions(options) { + return options ? options.split("").sort().join("") : ""; + } + toExtendedJSON(options) { + options = options || {}; + if (options.legacy) { + return { $regex: this.pattern, $options: this.options }; + } + return { $regularExpression: { pattern: this.pattern, options: this.options } }; + } + static fromExtendedJSON(doc) { + if ("$regex" in doc) { + if (typeof doc.$regex !== "string") { + if (doc.$regex._bsontype === "BSONRegExp") { + return doc; + } + } else { + return new _BSONRegExp(doc.$regex, _BSONRegExp.parseOptions(doc.$options)); + } + } + if ("$regularExpression" in doc) { + return new _BSONRegExp(doc.$regularExpression.pattern, _BSONRegExp.parseOptions(doc.$regularExpression.options)); + } + throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`); + } + inspect(depth, options, inspect) { + const stylize = getStylizeFunction(options) ?? ((v) => v); + inspect ??= defaultInspect; + const pattern = stylize(inspect(this.pattern), "regexp"); + const flags = stylize(inspect(this.options), "regexp"); + return `new BSONRegExp(${pattern}, ${flags})`; + } + }; + var BSONSymbol = class _BSONSymbol extends BSONValue { + get _bsontype() { + return "BSONSymbol"; + } + constructor(value) { + super(); + this.value = value; + } + valueOf() { + return this.value; + } + toString() { + return this.value; + } + toJSON() { + return this.value; + } + toExtendedJSON() { + return { $symbol: this.value }; + } + static fromExtendedJSON(doc) { + return new _BSONSymbol(doc.$symbol); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + return `new BSONSymbol(${inspect(this.value, options)})`; + } + }; + var LongWithoutOverridesClass = Long; + var Timestamp = class _Timestamp extends LongWithoutOverridesClass { + get _bsontype() { + return "Timestamp"; + } + get i() { + return this.low >>> 0; + } + get t() { + return this.high >>> 0; + } + constructor(low) { + if (low == null) { + super(0, 0, true); + } else if (typeof low === "bigint") { + super(low, true); + } else if (Long.isLong(low)) { + super(low.low, low.high, true); + } else if (typeof low === "object" && "t" in low && "i" in low) { + if (typeof low.t !== "number" && (typeof low.t !== "object" || low.t._bsontype !== "Int32")) { + throw new BSONError("Timestamp constructed from { t, i } must provide t as a number"); + } + if (typeof low.i !== "number" && (typeof low.i !== "object" || low.i._bsontype !== "Int32")) { + throw new BSONError("Timestamp constructed from { t, i } must provide i as a number"); + } + const t = Number(low.t); + const i = Number(low.i); + if (t < 0 || Number.isNaN(t)) { + throw new BSONError("Timestamp constructed from { t, i } must provide a positive t"); + } + if (i < 0 || Number.isNaN(i)) { + throw new BSONError("Timestamp constructed from { t, i } must provide a positive i"); + } + if (t > 4294967295) { + throw new BSONError("Timestamp constructed from { t, i } must provide t equal or less than uint32 max"); + } + if (i > 4294967295) { + throw new BSONError("Timestamp constructed from { t, i } must provide i equal or less than uint32 max"); + } + super(i, t, true); + } else { + throw new BSONError("A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }"); + } + } + toJSON() { + return { + $timestamp: this.toString() + }; + } + static fromInt(value) { + return new _Timestamp(Long.fromInt(value, true)); + } + static fromNumber(value) { + return new _Timestamp(Long.fromNumber(value, true)); + } + static fromBits(lowBits, highBits) { + return new _Timestamp({ i: lowBits, t: highBits }); + } + static fromString(str, optRadix) { + return new _Timestamp(Long.fromString(str, true, optRadix)); + } + toExtendedJSON() { + return { $timestamp: { t: this.t, i: this.i } }; + } + static fromExtendedJSON(doc) { + const i = Long.isLong(doc.$timestamp.i) ? doc.$timestamp.i.getLowBitsUnsigned() : doc.$timestamp.i; + const t = Long.isLong(doc.$timestamp.t) ? doc.$timestamp.t.getLowBitsUnsigned() : doc.$timestamp.t; + return new _Timestamp({ t, i }); + } + inspect(depth, options, inspect) { + inspect ??= defaultInspect; + const t = inspect(this.t, options); + const i = inspect(this.i, options); + return `new Timestamp({ t: ${t}, i: ${i} })`; + } + }; + Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE; + var JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX); + var JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN); + function internalDeserialize(buffer2, options, isArray) { + options = options == null ? {} : options; + const index = options && options.index ? options.index : 0; + const size = NumberUtils.getInt32LE(buffer2, index); + if (size < 5) { + throw new BSONError(`bson size must be >= 5, is ${size}`); + } + if (options.allowObjectSmallerThanBufferSize && buffer2.length < size) { + throw new BSONError(`buffer length ${buffer2.length} must be >= bson size ${size}`); + } + if (!options.allowObjectSmallerThanBufferSize && buffer2.length !== size) { + throw new BSONError(`buffer length ${buffer2.length} must === bson size ${size}`); + } + if (size + index > buffer2.byteLength) { + throw new BSONError(`(bson size ${size} + options.index ${index} must be <= buffer length ${buffer2.byteLength})`); + } + if (buffer2[index + size - 1] !== 0) { + throw new BSONError("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00"); + } + return deserializeObject(buffer2, index, options, isArray); + } + var allowedDBRefKeys = /^\$ref$|^\$id$|^\$db$/; + function deserializeObject(buffer2, index, options, isArray = false) { + const fieldsAsRaw = options["fieldsAsRaw"] == null ? null : options["fieldsAsRaw"]; + const raw = options["raw"] == null ? false : options["raw"]; + const bsonRegExp = typeof options["bsonRegExp"] === "boolean" ? options["bsonRegExp"] : false; + const promoteBuffers = options.promoteBuffers ?? false; + const promoteLongs = options.promoteLongs ?? true; + const promoteValues = options.promoteValues ?? true; + const useBigInt64 = options.useBigInt64 ?? false; + if (useBigInt64 && !promoteValues) { + throw new BSONError("Must either request bigint or Long for int64 deserialization"); + } + if (useBigInt64 && !promoteLongs) { + throw new BSONError("Must either request bigint or Long for int64 deserialization"); + } + const validation = options.validation == null ? { utf8: true } : options.validation; + let globalUTFValidation = true; + let validationSetting; + let utf8KeysSet; + const utf8ValidatedKeys = validation.utf8; + if (typeof utf8ValidatedKeys === "boolean") { + validationSetting = utf8ValidatedKeys; + } else { + globalUTFValidation = false; + const utf8ValidationValues = Object.keys(utf8ValidatedKeys).map(function(key) { + return utf8ValidatedKeys[key]; + }); + if (utf8ValidationValues.length === 0) { + throw new BSONError("UTF-8 validation setting cannot be empty"); + } + if (typeof utf8ValidationValues[0] !== "boolean") { + throw new BSONError("Invalid UTF-8 validation option, must specify boolean values"); + } + validationSetting = utf8ValidationValues[0]; + if (!utf8ValidationValues.every((item) => item === validationSetting)) { + throw new BSONError("Invalid UTF-8 validation option - keys must be all true or all false"); + } + } + if (!globalUTFValidation) { + utf8KeysSet = /* @__PURE__ */ new Set(); + for (const key of Object.keys(utf8ValidatedKeys)) { + utf8KeysSet.add(key); + } + } + const startIndex = index; + if (buffer2.length < 5) + throw new BSONError("corrupt bson message < 5 bytes long"); + const size = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (size < 5 || size > buffer2.length) + throw new BSONError("corrupt bson message"); + const object = isArray ? [] : {}; + let arrayIndex = 0; + let isPossibleDBRef = isArray ? false : null; + while (true) { + const elementType = buffer2[index++]; + if (elementType === 0) + break; + let i = index; + while (buffer2[i] !== 0 && i < buffer2.length) { + i++; + } + if (i >= buffer2.byteLength) + throw new BSONError("Bad BSON Document: illegal CString"); + const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer2, index, i, false); + let shouldValidateKey = true; + if (globalUTFValidation || utf8KeysSet?.has(name)) { + shouldValidateKey = validationSetting; + } else { + shouldValidateKey = !validationSetting; + } + if (isPossibleDBRef !== false && name[0] === "$") { + isPossibleDBRef = allowedDBRefKeys.test(name); + } + let value; + index = i + 1; + if (elementType === BSON_DATA_STRING) { + const stringSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (stringSize <= 0 || stringSize > buffer2.length - index || buffer2[index + stringSize - 1] !== 0) { + throw new BSONError("bad string length in bson"); + } + value = ByteUtils.toUTF8(buffer2, index, index + stringSize - 1, shouldValidateKey); + index = index + stringSize; + } else if (elementType === BSON_DATA_OID) { + const oid = ByteUtils.allocateUnsafe(12); + for (let i2 = 0; i2 < 12; i2++) + oid[i2] = buffer2[index + i2]; + value = new ObjectId(oid); + index = index + 12; + } else if (elementType === BSON_DATA_INT && promoteValues === false) { + value = new Int32(NumberUtils.getInt32LE(buffer2, index)); + index += 4; + } else if (elementType === BSON_DATA_INT) { + value = NumberUtils.getInt32LE(buffer2, index); + index += 4; + } else if (elementType === BSON_DATA_NUMBER) { + value = NumberUtils.getFloat64LE(buffer2, index); + index += 8; + if (promoteValues === false) + value = new Double(value); + } else if (elementType === BSON_DATA_DATE) { + const lowBits = NumberUtils.getInt32LE(buffer2, index); + const highBits = NumberUtils.getInt32LE(buffer2, index + 4); + index += 8; + value = new Date(new Long(lowBits, highBits).toNumber()); + } else if (elementType === BSON_DATA_BOOLEAN) { + if (buffer2[index] !== 0 && buffer2[index] !== 1) + throw new BSONError("illegal boolean type value"); + value = buffer2[index++] === 1; + } else if (elementType === BSON_DATA_OBJECT) { + const _index = index; + const objectSize = NumberUtils.getInt32LE(buffer2, index); + if (objectSize <= 0 || objectSize > buffer2.length - index) + throw new BSONError("bad embedded document length in bson"); + if (raw) { + value = buffer2.subarray(index, index + objectSize); + } else { + let objectOptions = options; + if (!globalUTFValidation) { + objectOptions = { ...options, validation: { utf8: shouldValidateKey } }; + } + value = deserializeObject(buffer2, _index, objectOptions, false); + } + index = index + objectSize; + } else if (elementType === BSON_DATA_ARRAY) { + const _index = index; + const objectSize = NumberUtils.getInt32LE(buffer2, index); + let arrayOptions = options; + const stopIndex = index + objectSize; + if (fieldsAsRaw && fieldsAsRaw[name]) { + arrayOptions = { ...options, raw: true }; + } + if (!globalUTFValidation) { + arrayOptions = { ...arrayOptions, validation: { utf8: shouldValidateKey } }; + } + value = deserializeObject(buffer2, _index, arrayOptions, true); + index = index + objectSize; + if (buffer2[index - 1] !== 0) + throw new BSONError("invalid array terminator byte"); + if (index !== stopIndex) + throw new BSONError("corrupted array bson"); + } else if (elementType === BSON_DATA_UNDEFINED) { + value = void 0; + } else if (elementType === BSON_DATA_NULL) { + value = null; + } else if (elementType === BSON_DATA_LONG) { + if (useBigInt64) { + value = NumberUtils.getBigInt64LE(buffer2, index); + index += 8; + } else { + const lowBits = NumberUtils.getInt32LE(buffer2, index); + const highBits = NumberUtils.getInt32LE(buffer2, index + 4); + index += 8; + const long = new Long(lowBits, highBits); + if (promoteLongs && promoteValues === true) { + value = long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG) ? long.toNumber() : long; + } else { + value = long; + } + } + } else if (elementType === BSON_DATA_DECIMAL128) { + const bytes = ByteUtils.allocateUnsafe(16); + for (let i2 = 0; i2 < 16; i2++) + bytes[i2] = buffer2[index + i2]; + index = index + 16; + value = new Decimal128(bytes); + } else if (elementType === BSON_DATA_BINARY) { + let binarySize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + const totalBinarySize = binarySize; + const subType = buffer2[index++]; + if (binarySize < 0) + throw new BSONError("Negative binary type element size found"); + if (binarySize > buffer2.byteLength) + throw new BSONError("Binary type size larger than document size"); + if (subType === Binary.SUBTYPE_BYTE_ARRAY) { + binarySize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (binarySize < 0) + throw new BSONError("Negative binary type element size found for subtype 0x02"); + if (binarySize > totalBinarySize - 4) + throw new BSONError("Binary type with subtype 0x02 contains too long binary size"); + if (binarySize < totalBinarySize - 4) + throw new BSONError("Binary type with subtype 0x02 contains too short binary size"); + } + if (promoteBuffers && promoteValues) { + value = ByteUtils.toLocalBufferType(buffer2.subarray(index, index + binarySize)); + } else { + value = new Binary(buffer2.subarray(index, index + binarySize), subType); + if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) { + value = value.toUUID(); + } + } + index = index + binarySize; + } else if (elementType === BSON_DATA_REGEXP && bsonRegExp === false) { + i = index; + while (buffer2[i] !== 0 && i < buffer2.length) { + i++; + } + if (i >= buffer2.length) + throw new BSONError("Bad BSON Document: illegal CString"); + const source = ByteUtils.toUTF8(buffer2, index, i, false); + index = i + 1; + i = index; + while (buffer2[i] !== 0 && i < buffer2.length) { + i++; + } + if (i >= buffer2.length) + throw new BSONError("Bad BSON Document: illegal CString"); + const regExpOptions = ByteUtils.toUTF8(buffer2, index, i, false); + index = i + 1; + const optionsArray = new Array(regExpOptions.length); + for (i = 0; i < regExpOptions.length; i++) { + switch (regExpOptions[i]) { + case "m": + optionsArray[i] = "m"; + break; + case "s": + optionsArray[i] = "g"; + break; + case "i": + optionsArray[i] = "i"; + break; + } + } + value = new RegExp(source, optionsArray.join("")); + } else if (elementType === BSON_DATA_REGEXP && bsonRegExp === true) { + i = index; + while (buffer2[i] !== 0 && i < buffer2.length) { + i++; + } + if (i >= buffer2.length) + throw new BSONError("Bad BSON Document: illegal CString"); + const source = ByteUtils.toUTF8(buffer2, index, i, false); + index = i + 1; + i = index; + while (buffer2[i] !== 0 && i < buffer2.length) { + i++; + } + if (i >= buffer2.length) + throw new BSONError("Bad BSON Document: illegal CString"); + const regExpOptions = ByteUtils.toUTF8(buffer2, index, i, false); + index = i + 1; + value = new BSONRegExp(source, regExpOptions); + } else if (elementType === BSON_DATA_SYMBOL) { + const stringSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (stringSize <= 0 || stringSize > buffer2.length - index || buffer2[index + stringSize - 1] !== 0) { + throw new BSONError("bad string length in bson"); + } + const symbol = ByteUtils.toUTF8(buffer2, index, index + stringSize - 1, shouldValidateKey); + value = promoteValues ? symbol : new BSONSymbol(symbol); + index = index + stringSize; + } else if (elementType === BSON_DATA_TIMESTAMP) { + value = new Timestamp({ + i: NumberUtils.getUint32LE(buffer2, index), + t: NumberUtils.getUint32LE(buffer2, index + 4) + }); + index += 8; + } else if (elementType === BSON_DATA_MIN_KEY) { + value = new MinKey(); + } else if (elementType === BSON_DATA_MAX_KEY) { + value = new MaxKey(); + } else if (elementType === BSON_DATA_CODE) { + const stringSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (stringSize <= 0 || stringSize > buffer2.length - index || buffer2[index + stringSize - 1] !== 0) { + throw new BSONError("bad string length in bson"); + } + const functionString = ByteUtils.toUTF8(buffer2, index, index + stringSize - 1, shouldValidateKey); + value = new Code(functionString); + index = index + stringSize; + } else if (elementType === BSON_DATA_CODE_W_SCOPE) { + const totalSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (totalSize < 4 + 4 + 4 + 1) { + throw new BSONError("code_w_scope total size shorter minimum expected length"); + } + const stringSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (stringSize <= 0 || stringSize > buffer2.length - index || buffer2[index + stringSize - 1] !== 0) { + throw new BSONError("bad string length in bson"); + } + const functionString = ByteUtils.toUTF8(buffer2, index, index + stringSize - 1, shouldValidateKey); + index = index + stringSize; + const _index = index; + const objectSize = NumberUtils.getInt32LE(buffer2, index); + const scopeObject = deserializeObject(buffer2, _index, options, false); + index = index + objectSize; + if (totalSize < 4 + 4 + objectSize + stringSize) { + throw new BSONError("code_w_scope total size is too short, truncating scope"); + } + if (totalSize > 4 + 4 + objectSize + stringSize) { + throw new BSONError("code_w_scope total size is too long, clips outer document"); + } + value = new Code(functionString, scopeObject); + } else if (elementType === BSON_DATA_DBPOINTER) { + const stringSize = NumberUtils.getInt32LE(buffer2, index); + index += 4; + if (stringSize <= 0 || stringSize > buffer2.length - index || buffer2[index + stringSize - 1] !== 0) + throw new BSONError("bad string length in bson"); + const namespace = ByteUtils.toUTF8(buffer2, index, index + stringSize - 1, shouldValidateKey); + index = index + stringSize; + const oidBuffer = ByteUtils.allocateUnsafe(12); + for (let i2 = 0; i2 < 12; i2++) + oidBuffer[i2] = buffer2[index + i2]; + const oid = new ObjectId(oidBuffer); + index = index + 12; + value = new DBRef(namespace, oid); + } else { + throw new BSONError(`Detected unknown BSON type ${elementType.toString(16)} for fieldname "${name}"`); + } + if (name === "__proto__") { + Object.defineProperty(object, name, { + value, + writable: true, + enumerable: true, + configurable: true + }); + } else { + object[name] = value; + } + } + if (size !== index - startIndex) { + if (isArray) + throw new BSONError("corrupt array bson"); + throw new BSONError("corrupt object bson"); + } + if (!isPossibleDBRef) + return object; + if (isDBRefLike(object)) { + const copy = Object.assign({}, object); + delete copy.$ref; + delete copy.$id; + delete copy.$db; + return new DBRef(object.$ref, object.$id, object.$db, copy); + } + return object; + } + var regexp = /\x00/; + var ignoreKeys = /* @__PURE__ */ new Set(["$db", "$ref", "$id", "$clusterTime"]); + function serializeString(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_STRING; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes + 1; + buffer2[index - 1] = 0; + const size = ByteUtils.encodeUTF8Into(buffer2, value, index + 4); + NumberUtils.setInt32LE(buffer2, index, size + 1); + index = index + 4 + size; + buffer2[index++] = 0; + return index; + } + function serializeNumber(buffer2, key, value, index) { + const isNegativeZero = Object.is(value, -0); + const type = !isNegativeZero && Number.isSafeInteger(value) && value <= BSON_INT32_MAX && value >= BSON_INT32_MIN ? BSON_DATA_INT : BSON_DATA_NUMBER; + buffer2[index++] = type; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + if (type === BSON_DATA_INT) { + index += NumberUtils.setInt32LE(buffer2, index, value); + } else { + index += NumberUtils.setFloat64LE(buffer2, index, value); + } + return index; + } + function serializeBigInt(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_LONG; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index += numberOfWrittenBytes; + buffer2[index++] = 0; + index += NumberUtils.setBigInt64LE(buffer2, index, value); + return index; + } + function serializeNull(buffer2, key, _, index) { + buffer2[index++] = BSON_DATA_NULL; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + return index; + } + function serializeBoolean(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_BOOLEAN; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + buffer2[index++] = value ? 1 : 0; + return index; + } + function serializeDate(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_DATE; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const dateInMilis = Long.fromNumber(value.getTime()); + const lowBits = dateInMilis.getLowBits(); + const highBits = dateInMilis.getHighBits(); + index += NumberUtils.setInt32LE(buffer2, index, lowBits); + index += NumberUtils.setInt32LE(buffer2, index, highBits); + return index; + } + function serializeRegExp(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_REGEXP; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + if (value.source && value.source.match(regexp) != null) { + throw new BSONError("value " + value.source + " must not contain null bytes"); + } + index = index + ByteUtils.encodeUTF8Into(buffer2, value.source, index); + buffer2[index++] = 0; + if (value.ignoreCase) + buffer2[index++] = 105; + if (value.global) + buffer2[index++] = 115; + if (value.multiline) + buffer2[index++] = 109; + buffer2[index++] = 0; + return index; + } + function serializeBSONRegExp(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_REGEXP; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + if (value.pattern.match(regexp) != null) { + throw new BSONError("pattern " + value.pattern + " must not contain null bytes"); + } + index = index + ByteUtils.encodeUTF8Into(buffer2, value.pattern, index); + buffer2[index++] = 0; + const sortedOptions = value.options.split("").sort().join(""); + index = index + ByteUtils.encodeUTF8Into(buffer2, sortedOptions, index); + buffer2[index++] = 0; + return index; + } + function serializeMinMax(buffer2, key, value, index) { + if (value === null) { + buffer2[index++] = BSON_DATA_NULL; + } else if (value._bsontype === "MinKey") { + buffer2[index++] = BSON_DATA_MIN_KEY; + } else { + buffer2[index++] = BSON_DATA_MAX_KEY; + } + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + return index; + } + function serializeObjectId(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_OID; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + index += value.serializeInto(buffer2, index); + return index; + } + function serializeBuffer(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_BINARY; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const size = value.length; + index += NumberUtils.setInt32LE(buffer2, index, size); + buffer2[index++] = BSON_BINARY_SUBTYPE_DEFAULT; + if (size <= 16) { + for (let i = 0; i < size; i++) + buffer2[index + i] = value[i]; + } else { + buffer2.set(value, index); + } + index = index + size; + return index; + } + function serializeObject(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path) { + if (path.has(value)) { + throw new BSONError("Cannot convert circular structure to BSON"); + } + path.add(value); + buffer2[index++] = Array.isArray(value) ? BSON_DATA_ARRAY : BSON_DATA_OBJECT; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const endIndex = serializeInto(buffer2, value, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path); + path.delete(value); + return endIndex; + } + function serializeDecimal128(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_DECIMAL128; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + for (let i = 0; i < 16; i++) + buffer2[index + i] = value.bytes[i]; + return index + 16; + } + function serializeLong(buffer2, key, value, index) { + buffer2[index++] = value._bsontype === "Long" ? BSON_DATA_LONG : BSON_DATA_TIMESTAMP; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const lowBits = value.getLowBits(); + const highBits = value.getHighBits(); + index += NumberUtils.setInt32LE(buffer2, index, lowBits); + index += NumberUtils.setInt32LE(buffer2, index, highBits); + return index; + } + function serializeInt32(buffer2, key, value, index) { + value = value.valueOf(); + buffer2[index++] = BSON_DATA_INT; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + index += NumberUtils.setInt32LE(buffer2, index, value); + return index; + } + function serializeDouble(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_NUMBER; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + index += NumberUtils.setFloat64LE(buffer2, index, value.value); + return index; + } + function serializeFunction(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_CODE; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const functionString = value.toString(); + const size = ByteUtils.encodeUTF8Into(buffer2, functionString, index + 4) + 1; + NumberUtils.setInt32LE(buffer2, index, size); + index = index + 4 + size - 1; + buffer2[index++] = 0; + return index; + } + function serializeCode(buffer2, key, value, index, checkKeys = false, depth = 0, serializeFunctions = false, ignoreUndefined = true, path) { + if (value.scope && typeof value.scope === "object") { + buffer2[index++] = BSON_DATA_CODE_W_SCOPE; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + let startIndex = index; + const functionString = value.code; + index = index + 4; + const codeSize = ByteUtils.encodeUTF8Into(buffer2, functionString, index + 4) + 1; + NumberUtils.setInt32LE(buffer2, index, codeSize); + buffer2[index + 4 + codeSize - 1] = 0; + index = index + codeSize + 4; + const endIndex = serializeInto(buffer2, value.scope, checkKeys, index, depth + 1, serializeFunctions, ignoreUndefined, path); + index = endIndex - 1; + const totalSize = endIndex - startIndex; + startIndex += NumberUtils.setInt32LE(buffer2, startIndex, totalSize); + buffer2[index++] = 0; + } else { + buffer2[index++] = BSON_DATA_CODE; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const functionString = value.code.toString(); + const size = ByteUtils.encodeUTF8Into(buffer2, functionString, index + 4) + 1; + NumberUtils.setInt32LE(buffer2, index, size); + index = index + 4 + size - 1; + buffer2[index++] = 0; + } + return index; + } + function serializeBinary(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_BINARY; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const data = value.buffer; + let size = value.position; + if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) + size = size + 4; + index += NumberUtils.setInt32LE(buffer2, index, size); + buffer2[index++] = value.sub_type; + if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) { + size = size - 4; + index += NumberUtils.setInt32LE(buffer2, index, size); + } + if (value.sub_type === Binary.SUBTYPE_VECTOR) { + validateBinaryVector(value); + } + if (size <= 16) { + for (let i = 0; i < size; i++) + buffer2[index + i] = data[i]; + } else { + buffer2.set(data, index); + } + index = index + value.position; + return index; + } + function serializeSymbol(buffer2, key, value, index) { + buffer2[index++] = BSON_DATA_SYMBOL; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + const size = ByteUtils.encodeUTF8Into(buffer2, value.value, index + 4) + 1; + NumberUtils.setInt32LE(buffer2, index, size); + index = index + 4 + size - 1; + buffer2[index++] = 0; + return index; + } + function serializeDBRef(buffer2, key, value, index, depth, serializeFunctions, path) { + buffer2[index++] = BSON_DATA_OBJECT; + const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer2, key, index); + index = index + numberOfWrittenBytes; + buffer2[index++] = 0; + let startIndex = index; + let output = { + $ref: value.collection || value.namespace, + $id: value.oid + }; + if (value.db != null) { + output.$db = value.db; + } + output = Object.assign(output, value.fields); + const endIndex = serializeInto(buffer2, output, false, index, depth + 1, serializeFunctions, true, path); + const size = endIndex - startIndex; + startIndex += NumberUtils.setInt32LE(buffer2, index, size); + return endIndex; + } + function serializeInto(buffer2, object, checkKeys, startingIndex, depth, serializeFunctions, ignoreUndefined, path) { + if (path == null) { + if (object == null) { + buffer2[0] = 5; + buffer2[1] = 0; + buffer2[2] = 0; + buffer2[3] = 0; + buffer2[4] = 0; + return 5; + } + if (Array.isArray(object)) { + throw new BSONError("serialize does not support an array as the root input"); + } + if (typeof object !== "object") { + throw new BSONError("serialize does not support non-object as the root input"); + } else if ("_bsontype" in object && typeof object._bsontype === "string") { + throw new BSONError(`BSON types cannot be serialized as a document`); + } else if (isDate(object) || isRegExp(object) || isUint8Array(object) || isAnyArrayBuffer(object)) { + throw new BSONError(`date, regexp, typedarray, and arraybuffer cannot be BSON documents`); + } + path = /* @__PURE__ */ new Set(); + } + path.add(object); + let index = startingIndex + 4; + if (Array.isArray(object)) { + for (let i = 0; i < object.length; i++) { + const key = `${i}`; + let value = object[i]; + if (typeof value?.toBSON === "function") { + value = value.toBSON(); + } + const type = typeof value; + if (value === void 0) { + index = serializeNull(buffer2, key, value, index); + } else if (value === null) { + index = serializeNull(buffer2, key, value, index); + } else if (type === "string") { + index = serializeString(buffer2, key, value, index); + } else if (type === "number") { + index = serializeNumber(buffer2, key, value, index); + } else if (type === "bigint") { + index = serializeBigInt(buffer2, key, value, index); + } else if (type === "boolean") { + index = serializeBoolean(buffer2, key, value, index); + } else if (type === "object" && value._bsontype == null) { + if (value instanceof Date || isDate(value)) { + index = serializeDate(buffer2, key, value, index); + } else if (value instanceof Uint8Array || isUint8Array(value)) { + index = serializeBuffer(buffer2, key, value, index); + } else if (value instanceof RegExp || isRegExp(value)) { + index = serializeRegExp(buffer2, key, value, index); + } else { + index = serializeObject(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } + } else if (type === "object") { + if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) { + throw new BSONVersionError(); + } else if (value._bsontype === "ObjectId") { + index = serializeObjectId(buffer2, key, value, index); + } else if (value._bsontype === "Decimal128") { + index = serializeDecimal128(buffer2, key, value, index); + } else if (value._bsontype === "Long" || value._bsontype === "Timestamp") { + index = serializeLong(buffer2, key, value, index); + } else if (value._bsontype === "Double") { + index = serializeDouble(buffer2, key, value, index); + } else if (value._bsontype === "Code") { + index = serializeCode(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } else if (value._bsontype === "Binary") { + index = serializeBinary(buffer2, key, value, index); + } else if (value._bsontype === "BSONSymbol") { + index = serializeSymbol(buffer2, key, value, index); + } else if (value._bsontype === "DBRef") { + index = serializeDBRef(buffer2, key, value, index, depth, serializeFunctions, path); + } else if (value._bsontype === "BSONRegExp") { + index = serializeBSONRegExp(buffer2, key, value, index); + } else if (value._bsontype === "Int32") { + index = serializeInt32(buffer2, key, value, index); + } else if (value._bsontype === "MinKey" || value._bsontype === "MaxKey") { + index = serializeMinMax(buffer2, key, value, index); + } else if (typeof value._bsontype !== "undefined") { + throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`); + } + } else if (type === "function" && serializeFunctions) { + index = serializeFunction(buffer2, key, value, index); + } + } + } else if (object instanceof Map || isMap(object)) { + const iterator = object.entries(); + let done = false; + while (!done) { + const entry = iterator.next(); + done = !!entry.done; + if (done) + continue; + const key = entry.value ? entry.value[0] : void 0; + let value = entry.value ? entry.value[1] : void 0; + if (typeof value?.toBSON === "function") { + value = value.toBSON(); + } + const type = typeof value; + if (typeof key === "string" && !ignoreKeys.has(key)) { + if (key.match(regexp) != null) { + throw new BSONError("key " + key + " must not contain null bytes"); + } + if (checkKeys) { + if ("$" === key[0]) { + throw new BSONError("key " + key + " must not start with '$'"); + } else if (key.includes(".")) { + throw new BSONError("key " + key + " must not contain '.'"); + } + } + } + if (value === void 0) { + if (ignoreUndefined === false) + index = serializeNull(buffer2, key, value, index); + } else if (value === null) { + index = serializeNull(buffer2, key, value, index); + } else if (type === "string") { + index = serializeString(buffer2, key, value, index); + } else if (type === "number") { + index = serializeNumber(buffer2, key, value, index); + } else if (type === "bigint") { + index = serializeBigInt(buffer2, key, value, index); + } else if (type === "boolean") { + index = serializeBoolean(buffer2, key, value, index); + } else if (type === "object" && value._bsontype == null) { + if (value instanceof Date || isDate(value)) { + index = serializeDate(buffer2, key, value, index); + } else if (value instanceof Uint8Array || isUint8Array(value)) { + index = serializeBuffer(buffer2, key, value, index); + } else if (value instanceof RegExp || isRegExp(value)) { + index = serializeRegExp(buffer2, key, value, index); + } else { + index = serializeObject(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } + } else if (type === "object") { + if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) { + throw new BSONVersionError(); + } else if (value._bsontype === "ObjectId") { + index = serializeObjectId(buffer2, key, value, index); + } else if (value._bsontype === "Decimal128") { + index = serializeDecimal128(buffer2, key, value, index); + } else if (value._bsontype === "Long" || value._bsontype === "Timestamp") { + index = serializeLong(buffer2, key, value, index); + } else if (value._bsontype === "Double") { + index = serializeDouble(buffer2, key, value, index); + } else if (value._bsontype === "Code") { + index = serializeCode(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } else if (value._bsontype === "Binary") { + index = serializeBinary(buffer2, key, value, index); + } else if (value._bsontype === "BSONSymbol") { + index = serializeSymbol(buffer2, key, value, index); + } else if (value._bsontype === "DBRef") { + index = serializeDBRef(buffer2, key, value, index, depth, serializeFunctions, path); + } else if (value._bsontype === "BSONRegExp") { + index = serializeBSONRegExp(buffer2, key, value, index); + } else if (value._bsontype === "Int32") { + index = serializeInt32(buffer2, key, value, index); + } else if (value._bsontype === "MinKey" || value._bsontype === "MaxKey") { + index = serializeMinMax(buffer2, key, value, index); + } else if (typeof value._bsontype !== "undefined") { + throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`); + } + } else if (type === "function" && serializeFunctions) { + index = serializeFunction(buffer2, key, value, index); + } + } + } else { + if (typeof object?.toBSON === "function") { + object = object.toBSON(); + if (object != null && typeof object !== "object") { + throw new BSONError("toBSON function did not return an object"); + } + } + for (const key of Object.keys(object)) { + let value = object[key]; + if (typeof value?.toBSON === "function") { + value = value.toBSON(); + } + const type = typeof value; + if (typeof key === "string" && !ignoreKeys.has(key)) { + if (key.match(regexp) != null) { + throw new BSONError("key " + key + " must not contain null bytes"); + } + if (checkKeys) { + if ("$" === key[0]) { + throw new BSONError("key " + key + " must not start with '$'"); + } else if (key.includes(".")) { + throw new BSONError("key " + key + " must not contain '.'"); + } + } + } + if (value === void 0) { + if (ignoreUndefined === false) + index = serializeNull(buffer2, key, value, index); + } else if (value === null) { + index = serializeNull(buffer2, key, value, index); + } else if (type === "string") { + index = serializeString(buffer2, key, value, index); + } else if (type === "number") { + index = serializeNumber(buffer2, key, value, index); + } else if (type === "bigint") { + index = serializeBigInt(buffer2, key, value, index); + } else if (type === "boolean") { + index = serializeBoolean(buffer2, key, value, index); + } else if (type === "object" && value._bsontype == null) { + if (value instanceof Date || isDate(value)) { + index = serializeDate(buffer2, key, value, index); + } else if (value instanceof Uint8Array || isUint8Array(value)) { + index = serializeBuffer(buffer2, key, value, index); + } else if (value instanceof RegExp || isRegExp(value)) { + index = serializeRegExp(buffer2, key, value, index); + } else { + index = serializeObject(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } + } else if (type === "object") { + if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) { + throw new BSONVersionError(); + } else if (value._bsontype === "ObjectId") { + index = serializeObjectId(buffer2, key, value, index); + } else if (value._bsontype === "Decimal128") { + index = serializeDecimal128(buffer2, key, value, index); + } else if (value._bsontype === "Long" || value._bsontype === "Timestamp") { + index = serializeLong(buffer2, key, value, index); + } else if (value._bsontype === "Double") { + index = serializeDouble(buffer2, key, value, index); + } else if (value._bsontype === "Code") { + index = serializeCode(buffer2, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path); + } else if (value._bsontype === "Binary") { + index = serializeBinary(buffer2, key, value, index); + } else if (value._bsontype === "BSONSymbol") { + index = serializeSymbol(buffer2, key, value, index); + } else if (value._bsontype === "DBRef") { + index = serializeDBRef(buffer2, key, value, index, depth, serializeFunctions, path); + } else if (value._bsontype === "BSONRegExp") { + index = serializeBSONRegExp(buffer2, key, value, index); + } else if (value._bsontype === "Int32") { + index = serializeInt32(buffer2, key, value, index); + } else if (value._bsontype === "MinKey" || value._bsontype === "MaxKey") { + index = serializeMinMax(buffer2, key, value, index); + } else if (typeof value._bsontype !== "undefined") { + throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`); + } + } else if (type === "function" && serializeFunctions) { + index = serializeFunction(buffer2, key, value, index); + } + } + } + path.delete(object); + buffer2[index++] = 0; + const size = index - startingIndex; + startingIndex += NumberUtils.setInt32LE(buffer2, startingIndex, size); + return index; + } + function isBSONType(value) { + return value != null && typeof value === "object" && "_bsontype" in value && typeof value._bsontype === "string"; + } + var keysToCodecs = { + $oid: ObjectId, + $binary: Binary, + $uuid: Binary, + $symbol: BSONSymbol, + $numberInt: Int32, + $numberDecimal: Decimal128, + $numberDouble: Double, + $numberLong: Long, + $minKey: MinKey, + $maxKey: MaxKey, + $regex: BSONRegExp, + $regularExpression: BSONRegExp, + $timestamp: Timestamp + }; + function deserializeValue(value, options = {}) { + if (typeof value === "number") { + const in32BitRange = value <= BSON_INT32_MAX && value >= BSON_INT32_MIN; + const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN; + if (options.relaxed || options.legacy) { + return value; + } + if (Number.isInteger(value) && !Object.is(value, -0)) { + if (in32BitRange) { + return new Int32(value); + } + if (in64BitRange) { + if (options.useBigInt64) { + return BigInt(value); + } + return Long.fromNumber(value); + } + } + return new Double(value); + } + if (value == null || typeof value !== "object") + return value; + if (value.$undefined) + return null; + const keys = Object.keys(value).filter((k) => k.startsWith("$") && value[k] != null); + for (let i = 0; i < keys.length; i++) { + const c = keysToCodecs[keys[i]]; + if (c) + return c.fromExtendedJSON(value, options); + } + if (value.$date != null) { + const d = value.$date; + const date = /* @__PURE__ */ new Date(); + if (options.legacy) { + if (typeof d === "number") + date.setTime(d); + else if (typeof d === "string") + date.setTime(Date.parse(d)); + else if (typeof d === "bigint") + date.setTime(Number(d)); + else + throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`); + } else { + if (typeof d === "string") + date.setTime(Date.parse(d)); + else if (Long.isLong(d)) + date.setTime(d.toNumber()); + else if (typeof d === "number" && options.relaxed) + date.setTime(d); + else if (typeof d === "bigint") + date.setTime(Number(d)); + else + throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`); + } + return date; + } + if (value.$code != null) { + const copy = Object.assign({}, value); + if (value.$scope) { + copy.$scope = deserializeValue(value.$scope); + } + return Code.fromExtendedJSON(value); + } + if (isDBRefLike(value) || value.$dbPointer) { + const v = value.$ref ? value : value.$dbPointer; + if (v instanceof DBRef) + return v; + const dollarKeys = Object.keys(v).filter((k) => k.startsWith("$")); + let valid = true; + dollarKeys.forEach((k) => { + if (["$ref", "$id", "$db"].indexOf(k) === -1) + valid = false; + }); + if (valid) + return DBRef.fromExtendedJSON(v); + } + return value; + } + function serializeArray(array, options) { + return array.map((v, index) => { + options.seenObjects.push({ propertyName: `index ${index}`, obj: null }); + try { + return serializeValue(v, options); + } finally { + options.seenObjects.pop(); + } + }); + } + function getISOString(date) { + const isoStr = date.toISOString(); + return date.getUTCMilliseconds() !== 0 ? isoStr : isoStr.slice(0, -5) + "Z"; + } + function serializeValue(value, options) { + if (value instanceof Map || isMap(value)) { + const obj = /* @__PURE__ */ Object.create(null); + for (const [k, v] of value) { + if (typeof k !== "string") { + throw new BSONError("Can only serialize maps with string keys"); + } + obj[k] = v; + } + return serializeValue(obj, options); + } + if ((typeof value === "object" || typeof value === "function") && value !== null) { + const index = options.seenObjects.findIndex((entry) => entry.obj === value); + if (index !== -1) { + const props = options.seenObjects.map((entry) => entry.propertyName); + const leadingPart = props.slice(0, index).map((prop) => `${prop} -> `).join(""); + const alreadySeen = props[index]; + const circularPart = " -> " + props.slice(index + 1, props.length - 1).map((prop) => `${prop} -> `).join(""); + const current = props[props.length - 1]; + const leadingSpace = " ".repeat(leadingPart.length + alreadySeen.length / 2); + const dashes = "-".repeat(circularPart.length + (alreadySeen.length + current.length) / 2 - 1); + throw new BSONError(`Converting circular structure to EJSON: + ${leadingPart}${alreadySeen}${circularPart}${current} + ${leadingSpace}\\${dashes}/`); + } + options.seenObjects[options.seenObjects.length - 1].obj = value; + } + if (Array.isArray(value)) + return serializeArray(value, options); + if (value === void 0) + return null; + if (value instanceof Date || isDate(value)) { + const dateNum = value.getTime(), inRange = dateNum > -1 && dateNum < 2534023188e5; + if (options.legacy) { + return options.relaxed && inRange ? { $date: value.getTime() } : { $date: getISOString(value) }; + } + return options.relaxed && inRange ? { $date: getISOString(value) } : { $date: { $numberLong: value.getTime().toString() } }; + } + if (typeof value === "number" && (!options.relaxed || !isFinite(value))) { + if (Number.isInteger(value) && !Object.is(value, -0)) { + if (value >= BSON_INT32_MIN && value <= BSON_INT32_MAX) { + return { $numberInt: value.toString() }; + } + if (value >= BSON_INT64_MIN && value <= BSON_INT64_MAX) { + return { $numberLong: value.toString() }; + } + } + return { $numberDouble: Object.is(value, -0) ? "-0.0" : value.toString() }; + } + if (typeof value === "bigint") { + if (!options.relaxed) { + return { $numberLong: BigInt.asIntN(64, value).toString() }; + } + return Number(BigInt.asIntN(64, value)); + } + if (value instanceof RegExp || isRegExp(value)) { + let flags = value.flags; + if (flags === void 0) { + const match = value.toString().match(/[gimuy]*$/); + if (match) { + flags = match[0]; + } + } + const rx = new BSONRegExp(value.source, flags); + return rx.toExtendedJSON(options); + } + if (value != null && typeof value === "object") + return serializeDocument(value, options); + return value; + } + var BSON_TYPE_MAPPINGS = { + Binary: (o) => new Binary(o.value(), o.sub_type), + Code: (o) => new Code(o.code, o.scope), + DBRef: (o) => new DBRef(o.collection || o.namespace, o.oid, o.db, o.fields), + Decimal128: (o) => new Decimal128(o.bytes), + Double: (o) => new Double(o.value), + Int32: (o) => new Int32(o.value), + Long: (o) => Long.fromBits(o.low != null ? o.low : o.low_, o.low != null ? o.high : o.high_, o.low != null ? o.unsigned : o.unsigned_), + MaxKey: () => new MaxKey(), + MinKey: () => new MinKey(), + ObjectId: (o) => new ObjectId(o), + BSONRegExp: (o) => new BSONRegExp(o.pattern, o.options), + BSONSymbol: (o) => new BSONSymbol(o.value), + Timestamp: (o) => Timestamp.fromBits(o.low, o.high) + }; + function serializeDocument(doc, options) { + if (doc == null || typeof doc !== "object") + throw new BSONError("not an object instance"); + const bsontype = doc._bsontype; + if (typeof bsontype === "undefined") { + const _doc = {}; + for (const name of Object.keys(doc)) { + options.seenObjects.push({ propertyName: name, obj: null }); + try { + const value = serializeValue(doc[name], options); + if (name === "__proto__") { + Object.defineProperty(_doc, name, { + value, + writable: true, + enumerable: true, + configurable: true + }); + } else { + _doc[name] = value; + } + } finally { + options.seenObjects.pop(); + } + } + return _doc; + } else if (doc != null && typeof doc === "object" && typeof doc._bsontype === "string" && doc[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) { + throw new BSONVersionError(); + } else if (isBSONType(doc)) { + let outDoc = doc; + if (typeof outDoc.toExtendedJSON !== "function") { + const mapper = BSON_TYPE_MAPPINGS[doc._bsontype]; + if (!mapper) { + throw new BSONError("Unrecognized or invalid _bsontype: " + doc._bsontype); + } + outDoc = mapper(outDoc); + } + if (bsontype === "Code" && outDoc.scope) { + outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options)); + } else if (bsontype === "DBRef" && outDoc.oid) { + outDoc = new DBRef(serializeValue(outDoc.collection, options), serializeValue(outDoc.oid, options), serializeValue(outDoc.db, options), serializeValue(outDoc.fields, options)); + } + return outDoc.toExtendedJSON(options); + } else { + throw new BSONError("_bsontype must be a string, but was: " + typeof bsontype); + } + } + function parse(text, options) { + const ejsonOptions = { + useBigInt64: options?.useBigInt64 ?? false, + relaxed: options?.relaxed ?? true, + legacy: options?.legacy ?? false + }; + return JSON.parse(text, (key, value) => { + if (key.indexOf("\0") !== -1) { + throw new BSONError(`BSON Document field names cannot contain null bytes, found: ${JSON.stringify(key)}`); + } + return deserializeValue(value, ejsonOptions); + }); + } + function stringify(value, replacer, space, options) { + if (space != null && typeof space === "object") { + options = space; + space = 0; + } + if (replacer != null && typeof replacer === "object" && !Array.isArray(replacer)) { + options = replacer; + replacer = void 0; + space = 0; + } + const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, { + seenObjects: [{ propertyName: "(root)", obj: null }] + }); + const doc = serializeValue(value, serializeOptions); + return JSON.stringify(doc, replacer, space); + } + function EJSONserialize(value, options) { + options = options || {}; + return JSON.parse(stringify(value, options)); + } + function EJSONdeserialize(ejson, options) { + options = options || {}; + return parse(JSON.stringify(ejson), options); + } + var EJSON = /* @__PURE__ */ Object.create(null); + EJSON.parse = parse; + EJSON.stringify = stringify; + EJSON.serialize = EJSONserialize; + EJSON.deserialize = EJSONdeserialize; + Object.freeze(EJSON); + var BSONElementType = { + double: 1, + string: 2, + object: 3, + array: 4, + binData: 5, + undefined: 6, + objectId: 7, + bool: 8, + date: 9, + null: 10, + regex: 11, + dbPointer: 12, + javascript: 13, + symbol: 14, + javascriptWithScope: 15, + int: 16, + timestamp: 17, + long: 18, + decimal: 19, + minKey: 255, + maxKey: 127 + }; + function getSize(source, offset) { + try { + return NumberUtils.getNonnegativeInt32LE(source, offset); + } catch (cause) { + throw new BSONOffsetError("BSON size cannot be negative", offset, { cause }); + } + } + function findNull(bytes, offset) { + let nullTerminatorOffset = offset; + for (; bytes[nullTerminatorOffset] !== 0; nullTerminatorOffset++) + ; + if (nullTerminatorOffset === bytes.length - 1) { + throw new BSONOffsetError("Null terminator not found", offset); + } + return nullTerminatorOffset; + } + function parseToElements(bytes, startOffset = 0) { + startOffset ??= 0; + if (bytes.length < 5) { + throw new BSONOffsetError(`Input must be at least 5 bytes, got ${bytes.length} bytes`, startOffset); + } + const documentSize = getSize(bytes, startOffset); + if (documentSize > bytes.length - startOffset) { + throw new BSONOffsetError(`Parsed documentSize (${documentSize} bytes) does not match input length (${bytes.length} bytes)`, startOffset); + } + if (bytes[startOffset + documentSize - 1] !== 0) { + throw new BSONOffsetError("BSON documents must end in 0x00", startOffset + documentSize); + } + const elements = []; + let offset = startOffset + 4; + while (offset <= documentSize + startOffset) { + const type = bytes[offset]; + offset += 1; + if (type === 0) { + if (offset - startOffset !== documentSize) { + throw new BSONOffsetError(`Invalid 0x00 type byte`, offset); + } + break; + } + const nameOffset = offset; + const nameLength = findNull(bytes, offset) - nameOffset; + offset += nameLength + 1; + let length; + if (type === BSONElementType.double || type === BSONElementType.long || type === BSONElementType.date || type === BSONElementType.timestamp) { + length = 8; + } else if (type === BSONElementType.int) { + length = 4; + } else if (type === BSONElementType.objectId) { + length = 12; + } else if (type === BSONElementType.decimal) { + length = 16; + } else if (type === BSONElementType.bool) { + length = 1; + } else if (type === BSONElementType.null || type === BSONElementType.undefined || type === BSONElementType.maxKey || type === BSONElementType.minKey) { + length = 0; + } else if (type === BSONElementType.regex) { + length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset; + } else if (type === BSONElementType.object || type === BSONElementType.array || type === BSONElementType.javascriptWithScope) { + length = getSize(bytes, offset); + } else if (type === BSONElementType.string || type === BSONElementType.binData || type === BSONElementType.dbPointer || type === BSONElementType.javascript || type === BSONElementType.symbol) { + length = getSize(bytes, offset) + 4; + if (type === BSONElementType.binData) { + length += 1; + } + if (type === BSONElementType.dbPointer) { + length += 12; + } + } else { + throw new BSONOffsetError(`Invalid 0x${type.toString(16).padStart(2, "0")} type byte`, offset); + } + if (length > documentSize) { + throw new BSONOffsetError("value reports length larger than document", offset); + } + elements.push([type, nameOffset, nameLength, offset, length]); + offset += length; + } + return elements; + } + var onDemand = /* @__PURE__ */ Object.create(null); + onDemand.parseToElements = parseToElements; + onDemand.ByteUtils = ByteUtils; + onDemand.NumberUtils = NumberUtils; + Object.freeze(onDemand); + var MAXSIZE = 1024 * 1024 * 17; + var buffer = ByteUtils.allocate(MAXSIZE); + function setInternalBufferSize(size) { + if (buffer.length < size) { + buffer = ByteUtils.allocate(size); + } + } + function serialize(object, options = {}) { + const checkKeys = typeof options.checkKeys === "boolean" ? options.checkKeys : false; + const serializeFunctions = typeof options.serializeFunctions === "boolean" ? options.serializeFunctions : false; + const ignoreUndefined = typeof options.ignoreUndefined === "boolean" ? options.ignoreUndefined : true; + const minInternalBufferSize = typeof options.minInternalBufferSize === "number" ? options.minInternalBufferSize : MAXSIZE; + if (buffer.length < minInternalBufferSize) { + buffer = ByteUtils.allocate(minInternalBufferSize); + } + const serializationIndex = serializeInto(buffer, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, null); + const finishedBuffer = ByteUtils.allocateUnsafe(serializationIndex); + finishedBuffer.set(buffer.subarray(0, serializationIndex), 0); + return finishedBuffer; + } + function serializeWithBufferAndIndex(object, finalBuffer, options = {}) { + const checkKeys = typeof options.checkKeys === "boolean" ? options.checkKeys : false; + const serializeFunctions = typeof options.serializeFunctions === "boolean" ? options.serializeFunctions : false; + const ignoreUndefined = typeof options.ignoreUndefined === "boolean" ? options.ignoreUndefined : true; + const startIndex = typeof options.index === "number" ? options.index : 0; + const serializationIndex = serializeInto(buffer, object, checkKeys, 0, 0, serializeFunctions, ignoreUndefined, null); + finalBuffer.set(buffer.subarray(0, serializationIndex), startIndex); + return startIndex + serializationIndex - 1; + } + function deserialize(buffer2, options = {}) { + return internalDeserialize(ByteUtils.toLocalBufferType(buffer2), options); + } + function calculateObjectSize(object, options = {}) { + options = options || {}; + const serializeFunctions = typeof options.serializeFunctions === "boolean" ? options.serializeFunctions : false; + const ignoreUndefined = typeof options.ignoreUndefined === "boolean" ? options.ignoreUndefined : true; + return internalCalculateObjectSize(object, serializeFunctions, ignoreUndefined); + } + function deserializeStream(data, startIndex, numberOfDocuments, documents, docStartIndex, options) { + const internalOptions = Object.assign({ allowObjectSmallerThanBufferSize: true, index: 0 }, options); + const bufferData = ByteUtils.toLocalBufferType(data); + let index = startIndex; + for (let i = 0; i < numberOfDocuments; i++) { + const size = NumberUtils.getInt32LE(bufferData, index); + internalOptions.index = index; + documents[docStartIndex + i] = internalDeserialize(bufferData, internalOptions); + index = index + size; + } + return index; + } + var bson = /* @__PURE__ */ Object.freeze({ + __proto__: null, + BSONError, + BSONOffsetError, + BSONRegExp, + BSONRuntimeError, + BSONSymbol, + BSONType, + BSONValue, + BSONVersionError, + Binary, + Code, + DBRef, + Decimal128, + Double, + EJSON, + Int32, + Long, + MaxKey, + MinKey, + ObjectId, + Timestamp, + UUID, + calculateObjectSize, + deserialize, + deserializeStream, + onDemand, + serialize, + serializeWithBufferAndIndex, + setInternalBufferSize + }); + exports2.BSON = bson; + exports2.BSONError = BSONError; + exports2.BSONOffsetError = BSONOffsetError; + exports2.BSONRegExp = BSONRegExp; + exports2.BSONRuntimeError = BSONRuntimeError; + exports2.BSONSymbol = BSONSymbol; + exports2.BSONType = BSONType; + exports2.BSONValue = BSONValue; + exports2.BSONVersionError = BSONVersionError; + exports2.Binary = Binary; + exports2.Code = Code; + exports2.DBRef = DBRef; + exports2.Decimal128 = Decimal128; + exports2.Double = Double; + exports2.EJSON = EJSON; + exports2.Int32 = Int32; + exports2.Long = Long; + exports2.MaxKey = MaxKey; + exports2.MinKey = MinKey; + exports2.ObjectId = ObjectId; + exports2.Timestamp = Timestamp; + exports2.UUID = UUID; + exports2.calculateObjectSize = calculateObjectSize; + exports2.deserialize = deserialize; + exports2.deserializeStream = deserializeStream; + exports2.onDemand = onDemand; + exports2.serialize = serialize; + exports2.serializeWithBufferAndIndex = serializeWithBufferAndIndex; + exports2.setInternalBufferSize = setInternalBufferSize; + } +}); + +// node_modules/mongodb/lib/bson.js +var require_bson2 = __commonJS({ + "node_modules/mongodb/lib/bson.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.toUTF8 = exports2.getBigInt64LE = exports2.getFloat64LE = exports2.getInt32LE = exports2.UUID = exports2.Timestamp = exports2.serialize = exports2.ObjectId = exports2.MinKey = exports2.MaxKey = exports2.Long = exports2.Int32 = exports2.EJSON = exports2.Double = exports2.deserialize = exports2.Decimal128 = exports2.DBRef = exports2.Code = exports2.calculateObjectSize = exports2.BSONType = exports2.BSONSymbol = exports2.BSONRegExp = exports2.BSONError = exports2.BSON = exports2.Binary = void 0; + exports2.parseToElementsToArray = parseToElementsToArray; + exports2.pluckBSONSerializeOptions = pluckBSONSerializeOptions; + exports2.resolveBSONOptions = resolveBSONOptions; + exports2.parseUtf8ValidationOption = parseUtf8ValidationOption; + var bson_1 = require_bson(); + var bson_2 = require_bson(); + Object.defineProperty(exports2, "Binary", { enumerable: true, get: function() { + return bson_2.Binary; + } }); + Object.defineProperty(exports2, "BSON", { enumerable: true, get: function() { + return bson_2.BSON; + } }); + Object.defineProperty(exports2, "BSONError", { enumerable: true, get: function() { + return bson_2.BSONError; + } }); + Object.defineProperty(exports2, "BSONRegExp", { enumerable: true, get: function() { + return bson_2.BSONRegExp; + } }); + Object.defineProperty(exports2, "BSONSymbol", { enumerable: true, get: function() { + return bson_2.BSONSymbol; + } }); + Object.defineProperty(exports2, "BSONType", { enumerable: true, get: function() { + return bson_2.BSONType; + } }); + Object.defineProperty(exports2, "calculateObjectSize", { enumerable: true, get: function() { + return bson_2.calculateObjectSize; + } }); + Object.defineProperty(exports2, "Code", { enumerable: true, get: function() { + return bson_2.Code; + } }); + Object.defineProperty(exports2, "DBRef", { enumerable: true, get: function() { + return bson_2.DBRef; + } }); + Object.defineProperty(exports2, "Decimal128", { enumerable: true, get: function() { + return bson_2.Decimal128; + } }); + Object.defineProperty(exports2, "deserialize", { enumerable: true, get: function() { + return bson_2.deserialize; + } }); + Object.defineProperty(exports2, "Double", { enumerable: true, get: function() { + return bson_2.Double; + } }); + Object.defineProperty(exports2, "EJSON", { enumerable: true, get: function() { + return bson_2.EJSON; + } }); + Object.defineProperty(exports2, "Int32", { enumerable: true, get: function() { + return bson_2.Int32; + } }); + Object.defineProperty(exports2, "Long", { enumerable: true, get: function() { + return bson_2.Long; + } }); + Object.defineProperty(exports2, "MaxKey", { enumerable: true, get: function() { + return bson_2.MaxKey; + } }); + Object.defineProperty(exports2, "MinKey", { enumerable: true, get: function() { + return bson_2.MinKey; + } }); + Object.defineProperty(exports2, "ObjectId", { enumerable: true, get: function() { + return bson_2.ObjectId; + } }); + Object.defineProperty(exports2, "serialize", { enumerable: true, get: function() { + return bson_2.serialize; + } }); + Object.defineProperty(exports2, "Timestamp", { enumerable: true, get: function() { + return bson_2.Timestamp; + } }); + Object.defineProperty(exports2, "UUID", { enumerable: true, get: function() { + return bson_2.UUID; + } }); + function parseToElementsToArray(bytes, offset) { + const res = bson_1.BSON.onDemand.parseToElements(bytes, offset); + return Array.isArray(res) ? res : [...res]; + } + exports2.getInt32LE = bson_1.BSON.onDemand.NumberUtils.getInt32LE; + exports2.getFloat64LE = bson_1.BSON.onDemand.NumberUtils.getFloat64LE; + exports2.getBigInt64LE = bson_1.BSON.onDemand.NumberUtils.getBigInt64LE; + exports2.toUTF8 = bson_1.BSON.onDemand.ByteUtils.toUTF8; + function pluckBSONSerializeOptions(options) { + const { fieldsAsRaw, useBigInt64, promoteValues, promoteBuffers, promoteLongs, serializeFunctions, ignoreUndefined, bsonRegExp, raw, enableUtf8Validation } = options; + return { + fieldsAsRaw, + useBigInt64, + promoteValues, + promoteBuffers, + promoteLongs, + serializeFunctions, + ignoreUndefined, + bsonRegExp, + raw, + enableUtf8Validation + }; + } + function resolveBSONOptions(options, parent) { + const parentOptions = parent?.bsonOptions; + return { + raw: options?.raw ?? parentOptions?.raw ?? false, + useBigInt64: options?.useBigInt64 ?? parentOptions?.useBigInt64 ?? false, + promoteLongs: options?.promoteLongs ?? parentOptions?.promoteLongs ?? true, + promoteValues: options?.promoteValues ?? parentOptions?.promoteValues ?? true, + promoteBuffers: options?.promoteBuffers ?? parentOptions?.promoteBuffers ?? false, + ignoreUndefined: options?.ignoreUndefined ?? parentOptions?.ignoreUndefined ?? false, + bsonRegExp: options?.bsonRegExp ?? parentOptions?.bsonRegExp ?? false, + serializeFunctions: options?.serializeFunctions ?? parentOptions?.serializeFunctions ?? false, + fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {}, + enableUtf8Validation: options?.enableUtf8Validation ?? parentOptions?.enableUtf8Validation ?? true + }; + } + function parseUtf8ValidationOption(options) { + const enableUtf8Validation = options?.enableUtf8Validation; + if (enableUtf8Validation === false) { + return { utf8: false }; + } + return { utf8: { writeErrors: false } }; + } + } +}); + +// node_modules/mongodb/lib/error.js +var require_error = __commonJS({ + "node_modules/mongodb/lib/error.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoWriteConcernError = exports2.MongoServerSelectionError = exports2.MongoSystemError = exports2.MongoMissingDependencyError = exports2.MongoMissingCredentialsError = exports2.MongoCompatibilityError = exports2.MongoInvalidArgumentError = exports2.MongoParseError = exports2.MongoNetworkTimeoutError = exports2.MongoNetworkError = exports2.MongoClientClosedError = exports2.MongoTopologyClosedError = exports2.MongoCursorExhaustedError = exports2.MongoServerClosedError = exports2.MongoCursorInUseError = exports2.MongoOperationTimeoutError = exports2.MongoUnexpectedServerResponseError = exports2.MongoGridFSChunkError = exports2.MongoGridFSStreamError = exports2.MongoTailableCursorError = exports2.MongoChangeStreamError = exports2.MongoClientBulkWriteExecutionError = exports2.MongoClientBulkWriteCursorError = exports2.MongoClientBulkWriteError = exports2.MongoGCPError = exports2.MongoAzureError = exports2.MongoOIDCError = exports2.MongoAWSError = exports2.MongoKerberosError = exports2.MongoExpiredSessionError = exports2.MongoTransactionError = exports2.MongoNotConnectedError = exports2.MongoDecompressionError = exports2.MongoBatchReExecutionError = exports2.MongoStalePrimaryError = exports2.MongoRuntimeError = exports2.MongoAPIError = exports2.MongoDriverError = exports2.MongoServerError = exports2.MongoError = exports2.MongoErrorLabel = exports2.GET_MORE_RESUMABLE_CODES = exports2.MONGODB_ERROR_CODES = exports2.NODE_IS_RECOVERING_ERROR_MESSAGE = exports2.LEGACY_NOT_PRIMARY_OR_SECONDARY_ERROR_MESSAGE = exports2.LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE = void 0; + exports2.needsRetryableWriteLabel = needsRetryableWriteLabel; + exports2.isRetryableWriteError = isRetryableWriteError; + exports2.isRetryableReadError = isRetryableReadError; + exports2.isNodeShuttingDownError = isNodeShuttingDownError; + exports2.isSDAMUnrecoverableError = isSDAMUnrecoverableError; + exports2.isNetworkTimeoutError = isNetworkTimeoutError; + exports2.isResumableError = isResumableError; + exports2.LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE = new RegExp("not master", "i"); + exports2.LEGACY_NOT_PRIMARY_OR_SECONDARY_ERROR_MESSAGE = new RegExp("not master or secondary", "i"); + exports2.NODE_IS_RECOVERING_ERROR_MESSAGE = new RegExp("node is recovering", "i"); + exports2.MONGODB_ERROR_CODES = Object.freeze({ + HostUnreachable: 6, + HostNotFound: 7, + AuthenticationFailed: 18, + NetworkTimeout: 89, + ShutdownInProgress: 91, + PrimarySteppedDown: 189, + ExceededTimeLimit: 262, + SocketException: 9001, + NotWritablePrimary: 10107, + InterruptedAtShutdown: 11600, + InterruptedDueToReplStateChange: 11602, + NotPrimaryNoSecondaryOk: 13435, + NotPrimaryOrSecondary: 13436, + StaleShardVersion: 63, + StaleEpoch: 150, + StaleConfig: 13388, + RetryChangeStream: 234, + FailedToSatisfyReadPreference: 133, + CursorNotFound: 43, + LegacyNotPrimary: 10058, + // WriteConcernTimeout is WriteConcernFailed on pre-8.1 servers + WriteConcernTimeout: 64, + NamespaceNotFound: 26, + IllegalOperation: 20, + MaxTimeMSExpired: 50, + UnknownReplWriteConcern: 79, + UnsatisfiableWriteConcern: 100, + Reauthenticate: 391, + ReadConcernMajorityNotAvailableYet: 134 + }); + exports2.GET_MORE_RESUMABLE_CODES = /* @__PURE__ */ new Set([ + exports2.MONGODB_ERROR_CODES.HostUnreachable, + exports2.MONGODB_ERROR_CODES.HostNotFound, + exports2.MONGODB_ERROR_CODES.NetworkTimeout, + exports2.MONGODB_ERROR_CODES.ShutdownInProgress, + exports2.MONGODB_ERROR_CODES.PrimarySteppedDown, + exports2.MONGODB_ERROR_CODES.ExceededTimeLimit, + exports2.MONGODB_ERROR_CODES.SocketException, + exports2.MONGODB_ERROR_CODES.NotWritablePrimary, + exports2.MONGODB_ERROR_CODES.InterruptedAtShutdown, + exports2.MONGODB_ERROR_CODES.InterruptedDueToReplStateChange, + exports2.MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk, + exports2.MONGODB_ERROR_CODES.NotPrimaryOrSecondary, + exports2.MONGODB_ERROR_CODES.StaleShardVersion, + exports2.MONGODB_ERROR_CODES.StaleEpoch, + exports2.MONGODB_ERROR_CODES.StaleConfig, + exports2.MONGODB_ERROR_CODES.RetryChangeStream, + exports2.MONGODB_ERROR_CODES.FailedToSatisfyReadPreference, + exports2.MONGODB_ERROR_CODES.CursorNotFound + ]); + exports2.MongoErrorLabel = Object.freeze({ + RetryableWriteError: "RetryableWriteError", + TransientTransactionError: "TransientTransactionError", + UnknownTransactionCommitResult: "UnknownTransactionCommitResult", + ResumableChangeStreamError: "ResumableChangeStreamError", + HandshakeError: "HandshakeError", + ResetPool: "ResetPool", + PoolRequstedRetry: "PoolRequstedRetry", + InterruptInUseConnections: "InterruptInUseConnections", + NoWritesPerformed: "NoWritesPerformed" + }); + function isAggregateError(e) { + return e != null && typeof e === "object" && "errors" in e && Array.isArray(e.errors); + } + var MongoError = class extends Error { + get errorLabels() { + return Array.from(this.errorLabelSet); + } + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + this.errorLabelSet = /* @__PURE__ */ new Set(); + } + /** @internal */ + static buildErrorMessage(e) { + if (typeof e === "string") { + return e; + } + if (isAggregateError(e) && e.message.length === 0) { + return e.errors.length === 0 ? "AggregateError has an empty errors array. Please check the `cause` property for more information." : e.errors.map(({ message }) => message).join(", "); + } + return e != null && typeof e === "object" && "message" in e && typeof e.message === "string" ? e.message : "empty error message"; + } + get name() { + return "MongoError"; + } + /** Legacy name for server error responses */ + get errmsg() { + return this.message; + } + /** + * Checks the error to see if it has an error label + * + * @param label - The error label to check for + * @returns returns true if the error has the provided error label + */ + hasErrorLabel(label) { + return this.errorLabelSet.has(label); + } + addErrorLabel(label) { + this.errorLabelSet.add(label); + } + }; + exports2.MongoError = MongoError; + var MongoServerError = class extends MongoError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message.message || message.errmsg || message.$err || "n/a"); + if (message.errorLabels) { + for (const label of message.errorLabels) + this.addErrorLabel(label); + } + this.errorResponse = message; + for (const name in message) { + if (name !== "errorLabels" && name !== "errmsg" && name !== "message" && name !== "errorResponse") { + this[name] = message[name]; + } + } + } + get name() { + return "MongoServerError"; + } + }; + exports2.MongoServerError = MongoServerError; + var MongoDriverError = class extends MongoError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoDriverError"; + } + }; + exports2.MongoDriverError = MongoDriverError; + var MongoAPIError = class extends MongoDriverError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoAPIError"; + } + }; + exports2.MongoAPIError = MongoAPIError; + var MongoRuntimeError = class extends MongoDriverError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoRuntimeError"; + } + }; + exports2.MongoRuntimeError = MongoRuntimeError; + var MongoStalePrimaryError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoStalePrimaryError"; + } + }; + exports2.MongoStalePrimaryError = MongoStalePrimaryError; + var MongoBatchReExecutionError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "This batch has already been executed, create new batch to execute") { + super(message); + } + get name() { + return "MongoBatchReExecutionError"; + } + }; + exports2.MongoBatchReExecutionError = MongoBatchReExecutionError; + var MongoDecompressionError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoDecompressionError"; + } + }; + exports2.MongoDecompressionError = MongoDecompressionError; + var MongoNotConnectedError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoNotConnectedError"; + } + }; + exports2.MongoNotConnectedError = MongoNotConnectedError; + var MongoTransactionError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoTransactionError"; + } + }; + exports2.MongoTransactionError = MongoTransactionError; + var MongoExpiredSessionError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "Cannot use a session that has ended") { + super(message); + } + get name() { + return "MongoExpiredSessionError"; + } + }; + exports2.MongoExpiredSessionError = MongoExpiredSessionError; + var MongoKerberosError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoKerberosError"; + } + }; + exports2.MongoKerberosError = MongoKerberosError; + var MongoAWSError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoAWSError"; + } + }; + exports2.MongoAWSError = MongoAWSError; + var MongoOIDCError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoOIDCError"; + } + }; + exports2.MongoOIDCError = MongoOIDCError; + var MongoAzureError = class extends MongoOIDCError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoAzureError"; + } + }; + exports2.MongoAzureError = MongoAzureError; + var MongoGCPError = class extends MongoOIDCError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoGCPError"; + } + }; + exports2.MongoGCPError = MongoGCPError; + var MongoClientBulkWriteError = class extends MongoServerError { + /** + * Initialize the client bulk write error. + * @param message - The error message. + */ + constructor(message) { + super(message); + this.writeConcernErrors = []; + this.writeErrors = /* @__PURE__ */ new Map(); + } + get name() { + return "MongoClientBulkWriteError"; + } + }; + exports2.MongoClientBulkWriteError = MongoClientBulkWriteError; + var MongoClientBulkWriteCursorError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoClientBulkWriteCursorError"; + } + }; + exports2.MongoClientBulkWriteCursorError = MongoClientBulkWriteCursorError; + var MongoClientBulkWriteExecutionError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoClientBulkWriteExecutionError"; + } + }; + exports2.MongoClientBulkWriteExecutionError = MongoClientBulkWriteExecutionError; + var MongoChangeStreamError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoChangeStreamError"; + } + }; + exports2.MongoChangeStreamError = MongoChangeStreamError; + var MongoTailableCursorError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "Tailable cursor does not support this operation") { + super(message); + } + get name() { + return "MongoTailableCursorError"; + } + }; + exports2.MongoTailableCursorError = MongoTailableCursorError; + var MongoGridFSStreamError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoGridFSStreamError"; + } + }; + exports2.MongoGridFSStreamError = MongoGridFSStreamError; + var MongoGridFSChunkError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoGridFSChunkError"; + } + }; + exports2.MongoGridFSChunkError = MongoGridFSChunkError; + var MongoUnexpectedServerResponseError = class extends MongoRuntimeError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoUnexpectedServerResponseError"; + } + }; + exports2.MongoUnexpectedServerResponseError = MongoUnexpectedServerResponseError; + var MongoOperationTimeoutError = class extends MongoDriverError { + get name() { + return "MongoOperationTimeoutError"; + } + }; + exports2.MongoOperationTimeoutError = MongoOperationTimeoutError; + var MongoCursorInUseError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "Cursor is already initialized") { + super(message); + } + get name() { + return "MongoCursorInUseError"; + } + }; + exports2.MongoCursorInUseError = MongoCursorInUseError; + var MongoServerClosedError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "Server is closed") { + super(message); + } + get name() { + return "MongoServerClosedError"; + } + }; + exports2.MongoServerClosedError = MongoServerClosedError; + var MongoCursorExhaustedError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message || "Cursor is exhausted"); + } + get name() { + return "MongoCursorExhaustedError"; + } + }; + exports2.MongoCursorExhaustedError = MongoCursorExhaustedError; + var MongoTopologyClosedError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message = "Topology is closed") { + super(message); + } + get name() { + return "MongoTopologyClosedError"; + } + }; + exports2.MongoTopologyClosedError = MongoTopologyClosedError; + var MongoClientClosedError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor() { + super("Operation interrupted because client was closed"); + } + get name() { + return "MongoClientClosedError"; + } + }; + exports2.MongoClientClosedError = MongoClientClosedError; + var MongoNetworkError = class extends MongoError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, { cause: options?.cause }); + this.beforeHandshake = !!options?.beforeHandshake; + } + get name() { + return "MongoNetworkError"; + } + }; + exports2.MongoNetworkError = MongoNetworkError; + var MongoNetworkTimeoutError = class extends MongoNetworkError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoNetworkTimeoutError"; + } + }; + exports2.MongoNetworkTimeoutError = MongoNetworkTimeoutError; + var MongoParseError = class extends MongoDriverError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoParseError"; + } + }; + exports2.MongoParseError = MongoParseError; + var MongoInvalidArgumentError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + } + get name() { + return "MongoInvalidArgumentError"; + } + }; + exports2.MongoInvalidArgumentError = MongoInvalidArgumentError; + var MongoCompatibilityError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoCompatibilityError"; + } + }; + exports2.MongoCompatibilityError = MongoCompatibilityError; + var MongoMissingCredentialsError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoMissingCredentialsError"; + } + }; + exports2.MongoMissingCredentialsError = MongoMissingCredentialsError; + var MongoMissingDependencyError = class extends MongoAPIError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options) { + super(message, options); + this.dependencyName = options.dependencyName; + } + get name() { + return "MongoMissingDependencyError"; + } + }; + exports2.MongoMissingDependencyError = MongoMissingDependencyError; + var MongoSystemError = class extends MongoError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, reason) { + if (reason && reason.error) { + super(MongoError.buildErrorMessage(reason.error.message || reason.error), { + cause: reason.error + }); + } else { + super(message); + } + if (reason) { + this.reason = reason; + } + this.code = reason.error?.code; + } + get name() { + return "MongoSystemError"; + } + }; + exports2.MongoSystemError = MongoSystemError; + var MongoServerSelectionError = class extends MongoSystemError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, reason) { + super(message, reason); + } + get name() { + return "MongoServerSelectionError"; + } + }; + exports2.MongoServerSelectionError = MongoServerSelectionError; + var MongoWriteConcernError = class extends MongoServerError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(result) { + super({ ...result.writeConcernError, ...result }); + this.errInfo = result.writeConcernError.errInfo; + this.result = result; + } + get name() { + return "MongoWriteConcernError"; + } + }; + exports2.MongoWriteConcernError = MongoWriteConcernError; + var RETRYABLE_READ_ERROR_CODES = /* @__PURE__ */ new Set([ + exports2.MONGODB_ERROR_CODES.HostUnreachable, + exports2.MONGODB_ERROR_CODES.HostNotFound, + exports2.MONGODB_ERROR_CODES.NetworkTimeout, + exports2.MONGODB_ERROR_CODES.ShutdownInProgress, + exports2.MONGODB_ERROR_CODES.PrimarySteppedDown, + exports2.MONGODB_ERROR_CODES.SocketException, + exports2.MONGODB_ERROR_CODES.NotWritablePrimary, + exports2.MONGODB_ERROR_CODES.InterruptedAtShutdown, + exports2.MONGODB_ERROR_CODES.InterruptedDueToReplStateChange, + exports2.MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk, + exports2.MONGODB_ERROR_CODES.NotPrimaryOrSecondary, + exports2.MONGODB_ERROR_CODES.ExceededTimeLimit, + exports2.MONGODB_ERROR_CODES.ReadConcernMajorityNotAvailableYet + ]); + var RETRYABLE_WRITE_ERROR_CODES = RETRYABLE_READ_ERROR_CODES; + function needsRetryableWriteLabel(error, maxWireVersion, serverType) { + if (error instanceof MongoNetworkError) { + return true; + } + if (error instanceof MongoError) { + if ((maxWireVersion >= 9 || isRetryableWriteError(error)) && !error.hasErrorLabel(exports2.MongoErrorLabel.HandshakeError)) { + return false; + } + } + if (error instanceof MongoWriteConcernError) { + if (serverType === "Mongos" && maxWireVersion < 9) { + return RETRYABLE_WRITE_ERROR_CODES.has(error.result.code ?? 0); + } + const code = error.result.writeConcernError.code ?? Number(error.code); + return RETRYABLE_WRITE_ERROR_CODES.has(Number.isNaN(code) ? 0 : code); + } + if (error instanceof MongoError) { + return RETRYABLE_WRITE_ERROR_CODES.has(Number(error.code)); + } + const isNotWritablePrimaryError2 = exports2.LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE.test(error.message); + if (isNotWritablePrimaryError2) { + return true; + } + const isNodeIsRecoveringError = exports2.NODE_IS_RECOVERING_ERROR_MESSAGE.test(error.message); + if (isNodeIsRecoveringError) { + return true; + } + return false; + } + function isRetryableWriteError(error) { + return error.hasErrorLabel(exports2.MongoErrorLabel.RetryableWriteError) || error.hasErrorLabel(exports2.MongoErrorLabel.PoolRequstedRetry); + } + function isRetryableReadError(error) { + const hasRetryableErrorCode = typeof error.code === "number" ? RETRYABLE_READ_ERROR_CODES.has(error.code) : false; + if (hasRetryableErrorCode) { + return true; + } + if (error instanceof MongoNetworkError) { + return true; + } + const isNotWritablePrimaryError2 = exports2.LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE.test(error.message); + if (isNotWritablePrimaryError2) { + return true; + } + const isNodeIsRecoveringError = exports2.NODE_IS_RECOVERING_ERROR_MESSAGE.test(error.message); + if (isNodeIsRecoveringError) { + return true; + } + return false; + } + var SDAM_RECOVERING_CODES = /* @__PURE__ */ new Set([ + exports2.MONGODB_ERROR_CODES.ShutdownInProgress, + exports2.MONGODB_ERROR_CODES.PrimarySteppedDown, + exports2.MONGODB_ERROR_CODES.InterruptedAtShutdown, + exports2.MONGODB_ERROR_CODES.InterruptedDueToReplStateChange, + exports2.MONGODB_ERROR_CODES.NotPrimaryOrSecondary + ]); + var SDAM_NOT_PRIMARY_CODES = /* @__PURE__ */ new Set([ + exports2.MONGODB_ERROR_CODES.NotWritablePrimary, + exports2.MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk, + exports2.MONGODB_ERROR_CODES.LegacyNotPrimary + ]); + var SDAM_NODE_SHUTTING_DOWN_ERROR_CODES = /* @__PURE__ */ new Set([ + exports2.MONGODB_ERROR_CODES.InterruptedAtShutdown, + exports2.MONGODB_ERROR_CODES.ShutdownInProgress + ]); + function isRecoveringError(err) { + if (typeof err.code === "number") { + return SDAM_RECOVERING_CODES.has(err.code); + } + return exports2.LEGACY_NOT_PRIMARY_OR_SECONDARY_ERROR_MESSAGE.test(err.message) || exports2.NODE_IS_RECOVERING_ERROR_MESSAGE.test(err.message); + } + function isNotWritablePrimaryError(err) { + if (typeof err.code === "number") { + return SDAM_NOT_PRIMARY_CODES.has(err.code); + } + if (isRecoveringError(err)) { + return false; + } + return exports2.LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE.test(err.message); + } + function isNodeShuttingDownError(err) { + return !!(typeof err.code === "number" && SDAM_NODE_SHUTTING_DOWN_ERROR_CODES.has(err.code)); + } + function isSDAMUnrecoverableError(error) { + if (error instanceof MongoParseError || error == null) { + return true; + } + return isRecoveringError(error) || isNotWritablePrimaryError(error); + } + function isNetworkTimeoutError(err) { + return !!(err instanceof MongoNetworkError && err.message.match(/timed out/)); + } + function isResumableError(error, wireVersion) { + if (error == null || !(error instanceof MongoError)) { + return false; + } + if (error instanceof MongoNetworkError) { + return true; + } + if (error instanceof MongoServerSelectionError) { + return true; + } + if (wireVersion != null && wireVersion >= 9) { + if (error.code === exports2.MONGODB_ERROR_CODES.CursorNotFound) { + return true; + } + return error.hasErrorLabel(exports2.MongoErrorLabel.ResumableChangeStreamError); + } + if (typeof error.code === "number") { + return exports2.GET_MORE_RESUMABLE_CODES.has(error.code); + } + return false; + } + } +}); + +// node_modules/mongodb/lib/read_preference.js +var require_read_preference = __commonJS({ + "node_modules/mongodb/lib/read_preference.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ReadPreference = exports2.ReadPreferenceMode = void 0; + var error_1 = require_error(); + exports2.ReadPreferenceMode = Object.freeze({ + primary: "primary", + primaryPreferred: "primaryPreferred", + secondary: "secondary", + secondaryPreferred: "secondaryPreferred", + nearest: "nearest" + }); + var ReadPreference = class _ReadPreference { + /** + * @param mode - A string describing the read preference mode (primary|primaryPreferred|secondary|secondaryPreferred|nearest) + * @param tags - A tag set used to target reads to members with the specified tag(s). tagSet is not available if using read preference mode primary. + * @param options - Additional read preference options + */ + constructor(mode, tags, options) { + if (!_ReadPreference.isValid(mode)) { + throw new error_1.MongoInvalidArgumentError(`Invalid read preference mode ${JSON.stringify(mode)}`); + } + if (options == null && typeof tags === "object" && !Array.isArray(tags)) { + options = tags; + tags = void 0; + } else if (tags && !Array.isArray(tags)) { + throw new error_1.MongoInvalidArgumentError("ReadPreference tags must be an array"); + } + this.mode = mode; + this.tags = tags; + this.hedge = options?.hedge; + this.maxStalenessSeconds = void 0; + this.minWireVersion = void 0; + options = options ?? {}; + if (options.maxStalenessSeconds != null) { + if (options.maxStalenessSeconds <= 0) { + throw new error_1.MongoInvalidArgumentError("maxStalenessSeconds must be a positive integer"); + } + this.maxStalenessSeconds = options.maxStalenessSeconds; + this.minWireVersion = 5; + } + if (this.mode === _ReadPreference.PRIMARY) { + if (this.tags && Array.isArray(this.tags) && this.tags.length > 0) { + throw new error_1.MongoInvalidArgumentError("Primary read preference cannot be combined with tags"); + } + if (this.maxStalenessSeconds) { + throw new error_1.MongoInvalidArgumentError("Primary read preference cannot be combined with maxStalenessSeconds"); + } + if (this.hedge) { + throw new error_1.MongoInvalidArgumentError("Primary read preference cannot be combined with hedge"); + } + } + } + // Support the deprecated `preference` property introduced in the porcelain layer + get preference() { + return this.mode; + } + static fromString(mode) { + return new _ReadPreference(mode); + } + /** + * Construct a ReadPreference given an options object. + * + * @param options - The options object from which to extract the read preference. + */ + static fromOptions(options) { + if (!options) + return; + const readPreference = options.readPreference ?? options.session?.transaction.options.readPreference; + const readPreferenceTags = options.readPreferenceTags; + if (readPreference == null) { + return; + } + if (typeof readPreference === "string") { + return new _ReadPreference(readPreference, readPreferenceTags, { + maxStalenessSeconds: options.maxStalenessSeconds, + hedge: options.hedge + }); + } else if (!(readPreference instanceof _ReadPreference) && typeof readPreference === "object") { + const mode = readPreference.mode || readPreference.preference; + if (mode && typeof mode === "string") { + return new _ReadPreference(mode, readPreference.tags ?? readPreferenceTags, { + maxStalenessSeconds: readPreference.maxStalenessSeconds, + hedge: options.hedge + }); + } + } + if (readPreferenceTags) { + readPreference.tags = readPreferenceTags; + } + return readPreference; + } + /** + * Replaces options.readPreference with a ReadPreference instance + */ + static translate(options) { + if (options.readPreference == null) + return options; + const r = options.readPreference; + if (typeof r === "string") { + options.readPreference = new _ReadPreference(r); + } else if (r && !(r instanceof _ReadPreference) && typeof r === "object") { + const mode = r.mode || r.preference; + if (mode && typeof mode === "string") { + options.readPreference = new _ReadPreference(mode, r.tags, { + maxStalenessSeconds: r.maxStalenessSeconds + }); + } + } else if (!(r instanceof _ReadPreference)) { + throw new error_1.MongoInvalidArgumentError(`Invalid read preference: ${r}`); + } + return options; + } + /** + * Validate if a mode is legal + * + * @param mode - The string representing the read preference mode. + */ + static isValid(mode) { + const VALID_MODES = /* @__PURE__ */ new Set([ + _ReadPreference.PRIMARY, + _ReadPreference.PRIMARY_PREFERRED, + _ReadPreference.SECONDARY, + _ReadPreference.SECONDARY_PREFERRED, + _ReadPreference.NEAREST, + null + ]); + return VALID_MODES.has(mode); + } + /** + * Validate if a mode is legal + * + * @param mode - The string representing the read preference mode. + */ + isValid(mode) { + return _ReadPreference.isValid(typeof mode === "string" ? mode : this.mode); + } + /** + * Indicates that this readPreference needs the "SecondaryOk" bit when sent over the wire + * @see https://www.mongodb.com/docs/manual/reference/mongodb-wire-protocol/#op-query + */ + secondaryOk() { + const NEEDS_SECONDARYOK = /* @__PURE__ */ new Set([ + _ReadPreference.PRIMARY_PREFERRED, + _ReadPreference.SECONDARY, + _ReadPreference.SECONDARY_PREFERRED, + _ReadPreference.NEAREST + ]); + return NEEDS_SECONDARYOK.has(this.mode); + } + /** + * Check if the two ReadPreferences are equivalent + * + * @param readPreference - The read preference with which to check equality + */ + equals(readPreference) { + return readPreference.mode === this.mode; + } + /** Return JSON representation */ + toJSON() { + const readPreference = { mode: this.mode }; + if (Array.isArray(this.tags)) + readPreference.tags = this.tags; + if (this.maxStalenessSeconds) + readPreference.maxStalenessSeconds = this.maxStalenessSeconds; + if (this.hedge) + readPreference.hedge = this.hedge; + return readPreference; + } + }; + exports2.ReadPreference = ReadPreference; + ReadPreference.PRIMARY = exports2.ReadPreferenceMode.primary; + ReadPreference.PRIMARY_PREFERRED = exports2.ReadPreferenceMode.primaryPreferred; + ReadPreference.SECONDARY = exports2.ReadPreferenceMode.secondary; + ReadPreference.SECONDARY_PREFERRED = exports2.ReadPreferenceMode.secondaryPreferred; + ReadPreference.NEAREST = exports2.ReadPreferenceMode.nearest; + ReadPreference.primary = new ReadPreference(exports2.ReadPreferenceMode.primary); + ReadPreference.primaryPreferred = new ReadPreference(exports2.ReadPreferenceMode.primaryPreferred); + ReadPreference.secondary = new ReadPreference(exports2.ReadPreferenceMode.secondary); + ReadPreference.secondaryPreferred = new ReadPreference(exports2.ReadPreferenceMode.secondaryPreferred); + ReadPreference.nearest = new ReadPreference(exports2.ReadPreferenceMode.nearest); + } +}); + +// node_modules/mongodb/lib/sdam/common.js +var require_common = __commonJS({ + "node_modules/mongodb/lib/sdam/common.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ServerType = exports2.TopologyType = exports2.STATE_CONNECTED = exports2.STATE_CONNECTING = exports2.STATE_CLOSED = exports2.STATE_CLOSING = void 0; + exports2._advanceClusterTime = _advanceClusterTime; + exports2.STATE_CLOSING = "closing"; + exports2.STATE_CLOSED = "closed"; + exports2.STATE_CONNECTING = "connecting"; + exports2.STATE_CONNECTED = "connected"; + exports2.TopologyType = Object.freeze({ + Single: "Single", + ReplicaSetNoPrimary: "ReplicaSetNoPrimary", + ReplicaSetWithPrimary: "ReplicaSetWithPrimary", + Sharded: "Sharded", + Unknown: "Unknown", + LoadBalanced: "LoadBalanced" + }); + exports2.ServerType = Object.freeze({ + Standalone: "Standalone", + Mongos: "Mongos", + PossiblePrimary: "PossiblePrimary", + RSPrimary: "RSPrimary", + RSSecondary: "RSSecondary", + RSArbiter: "RSArbiter", + RSOther: "RSOther", + RSGhost: "RSGhost", + Unknown: "Unknown", + LoadBalancer: "LoadBalancer" + }); + function _advanceClusterTime(entity, $clusterTime) { + if (entity.clusterTime == null) { + entity.clusterTime = $clusterTime; + } else { + if ($clusterTime.clusterTime.greaterThan(entity.clusterTime.clusterTime)) { + entity.clusterTime = $clusterTime; + } + } + } + } +}); + +// node_modules/mongodb/lib/sdam/server_selection.js +var require_server_selection = __commonJS({ + "node_modules/mongodb/lib/sdam/server_selection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MIN_SECONDARY_WRITE_WIRE_VERSION = void 0; + exports2.writableServerSelector = writableServerSelector; + exports2.sameServerSelector = sameServerSelector; + exports2.secondaryWritableServerSelector = secondaryWritableServerSelector; + exports2.readPreferenceServerSelector = readPreferenceServerSelector; + var error_1 = require_error(); + var read_preference_1 = require_read_preference(); + var common_1 = require_common(); + var IDLE_WRITE_PERIOD = 1e4; + var SMALLEST_MAX_STALENESS_SECONDS = 90; + exports2.MIN_SECONDARY_WRITE_WIRE_VERSION = 13; + function writableServerSelector() { + return function writableServer(topologyDescription, servers) { + return latencyWindowReducer(topologyDescription, servers.filter((s) => s.isWritable)); + }; + } + function sameServerSelector(description) { + return function sameServerSelector2(topologyDescription, servers) { + if (!description) + return []; + return servers.filter((sd) => { + return sd.address === description.address && sd.type !== common_1.ServerType.Unknown; + }); + }; + } + function secondaryWritableServerSelector(wireVersion, readPreference) { + if (!readPreference || !wireVersion || wireVersion && wireVersion < exports2.MIN_SECONDARY_WRITE_WIRE_VERSION) { + return readPreferenceServerSelector(read_preference_1.ReadPreference.primary); + } + return readPreferenceServerSelector(readPreference); + } + function maxStalenessReducer(readPreference, topologyDescription, servers) { + if (readPreference.maxStalenessSeconds == null || readPreference.maxStalenessSeconds < 0) { + return servers; + } + const maxStaleness = readPreference.maxStalenessSeconds; + const maxStalenessVariance = (topologyDescription.heartbeatFrequencyMS + IDLE_WRITE_PERIOD) / 1e3; + if (maxStaleness < maxStalenessVariance) { + throw new error_1.MongoInvalidArgumentError(`Option "maxStalenessSeconds" must be at least ${maxStalenessVariance} seconds`); + } + if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) { + throw new error_1.MongoInvalidArgumentError(`Option "maxStalenessSeconds" must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`); + } + if (topologyDescription.type === common_1.TopologyType.ReplicaSetWithPrimary) { + const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0]; + return servers.reduce((result, server) => { + const stalenessMS = server.lastUpdateTime - server.lastWriteDate - (primary.lastUpdateTime - primary.lastWriteDate) + topologyDescription.heartbeatFrequencyMS; + const staleness = stalenessMS / 1e3; + const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0; + if (staleness <= maxStalenessSeconds) { + result.push(server); + } + return result; + }, []); + } + if (topologyDescription.type === common_1.TopologyType.ReplicaSetNoPrimary) { + if (servers.length === 0) { + return servers; + } + const sMax = servers.reduce((max, s) => s.lastWriteDate > max.lastWriteDate ? s : max); + return servers.reduce((result, server) => { + const stalenessMS = sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS; + const staleness = stalenessMS / 1e3; + const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0; + if (staleness <= maxStalenessSeconds) { + result.push(server); + } + return result; + }, []); + } + return servers; + } + function tagSetMatch(tagSet, serverTags) { + const keys = Object.keys(tagSet); + const serverTagKeys = Object.keys(serverTags); + for (let i = 0; i < keys.length; ++i) { + const key = keys[i]; + if (serverTagKeys.indexOf(key) === -1 || serverTags[key] !== tagSet[key]) { + return false; + } + } + return true; + } + function tagSetReducer(readPreference, servers) { + if (readPreference.tags == null || Array.isArray(readPreference.tags) && readPreference.tags.length === 0) { + return servers; + } + for (let i = 0; i < readPreference.tags.length; ++i) { + const tagSet = readPreference.tags[i]; + const serversMatchingTagset = servers.reduce((matched, server) => { + if (tagSetMatch(tagSet, server.tags)) + matched.push(server); + return matched; + }, []); + if (serversMatchingTagset.length) { + return serversMatchingTagset; + } + } + return []; + } + function latencyWindowReducer(topologyDescription, servers) { + const low = servers.reduce((min, server) => Math.min(server.roundTripTime, min), Infinity); + const high = low + topologyDescription.localThresholdMS; + return servers.reduce((result, server) => { + if (server.roundTripTime <= high && server.roundTripTime >= low) + result.push(server); + return result; + }, []); + } + function primaryFilter(server) { + return server.type === common_1.ServerType.RSPrimary; + } + function secondaryFilter(server) { + return server.type === common_1.ServerType.RSSecondary; + } + function nearestFilter(server) { + return server.type === common_1.ServerType.RSSecondary || server.type === common_1.ServerType.RSPrimary; + } + function knownFilter(server) { + return server.type !== common_1.ServerType.Unknown; + } + function loadBalancerFilter(server) { + return server.type === common_1.ServerType.LoadBalancer; + } + function readPreferenceServerSelector(readPreference) { + if (!readPreference.isValid()) { + throw new error_1.MongoInvalidArgumentError("Invalid read preference specified"); + } + return function readPreferenceServers(topologyDescription, servers, deprioritized = []) { + if (topologyDescription.type === common_1.TopologyType.LoadBalanced) { + return servers.filter(loadBalancerFilter); + } + if (topologyDescription.type === common_1.TopologyType.Unknown) { + return []; + } + if (topologyDescription.type === common_1.TopologyType.Single) { + return latencyWindowReducer(topologyDescription, servers.filter(knownFilter)); + } + if (topologyDescription.type === common_1.TopologyType.Sharded) { + const filtered = servers.filter((server) => { + return !deprioritized.includes(server); + }); + const selectable = filtered.length > 0 ? filtered : deprioritized; + return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter)); + } + const mode = readPreference.mode; + if (mode === read_preference_1.ReadPreference.PRIMARY) { + return servers.filter(primaryFilter); + } + if (mode === read_preference_1.ReadPreference.PRIMARY_PREFERRED) { + const result = servers.filter(primaryFilter); + if (result.length) { + return result; + } + } + const filter = mode === read_preference_1.ReadPreference.NEAREST ? nearestFilter : secondaryFilter; + const selectedServers = latencyWindowReducer(topologyDescription, tagSetReducer(readPreference, maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter)))); + if (mode === read_preference_1.ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) { + return servers.filter(primaryFilter); + } + return selectedServers; + }; + } + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/constants.js +var require_constants = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.OP_MSG = exports2.OP_COMPRESSED = exports2.OP_DELETE = exports2.OP_QUERY = exports2.OP_INSERT = exports2.OP_UPDATE = exports2.OP_REPLY = exports2.MIN_SUPPORTED_RAW_DATA_SERVER_VERSION = exports2.MIN_SUPPORTED_RAW_DATA_WIRE_VERSION = exports2.MIN_SUPPORTED_QE_SERVER_VERSION = exports2.MIN_SUPPORTED_QE_WIRE_VERSION = exports2.MAX_SUPPORTED_WIRE_VERSION = exports2.MIN_SUPPORTED_WIRE_VERSION = exports2.MAX_SUPPORTED_SERVER_VERSION = exports2.MIN_SUPPORTED_SERVER_VERSION = void 0; + exports2.MIN_SUPPORTED_SERVER_VERSION = "4.2"; + exports2.MAX_SUPPORTED_SERVER_VERSION = "8.2"; + exports2.MIN_SUPPORTED_WIRE_VERSION = 8; + exports2.MAX_SUPPORTED_WIRE_VERSION = 27; + exports2.MIN_SUPPORTED_QE_WIRE_VERSION = 21; + exports2.MIN_SUPPORTED_QE_SERVER_VERSION = "7.0"; + exports2.MIN_SUPPORTED_RAW_DATA_WIRE_VERSION = 27; + exports2.MIN_SUPPORTED_RAW_DATA_SERVER_VERSION = "8.2"; + exports2.OP_REPLY = 1; + exports2.OP_UPDATE = 2001; + exports2.OP_INSERT = 2002; + exports2.OP_QUERY = 2004; + exports2.OP_DELETE = 2006; + exports2.OP_COMPRESSED = 2012; + exports2.OP_MSG = 2013; + } +}); + +// node_modules/mongodb/lib/constants.js +var require_constants2 = __commonJS({ + "node_modules/mongodb/lib/constants.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.END = exports2.CHANGE = exports2.INIT = exports2.MORE = exports2.RESPONSE = exports2.SERVER_HEARTBEAT_FAILED = exports2.SERVER_HEARTBEAT_SUCCEEDED = exports2.SERVER_HEARTBEAT_STARTED = exports2.COMMAND_FAILED = exports2.COMMAND_SUCCEEDED = exports2.COMMAND_STARTED = exports2.CLUSTER_TIME_RECEIVED = exports2.CONNECTION_CHECKED_IN = exports2.CONNECTION_CHECKED_OUT = exports2.CONNECTION_CHECK_OUT_FAILED = exports2.CONNECTION_CHECK_OUT_STARTED = exports2.CONNECTION_CLOSED = exports2.CONNECTION_READY = exports2.CONNECTION_CREATED = exports2.CONNECTION_POOL_READY = exports2.CONNECTION_POOL_CLEARED = exports2.CONNECTION_POOL_CLOSED = exports2.CONNECTION_POOL_CREATED = exports2.WAITING_FOR_SUITABLE_SERVER = exports2.SERVER_SELECTION_SUCCEEDED = exports2.SERVER_SELECTION_FAILED = exports2.SERVER_SELECTION_STARTED = exports2.TOPOLOGY_DESCRIPTION_CHANGED = exports2.TOPOLOGY_CLOSED = exports2.TOPOLOGY_OPENING = exports2.SERVER_DESCRIPTION_CHANGED = exports2.SERVER_CLOSED = exports2.SERVER_OPENING = exports2.DESCRIPTION_RECEIVED = exports2.UNPINNED = exports2.PINNED = exports2.MESSAGE = exports2.ENDED = exports2.CLOSED = exports2.CONNECT = exports2.OPEN = exports2.CLOSE = exports2.TIMEOUT = exports2.ERROR = exports2.SYSTEM_JS_COLLECTION = exports2.SYSTEM_COMMAND_COLLECTION = exports2.SYSTEM_USER_COLLECTION = exports2.SYSTEM_PROFILE_COLLECTION = exports2.SYSTEM_INDEX_COLLECTION = exports2.SYSTEM_NAMESPACE_COLLECTION = void 0; + exports2.kDecoratedKeys = exports2.kDecorateResult = exports2.LEGACY_HELLO_COMMAND_CAMEL_CASE = exports2.LEGACY_HELLO_COMMAND = exports2.MONGO_CLIENT_EVENTS = exports2.LOCAL_SERVER_EVENTS = exports2.SERVER_RELAY_EVENTS = exports2.APM_EVENTS = exports2.TOPOLOGY_EVENTS = exports2.CMAP_EVENTS = exports2.HEARTBEAT_EVENTS = exports2.RESUME_TOKEN_CHANGED = void 0; + exports2.SYSTEM_NAMESPACE_COLLECTION = "system.namespaces"; + exports2.SYSTEM_INDEX_COLLECTION = "system.indexes"; + exports2.SYSTEM_PROFILE_COLLECTION = "system.profile"; + exports2.SYSTEM_USER_COLLECTION = "system.users"; + exports2.SYSTEM_COMMAND_COLLECTION = "$cmd"; + exports2.SYSTEM_JS_COLLECTION = "system.js"; + exports2.ERROR = "error"; + exports2.TIMEOUT = "timeout"; + exports2.CLOSE = "close"; + exports2.OPEN = "open"; + exports2.CONNECT = "connect"; + exports2.CLOSED = "closed"; + exports2.ENDED = "ended"; + exports2.MESSAGE = "message"; + exports2.PINNED = "pinned"; + exports2.UNPINNED = "unpinned"; + exports2.DESCRIPTION_RECEIVED = "descriptionReceived"; + exports2.SERVER_OPENING = "serverOpening"; + exports2.SERVER_CLOSED = "serverClosed"; + exports2.SERVER_DESCRIPTION_CHANGED = "serverDescriptionChanged"; + exports2.TOPOLOGY_OPENING = "topologyOpening"; + exports2.TOPOLOGY_CLOSED = "topologyClosed"; + exports2.TOPOLOGY_DESCRIPTION_CHANGED = "topologyDescriptionChanged"; + exports2.SERVER_SELECTION_STARTED = "serverSelectionStarted"; + exports2.SERVER_SELECTION_FAILED = "serverSelectionFailed"; + exports2.SERVER_SELECTION_SUCCEEDED = "serverSelectionSucceeded"; + exports2.WAITING_FOR_SUITABLE_SERVER = "waitingForSuitableServer"; + exports2.CONNECTION_POOL_CREATED = "connectionPoolCreated"; + exports2.CONNECTION_POOL_CLOSED = "connectionPoolClosed"; + exports2.CONNECTION_POOL_CLEARED = "connectionPoolCleared"; + exports2.CONNECTION_POOL_READY = "connectionPoolReady"; + exports2.CONNECTION_CREATED = "connectionCreated"; + exports2.CONNECTION_READY = "connectionReady"; + exports2.CONNECTION_CLOSED = "connectionClosed"; + exports2.CONNECTION_CHECK_OUT_STARTED = "connectionCheckOutStarted"; + exports2.CONNECTION_CHECK_OUT_FAILED = "connectionCheckOutFailed"; + exports2.CONNECTION_CHECKED_OUT = "connectionCheckedOut"; + exports2.CONNECTION_CHECKED_IN = "connectionCheckedIn"; + exports2.CLUSTER_TIME_RECEIVED = "clusterTimeReceived"; + exports2.COMMAND_STARTED = "commandStarted"; + exports2.COMMAND_SUCCEEDED = "commandSucceeded"; + exports2.COMMAND_FAILED = "commandFailed"; + exports2.SERVER_HEARTBEAT_STARTED = "serverHeartbeatStarted"; + exports2.SERVER_HEARTBEAT_SUCCEEDED = "serverHeartbeatSucceeded"; + exports2.SERVER_HEARTBEAT_FAILED = "serverHeartbeatFailed"; + exports2.RESPONSE = "response"; + exports2.MORE = "more"; + exports2.INIT = "init"; + exports2.CHANGE = "change"; + exports2.END = "end"; + exports2.RESUME_TOKEN_CHANGED = "resumeTokenChanged"; + exports2.HEARTBEAT_EVENTS = Object.freeze([ + exports2.SERVER_HEARTBEAT_STARTED, + exports2.SERVER_HEARTBEAT_SUCCEEDED, + exports2.SERVER_HEARTBEAT_FAILED + ]); + exports2.CMAP_EVENTS = Object.freeze([ + exports2.CONNECTION_POOL_CREATED, + exports2.CONNECTION_POOL_READY, + exports2.CONNECTION_POOL_CLEARED, + exports2.CONNECTION_POOL_CLOSED, + exports2.CONNECTION_CREATED, + exports2.CONNECTION_READY, + exports2.CONNECTION_CLOSED, + exports2.CONNECTION_CHECK_OUT_STARTED, + exports2.CONNECTION_CHECK_OUT_FAILED, + exports2.CONNECTION_CHECKED_OUT, + exports2.CONNECTION_CHECKED_IN + ]); + exports2.TOPOLOGY_EVENTS = Object.freeze([ + exports2.SERVER_OPENING, + exports2.SERVER_CLOSED, + exports2.SERVER_DESCRIPTION_CHANGED, + exports2.TOPOLOGY_OPENING, + exports2.TOPOLOGY_CLOSED, + exports2.TOPOLOGY_DESCRIPTION_CHANGED, + exports2.ERROR, + exports2.TIMEOUT, + exports2.CLOSE + ]); + exports2.APM_EVENTS = Object.freeze([ + exports2.COMMAND_STARTED, + exports2.COMMAND_SUCCEEDED, + exports2.COMMAND_FAILED + ]); + exports2.SERVER_RELAY_EVENTS = Object.freeze([ + exports2.SERVER_HEARTBEAT_STARTED, + exports2.SERVER_HEARTBEAT_SUCCEEDED, + exports2.SERVER_HEARTBEAT_FAILED, + exports2.COMMAND_STARTED, + exports2.COMMAND_SUCCEEDED, + exports2.COMMAND_FAILED, + ...exports2.CMAP_EVENTS + ]); + exports2.LOCAL_SERVER_EVENTS = Object.freeze([ + exports2.CONNECT, + exports2.DESCRIPTION_RECEIVED, + exports2.CLOSED, + exports2.ENDED + ]); + exports2.MONGO_CLIENT_EVENTS = Object.freeze([ + ...exports2.CMAP_EVENTS, + ...exports2.APM_EVENTS, + ...exports2.TOPOLOGY_EVENTS, + ...exports2.HEARTBEAT_EVENTS + ]); + exports2.LEGACY_HELLO_COMMAND = "ismaster"; + exports2.LEGACY_HELLO_COMMAND_CAMEL_CASE = "isMaster"; + exports2.kDecorateResult = /* @__PURE__ */ Symbol.for("@@mdb.decorateDecryptionResult"); + exports2.kDecoratedKeys = /* @__PURE__ */ Symbol.for("@@mdb.decryptedKeys"); + } +}); + +// node_modules/mongodb/lib/read_concern.js +var require_read_concern = __commonJS({ + "node_modules/mongodb/lib/read_concern.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ReadConcern = exports2.ReadConcernLevel = void 0; + exports2.ReadConcernLevel = Object.freeze({ + local: "local", + majority: "majority", + linearizable: "linearizable", + available: "available", + snapshot: "snapshot" + }); + var ReadConcern = class _ReadConcern { + /** Constructs a ReadConcern from the read concern level.*/ + constructor(level) { + this.level = exports2.ReadConcernLevel[level] ?? level; + } + /** + * Construct a ReadConcern given an options object. + * + * @param options - The options object from which to extract the write concern. + */ + static fromOptions(options) { + if (options == null) { + return; + } + if (options.readConcern) { + const { readConcern } = options; + if (readConcern instanceof _ReadConcern) { + return readConcern; + } else if (typeof readConcern === "string") { + return new _ReadConcern(readConcern); + } else if ("level" in readConcern && readConcern.level) { + return new _ReadConcern(readConcern.level); + } + } + if (options.level) { + return new _ReadConcern(options.level); + } + return; + } + static get MAJORITY() { + return exports2.ReadConcernLevel.majority; + } + static get AVAILABLE() { + return exports2.ReadConcernLevel.available; + } + static get LINEARIZABLE() { + return exports2.ReadConcernLevel.linearizable; + } + static get SNAPSHOT() { + return exports2.ReadConcernLevel.snapshot; + } + toJSON() { + return { level: this.level }; + } + }; + exports2.ReadConcern = ReadConcern; + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/on_demand/document.js +var require_document = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/on_demand/document.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.OnDemandDocument = void 0; + var bson_1 = require_bson2(); + var BSONElementOffset = { + type: 0, + nameOffset: 1, + nameLength: 2, + offset: 3, + length: 4 + }; + var OnDemandDocument = class _OnDemandDocument { + constructor(bson, offset = 0, isArray = false, elements) { + this.cache = /* @__PURE__ */ Object.create(null); + this.indexFound = /* @__PURE__ */ Object.create(null); + this.bson = bson; + this.offset = offset; + this.isArray = isArray; + this.elements = elements ?? (0, bson_1.parseToElementsToArray)(this.bson, offset); + } + /** Only supports basic latin strings */ + isElementName(name, element) { + const nameLength = element[BSONElementOffset.nameLength]; + const nameOffset = element[BSONElementOffset.nameOffset]; + if (name.length !== nameLength) + return false; + const nameEnd = nameOffset + nameLength; + for (let byteIndex = nameOffset, charIndex = 0; charIndex < name.length && byteIndex < nameEnd; charIndex++, byteIndex++) { + if (this.bson[byteIndex] !== name.charCodeAt(charIndex)) + return false; + } + return true; + } + /** + * Seeks into the elements array for an element matching the given name. + * + * @remarks + * Caching: + * - Caches the existence of a property making subsequent look ups for non-existent properties return immediately + * - Caches names mapped to elements to avoid reiterating the array and comparing the name again + * - Caches the index at which an element has been found to prevent rechecking against elements already determined to belong to another name + * + * @param name - a basic latin string name of a BSON element + * @returns + */ + getElement(name) { + const cachedElement = this.cache[name]; + if (cachedElement === false) + return null; + if (cachedElement != null) { + return cachedElement; + } + if (typeof name === "number") { + if (this.isArray) { + if (name < this.elements.length) { + const element = this.elements[name]; + const cachedElement2 = { element, value: void 0 }; + this.cache[name] = cachedElement2; + this.indexFound[name] = true; + return cachedElement2; + } else { + return null; + } + } else { + return null; + } + } + for (let index = 0; index < this.elements.length; index++) { + const element = this.elements[index]; + if (!(index in this.indexFound) && this.isElementName(name, element)) { + const cachedElement2 = { element, value: void 0 }; + this.cache[name] = cachedElement2; + this.indexFound[index] = true; + return cachedElement2; + } + } + this.cache[name] = false; + return null; + } + toJSValue(element, as) { + const type = element[BSONElementOffset.type]; + const offset = element[BSONElementOffset.offset]; + const length = element[BSONElementOffset.length]; + if (as !== type) { + return null; + } + switch (as) { + case bson_1.BSONType.null: + case bson_1.BSONType.undefined: + return null; + case bson_1.BSONType.double: + return (0, bson_1.getFloat64LE)(this.bson, offset); + case bson_1.BSONType.int: + return (0, bson_1.getInt32LE)(this.bson, offset); + case bson_1.BSONType.long: + return (0, bson_1.getBigInt64LE)(this.bson, offset); + case bson_1.BSONType.bool: + return Boolean(this.bson[offset]); + case bson_1.BSONType.objectId: + return new bson_1.ObjectId(this.bson.subarray(offset, offset + 12)); + case bson_1.BSONType.timestamp: + return new bson_1.Timestamp((0, bson_1.getBigInt64LE)(this.bson, offset)); + case bson_1.BSONType.string: + return (0, bson_1.toUTF8)(this.bson, offset + 4, offset + length - 1, false); + case bson_1.BSONType.binData: { + const totalBinarySize = (0, bson_1.getInt32LE)(this.bson, offset); + const subType = this.bson[offset + 4]; + if (subType === 2) { + const subType2BinarySize = (0, bson_1.getInt32LE)(this.bson, offset + 1 + 4); + if (subType2BinarySize < 0) + throw new bson_1.BSONError("Negative binary type element size found for subtype 0x02"); + if (subType2BinarySize > totalBinarySize - 4) + throw new bson_1.BSONError("Binary type with subtype 0x02 contains too long binary size"); + if (subType2BinarySize < totalBinarySize - 4) + throw new bson_1.BSONError("Binary type with subtype 0x02 contains too short binary size"); + return new bson_1.Binary(this.bson.subarray(offset + 1 + 4 + 4, offset + 1 + 4 + 4 + subType2BinarySize), 2); + } + return new bson_1.Binary(this.bson.subarray(offset + 1 + 4, offset + 1 + 4 + totalBinarySize), subType); + } + case bson_1.BSONType.date: + return new Date(Number((0, bson_1.getBigInt64LE)(this.bson, offset))); + case bson_1.BSONType.object: + return new _OnDemandDocument(this.bson, offset); + case bson_1.BSONType.array: + return new _OnDemandDocument(this.bson, offset, true); + default: + throw new bson_1.BSONError(`Unsupported BSON type: ${as}`); + } + } + /** + * Returns the number of elements in this BSON document + */ + size() { + return this.elements.length; + } + /** + * Checks for the existence of an element by name. + * + * @remarks + * Uses `getElement` with the expectation that will populate caches such that a `has` call + * followed by a `getElement` call will not repeat the cost paid by the first look up. + * + * @param name - element name + */ + has(name) { + const cachedElement = this.cache[name]; + if (cachedElement === false) + return false; + if (cachedElement != null) + return true; + return this.getElement(name) != null; + } + get(name, as, required) { + const element = this.getElement(name); + if (element == null) { + if (required === true) { + throw new bson_1.BSONError(`BSON element "${name}" is missing`); + } else { + return null; + } + } + if (element.value == null) { + const value = this.toJSValue(element.element, as); + if (value == null) { + if (required === true) { + throw new bson_1.BSONError(`BSON element "${name}" is missing`); + } else { + return null; + } + } + element.value = value; + } + return element.value; + } + getNumber(name, required) { + const maybeBool = this.get(name, bson_1.BSONType.bool); + const bool = maybeBool == null ? null : maybeBool ? 1 : 0; + const maybeLong = this.get(name, bson_1.BSONType.long); + const long = maybeLong == null ? null : Number(maybeLong); + const result = bool ?? long ?? this.get(name, bson_1.BSONType.int) ?? this.get(name, bson_1.BSONType.double); + if (required === true && result == null) { + throw new bson_1.BSONError(`BSON element "${name}" is missing`); + } + return result; + } + /** + * Deserialize this object, DOES NOT cache result so avoid multiple invocations + * @param options - BSON deserialization options + */ + toObject(options) { + return (0, bson_1.deserialize)(this.bson, { + ...options, + index: this.offset, + allowObjectSmallerThanBufferSize: true + }); + } + /** Returns this document's bytes only */ + toBytes() { + const size = (0, bson_1.getInt32LE)(this.bson, this.offset); + return this.bson.subarray(this.offset, this.offset + size); + } + }; + exports2.OnDemandDocument = OnDemandDocument; + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/responses.js +var require_responses = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/responses.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientBulkWriteCursorResponse = exports2.ExplainedCursorResponse = exports2.CursorResponse = exports2.MongoDBResponse = void 0; + exports2.isErrorResponse = isErrorResponse; + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var document_1 = require_document(); + var BSONElementOffset = { + type: 0, + nameOffset: 1, + nameLength: 2, + offset: 3, + length: 4 + }; + function isErrorResponse(bson, elements) { + for (let eIdx = 0; eIdx < elements.length; eIdx++) { + const element = elements[eIdx]; + if (element[BSONElementOffset.nameLength] === 2) { + const nameOffset = element[BSONElementOffset.nameOffset]; + if (bson[nameOffset] === 111 && bson[nameOffset + 1] === 107) { + const valueOffset = element[BSONElementOffset.offset]; + const valueLength = element[BSONElementOffset.length]; + for (let i = valueOffset; i < valueOffset + valueLength; i++) { + if (bson[i] !== 0) + return false; + } + return true; + } + } + } + return true; + } + var MongoDBResponse = class _MongoDBResponse extends document_1.OnDemandDocument { + get(name, as, required) { + try { + return super.get(name, as, required); + } catch (cause) { + throw new error_1.MongoUnexpectedServerResponseError(cause.message, { cause }); + } + } + static is(value) { + return value instanceof _MongoDBResponse; + } + static make(bson) { + const elements = (0, bson_1.parseToElementsToArray)(bson, 0); + const isError = isErrorResponse(bson, elements); + return isError ? new _MongoDBResponse(bson, 0, false, elements) : new this(bson, 0, false, elements); + } + /** + * Returns true iff: + * - ok is 0 and the top-level code === 50 + * - ok is 1 and the writeErrors array contains a code === 50 + * - ok is 1 and the writeConcern object contains a code === 50 + */ + get isMaxTimeExpiredError() { + const isTopLevel = this.ok === 0 && this.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired; + if (isTopLevel) + return true; + if (this.ok === 0) + return false; + const isWriteConcern = this.get("writeConcernError", bson_1.BSONType.object)?.getNumber("code") === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired; + if (isWriteConcern) + return true; + const writeErrors = this.get("writeErrors", bson_1.BSONType.array); + if (writeErrors?.size()) { + for (let i = 0; i < writeErrors.size(); i++) { + const isWriteError = writeErrors.get(i, bson_1.BSONType.object)?.getNumber("code") === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired; + if (isWriteError) + return true; + } + } + return false; + } + /** + * Drivers can safely assume that the `recoveryToken` field is always a BSON document but drivers MUST NOT modify the + * contents of the document. + */ + get recoveryToken() { + return this.get("recoveryToken", bson_1.BSONType.object)?.toObject({ + promoteValues: false, + promoteLongs: false, + promoteBuffers: false, + validation: { utf8: true } + }) ?? null; + } + /** + * The server creates a cursor in response to a snapshot find/aggregate command and reports atClusterTime within the cursor field in the response. + * For the distinct command the server adds a top-level atClusterTime field to the response. + * The atClusterTime field represents the timestamp of the read and is guaranteed to be majority committed. + */ + get atClusterTime() { + return this.get("cursor", bson_1.BSONType.object)?.get("atClusterTime", bson_1.BSONType.timestamp) ?? this.get("atClusterTime", bson_1.BSONType.timestamp); + } + get operationTime() { + return this.get("operationTime", bson_1.BSONType.timestamp); + } + /** Normalizes whatever BSON value is "ok" to a JS number 1 or 0. */ + get ok() { + return this.getNumber("ok") ? 1 : 0; + } + get $err() { + return this.get("$err", bson_1.BSONType.string); + } + get errmsg() { + return this.get("errmsg", bson_1.BSONType.string); + } + get code() { + return this.getNumber("code"); + } + get $clusterTime() { + if (!("clusterTime" in this)) { + const clusterTimeDoc = this.get("$clusterTime", bson_1.BSONType.object); + if (clusterTimeDoc == null) { + this.clusterTime = null; + return null; + } + const clusterTime = clusterTimeDoc.get("clusterTime", bson_1.BSONType.timestamp, true); + const signature = clusterTimeDoc.get("signature", bson_1.BSONType.object)?.toObject(); + this.clusterTime = { clusterTime, signature }; + } + return this.clusterTime ?? null; + } + toObject(options) { + const exactBSONOptions = { + ...(0, bson_1.pluckBSONSerializeOptions)(options ?? {}), + validation: (0, bson_1.parseUtf8ValidationOption)(options) + }; + return super.toObject(exactBSONOptions); + } + }; + exports2.MongoDBResponse = MongoDBResponse; + MongoDBResponse.empty = new MongoDBResponse(new Uint8Array([13, 0, 0, 0, 16, 111, 107, 0, 1, 0, 0, 0, 0])); + var CursorResponse = class _CursorResponse extends MongoDBResponse { + constructor() { + super(...arguments); + this._batch = null; + this.iterated = 0; + this._encryptedBatch = null; + } + /** + * This supports a feature of the FindCursor. + * It is an optimization to avoid an extra getMore when the limit has been reached + */ + static get emptyGetMore() { + return new _CursorResponse((0, bson_1.serialize)({ ok: 1, cursor: { id: 0n, nextBatch: [] } })); + } + static is(value) { + return value instanceof _CursorResponse || value === _CursorResponse.emptyGetMore; + } + get cursor() { + return this.get("cursor", bson_1.BSONType.object, true); + } + get id() { + try { + return bson_1.Long.fromBigInt(this.cursor.get("id", bson_1.BSONType.long, true)); + } catch (cause) { + throw new error_1.MongoUnexpectedServerResponseError(cause.message, { cause }); + } + } + get ns() { + const namespace = this.cursor.get("ns", bson_1.BSONType.string); + if (namespace != null) + return (0, utils_1.ns)(namespace); + return null; + } + get length() { + return Math.max(this.batchSize - this.iterated, 0); + } + get encryptedBatch() { + if (this.encryptedResponse == null) + return null; + if (this._encryptedBatch != null) + return this._encryptedBatch; + const cursor = this.encryptedResponse?.get("cursor", bson_1.BSONType.object); + if (cursor?.has("firstBatch")) + this._encryptedBatch = cursor.get("firstBatch", bson_1.BSONType.array, true); + else if (cursor?.has("nextBatch")) + this._encryptedBatch = cursor.get("nextBatch", bson_1.BSONType.array, true); + else + throw new error_1.MongoUnexpectedServerResponseError("Cursor document did not contain a batch"); + return this._encryptedBatch; + } + get batch() { + if (this._batch != null) + return this._batch; + const cursor = this.cursor; + if (cursor.has("firstBatch")) + this._batch = cursor.get("firstBatch", bson_1.BSONType.array, true); + else if (cursor.has("nextBatch")) + this._batch = cursor.get("nextBatch", bson_1.BSONType.array, true); + else + throw new error_1.MongoUnexpectedServerResponseError("Cursor document did not contain a batch"); + return this._batch; + } + get batchSize() { + return this.batch?.size(); + } + get postBatchResumeToken() { + return this.cursor.get("postBatchResumeToken", bson_1.BSONType.object)?.toObject({ + promoteValues: false, + promoteLongs: false, + promoteBuffers: false, + validation: { utf8: true } + }) ?? null; + } + shift(options) { + if (this.iterated >= this.batchSize) { + return null; + } + const result = this.batch.get(this.iterated, bson_1.BSONType.object, true) ?? null; + const encryptedResult = this.encryptedBatch?.get(this.iterated, bson_1.BSONType.object, true) ?? null; + this.iterated += 1; + if (options?.raw) { + return result.toBytes(); + } else { + const object = result.toObject(options); + if (encryptedResult) { + (0, utils_1.decorateDecryptionResult)(object, encryptedResult.toObject(options), true); + } + return object; + } + } + clear() { + this.iterated = this.batchSize; + } + }; + exports2.CursorResponse = CursorResponse; + var ExplainedCursorResponse = class extends CursorResponse { + constructor() { + super(...arguments); + this.isExplain = true; + this._length = 1; + } + get id() { + return bson_1.Long.fromBigInt(0n); + } + get batchSize() { + return 0; + } + get ns() { + return null; + } + get length() { + return this._length; + } + shift(options) { + if (this._length === 0) + return null; + this._length -= 1; + return this.toObject(options); + } + }; + exports2.ExplainedCursorResponse = ExplainedCursorResponse; + var ClientBulkWriteCursorResponse = class extends CursorResponse { + get insertedCount() { + return this.get("nInserted", bson_1.BSONType.int, true); + } + get upsertedCount() { + return this.get("nUpserted", bson_1.BSONType.int, true); + } + get matchedCount() { + return this.get("nMatched", bson_1.BSONType.int, true); + } + get modifiedCount() { + return this.get("nModified", bson_1.BSONType.int, true); + } + get deletedCount() { + return this.get("nDeleted", bson_1.BSONType.int, true); + } + get writeConcernError() { + return this.get("writeConcernError", bson_1.BSONType.object, false); + } + }; + exports2.ClientBulkWriteCursorResponse = ClientBulkWriteCursorResponse; + } +}); + +// node_modules/mongodb/lib/write_concern.js +var require_write_concern = __commonJS({ + "node_modules/mongodb/lib/write_concern.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.WriteConcern = exports2.WRITE_CONCERN_KEYS = void 0; + exports2.throwIfWriteConcernError = throwIfWriteConcernError; + var responses_1 = require_responses(); + var error_1 = require_error(); + exports2.WRITE_CONCERN_KEYS = ["w", "wtimeout", "j", "journal", "fsync"]; + var WriteConcern = class _WriteConcern { + /** + * Constructs a WriteConcern from the write concern properties. + * @param w - request acknowledgment that the write operation has propagated to a specified number of mongod instances or to mongod instances with specified tags. + * @param wtimeoutMS - specify a time limit to prevent write operations from blocking indefinitely + * @param journal - request acknowledgment that the write operation has been written to the on-disk journal + * @param fsync - equivalent to the j option. Is deprecated and will be removed in the next major version. + */ + constructor(w, wtimeoutMS, journal, fsync) { + if (w != null) { + if (!Number.isNaN(Number(w))) { + this.w = Number(w); + } else { + this.w = w; + } + } + if (wtimeoutMS != null) { + this.wtimeoutMS = this.wtimeout = wtimeoutMS; + } + if (journal != null) { + this.journal = this.j = journal; + } + if (fsync != null) { + this.journal = this.j = fsync ? true : false; + } + } + /** + * Apply a write concern to a command document. Will modify and return the command. + */ + static apply(command, writeConcern) { + const wc = {}; + if (writeConcern.w != null) + wc.w = writeConcern.w; + if (writeConcern.wtimeoutMS != null) + wc.wtimeout = writeConcern.wtimeoutMS; + if (writeConcern.journal != null) + wc.j = writeConcern.j; + command.writeConcern = wc; + return command; + } + /** Construct a WriteConcern given an options object. */ + static fromOptions(options, inherit) { + if (options == null) + return void 0; + inherit = inherit ?? {}; + let opts; + if (typeof options === "string" || typeof options === "number") { + opts = { w: options }; + } else if (options instanceof _WriteConcern) { + opts = options; + } else { + opts = options.writeConcern; + } + const parentOpts = inherit instanceof _WriteConcern ? inherit : inherit.writeConcern; + const mergedOpts = { ...parentOpts, ...opts }; + const { w = void 0, wtimeout = void 0, j = void 0, fsync = void 0, journal = void 0, wtimeoutMS = void 0 } = mergedOpts; + if (w != null || wtimeout != null || wtimeoutMS != null || j != null || journal != null || fsync != null) { + return new _WriteConcern(w, wtimeout ?? wtimeoutMS, j ?? journal, fsync); + } + return void 0; + } + }; + exports2.WriteConcern = WriteConcern; + function throwIfWriteConcernError(response) { + if (typeof response === "object" && response != null) { + const writeConcernError = responses_1.MongoDBResponse.is(response) && response.has("writeConcernError") ? response.toObject() : !responses_1.MongoDBResponse.is(response) && "writeConcernError" in response ? response : null; + if (writeConcernError != null) { + throw new error_1.MongoWriteConcernError(writeConcernError); + } + } + } + } +}); + +// node_modules/mongodb/lib/utils.js +var require_utils3 = __commonJS({ + "node_modules/mongodb/lib/utils.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.kDispose = exports2.randomBytes = exports2.COSMOS_DB_MSG = exports2.DOCUMENT_DB_MSG = exports2.COSMOS_DB_CHECK = exports2.DOCUMENT_DB_CHECK = exports2.MONGODB_WARNING_CODE = exports2.DEFAULT_PK_FACTORY = exports2.HostAddress = exports2.BufferPool = exports2.List = exports2.MongoDBCollectionNamespace = exports2.MongoDBNamespace = exports2.ByteUtils = void 0; + exports2.isUint8Array = isUint8Array; + exports2.hostMatchesWildcards = hostMatchesWildcards; + exports2.normalizeHintField = normalizeHintField; + exports2.isObject = isObject; + exports2.mergeOptions = mergeOptions; + exports2.filterOptions = filterOptions; + exports2.applyRetryableWrites = applyRetryableWrites; + exports2.isPromiseLike = isPromiseLike; + exports2.decorateWithCollation = decorateWithCollation; + exports2.decorateWithReadConcern = decorateWithReadConcern; + exports2.getTopology = getTopology; + exports2.ns = ns; + exports2.makeCounter = makeCounter; + exports2.uuidV4 = uuidV4; + exports2.maxWireVersion = maxWireVersion; + exports2.arrayStrictEqual = arrayStrictEqual; + exports2.errorStrictEqual = errorStrictEqual; + exports2.makeStateMachine = makeStateMachine; + exports2.now = now; + exports2.calculateDurationInMs = calculateDurationInMs; + exports2.hasAtomicOperators = hasAtomicOperators; + exports2.resolveTimeoutOptions = resolveTimeoutOptions; + exports2.resolveOptions = resolveOptions; + exports2.isSuperset = isSuperset; + exports2.isHello = isHello; + exports2.setDifference = setDifference; + exports2.isRecord = isRecord; + exports2.emitWarning = emitWarning; + exports2.emitWarningOnce = emitWarningOnce; + exports2.enumToString = enumToString; + exports2.supportsRetryableWrites = supportsRetryableWrites; + exports2.shuffle = shuffle; + exports2.commandSupportsReadConcern = commandSupportsReadConcern; + exports2.compareObjectId = compareObjectId; + exports2.parseInteger = parseInteger; + exports2.parseUnsignedInteger = parseUnsignedInteger; + exports2.checkParentDomainMatch = checkParentDomainMatch; + exports2.get = get; + exports2.request = request; + exports2.isHostMatch = isHostMatch; + exports2.promiseWithResolvers = promiseWithResolvers; + exports2.squashError = squashError; + exports2.once = once; + exports2.maybeAddIdToDocuments = maybeAddIdToDocuments; + exports2.fileIsAccessible = fileIsAccessible; + exports2.csotMin = csotMin; + exports2.noop = noop; + exports2.decorateDecryptionResult = decorateDecryptionResult; + exports2.addAbortListener = addAbortListener; + exports2.abortable = abortable; + var crypto = require("crypto"); + var fs_1 = require("fs"); + var http = require("http"); + var timers_1 = require("timers"); + var url = require("url"); + var url_1 = require("url"); + var util_1 = require("util"); + var bson_1 = require_bson2(); + var constants_1 = require_constants(); + var constants_2 = require_constants2(); + var error_1 = require_error(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var common_1 = require_common(); + var write_concern_1 = require_write_concern(); + exports2.ByteUtils = { + toLocalBufferType(buffer) { + return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength); + }, + equals(seqA, seqB) { + return exports2.ByteUtils.toLocalBufferType(seqA).equals(seqB); + }, + compare(seqA, seqB) { + return exports2.ByteUtils.toLocalBufferType(seqA).compare(seqB); + }, + toBase64(uint8array) { + return exports2.ByteUtils.toLocalBufferType(uint8array).toString("base64"); + } + }; + function isUint8Array(value) { + return value != null && typeof value === "object" && Symbol.toStringTag in value && value[Symbol.toStringTag] === "Uint8Array"; + } + function hostMatchesWildcards(host, wildcards) { + for (const wildcard of wildcards) { + if (host === wildcard || wildcard.startsWith("*.") && host?.endsWith(wildcard.substring(2, wildcard.length)) || wildcard.startsWith("*/") && host?.endsWith(wildcard.substring(2, wildcard.length))) { + return true; + } + } + return false; + } + function normalizeHintField(hint) { + let finalHint = void 0; + if (typeof hint === "string") { + finalHint = hint; + } else if (Array.isArray(hint)) { + finalHint = {}; + hint.forEach((param) => { + finalHint[param] = 1; + }); + } else if (hint != null && typeof hint === "object") { + finalHint = {}; + for (const name in hint) { + finalHint[name] = hint[name]; + } + } + return finalHint; + } + var TO_STRING = (object) => Object.prototype.toString.call(object); + function isObject(arg) { + return "[object Object]" === TO_STRING(arg); + } + function mergeOptions(target, source) { + return { ...target, ...source }; + } + function filterOptions(options, names) { + const filterOptions2 = {}; + for (const name in options) { + if (names.includes(name)) { + filterOptions2[name] = options[name]; + } + } + return filterOptions2; + } + function applyRetryableWrites(target, db) { + if (db && db.s.options?.retryWrites) { + target.retryWrites = true; + } + return target; + } + function isPromiseLike(value) { + return value != null && typeof value === "object" && "then" in value && typeof value.then === "function"; + } + function decorateWithCollation(command, options) { + if (options.collation && typeof options.collation === "object") { + command.collation = options.collation; + } + } + function decorateWithReadConcern(command, coll, options) { + if (options && options.session && options.session.inTransaction()) { + return; + } + const readConcern = Object.assign({}, command.readConcern || {}); + if (coll.s.readConcern) { + Object.assign(readConcern, coll.s.readConcern); + } + if (Object.keys(readConcern).length > 0) { + Object.assign(command, { readConcern }); + } + } + function getTopology(provider) { + if ("topology" in provider && provider.topology) { + return provider.topology; + } else if ("client" in provider && provider.client.topology) { + return provider.client.topology; + } + throw new error_1.MongoNotConnectedError("MongoClient must be connected to perform this operation"); + } + function ns(ns2) { + return MongoDBNamespace.fromString(ns2); + } + var MongoDBNamespace = class _MongoDBNamespace { + /** + * Create a namespace object + * + * @param db - database name + * @param collection - collection name + */ + constructor(db, collection) { + this.db = db; + this.collection = collection === "" ? void 0 : collection; + } + toString() { + return this.collection ? `${this.db}.${this.collection}` : this.db; + } + withCollection(collection) { + return new MongoDBCollectionNamespace(this.db, collection); + } + static fromString(namespace) { + if (typeof namespace !== "string" || namespace === "") { + throw new error_1.MongoRuntimeError(`Cannot parse namespace from "${namespace}"`); + } + const [db, ...collectionParts] = namespace.split("."); + const collection = collectionParts.join("."); + return new _MongoDBNamespace(db, collection === "" ? void 0 : collection); + } + }; + exports2.MongoDBNamespace = MongoDBNamespace; + var MongoDBCollectionNamespace = class extends MongoDBNamespace { + constructor(db, collection) { + super(db, collection); + this.collection = collection; + } + static fromString(namespace) { + return super.fromString(namespace); + } + }; + exports2.MongoDBCollectionNamespace = MongoDBCollectionNamespace; + function* makeCounter(seed = 0) { + let count = seed; + while (true) { + const newCount = count; + count += 1; + yield newCount; + } + } + function uuidV4() { + const result = crypto.randomBytes(16); + result[6] = result[6] & 15 | 64; + result[8] = result[8] & 63 | 128; + return result; + } + function maxWireVersion(handshakeAware) { + if (handshakeAware) { + if (handshakeAware.hello) { + return handshakeAware.hello.maxWireVersion; + } + if (handshakeAware.serverApi?.version) { + return constants_1.MAX_SUPPORTED_WIRE_VERSION; + } + if (handshakeAware.loadBalanced) { + return constants_1.MAX_SUPPORTED_WIRE_VERSION; + } + if ("lastHello" in handshakeAware && typeof handshakeAware.lastHello === "function") { + const lastHello = handshakeAware.lastHello(); + if (lastHello) { + return lastHello.maxWireVersion; + } + } + if (handshakeAware.description && "maxWireVersion" in handshakeAware.description && handshakeAware.description.maxWireVersion != null) { + return handshakeAware.description.maxWireVersion; + } + } + return 0; + } + function arrayStrictEqual(arr, arr2) { + if (!Array.isArray(arr) || !Array.isArray(arr2)) { + return false; + } + return arr.length === arr2.length && arr.every((elt, idx) => elt === arr2[idx]); + } + function errorStrictEqual(lhs, rhs) { + if (lhs === rhs) { + return true; + } + if (!lhs || !rhs) { + return lhs === rhs; + } + if (lhs == null && rhs != null || lhs != null && rhs == null) { + return false; + } + if (lhs.constructor.name !== rhs.constructor.name) { + return false; + } + if (lhs.message !== rhs.message) { + return false; + } + return true; + } + function makeStateMachine(stateTable) { + return function stateTransition(target, newState) { + const legalStates = stateTable[target.s.state]; + if (legalStates && legalStates.indexOf(newState) < 0) { + throw new error_1.MongoRuntimeError(`illegal state transition from [${target.s.state}] => [${newState}], allowed: [${legalStates}]`); + } + target.emit("stateChanged", target.s.state, newState); + target.s.state = newState; + }; + } + function now() { + const hrtime = process.hrtime(); + return Math.floor(hrtime[0] * 1e3 + hrtime[1] / 1e6); + } + function calculateDurationInMs(started) { + if (typeof started !== "number") { + return -1; + } + const elapsed = now() - started; + return elapsed < 0 ? 0 : elapsed; + } + function hasAtomicOperators(doc, options) { + if (Array.isArray(doc)) { + for (const document of doc) { + if (hasAtomicOperators(document)) { + return true; + } + } + return false; + } + const keys = Object.keys(doc); + if (options?.ignoreUndefined) { + let allUndefined = true; + for (const key of keys) { + if (doc[key] !== void 0) { + allUndefined = false; + break; + } + } + if (allUndefined) { + throw new error_1.MongoInvalidArgumentError("Update operations require that all atomic operators have defined values, but none were provided."); + } + } + return keys.length > 0 && keys[0][0] === "$"; + } + function resolveTimeoutOptions(client, options) { + const { socketTimeoutMS, serverSelectionTimeoutMS, waitQueueTimeoutMS } = client.s.options; + return { + socketTimeoutMS, + serverSelectionTimeoutMS, + waitQueueTimeoutMS, + ...options, + timeoutMS: void 0 + }; + } + function resolveOptions(parent, options) { + const result = Object.assign({}, options, (0, bson_1.resolveBSONOptions)(options, parent)); + const session = options?.session; + if (!session?.inTransaction()) { + const readConcern = read_concern_1.ReadConcern.fromOptions(options) ?? parent?.readConcern; + if (readConcern) { + result.readConcern = readConcern; + } + const writeConcern = write_concern_1.WriteConcern.fromOptions(options) ?? parent?.writeConcern; + if (writeConcern) { + result.writeConcern = writeConcern; + } + } + result.timeoutMS = void 0; + const readPreference = read_preference_1.ReadPreference.fromOptions(options) ?? parent?.readPreference; + if (readPreference) { + result.readPreference = readPreference; + } + return result; + } + function isSuperset(set, subset) { + set = Array.isArray(set) ? new Set(set) : set; + subset = Array.isArray(subset) ? new Set(subset) : subset; + for (const elem of subset) { + if (!set.has(elem)) { + return false; + } + } + return true; + } + function isHello(doc) { + return doc[constants_2.LEGACY_HELLO_COMMAND] || doc.hello ? true : false; + } + function setDifference(setA, setB) { + const difference = new Set(setA); + for (const elem of setB) { + difference.delete(elem); + } + return difference; + } + var HAS_OWN = (object, prop) => Object.prototype.hasOwnProperty.call(object, prop); + function isRecord(value, requiredKeys = void 0) { + if (!isObject(value)) { + return false; + } + const ctor = value.constructor; + if (ctor && ctor.prototype) { + if (!isObject(ctor.prototype)) { + return false; + } + if (!HAS_OWN(ctor.prototype, "isPrototypeOf")) { + return false; + } + } + if (requiredKeys) { + const keys = Object.keys(value); + return isSuperset(keys, requiredKeys); + } + return true; + } + var List = class { + get length() { + return this.count; + } + get [Symbol.toStringTag]() { + return "List"; + } + constructor() { + this.count = 0; + this.head = { + next: null, + prev: null, + value: null + }; + this.head.next = this.head; + this.head.prev = this.head; + } + toArray() { + return Array.from(this); + } + toString() { + return `head <=> ${this.toArray().join(" <=> ")} <=> head`; + } + *[Symbol.iterator]() { + for (const node of this.nodes()) { + yield node.value; + } + } + *nodes() { + let ptr = this.head.next; + while (ptr !== this.head) { + const { next } = ptr; + yield ptr; + ptr = next; + } + } + /** Insert at end of list */ + push(value) { + this.count += 1; + const newNode = { + next: this.head, + prev: this.head.prev, + value + }; + this.head.prev.next = newNode; + this.head.prev = newNode; + } + /** Inserts every item inside an iterable instead of the iterable itself */ + pushMany(iterable) { + for (const value of iterable) { + this.push(value); + } + } + /** Insert at front of list */ + unshift(value) { + this.count += 1; + const newNode = { + next: this.head.next, + prev: this.head, + value + }; + this.head.next.prev = newNode; + this.head.next = newNode; + } + remove(node) { + if (node === this.head || this.length === 0) { + return null; + } + this.count -= 1; + const prevNode = node.prev; + const nextNode = node.next; + prevNode.next = nextNode; + nextNode.prev = prevNode; + return node.value; + } + /** Removes the first node at the front of the list */ + shift() { + return this.remove(this.head.next); + } + /** Removes the last node at the end of the list */ + pop() { + return this.remove(this.head.prev); + } + /** Iterates through the list and removes nodes where filter returns true */ + prune(filter) { + for (const node of this.nodes()) { + if (filter(node.value)) { + this.remove(node); + } + } + } + clear() { + this.count = 0; + this.head.next = this.head; + this.head.prev = this.head; + } + /** Returns the first item in the list, does not remove */ + first() { + return this.head.next.value; + } + /** Returns the last item in the list, does not remove */ + last() { + return this.head.prev.value; + } + }; + exports2.List = List; + var BufferPool = class { + constructor() { + this.buffers = new List(); + this.totalByteLength = 0; + } + get length() { + return this.totalByteLength; + } + /** Adds a buffer to the internal buffer pool list */ + append(buffer) { + this.buffers.push(buffer); + this.totalByteLength += buffer.length; + } + /** + * If BufferPool contains 4 bytes or more construct an int32 from the leading bytes, + * otherwise return null. Size can be negative, caller should error check. + */ + getInt32() { + if (this.totalByteLength < 4) { + return null; + } + const firstBuffer = this.buffers.first(); + if (firstBuffer != null && firstBuffer.byteLength >= 4) { + return firstBuffer.readInt32LE(0); + } + const top4Bytes = this.read(4); + const value = top4Bytes.readInt32LE(0); + this.totalByteLength += 4; + this.buffers.unshift(top4Bytes); + return value; + } + /** Reads the requested number of bytes, optionally consuming them */ + read(size) { + if (typeof size !== "number" || size < 0) { + throw new error_1.MongoInvalidArgumentError('Argument "size" must be a non-negative number'); + } + if (size > this.totalByteLength) { + return Buffer.alloc(0); + } + const result = Buffer.allocUnsafe(size); + for (let bytesRead = 0; bytesRead < size; ) { + const buffer = this.buffers.shift(); + if (buffer == null) { + break; + } + const bytesRemaining = size - bytesRead; + const bytesReadable = Math.min(bytesRemaining, buffer.byteLength); + const bytes = buffer.subarray(0, bytesReadable); + result.set(bytes, bytesRead); + bytesRead += bytesReadable; + this.totalByteLength -= bytesReadable; + if (bytesReadable < buffer.byteLength) { + this.buffers.unshift(buffer.subarray(bytesReadable)); + } + } + return result; + } + }; + exports2.BufferPool = BufferPool; + var HostAddress = class _HostAddress { + constructor(hostString) { + this.host = void 0; + this.port = void 0; + this.socketPath = void 0; + this.isIPv6 = false; + const escapedHost = hostString.split(" ").join("%20"); + if (escapedHost.endsWith(".sock")) { + this.socketPath = decodeURIComponent(escapedHost); + return; + } + const urlString = `iLoveJS://${escapedHost}`; + let url2; + try { + url2 = new url_1.URL(urlString); + } catch (urlError) { + const runtimeError = new error_1.MongoRuntimeError(`Unable to parse ${escapedHost} with URL`); + runtimeError.cause = urlError; + throw runtimeError; + } + const hostname = url2.hostname; + const port = url2.port; + let normalized = decodeURIComponent(hostname).toLowerCase(); + if (normalized.startsWith("[") && normalized.endsWith("]")) { + this.isIPv6 = true; + normalized = normalized.substring(1, hostname.length - 1); + } + this.host = normalized.toLowerCase(); + if (typeof port === "number") { + this.port = port; + } else if (typeof port === "string" && port !== "") { + this.port = Number.parseInt(port, 10); + } else { + this.port = 27017; + } + if (this.port === 0) { + throw new error_1.MongoParseError("Invalid port (zero) with hostname"); + } + Object.freeze(this); + } + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() { + return this.inspect(); + } + inspect() { + return `new HostAddress('${this.toString()}')`; + } + toString() { + if (typeof this.host === "string") { + if (this.isIPv6) { + return `[${this.host}]:${this.port}`; + } + return `${this.host}:${this.port}`; + } + return `${this.socketPath}`; + } + static fromString(s) { + return new _HostAddress(s); + } + static fromHostPort(host, port) { + if (host.includes(":")) { + host = `[${host}]`; + } + return _HostAddress.fromString(`${host}:${port}`); + } + static fromSrvRecord({ name, port }) { + return _HostAddress.fromHostPort(name, port); + } + toHostPort() { + if (this.socketPath) { + return { host: this.socketPath, port: 0 }; + } + const host = this.host ?? ""; + const port = this.port ?? 0; + return { host, port }; + } + }; + exports2.HostAddress = HostAddress; + exports2.DEFAULT_PK_FACTORY = { + // We prefer not to rely on ObjectId having a createPk method + createPk() { + return new bson_1.ObjectId(); + } + }; + exports2.MONGODB_WARNING_CODE = "MONGODB DRIVER"; + function emitWarning(message) { + return process.emitWarning(message, { code: exports2.MONGODB_WARNING_CODE }); + } + var emittedWarnings = /* @__PURE__ */ new Set(); + function emitWarningOnce(message) { + if (!emittedWarnings.has(message)) { + emittedWarnings.add(message); + return emitWarning(message); + } + } + function enumToString(en) { + return Object.values(en).join(", "); + } + function supportsRetryableWrites(server) { + if (!server) { + return false; + } + if (server.loadBalanced) { + return true; + } + if (server.description.logicalSessionTimeoutMinutes != null) { + if (server.description.type !== common_1.ServerType.Standalone) { + return true; + } + } + return false; + } + function shuffle(sequence, limit = 0) { + const items = Array.from(sequence); + if (limit > items.length) { + throw new error_1.MongoRuntimeError("Limit must be less than the number of items"); + } + let remainingItemsToShuffle = items.length; + const lowerBound = limit % items.length === 0 ? 1 : items.length - limit; + while (remainingItemsToShuffle > lowerBound) { + const randomIndex = Math.floor(Math.random() * remainingItemsToShuffle); + remainingItemsToShuffle -= 1; + const swapHold = items[remainingItemsToShuffle]; + items[remainingItemsToShuffle] = items[randomIndex]; + items[randomIndex] = swapHold; + } + return limit % items.length === 0 ? items : items.slice(lowerBound); + } + function commandSupportsReadConcern(command) { + if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) { + return true; + } + return false; + } + function compareObjectId(oid1, oid2) { + if (oid1 == null && oid2 == null) { + return 0; + } + if (oid1 == null) { + return -1; + } + if (oid2 == null) { + return 1; + } + return exports2.ByteUtils.compare(oid1.id, oid2.id); + } + function parseInteger(value) { + if (typeof value === "number") + return Math.trunc(value); + const parsedValue = Number.parseInt(String(value), 10); + return Number.isNaN(parsedValue) ? null : parsedValue; + } + function parseUnsignedInteger(value) { + const parsedInt = parseInteger(value); + return parsedInt != null && parsedInt >= 0 ? parsedInt : null; + } + function checkParentDomainMatch(address, srvHost) { + const normalizedAddress = address.endsWith(".") ? address.slice(0, address.length - 1) : address; + const normalizedSrvHost = srvHost.endsWith(".") ? srvHost.slice(0, srvHost.length - 1) : srvHost; + const allCharacterBeforeFirstDot = /^.*?\./; + const srvIsLessThanThreeParts = normalizedSrvHost.split(".").length < 3; + const addressDomain = `.${normalizedAddress.replace(allCharacterBeforeFirstDot, "")}`; + let srvHostDomain = srvIsLessThanThreeParts ? normalizedSrvHost : `.${normalizedSrvHost.replace(allCharacterBeforeFirstDot, "")}`; + if (!srvHostDomain.startsWith(".")) { + srvHostDomain = "." + srvHostDomain; + } + if (srvIsLessThanThreeParts && normalizedAddress.split(".").length <= normalizedSrvHost.split(".").length) { + throw new error_1.MongoAPIError("Server record does not have at least one more domain level than parent URI"); + } + if (!addressDomain.endsWith(srvHostDomain)) { + throw new error_1.MongoAPIError("Server record does not share hostname with parent URI"); + } + } + function get(url2, options = {}) { + return new Promise((resolve, reject) => { + let timeoutId; + const request2 = http.get(url2, options, (response) => { + response.setEncoding("utf8"); + let body = ""; + response.on("data", (chunk) => body += chunk); + response.on("end", () => { + (0, timers_1.clearTimeout)(timeoutId); + resolve({ status: response.statusCode, body }); + }); + }).on("error", (error) => { + (0, timers_1.clearTimeout)(timeoutId); + reject(error); + }).end(); + timeoutId = (0, timers_1.setTimeout)(() => { + request2.destroy(new error_1.MongoNetworkTimeoutError(`request timed out after 10 seconds`)); + }, 1e4); + }); + } + async function request(uri, options = {}) { + return await new Promise((resolve, reject) => { + const requestOptions = { + method: "GET", + timeout: 1e4, + json: true, + ...url.parse(uri), + ...options + }; + const req = http.request(requestOptions, (res) => { + res.setEncoding("utf8"); + let data = ""; + res.on("data", (d) => { + data += d; + }); + res.once("end", () => { + if (options.json === false) { + resolve(data); + return; + } + try { + const parsed = JSON.parse(data); + resolve(parsed); + } catch { + reject(new error_1.MongoRuntimeError(`Invalid JSON response: "${data}"`)); + } + }); + }); + req.once("timeout", () => req.destroy(new error_1.MongoNetworkTimeoutError(`Network request to ${uri} timed out after ${options.timeout} ms`))); + req.once("error", (error) => reject(error)); + req.end(); + }); + } + exports2.DOCUMENT_DB_CHECK = /(\.docdb\.amazonaws\.com$)|(\.docdb-elastic\.amazonaws\.com$)/; + exports2.COSMOS_DB_CHECK = /\.cosmos\.azure\.com$/; + exports2.DOCUMENT_DB_MSG = "You appear to be connected to a DocumentDB cluster. For more information regarding feature compatibility and support please visit https://www.mongodb.com/supportability/documentdb"; + exports2.COSMOS_DB_MSG = "You appear to be connected to a CosmosDB cluster. For more information regarding feature compatibility and support please visit https://www.mongodb.com/supportability/cosmosdb"; + function isHostMatch(match, host) { + return host && match.test(host.toLowerCase()) ? true : false; + } + function promiseWithResolvers() { + let resolve; + let reject; + const promise = new Promise(function withResolversExecutor(promiseResolve, promiseReject) { + resolve = promiseResolve; + reject = promiseReject; + }); + return { promise, resolve, reject }; + } + function squashError(_error) { + return; + } + exports2.randomBytes = (0, util_1.promisify)(crypto.randomBytes); + async function once(ee, name, options) { + options?.signal?.throwIfAborted(); + const { promise, resolve, reject } = promiseWithResolvers(); + const onEvent = (data) => resolve(data); + const onError = (error) => reject(error); + const abortListener = addAbortListener(options?.signal, function() { + reject(this.reason); + }); + ee.once(name, onEvent).once("error", onError); + try { + return await promise; + } finally { + ee.off(name, onEvent); + ee.off("error", onError); + abortListener?.[exports2.kDispose](); + } + } + function maybeAddIdToDocuments(collection, document, options) { + const forceServerObjectId = options.forceServerObjectId ?? collection.db.options?.forceServerObjectId ?? false; + if (forceServerObjectId) { + return document; + } + if (document._id == null) { + document._id = collection.s.pkFactory.createPk(); + } + return document; + } + async function fileIsAccessible(fileName, mode) { + try { + await fs_1.promises.access(fileName, mode); + return true; + } catch { + return false; + } + } + function csotMin(duration1, duration2) { + if (duration1 === 0) + return duration2; + if (duration2 === 0) + return duration1; + return Math.min(duration1, duration2); + } + function noop() { + return; + } + function decorateDecryptionResult(decrypted, original, isTopLevelDecorateCall = true) { + if (isTopLevelDecorateCall) { + if (Buffer.isBuffer(original)) { + original = (0, bson_1.deserialize)(original); + } + if (Buffer.isBuffer(decrypted)) { + throw new error_1.MongoRuntimeError("Expected result of decryption to be deserialized BSON object"); + } + } + if (!decrypted || typeof decrypted !== "object") + return; + for (const k of Object.keys(decrypted)) { + const originalValue = original[k]; + if (originalValue && originalValue._bsontype === "Binary" && originalValue.sub_type === 6) { + if (!decrypted[constants_2.kDecoratedKeys]) { + Object.defineProperty(decrypted, constants_2.kDecoratedKeys, { + value: [], + configurable: true, + enumerable: false, + writable: false + }); + } + decrypted[constants_2.kDecoratedKeys].push(k); + continue; + } + decorateDecryptionResult(decrypted[k], originalValue, false); + } + } + exports2.kDispose = Symbol.dispose ?? /* @__PURE__ */ Symbol("dispose"); + function addAbortListener(signal, listener) { + if (signal == null) + return; + signal.addEventListener("abort", listener, { once: true }); + return { [exports2.kDispose]: () => signal.removeEventListener("abort", listener) }; + } + async function abortable(promise, { signal }) { + if (signal == null) { + return await promise; + } + const { promise: aborted, reject } = promiseWithResolvers(); + const abortListener = signal.aborted ? reject(signal.reason) : addAbortListener(signal, function() { + reject(this.reason); + }); + try { + return await Promise.race([promise, aborted]); + } finally { + abortListener?.[exports2.kDispose](); + } + } + } +}); + +// node_modules/mongodb/lib/timeout.js +var require_timeout = __commonJS({ + "node_modules/mongodb/lib/timeout.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.LegacyTimeoutContext = exports2.CSOTTimeoutContext = exports2.TimeoutContext = exports2.Timeout = exports2.TimeoutError = void 0; + var timers_1 = require("timers"); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var TimeoutError = class extends Error { + get name() { + return "TimeoutError"; + } + constructor(message, options) { + super(message, options); + this.duration = options.duration; + } + static is(error) { + return error != null && typeof error === "object" && "name" in error && error.name === "TimeoutError"; + } + }; + exports2.TimeoutError = TimeoutError; + var Timeout = class _Timeout extends Promise { + get remainingTime() { + if (this.timedOut) + return 0; + if (this.duration === 0) + return Infinity; + return this.start + this.duration - Math.trunc(performance.now()); + } + get timeElapsed() { + return Math.trunc(performance.now()) - this.start; + } + /** Create a new timeout that expires in `duration` ms */ + constructor(executor = () => null, options) { + const duration = options?.duration ?? 0; + const unref = !!options?.unref; + const rejection = options?.rejection; + if (duration < 0) { + throw new error_1.MongoInvalidArgumentError("Cannot create a Timeout with a negative duration"); + } + let reject; + super((_, promiseReject) => { + reject = promiseReject; + executor(utils_1.noop, promiseReject); + }); + this.ended = null; + this.timedOut = false; + this.cleared = false; + this.duration = duration; + this.start = Math.trunc(performance.now()); + if (rejection == null && this.duration > 0) { + this.id = (0, timers_1.setTimeout)(() => { + this.ended = Math.trunc(performance.now()); + this.timedOut = true; + reject(new TimeoutError(`Expired after ${duration}ms`, { duration })); + }, this.duration); + if (typeof this.id.unref === "function" && unref) { + this.id.unref(); + } + } else if (rejection != null) { + this.ended = Math.trunc(performance.now()); + this.timedOut = true; + reject(rejection); + } + } + /** + * Clears the underlying timeout. This method is idempotent + */ + clear() { + (0, timers_1.clearTimeout)(this.id); + this.id = void 0; + this.timedOut = false; + this.cleared = true; + } + throwIfExpired() { + if (this.timedOut) { + this.then(void 0, utils_1.squashError); + throw new TimeoutError("Timed out", { duration: this.duration }); + } + } + static expires(duration, unref) { + return new _Timeout(void 0, { duration, unref }); + } + static reject(rejection) { + return new _Timeout(void 0, { duration: 0, unref: true, rejection }); + } + }; + exports2.Timeout = Timeout; + function isLegacyTimeoutContextOptions(v) { + return v != null && typeof v === "object" && "serverSelectionTimeoutMS" in v && typeof v.serverSelectionTimeoutMS === "number" && "waitQueueTimeoutMS" in v && typeof v.waitQueueTimeoutMS === "number"; + } + var TimeoutContext = class { + static create(options) { + if (options.session?.timeoutContext != null) + return options.session?.timeoutContext; + if (isLegacyTimeoutContextOptions(options)) + return new LegacyTimeoutContext(options); + else + throw new error_1.MongoRuntimeError("Unrecognized options"); + } + }; + exports2.TimeoutContext = TimeoutContext; + var CSOTTimeoutContext = class _CSOTTimeoutContext extends TimeoutContext { + constructor(options) { + super(); + this.minRoundTripTime = 0; + this.start = Math.trunc(performance.now()); + this.timeoutMS = options.timeoutMS; + this.serverSelectionTimeoutMS = options.serverSelectionTimeoutMS; + this.socketTimeoutMS = options.socketTimeoutMS; + this.clearServerSelectionTimeout = false; + } + get maxTimeMS() { + return this.remainingTimeMS - this.minRoundTripTime; + } + get remainingTimeMS() { + const timePassed = Math.trunc(performance.now()) - this.start; + return this.timeoutMS <= 0 ? Infinity : this.timeoutMS - timePassed; + } + csotEnabled() { + return true; + } + get serverSelectionTimeout() { + if (typeof this._serverSelectionTimeout !== "object" || this._serverSelectionTimeout?.cleared) { + const { remainingTimeMS, serverSelectionTimeoutMS } = this; + if (remainingTimeMS <= 0) + return Timeout.reject(new error_1.MongoOperationTimeoutError(`Timed out in server selection after ${this.timeoutMS}ms`)); + const usingServerSelectionTimeoutMS = serverSelectionTimeoutMS !== 0 && (0, utils_1.csotMin)(remainingTimeMS, serverSelectionTimeoutMS) === serverSelectionTimeoutMS; + if (usingServerSelectionTimeoutMS) { + this._serverSelectionTimeout = Timeout.expires(serverSelectionTimeoutMS); + } else { + if (remainingTimeMS > 0 && Number.isFinite(remainingTimeMS)) { + this._serverSelectionTimeout = Timeout.expires(remainingTimeMS); + } else { + this._serverSelectionTimeout = null; + } + } + } + return this._serverSelectionTimeout; + } + get connectionCheckoutTimeout() { + if (typeof this._connectionCheckoutTimeout !== "object" || this._connectionCheckoutTimeout?.cleared) { + if (typeof this._serverSelectionTimeout === "object") { + this._connectionCheckoutTimeout = this._serverSelectionTimeout; + } else { + throw new error_1.MongoRuntimeError("Unreachable. If you are seeing this error, please file a ticket on the NODE driver project on Jira"); + } + } + return this._connectionCheckoutTimeout; + } + get timeoutForSocketWrite() { + const { remainingTimeMS } = this; + if (!Number.isFinite(remainingTimeMS)) + return null; + if (remainingTimeMS > 0) + return Timeout.expires(remainingTimeMS); + return Timeout.reject(new error_1.MongoOperationTimeoutError("Timed out before socket write")); + } + get timeoutForSocketRead() { + const { remainingTimeMS } = this; + if (!Number.isFinite(remainingTimeMS)) + return null; + if (remainingTimeMS > 0) + return Timeout.expires(remainingTimeMS); + return Timeout.reject(new error_1.MongoOperationTimeoutError("Timed out before socket read")); + } + refresh() { + this.start = Math.trunc(performance.now()); + this.minRoundTripTime = 0; + this._serverSelectionTimeout?.clear(); + this._connectionCheckoutTimeout?.clear(); + } + clear() { + this._serverSelectionTimeout?.clear(); + this._connectionCheckoutTimeout?.clear(); + } + /** + * @internal + * Throws a MongoOperationTimeoutError if the context has expired. + * If the context has not expired, returns the `remainingTimeMS` + **/ + getRemainingTimeMSOrThrow(message) { + const { remainingTimeMS } = this; + if (remainingTimeMS <= 0) + throw new error_1.MongoOperationTimeoutError(message ?? `Expired after ${this.timeoutMS}ms`); + return remainingTimeMS; + } + /** + * @internal + * This method is intended to be used in situations where concurrent operation are on the same deadline, but cannot share a single `TimeoutContext` instance. + * Returns a new instance of `CSOTTimeoutContext` constructed with identical options, but setting the `start` property to `this.start`. + */ + clone() { + const timeoutContext = new _CSOTTimeoutContext({ + timeoutMS: this.timeoutMS, + serverSelectionTimeoutMS: this.serverSelectionTimeoutMS + }); + timeoutContext.start = this.start; + return timeoutContext; + } + refreshed() { + return new _CSOTTimeoutContext(this); + } + addMaxTimeMSToCommand(command, options) { + if (options.omitMaxTimeMS) + return; + const maxTimeMS = this.remainingTimeMS - this.minRoundTripTime; + if (maxTimeMS > 0 && Number.isFinite(maxTimeMS)) + command.maxTimeMS = maxTimeMS; + } + getSocketTimeoutMS() { + return 0; + } + }; + exports2.CSOTTimeoutContext = CSOTTimeoutContext; + var LegacyTimeoutContext = class _LegacyTimeoutContext extends TimeoutContext { + constructor(options) { + super(); + this.options = options; + this.clearServerSelectionTimeout = true; + } + csotEnabled() { + return false; + } + get serverSelectionTimeout() { + if (this.options.serverSelectionTimeoutMS != null && this.options.serverSelectionTimeoutMS > 0) + return Timeout.expires(this.options.serverSelectionTimeoutMS); + return null; + } + get connectionCheckoutTimeout() { + if (this.options.waitQueueTimeoutMS != null && this.options.waitQueueTimeoutMS > 0) + return Timeout.expires(this.options.waitQueueTimeoutMS); + return null; + } + get timeoutForSocketWrite() { + return null; + } + get timeoutForSocketRead() { + return null; + } + refresh() { + return; + } + clear() { + return; + } + get maxTimeMS() { + return null; + } + refreshed() { + return new _LegacyTimeoutContext(this.options); + } + addMaxTimeMSToCommand(_command, _options) { + } + getSocketTimeoutMS() { + return this.options.socketTimeoutMS; + } + }; + exports2.LegacyTimeoutContext = LegacyTimeoutContext; + } +}); + +// node_modules/mongodb/lib/explain.js +var require_explain = __commonJS({ + "node_modules/mongodb/lib/explain.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Explain = exports2.ExplainVerbosity = void 0; + exports2.decorateWithExplain = decorateWithExplain; + exports2.ExplainVerbosity = Object.freeze({ + queryPlanner: "queryPlanner", + queryPlannerExtended: "queryPlannerExtended", + executionStats: "executionStats", + allPlansExecution: "allPlansExecution" + }); + var Explain = class _Explain { + constructor(verbosity, maxTimeMS) { + if (typeof verbosity === "boolean") { + this.verbosity = verbosity ? exports2.ExplainVerbosity.allPlansExecution : exports2.ExplainVerbosity.queryPlanner; + } else { + this.verbosity = verbosity; + } + this.maxTimeMS = maxTimeMS; + } + static fromOptions({ explain } = {}) { + if (explain == null) + return; + if (typeof explain === "boolean" || typeof explain === "string") { + return new _Explain(explain); + } + const { verbosity, maxTimeMS } = explain; + return new _Explain(verbosity, maxTimeMS); + } + }; + exports2.Explain = Explain; + function decorateWithExplain(command, explain) { + const { verbosity, maxTimeMS } = explain; + const baseCommand = { explain: command, verbosity }; + if (typeof maxTimeMS === "number") { + baseCommand.maxTimeMS = maxTimeMS; + } + return baseCommand; + } + } +}); + +// node_modules/mongodb/lib/operations/operation.js +var require_operation = __commonJS({ + "node_modules/mongodb/lib/operations/operation.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AbstractOperation = exports2.Aspect = void 0; + exports2.defineAspects = defineAspects; + var bson_1 = require_bson2(); + var read_preference_1 = require_read_preference(); + exports2.Aspect = { + READ_OPERATION: /* @__PURE__ */ Symbol("READ_OPERATION"), + WRITE_OPERATION: /* @__PURE__ */ Symbol("WRITE_OPERATION"), + RETRYABLE: /* @__PURE__ */ Symbol("RETRYABLE"), + EXPLAINABLE: /* @__PURE__ */ Symbol("EXPLAINABLE"), + SKIP_COLLATION: /* @__PURE__ */ Symbol("SKIP_COLLATION"), + CURSOR_CREATING: /* @__PURE__ */ Symbol("CURSOR_CREATING"), + MUST_SELECT_SAME_SERVER: /* @__PURE__ */ Symbol("MUST_SELECT_SAME_SERVER"), + COMMAND_BATCHING: /* @__PURE__ */ Symbol("COMMAND_BATCHING"), + SUPPORTS_RAW_DATA: /* @__PURE__ */ Symbol("SUPPORTS_RAW_DATA") + }; + var AbstractOperation = class { + constructor(options = {}) { + this.readPreference = this.hasAspect(exports2.Aspect.WRITE_OPERATION) ? read_preference_1.ReadPreference.primary : read_preference_1.ReadPreference.fromOptions(options) ?? read_preference_1.ReadPreference.primary; + this.bsonOptions = (0, bson_1.resolveBSONOptions)(options); + this._session = options.session != null ? options.session : void 0; + this.options = options; + this.bypassPinningCheck = !!options.bypassPinningCheck; + } + hasAspect(aspect) { + const ctor = this.constructor; + if (ctor.aspects == null) { + return false; + } + return ctor.aspects.has(aspect); + } + // Make sure the session is not writable from outside this class. + get session() { + return this._session; + } + set session(session) { + this._session = session; + } + clearSession() { + this._session = void 0; + } + resetBatch() { + return true; + } + get canRetryRead() { + return this.hasAspect(exports2.Aspect.RETRYABLE) && this.hasAspect(exports2.Aspect.READ_OPERATION); + } + get canRetryWrite() { + return this.hasAspect(exports2.Aspect.RETRYABLE) && this.hasAspect(exports2.Aspect.WRITE_OPERATION); + } + /** + * Given an instance of a MongoDBResponse, map the response to the correct result type. For + * example, a `CountOperation` might map the response as follows: + * + * ```typescript + * override handleOk(response: InstanceType): TResult { + * return response.toObject(this.bsonOptions).n ?? 0; + * } + * + * // or, with type safety: + * override handleOk(response: InstanceType): TResult { + * return response.getNumber('n') ?? 0; + * } + * ``` + */ + handleOk(response) { + return response.toObject(this.bsonOptions); + } + /** + * Optional. + * + * If the operation performs error handling, such as wrapping, renaming the error, or squashing errors + * this method can be overridden. + */ + handleError(error) { + throw error; + } + }; + exports2.AbstractOperation = AbstractOperation; + function defineAspects(operation, aspects) { + if (!Array.isArray(aspects) && !(aspects instanceof Set)) { + aspects = [aspects]; + } + aspects = new Set(aspects); + Object.defineProperty(operation, "aspects", { + value: aspects, + writable: false + }); + return aspects; + } + } +}); + +// node_modules/mongodb/lib/operations/command.js +var require_command2 = __commonJS({ + "node_modules/mongodb/lib/operations/command.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CommandOperation = void 0; + var constants_1 = require_constants(); + var error_1 = require_error(); + var explain_1 = require_explain(); + var read_concern_1 = require_read_concern(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var operation_1 = require_operation(); + var CommandOperation = class extends operation_1.AbstractOperation { + constructor(parent, options) { + super(options); + this.options = options ?? {}; + const dbNameOverride = options?.dbName || options?.authdb; + if (dbNameOverride) { + this.ns = new utils_1.MongoDBNamespace(dbNameOverride, "$cmd"); + } else { + this.ns = parent ? parent.s.namespace.withCollection("$cmd") : new utils_1.MongoDBNamespace("admin", "$cmd"); + } + this.readConcern = read_concern_1.ReadConcern.fromOptions(options); + this.writeConcern = write_concern_1.WriteConcern.fromOptions(options); + if (this.hasAspect(operation_1.Aspect.EXPLAINABLE)) { + this.explain = explain_1.Explain.fromOptions(options); + } else if (options?.explain != null) { + throw new error_1.MongoInvalidArgumentError(`Option "explain" is not supported on this command`); + } + } + get canRetryWrite() { + if (this.hasAspect(operation_1.Aspect.EXPLAINABLE)) { + return this.explain == null; + } + return super.canRetryWrite; + } + buildOptions(timeoutContext) { + return { + ...this.options, + ...this.bsonOptions, + timeoutContext, + readPreference: this.readPreference, + session: this.session + }; + } + buildCommand(connection, session) { + const command = this.buildCommandDocument(connection, session); + const inTransaction = this.session && this.session.inTransaction(); + if (this.readConcern && (0, utils_1.commandSupportsReadConcern)(command) && !inTransaction) { + Object.assign(command, { readConcern: this.readConcern }); + } + if (this.writeConcern && this.hasAspect(operation_1.Aspect.WRITE_OPERATION) && !inTransaction) { + write_concern_1.WriteConcern.apply(command, this.writeConcern); + } + if (this.options.collation && typeof this.options.collation === "object" && !this.hasAspect(operation_1.Aspect.SKIP_COLLATION)) { + Object.assign(command, { collation: this.options.collation }); + } + if (typeof this.options.maxTimeMS === "number") { + command.maxTimeMS = this.options.maxTimeMS; + } + if (this.options.rawData != null && this.hasAspect(operation_1.Aspect.SUPPORTS_RAW_DATA) && (0, utils_1.maxWireVersion)(connection) >= constants_1.MIN_SUPPORTED_RAW_DATA_WIRE_VERSION) { + command.rawData = this.options.rawData; + } + if (this.hasAspect(operation_1.Aspect.EXPLAINABLE) && this.explain) { + return (0, explain_1.decorateWithExplain)(command, this.explain); + } + return command; + } + }; + exports2.CommandOperation = CommandOperation; + } +}); + +// node_modules/mongodb/lib/operations/aggregate.js +var require_aggregate = __commonJS({ + "node_modules/mongodb/lib/operations/aggregate.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AggregateOperation = exports2.DB_AGGREGATE_COLLECTION = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var write_concern_1 = require_write_concern(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + exports2.DB_AGGREGATE_COLLECTION = 1; + var AggregateOperation = class extends command_1.CommandOperation { + constructor(ns, pipeline, options) { + super(void 0, { ...options, dbName: ns.db }); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + this.options = { ...options }; + this.target = ns.collection || exports2.DB_AGGREGATE_COLLECTION; + this.pipeline = pipeline; + this.hasWriteStage = false; + if (typeof options?.out === "string") { + this.pipeline = this.pipeline.concat({ $out: options.out }); + this.hasWriteStage = true; + } else if (pipeline.length > 0) { + const finalStage = pipeline[pipeline.length - 1]; + if (finalStage.$out || finalStage.$merge) { + this.hasWriteStage = true; + } + } + if (!this.hasWriteStage) { + delete this.options.writeConcern; + } + if (this.explain && this.writeConcern) { + throw new error_1.MongoInvalidArgumentError('Option "explain" cannot be used on an aggregate call with writeConcern'); + } + if (options?.cursor != null && typeof options.cursor !== "object") { + throw new error_1.MongoInvalidArgumentError("Cursor options must be an object"); + } + this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse; + } + get commandName() { + return "aggregate"; + } + get canRetryRead() { + return !this.hasWriteStage; + } + addToPipeline(stage) { + this.pipeline.push(stage); + } + buildCommandDocument() { + const options = this.options; + const command = { aggregate: this.target, pipeline: this.pipeline }; + if (this.hasWriteStage && this.writeConcern) { + write_concern_1.WriteConcern.apply(command, this.writeConcern); + } + if (options.bypassDocumentValidation === true) { + command.bypassDocumentValidation = options.bypassDocumentValidation; + } + if (typeof options.allowDiskUse === "boolean") { + command.allowDiskUse = options.allowDiskUse; + } + if (options.hint) { + command.hint = options.hint; + } + if (options.let) { + command.let = options.let; + } + if (options.comment !== void 0) { + command.comment = options.comment; + } + command.cursor = options.cursor || {}; + if (options.batchSize && !this.hasWriteStage) { + command.cursor.batchSize = options.batchSize; + } + return command; + } + handleOk(response) { + return response; + } + }; + exports2.AggregateOperation = AggregateOperation; + (0, operation_1.defineAspects)(AggregateOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/operations/execute_operation.js +var require_execute_operation = __commonJS({ + "node_modules/mongodb/lib/operations/execute_operation.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.executeOperation = executeOperation; + exports2.autoConnect = autoConnect; + var error_1 = require_error(); + var read_preference_1 = require_read_preference(); + var server_selection_1 = require_server_selection(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var aggregate_1 = require_aggregate(); + var operation_1 = require_operation(); + var MMAPv1_RETRY_WRITES_ERROR_CODE = error_1.MONGODB_ERROR_CODES.IllegalOperation; + var MMAPv1_RETRY_WRITES_ERROR_MESSAGE = "This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string."; + async function executeOperation(client, operation, timeoutContext) { + if (!(operation instanceof operation_1.AbstractOperation)) { + throw new error_1.MongoRuntimeError("This method requires a valid operation instance"); + } + const topology = client.topology == null ? await (0, utils_1.abortable)(autoConnect(client), operation.options) : client.topology; + let session = operation.session; + let owner; + if (session == null) { + owner = /* @__PURE__ */ Symbol(); + session = client.startSession({ owner, explicit: false }); + } else if (session.hasEnded) { + throw new error_1.MongoExpiredSessionError("Use of expired sessions is not permitted"); + } else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) { + throw new error_1.MongoCompatibilityError("Snapshot reads require MongoDB 5.0 or later"); + } else if (session.client !== client) { + throw new error_1.MongoInvalidArgumentError("ClientSession must be from the same MongoClient"); + } + operation.session ??= session; + const readPreference = operation.readPreference ?? read_preference_1.ReadPreference.primary; + const inTransaction = !!session?.inTransaction(); + const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION); + if (inTransaction && !readPreference.equals(read_preference_1.ReadPreference.primary) && (hasReadAspect || operation.commandName === "runCommand")) { + throw new error_1.MongoTransactionError(`Read preference in a transaction must be primary, not: ${readPreference.mode}`); + } + if (session?.isPinned && session.transaction.isCommitted && !operation.bypassPinningCheck) { + session.unpin(); + } + timeoutContext ??= timeout_1.TimeoutContext.create({ + session, + serverSelectionTimeoutMS: client.s.options.serverSelectionTimeoutMS, + waitQueueTimeoutMS: client.s.options.waitQueueTimeoutMS, + timeoutMS: operation.options.timeoutMS + }); + try { + return await tryOperation(operation, { + topology, + timeoutContext, + session, + readPreference + }); + } finally { + if (session?.owner != null && session.owner === owner) { + await session.endSession(); + } + } + } + async function autoConnect(client) { + if (client.topology == null) { + if (client.s.hasBeenClosed) { + throw new error_1.MongoNotConnectedError("Client must be connected before running operations"); + } + client.s.options.__skipPingOnConnect = true; + try { + await client.connect(); + if (client.topology == null) { + throw new error_1.MongoRuntimeError("client.connect did not create a topology but also did not throw"); + } + return client.topology; + } finally { + delete client.s.options.__skipPingOnConnect; + } + } + return client.topology; + } + async function tryOperation(operation, { topology, timeoutContext, session, readPreference }) { + let selector; + if (operation.hasAspect(operation_1.Aspect.MUST_SELECT_SAME_SERVER)) { + selector = (0, server_selection_1.sameServerSelector)(operation.server?.description); + } else if (operation instanceof aggregate_1.AggregateOperation && operation.hasWriteStage) { + selector = (0, server_selection_1.secondaryWritableServerSelector)(topology.commonWireVersion, readPreference); + } else { + selector = readPreference; + } + let server = await topology.selectServer(selector, { + session, + operationName: operation.commandName, + timeoutContext, + signal: operation.options.signal + }); + const hasReadAspect = operation.hasAspect(operation_1.Aspect.READ_OPERATION); + const hasWriteAspect = operation.hasAspect(operation_1.Aspect.WRITE_OPERATION); + const inTransaction = session?.inTransaction() ?? false; + const willRetryRead = topology.s.options.retryReads && !inTransaction && operation.canRetryRead; + const willRetryWrite = topology.s.options.retryWrites && !inTransaction && (0, utils_1.supportsRetryableWrites)(server) && operation.canRetryWrite; + const willRetry = operation.hasAspect(operation_1.Aspect.RETRYABLE) && session != null && (hasReadAspect && willRetryRead || hasWriteAspect && willRetryWrite); + if (hasWriteAspect && willRetryWrite && session != null) { + operation.options.willRetryWrite = true; + session.incrementTransactionNumber(); + } + const maxTries = willRetry ? timeoutContext.csotEnabled() ? Infinity : 2 : 1; + let previousOperationError; + let previousServer; + for (let tries = 0; tries < maxTries; tries++) { + if (previousOperationError) { + if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) { + throw new error_1.MongoServerError({ + message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE, + errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE, + originalError: previousOperationError + }); + } + if (operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING) && !operation.canRetryWrite) { + throw previousOperationError; + } + if (hasWriteAspect && !(0, error_1.isRetryableWriteError)(previousOperationError)) + throw previousOperationError; + if (hasReadAspect && !(0, error_1.isRetryableReadError)(previousOperationError)) { + throw previousOperationError; + } + if (previousOperationError instanceof error_1.MongoNetworkError && operation.hasAspect(operation_1.Aspect.CURSOR_CREATING) && session != null && session.isPinned && !session.inTransaction()) { + session.unpin({ force: true, forceClear: true }); + } + server = await topology.selectServer(selector, { + session, + operationName: operation.commandName, + previousServer, + signal: operation.options.signal + }); + if (hasWriteAspect && !(0, utils_1.supportsRetryableWrites)(server)) { + throw new error_1.MongoUnexpectedServerResponseError("Selected server does not support retryable writes"); + } + } + operation.server = server; + try { + if (tries > 0 && operation.hasAspect(operation_1.Aspect.COMMAND_BATCHING)) { + operation.resetBatch(); + } + try { + const result = await server.command(operation, timeoutContext); + return operation.handleOk(result); + } catch (error) { + return operation.handleError(error); + } + } catch (operationError) { + if (!(operationError instanceof error_1.MongoError)) + throw operationError; + if (previousOperationError != null && operationError.hasErrorLabel(error_1.MongoErrorLabel.NoWritesPerformed)) { + throw previousOperationError; + } + previousServer = server.description; + previousOperationError = operationError; + timeoutContext.clear(); + } + } + throw previousOperationError ?? new error_1.MongoRuntimeError("Tried to propagate retryability error, but no error was found."); + } + } +}); + +// node_modules/mongodb/lib/operations/list_databases.js +var require_list_databases = __commonJS({ + "node_modules/mongodb/lib/operations/list_databases.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListDatabasesOperation = void 0; + var responses_1 = require_responses(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var ListDatabasesOperation = class extends command_1.CommandOperation { + constructor(db, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options ?? {}; + this.ns = new utils_1.MongoDBNamespace("admin", "$cmd"); + } + get commandName() { + return "listDatabases"; + } + buildCommandDocument(connection, _session) { + const cmd = { listDatabases: 1 }; + if (typeof this.options.nameOnly === "boolean") { + cmd.nameOnly = this.options.nameOnly; + } + if (this.options.filter) { + cmd.filter = this.options.filter; + } + if (typeof this.options.authorizedDatabases === "boolean") { + cmd.authorizedDatabases = this.options.authorizedDatabases; + } + if ((0, utils_1.maxWireVersion)(connection) >= 9 && this.options.comment !== void 0) { + cmd.comment = this.options.comment; + } + return cmd; + } + }; + exports2.ListDatabasesOperation = ListDatabasesOperation; + (0, operation_1.defineAspects)(ListDatabasesOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE]); + } +}); + +// node_modules/mongodb/lib/operations/remove_user.js +var require_remove_user = __commonJS({ + "node_modules/mongodb/lib/operations/remove_user.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.RemoveUserOperation = void 0; + var responses_1 = require_responses(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var RemoveUserOperation = class extends command_1.CommandOperation { + constructor(db, username, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.username = username; + } + get commandName() { + return "dropUser"; + } + buildCommandDocument(_connection) { + return { dropUser: this.username }; + } + handleOk(_response) { + return true; + } + }; + exports2.RemoveUserOperation = RemoveUserOperation; + (0, operation_1.defineAspects)(RemoveUserOperation, [operation_1.Aspect.WRITE_OPERATION]); + } +}); + +// node_modules/mongodb/lib/operations/run_command.js +var require_run_command = __commonJS({ + "node_modules/mongodb/lib/operations/run_command.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.RunCursorCommandOperation = exports2.RunCommandOperation = void 0; + var responses_1 = require_responses(); + var operation_1 = require_operation(); + var RunCommandOperation = class extends operation_1.AbstractOperation { + constructor(namespace, command, options) { + super(options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.command = command; + this.options = options; + this.ns = namespace.withCollection("$cmd"); + } + get commandName() { + return "runCommand"; + } + buildCommand(_connection, _session) { + return this.command; + } + buildOptions(timeoutContext) { + return { + ...this.options, + session: this.session, + timeoutContext, + signal: this.options.signal, + readPreference: this.options.readPreference + }; + } + }; + exports2.RunCommandOperation = RunCommandOperation; + var RunCursorCommandOperation = class extends RunCommandOperation { + constructor() { + super(...arguments); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + } + handleOk(response) { + return response; + } + }; + exports2.RunCursorCommandOperation = RunCursorCommandOperation; + } +}); + +// node_modules/mongodb/lib/operations/validate_collection.js +var require_validate_collection = __commonJS({ + "node_modules/mongodb/lib/operations/validate_collection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ValidateCollectionOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var command_1 = require_command2(); + var ValidateCollectionOperation = class extends command_1.CommandOperation { + constructor(admin, collectionName, options) { + super(admin.s.db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.collectionName = collectionName; + } + get commandName() { + return "validate"; + } + buildCommandDocument(_connection, _session) { + return { + validate: this.collectionName, + ...Object.fromEntries(Object.entries(this.options).filter((entry) => entry[0] !== "session")) + }; + } + handleOk(response) { + const result = super.handleOk(response); + if (result.result != null && typeof result.result !== "string") + throw new error_1.MongoUnexpectedServerResponseError("Error with validation data"); + if (result.result != null && result.result.match(/exception|corrupt/) != null) + throw new error_1.MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`); + if (result.valid != null && !result.valid) + throw new error_1.MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`); + return response; + } + }; + exports2.ValidateCollectionOperation = ValidateCollectionOperation; + } +}); + +// node_modules/mongodb/lib/admin.js +var require_admin = __commonJS({ + "node_modules/mongodb/lib/admin.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Admin = void 0; + var bson_1 = require_bson2(); + var execute_operation_1 = require_execute_operation(); + var list_databases_1 = require_list_databases(); + var remove_user_1 = require_remove_user(); + var run_command_1 = require_run_command(); + var validate_collection_1 = require_validate_collection(); + var utils_1 = require_utils3(); + var Admin = class { + /** + * Create a new Admin instance + * @internal + */ + constructor(db) { + this.s = { db }; + } + /** + * Execute a command + * + * The driver will ensure the following fields are attached to the command sent to the server: + * - `lsid` - sourced from an implicit session or options.session + * - `$readPreference` - defaults to primary or can be configured by options.readPreference + * - `$db` - sourced from the name of this database + * + * If the client has a serverApi setting: + * - `apiVersion` + * - `apiStrict` + * - `apiDeprecationErrors` + * + * When in a transaction: + * - `readConcern` - sourced from readConcern set on the TransactionOptions + * - `writeConcern` - sourced from writeConcern set on the TransactionOptions + * + * Attaching any of the above fields to the command will have no effect as the driver will overwrite the value. + * + * @param command - The command to execute + * @param options - Optional settings for the command + */ + async command(command, options) { + return await (0, execute_operation_1.executeOperation)(this.s.db.client, new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace("admin"), command, { + ...(0, bson_1.resolveBSONOptions)(options), + session: options?.session, + readPreference: options?.readPreference, + timeoutMS: options?.timeoutMS ?? this.s.db.timeoutMS + })); + } + /** + * Retrieve the server build information + * + * @param options - Optional settings for the command + */ + async buildInfo(options) { + return await this.command({ buildinfo: 1 }, options); + } + /** + * Retrieve the server build information + * + * @param options - Optional settings for the command + */ + async serverInfo(options) { + return await this.command({ buildinfo: 1 }, options); + } + /** + * Retrieve this db's server status. + * + * @param options - Optional settings for the command + */ + async serverStatus(options) { + return await this.command({ serverStatus: 1 }, options); + } + /** + * Ping the MongoDB server and retrieve results + * + * @param options - Optional settings for the command + */ + async ping(options) { + return await this.command({ ping: 1 }, options); + } + /** + * Remove a user from a database + * + * @param username - The username to remove + * @param options - Optional settings for the command + */ + async removeUser(username, options) { + return await (0, execute_operation_1.executeOperation)(this.s.db.client, new remove_user_1.RemoveUserOperation(this.s.db, username, { dbName: "admin", ...options })); + } + /** + * Validate an existing collection + * + * @param collectionName - The name of the collection to validate. + * @param options - Optional settings for the command + */ + async validateCollection(collectionName, options = {}) { + return await (0, execute_operation_1.executeOperation)(this.s.db.client, new validate_collection_1.ValidateCollectionOperation(this, collectionName, options)); + } + /** + * List the available databases + * + * @param options - Optional settings for the command + */ + async listDatabases(options) { + return await (0, execute_operation_1.executeOperation)(this.s.db.client, new list_databases_1.ListDatabasesOperation(this.s.db, { timeoutMS: this.s.db.timeoutMS, ...options })); + } + /** + * Get ReplicaSet status + * + * @param options - Optional settings for the command + */ + async replSetGetStatus(options) { + return await this.command({ replSetGetStatus: 1 }, options); + } + }; + exports2.Admin = Admin; + } +}); + +// node_modules/mongodb/lib/operations/delete.js +var require_delete = __commonJS({ + "node_modules/mongodb/lib/operations/delete.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DeleteManyOperation = exports2.DeleteOneOperation = exports2.DeleteOperation = void 0; + exports2.makeDeleteStatement = makeDeleteStatement; + var responses_1 = require_responses(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var DeleteOperation = class extends command_1.CommandOperation { + constructor(ns, statements, options) { + super(void 0, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.ns = ns; + this.statements = statements; + } + get commandName() { + return "delete"; + } + get canRetryWrite() { + if (super.canRetryWrite === false) { + return false; + } + return this.statements.every((op) => op.limit != null ? op.limit > 0 : true); + } + buildCommandDocument(connection, _session) { + const options = this.options; + const ordered = typeof options.ordered === "boolean" ? options.ordered : true; + const command = { + delete: this.ns.collection, + deletes: this.statements, + ordered + }; + if (options.let) { + command.let = options.let; + } + if (options.comment !== void 0) { + command.comment = options.comment; + } + const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0; + if (unacknowledgedWrite && (0, utils_1.maxWireVersion)(connection) < 9) { + if (this.statements.find((o) => o.hint)) { + throw new error_1.MongoCompatibilityError(`hint for the delete command is only supported on MongoDB 4.4+`); + } + } + return command; + } + }; + exports2.DeleteOperation = DeleteOperation; + var DeleteOneOperation = class extends DeleteOperation { + constructor(ns, filter, options) { + super(ns, [makeDeleteStatement(filter, { ...options, limit: 1 })], options); + } + handleOk(response) { + const res = super.handleOk(response); + if (this.explain) + return res; + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) + throw new error_1.MongoServerError(res.writeErrors[0]); + return { + acknowledged: this.writeConcern?.w !== 0, + deletedCount: res.n + }; + } + }; + exports2.DeleteOneOperation = DeleteOneOperation; + var DeleteManyOperation = class extends DeleteOperation { + constructor(ns, filter, options) { + super(ns, [makeDeleteStatement(filter, options)], options); + } + handleOk(response) { + const res = super.handleOk(response); + if (this.explain) + return res; + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) + throw new error_1.MongoServerError(res.writeErrors[0]); + return { + acknowledged: this.writeConcern?.w !== 0, + deletedCount: res.n + }; + } + }; + exports2.DeleteManyOperation = DeleteManyOperation; + function makeDeleteStatement(filter, options) { + const op = { + q: filter, + limit: typeof options.limit === "number" ? options.limit : 0 + }; + if (options.collation) { + op.collation = options.collation; + } + if (options.hint) { + op.hint = options.hint; + } + return op; + } + (0, operation_1.defineAspects)(DeleteOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(DeleteOneOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(DeleteManyOperation, [ + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/operations/insert.js +var require_insert = __commonJS({ + "node_modules/mongodb/lib/operations/insert.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.InsertOneOperation = exports2.InsertOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var InsertOperation = class extends command_1.CommandOperation { + constructor(ns, documents, options) { + super(void 0, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = { ...options, checkKeys: options.checkKeys ?? false }; + this.ns = ns; + this.documents = documents; + } + get commandName() { + return "insert"; + } + buildCommandDocument(_connection, _session) { + const options = this.options ?? {}; + const ordered = typeof options.ordered === "boolean" ? options.ordered : true; + const command = { + insert: this.ns.collection, + documents: this.documents, + ordered + }; + if (typeof options.bypassDocumentValidation === "boolean") { + command.bypassDocumentValidation = options.bypassDocumentValidation; + } + if (options.comment !== void 0) { + command.comment = options.comment; + } + return command; + } + }; + exports2.InsertOperation = InsertOperation; + var InsertOneOperation = class extends InsertOperation { + constructor(collection, doc, options) { + super(collection.s.namespace, [(0, utils_1.maybeAddIdToDocuments)(collection, doc, options)], options); + } + handleOk(response) { + const res = super.handleOk(response); + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) { + throw new error_1.MongoServerError(res.writeErrors[0]); + } + return { + acknowledged: this.writeConcern?.w !== 0, + insertedId: this.documents[0]._id + }; + } + }; + exports2.InsertOneOperation = InsertOneOperation; + (0, operation_1.defineAspects)(InsertOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(InsertOneOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/sort.js +var require_sort = __commonJS({ + "node_modules/mongodb/lib/sort.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.formatSort = formatSort; + var error_1 = require_error(); + function prepareDirection(direction = 1) { + const value = `${direction}`.toLowerCase(); + if (isMeta(direction)) + return direction; + switch (value) { + case "ascending": + case "asc": + case "1": + return 1; + case "descending": + case "desc": + case "-1": + return -1; + default: + throw new error_1.MongoInvalidArgumentError(`Invalid sort direction: ${JSON.stringify(direction)}`); + } + } + function isMeta(t) { + return typeof t === "object" && t != null && "$meta" in t && typeof t.$meta === "string"; + } + function isPair(t) { + if (Array.isArray(t) && t.length === 2) { + try { + prepareDirection(t[1]); + return true; + } catch { + return false; + } + } + return false; + } + function isDeep(t) { + return Array.isArray(t) && Array.isArray(t[0]); + } + function isMap(t) { + return t instanceof Map && t.size > 0; + } + function isReadonlyArray(value) { + return Array.isArray(value); + } + function pairToMap(v) { + return /* @__PURE__ */ new Map([[`${v[0]}`, prepareDirection([v[1]])]]); + } + function deepToMap(t) { + const sortEntries = t.map(([k, v]) => [`${k}`, prepareDirection(v)]); + return new Map(sortEntries); + } + function stringsToMap(t) { + const sortEntries = t.map((key) => [`${key}`, 1]); + return new Map(sortEntries); + } + function objectToMap(t) { + const sortEntries = Object.entries(t).map(([k, v]) => [ + `${k}`, + prepareDirection(v) + ]); + return new Map(sortEntries); + } + function mapToMap(t) { + const sortEntries = Array.from(t).map(([k, v]) => [ + `${k}`, + prepareDirection(v) + ]); + return new Map(sortEntries); + } + function formatSort(sort, direction) { + if (sort == null) + return void 0; + if (typeof sort === "string") + return /* @__PURE__ */ new Map([[sort, prepareDirection(direction)]]); + if (typeof sort !== "object") { + throw new error_1.MongoInvalidArgumentError(`Invalid sort format: ${JSON.stringify(sort)} Sort must be a valid object`); + } + if (!isReadonlyArray(sort)) { + if (isMap(sort)) + return mapToMap(sort); + if (Object.keys(sort).length) + return objectToMap(sort); + return void 0; + } + if (!sort.length) + return void 0; + if (isDeep(sort)) + return deepToMap(sort); + if (isPair(sort)) + return pairToMap(sort); + return stringsToMap(sort); + } + } +}); + +// node_modules/mongodb/lib/operations/update.js +var require_update = __commonJS({ + "node_modules/mongodb/lib/operations/update.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ReplaceOneOperation = exports2.UpdateManyOperation = exports2.UpdateOneOperation = exports2.UpdateOperation = void 0; + exports2.makeUpdateStatement = makeUpdateStatement; + var responses_1 = require_responses(); + var error_1 = require_error(); + var sort_1 = require_sort(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var UpdateOperation = class extends command_1.CommandOperation { + constructor(ns, statements, options) { + super(void 0, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.ns = ns; + this.statements = statements; + } + get commandName() { + return "update"; + } + get canRetryWrite() { + if (super.canRetryWrite === false) { + return false; + } + return this.statements.every((op) => op.multi == null || op.multi === false); + } + buildCommandDocument(_connection, _session) { + const options = this.options; + const command = { + update: this.ns.collection, + updates: this.statements, + ordered: options.ordered ?? true + }; + if (typeof options.bypassDocumentValidation === "boolean") { + command.bypassDocumentValidation = options.bypassDocumentValidation; + } + if (options.let) { + command.let = options.let; + } + if (options.comment !== void 0) { + command.comment = options.comment; + } + return command; + } + }; + exports2.UpdateOperation = UpdateOperation; + var UpdateOneOperation = class extends UpdateOperation { + constructor(ns, filter, update, options) { + super(ns, [makeUpdateStatement(filter, update, { ...options, multi: false })], options); + if (!(0, utils_1.hasAtomicOperators)(update, options)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + } + handleOk(response) { + const res = super.handleOk(response); + if (this.explain != null) + return res; + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) + throw new error_1.MongoServerError(res.writeErrors[0]); + return { + acknowledged: this.writeConcern?.w !== 0, + modifiedCount: res.nModified ?? res.n, + upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null, + upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0, + matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n + }; + } + }; + exports2.UpdateOneOperation = UpdateOneOperation; + var UpdateManyOperation = class extends UpdateOperation { + constructor(ns, filter, update, options) { + super(ns, [makeUpdateStatement(filter, update, { ...options, multi: true })], options); + if (!(0, utils_1.hasAtomicOperators)(update, options)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + } + handleOk(response) { + const res = super.handleOk(response); + if (this.explain != null) + return res; + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) + throw new error_1.MongoServerError(res.writeErrors[0]); + return { + acknowledged: this.writeConcern?.w !== 0, + modifiedCount: res.nModified ?? res.n, + upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null, + upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0, + matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n + }; + } + }; + exports2.UpdateManyOperation = UpdateManyOperation; + var ReplaceOneOperation = class extends UpdateOperation { + constructor(ns, filter, replacement, options) { + super(ns, [makeUpdateStatement(filter, replacement, { ...options, multi: false })], options); + if ((0, utils_1.hasAtomicOperators)(replacement)) { + throw new error_1.MongoInvalidArgumentError("Replacement document must not contain atomic operators"); + } + } + handleOk(response) { + const res = super.handleOk(response); + if (this.explain != null) + return res; + if (res.code) + throw new error_1.MongoServerError(res); + if (res.writeErrors) + throw new error_1.MongoServerError(res.writeErrors[0]); + return { + acknowledged: this.writeConcern?.w !== 0, + modifiedCount: res.nModified ?? res.n, + upsertedId: Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null, + upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0, + matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n + }; + } + }; + exports2.ReplaceOneOperation = ReplaceOneOperation; + function makeUpdateStatement(filter, update, options) { + if (filter == null || typeof filter !== "object") { + throw new error_1.MongoInvalidArgumentError("Selector must be a valid JavaScript object"); + } + if (update == null || typeof update !== "object") { + throw new error_1.MongoInvalidArgumentError("Document must be a valid JavaScript object"); + } + const op = { q: filter, u: update }; + if (typeof options.upsert === "boolean") { + op.upsert = options.upsert; + } + if (options.multi) { + op.multi = options.multi; + } + if (options.hint) { + op.hint = options.hint; + } + if (options.arrayFilters) { + op.arrayFilters = options.arrayFilters; + } + if (options.collation) { + op.collation = options.collation; + } + if (!options.multi && options.sort != null) { + op.sort = (0, sort_1.formatSort)(options.sort); + } + return op; + } + (0, operation_1.defineAspects)(UpdateOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(UpdateOneOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(UpdateManyOperation, [ + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(ReplaceOneOperation, [ + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/bulk/common.js +var require_common2 = __commonJS({ + "node_modules/mongodb/lib/bulk/common.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.BulkOperationBase = exports2.FindOperators = exports2.MongoBulkWriteError = exports2.WriteError = exports2.WriteConcernError = exports2.BulkWriteResult = exports2.Batch = exports2.BatchType = void 0; + exports2.mergeBatchResults = mergeBatchResults; + var bson_1 = require_bson2(); + var error_1 = require_error(); + var delete_1 = require_delete(); + var execute_operation_1 = require_execute_operation(); + var insert_1 = require_insert(); + var update_1 = require_update(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + exports2.BatchType = Object.freeze({ + INSERT: 1, + UPDATE: 2, + DELETE: 3 + }); + var Batch = class { + constructor(batchType, originalZeroIndex) { + this.originalZeroIndex = originalZeroIndex; + this.currentIndex = 0; + this.originalIndexes = []; + this.batchType = batchType; + this.operations = []; + this.size = 0; + this.sizeBytes = 0; + } + }; + exports2.Batch = Batch; + var BulkWriteResult = class _BulkWriteResult { + static generateIdMap(ids) { + const idMap = {}; + for (const doc of ids) { + idMap[doc.index] = doc._id; + } + return idMap; + } + /** + * Create a new BulkWriteResult instance + * @internal + */ + constructor(bulkResult, isOrdered) { + this.result = bulkResult; + this.insertedCount = this.result.nInserted ?? 0; + this.matchedCount = this.result.nMatched ?? 0; + this.modifiedCount = this.result.nModified ?? 0; + this.deletedCount = this.result.nRemoved ?? 0; + this.upsertedCount = this.result.upserted.length ?? 0; + this.upsertedIds = _BulkWriteResult.generateIdMap(this.result.upserted); + this.insertedIds = _BulkWriteResult.generateIdMap(this.getSuccessfullyInsertedIds(bulkResult, isOrdered)); + Object.defineProperty(this, "result", { value: this.result, enumerable: false }); + } + /** Evaluates to true if the bulk operation correctly executes */ + get ok() { + return this.result.ok; + } + /** + * Returns document_ids that were actually inserted + * @internal + */ + getSuccessfullyInsertedIds(bulkResult, isOrdered) { + if (bulkResult.writeErrors.length === 0) + return bulkResult.insertedIds; + if (isOrdered) { + return bulkResult.insertedIds.slice(0, bulkResult.writeErrors[0].index); + } + return bulkResult.insertedIds.filter(({ index }) => !bulkResult.writeErrors.some((writeError) => index === writeError.index)); + } + /** Returns the upserted id at the given index */ + getUpsertedIdAt(index) { + return this.result.upserted[index]; + } + /** Returns raw internal result */ + getRawResponse() { + return this.result; + } + /** Returns true if the bulk operation contains a write error */ + hasWriteErrors() { + return this.result.writeErrors.length > 0; + } + /** Returns the number of write errors from the bulk operation */ + getWriteErrorCount() { + return this.result.writeErrors.length; + } + /** Returns a specific write error object */ + getWriteErrorAt(index) { + return index < this.result.writeErrors.length ? this.result.writeErrors[index] : void 0; + } + /** Retrieve all write errors */ + getWriteErrors() { + return this.result.writeErrors; + } + /** Retrieve the write concern error if one exists */ + getWriteConcernError() { + if (this.result.writeConcernErrors.length === 0) { + return; + } else if (this.result.writeConcernErrors.length === 1) { + return this.result.writeConcernErrors[0]; + } else { + let errmsg = ""; + for (let i = 0; i < this.result.writeConcernErrors.length; i++) { + const err = this.result.writeConcernErrors[i]; + errmsg = errmsg + err.errmsg; + if (i === 0) + errmsg = errmsg + " and "; + } + return new WriteConcernError({ errmsg, code: error_1.MONGODB_ERROR_CODES.WriteConcernTimeout }); + } + } + toString() { + return `BulkWriteResult(${bson_1.EJSON.stringify(this.result)})`; + } + isOk() { + return this.result.ok === 1; + } + }; + exports2.BulkWriteResult = BulkWriteResult; + var WriteConcernError = class { + constructor(error) { + this.serverError = error; + } + /** Write concern error code. */ + get code() { + return this.serverError.code; + } + /** Write concern error message. */ + get errmsg() { + return this.serverError.errmsg; + } + /** Write concern error info. */ + get errInfo() { + return this.serverError.errInfo; + } + toJSON() { + return this.serverError; + } + toString() { + return `WriteConcernError(${this.errmsg})`; + } + }; + exports2.WriteConcernError = WriteConcernError; + var WriteError = class { + constructor(err) { + this.err = err; + } + /** WriteError code. */ + get code() { + return this.err.code; + } + /** WriteError original bulk operation index. */ + get index() { + return this.err.index; + } + /** WriteError message. */ + get errmsg() { + return this.err.errmsg; + } + /** WriteError details. */ + get errInfo() { + return this.err.errInfo; + } + /** Returns the underlying operation that caused the error */ + getOperation() { + return this.err.op; + } + toJSON() { + return { code: this.err.code, index: this.err.index, errmsg: this.err.errmsg, op: this.err.op }; + } + toString() { + return `WriteError(${JSON.stringify(this.toJSON())})`; + } + }; + exports2.WriteError = WriteError; + function mergeBatchResults(batch, bulkResult, err, result) { + if (err) { + result = err; + } else if (result && result.result) { + result = result.result; + } + if (result == null) { + return; + } + if (result.ok === 0 && bulkResult.ok === 1) { + bulkResult.ok = 0; + const writeError = { + index: 0, + code: result.code || 0, + errmsg: result.message, + errInfo: result.errInfo, + op: batch.operations[0] + }; + bulkResult.writeErrors.push(new WriteError(writeError)); + return; + } else if (result.ok === 0 && bulkResult.ok === 0) { + return; + } + if (isInsertBatch(batch) && result.n) { + bulkResult.nInserted = bulkResult.nInserted + result.n; + } + if (isDeleteBatch(batch) && result.n) { + bulkResult.nRemoved = bulkResult.nRemoved + result.n; + } + let nUpserted = 0; + if (Array.isArray(result.upserted)) { + nUpserted = result.upserted.length; + for (let i = 0; i < result.upserted.length; i++) { + bulkResult.upserted.push({ + index: result.upserted[i].index + batch.originalZeroIndex, + _id: result.upserted[i]._id + }); + } + } else if (result.upserted) { + nUpserted = 1; + bulkResult.upserted.push({ + index: batch.originalZeroIndex, + _id: result.upserted + }); + } + if (isUpdateBatch(batch) && result.n) { + const nModified = result.nModified; + bulkResult.nUpserted = bulkResult.nUpserted + nUpserted; + bulkResult.nMatched = bulkResult.nMatched + (result.n - nUpserted); + if (typeof nModified === "number") { + bulkResult.nModified = bulkResult.nModified + nModified; + } else { + bulkResult.nModified = 0; + } + } + if (Array.isArray(result.writeErrors)) { + for (let i = 0; i < result.writeErrors.length; i++) { + const writeError = { + index: batch.originalIndexes[result.writeErrors[i].index], + code: result.writeErrors[i].code, + errmsg: result.writeErrors[i].errmsg, + errInfo: result.writeErrors[i].errInfo, + op: batch.operations[result.writeErrors[i].index] + }; + bulkResult.writeErrors.push(new WriteError(writeError)); + } + } + if (result.writeConcernError) { + bulkResult.writeConcernErrors.push(new WriteConcernError(result.writeConcernError)); + } + } + async function executeCommands(bulkOperation, options) { + if (bulkOperation.s.batches.length === 0) { + return new BulkWriteResult(bulkOperation.s.bulkResult, bulkOperation.isOrdered); + } + for (const batch of bulkOperation.s.batches) { + const finalOptions = (0, utils_1.resolveOptions)(bulkOperation, { + ...options, + ordered: bulkOperation.isOrdered + }); + if (finalOptions.bypassDocumentValidation !== true) { + delete finalOptions.bypassDocumentValidation; + } + if (bulkOperation.s.bypassDocumentValidation === true) { + finalOptions.bypassDocumentValidation = true; + } + if (bulkOperation.s.checkKeys === false) { + finalOptions.checkKeys = false; + } + if (finalOptions.retryWrites) { + if (isUpdateBatch(batch)) { + finalOptions.retryWrites = finalOptions.retryWrites && !batch.operations.some((op) => op.multi); + } + if (isDeleteBatch(batch)) { + finalOptions.retryWrites = finalOptions.retryWrites && !batch.operations.some((op) => op.limit === 0); + } + } + const operation = isInsertBatch(batch) ? new insert_1.InsertOperation(bulkOperation.s.namespace, batch.operations, finalOptions) : isUpdateBatch(batch) ? new update_1.UpdateOperation(bulkOperation.s.namespace, batch.operations, finalOptions) : isDeleteBatch(batch) ? new delete_1.DeleteOperation(bulkOperation.s.namespace, batch.operations, finalOptions) : null; + if (operation == null) + throw new error_1.MongoRuntimeError(`Unknown batchType: ${batch.batchType}`); + let thrownError = null; + let result; + try { + result = await (0, execute_operation_1.executeOperation)(bulkOperation.s.collection.client, operation, finalOptions.timeoutContext); + } catch (error) { + thrownError = error; + } + if (thrownError != null) { + if (thrownError instanceof error_1.MongoWriteConcernError) { + mergeBatchResults(batch, bulkOperation.s.bulkResult, thrownError, result); + const writeResult3 = new BulkWriteResult(bulkOperation.s.bulkResult, bulkOperation.isOrdered); + throw new MongoBulkWriteError({ + message: thrownError.result.writeConcernError.errmsg, + code: thrownError.result.writeConcernError.code + }, writeResult3); + } else { + throw new MongoBulkWriteError(thrownError, new BulkWriteResult(bulkOperation.s.bulkResult, bulkOperation.isOrdered)); + } + } + mergeBatchResults(batch, bulkOperation.s.bulkResult, thrownError, result); + const writeResult2 = new BulkWriteResult(bulkOperation.s.bulkResult, bulkOperation.isOrdered); + bulkOperation.handleWriteError(writeResult2); + } + bulkOperation.s.batches.length = 0; + const writeResult = new BulkWriteResult(bulkOperation.s.bulkResult, bulkOperation.isOrdered); + bulkOperation.handleWriteError(writeResult); + return writeResult; + } + var MongoBulkWriteError = class extends error_1.MongoServerError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(error, result) { + super(error); + this.writeErrors = []; + if (error instanceof WriteConcernError) + this.err = error; + else if (!(error instanceof Error)) { + this.message = error.message; + this.code = error.code; + this.writeErrors = error.writeErrors ?? []; + } + this.result = result; + Object.assign(this, error); + } + get name() { + return "MongoBulkWriteError"; + } + /** Number of documents inserted. */ + get insertedCount() { + return this.result.insertedCount; + } + /** Number of documents matched for update. */ + get matchedCount() { + return this.result.matchedCount; + } + /** Number of documents modified. */ + get modifiedCount() { + return this.result.modifiedCount; + } + /** Number of documents deleted. */ + get deletedCount() { + return this.result.deletedCount; + } + /** Number of documents upserted. */ + get upsertedCount() { + return this.result.upsertedCount; + } + /** Inserted document generated Id's, hash key is the index of the originating operation */ + get insertedIds() { + return this.result.insertedIds; + } + /** Upserted document generated Id's, hash key is the index of the originating operation */ + get upsertedIds() { + return this.result.upsertedIds; + } + }; + exports2.MongoBulkWriteError = MongoBulkWriteError; + var FindOperators = class { + /** + * Creates a new FindOperators object. + * @internal + */ + constructor(bulkOperation) { + this.bulkOperation = bulkOperation; + } + /** Add a multiple update operation to the bulk operation */ + update(updateDocument) { + const currentOp = buildCurrentOp(this.bulkOperation); + return this.bulkOperation.addToOperationsList(exports2.BatchType.UPDATE, (0, update_1.makeUpdateStatement)(currentOp.selector, updateDocument, { + ...currentOp, + multi: true + })); + } + /** Add a single update operation to the bulk operation */ + updateOne(updateDocument) { + if (!(0, utils_1.hasAtomicOperators)(updateDocument, this.bulkOperation.bsonOptions)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + const currentOp = buildCurrentOp(this.bulkOperation); + return this.bulkOperation.addToOperationsList(exports2.BatchType.UPDATE, (0, update_1.makeUpdateStatement)(currentOp.selector, updateDocument, { ...currentOp, multi: false })); + } + /** Add a replace one operation to the bulk operation */ + replaceOne(replacement) { + if ((0, utils_1.hasAtomicOperators)(replacement)) { + throw new error_1.MongoInvalidArgumentError("Replacement document must not use atomic operators"); + } + const currentOp = buildCurrentOp(this.bulkOperation); + return this.bulkOperation.addToOperationsList(exports2.BatchType.UPDATE, (0, update_1.makeUpdateStatement)(currentOp.selector, replacement, { ...currentOp, multi: false })); + } + /** Add a delete one operation to the bulk operation */ + deleteOne() { + const currentOp = buildCurrentOp(this.bulkOperation); + return this.bulkOperation.addToOperationsList(exports2.BatchType.DELETE, (0, delete_1.makeDeleteStatement)(currentOp.selector, { ...currentOp, limit: 1 })); + } + /** Add a delete many operation to the bulk operation */ + delete() { + const currentOp = buildCurrentOp(this.bulkOperation); + return this.bulkOperation.addToOperationsList(exports2.BatchType.DELETE, (0, delete_1.makeDeleteStatement)(currentOp.selector, { ...currentOp, limit: 0 })); + } + /** Upsert modifier for update bulk operation, noting that this operation is an upsert. */ + upsert() { + if (!this.bulkOperation.s.currentOp) { + this.bulkOperation.s.currentOp = {}; + } + this.bulkOperation.s.currentOp.upsert = true; + return this; + } + /** Specifies the collation for the query condition. */ + collation(collation) { + if (!this.bulkOperation.s.currentOp) { + this.bulkOperation.s.currentOp = {}; + } + this.bulkOperation.s.currentOp.collation = collation; + return this; + } + /** Specifies arrayFilters for UpdateOne or UpdateMany bulk operations. */ + arrayFilters(arrayFilters) { + if (!this.bulkOperation.s.currentOp) { + this.bulkOperation.s.currentOp = {}; + } + this.bulkOperation.s.currentOp.arrayFilters = arrayFilters; + return this; + } + /** Specifies hint for the bulk operation. */ + hint(hint) { + if (!this.bulkOperation.s.currentOp) { + this.bulkOperation.s.currentOp = {}; + } + this.bulkOperation.s.currentOp.hint = hint; + return this; + } + }; + exports2.FindOperators = FindOperators; + var BulkOperationBase = class { + /** + * Create a new OrderedBulkOperation or UnorderedBulkOperation instance + * @internal + */ + constructor(collection, options, isOrdered) { + this.collection = collection; + this.isOrdered = isOrdered; + const topology = (0, utils_1.getTopology)(collection); + options = options == null ? {} : options; + const namespace = collection.s.namespace; + const executed = false; + const currentOp = void 0; + const hello = topology.lastHello(); + const usingAutoEncryption = !!(topology.s.options && topology.s.options.autoEncrypter); + const maxBsonObjectSize = hello && hello.maxBsonObjectSize ? hello.maxBsonObjectSize : 1024 * 1024 * 16; + const maxBatchSizeBytes = usingAutoEncryption ? 1024 * 1024 * 2 : maxBsonObjectSize; + const maxWriteBatchSize = hello && hello.maxWriteBatchSize ? hello.maxWriteBatchSize : 1e3; + const maxKeySize = (maxWriteBatchSize - 1).toString(10).length + 2; + let finalOptions = Object.assign({}, options); + finalOptions = (0, utils_1.applyRetryableWrites)(finalOptions, collection.db); + const bulkResult = { + ok: 1, + writeErrors: [], + writeConcernErrors: [], + insertedIds: [], + nInserted: 0, + nUpserted: 0, + nMatched: 0, + nModified: 0, + nRemoved: 0, + upserted: [] + }; + this.s = { + // Final result + bulkResult, + // Current batch state + currentBatch: void 0, + currentIndex: 0, + // ordered specific + currentBatchSize: 0, + currentBatchSizeBytes: 0, + // unordered specific + currentInsertBatch: void 0, + currentUpdateBatch: void 0, + currentRemoveBatch: void 0, + batches: [], + // Write concern + writeConcern: write_concern_1.WriteConcern.fromOptions(options), + // Max batch size options + maxBsonObjectSize, + maxBatchSizeBytes, + maxWriteBatchSize, + maxKeySize, + // Namespace + namespace, + // Topology + topology, + // Options + options: finalOptions, + // BSON options + bsonOptions: (0, bson_1.resolveBSONOptions)(options), + // Current operation + currentOp, + // Executed + executed, + // Collection + collection, + // Fundamental error + err: void 0, + // check keys + checkKeys: typeof options.checkKeys === "boolean" ? options.checkKeys : false + }; + if (options.bypassDocumentValidation === true) { + this.s.bypassDocumentValidation = true; + } + } + /** + * Add a single insert document to the bulk operation + * + * @example + * ```ts + * const bulkOp = collection.initializeOrderedBulkOp(); + * + * // Adds three inserts to the bulkOp. + * bulkOp + * .insert({ a: 1 }) + * .insert({ b: 2 }) + * .insert({ c: 3 }); + * await bulkOp.execute(); + * ``` + */ + insert(document) { + (0, utils_1.maybeAddIdToDocuments)(this.collection, document, { + forceServerObjectId: this.shouldForceServerObjectId() + }); + return this.addToOperationsList(exports2.BatchType.INSERT, document); + } + /** + * Builds a find operation for an update/updateOne/delete/deleteOne/replaceOne. + * Returns a builder object used to complete the definition of the operation. + * + * @example + * ```ts + * const bulkOp = collection.initializeOrderedBulkOp(); + * + * // Add an updateOne to the bulkOp + * bulkOp.find({ a: 1 }).updateOne({ $set: { b: 2 } }); + * + * // Add an updateMany to the bulkOp + * bulkOp.find({ c: 3 }).update({ $set: { d: 4 } }); + * + * // Add an upsert + * bulkOp.find({ e: 5 }).upsert().updateOne({ $set: { f: 6 } }); + * + * // Add a deletion + * bulkOp.find({ g: 7 }).deleteOne(); + * + * // Add a multi deletion + * bulkOp.find({ h: 8 }).delete(); + * + * // Add a replaceOne + * bulkOp.find({ i: 9 }).replaceOne({writeConcern: { j: 10 }}); + * + * // Update using a pipeline (requires Mongodb 4.2 or higher) + * bulk.find({ k: 11, y: { $exists: true }, z: { $exists: true } }).updateOne([ + * { $set: { total: { $sum: [ '$y', '$z' ] } } } + * ]); + * + * // All of the ops will now be executed + * await bulkOp.execute(); + * ``` + */ + find(selector) { + if (!selector) { + throw new error_1.MongoInvalidArgumentError("Bulk find operation must specify a selector"); + } + this.s.currentOp = { + selector + }; + return new FindOperators(this); + } + /** Specifies a raw operation to perform in the bulk write. */ + raw(op) { + if (op == null || typeof op !== "object") { + throw new error_1.MongoInvalidArgumentError("Operation must be an object with an operation key"); + } + if ("insertOne" in op) { + const forceServerObjectId = this.shouldForceServerObjectId(); + const document = op.insertOne && op.insertOne.document == null ? ( + // TODO(NODE-6003): remove support for omitting the `documents` subdocument in bulk inserts + op.insertOne + ) : op.insertOne.document; + (0, utils_1.maybeAddIdToDocuments)(this.collection, document, { forceServerObjectId }); + return this.addToOperationsList(exports2.BatchType.INSERT, document); + } + if ("replaceOne" in op || "updateOne" in op || "updateMany" in op) { + if ("replaceOne" in op) { + if ("q" in op.replaceOne) { + throw new error_1.MongoInvalidArgumentError("Raw operations are not allowed"); + } + const updateStatement = (0, update_1.makeUpdateStatement)(op.replaceOne.filter, op.replaceOne.replacement, { ...op.replaceOne, multi: false }); + if ((0, utils_1.hasAtomicOperators)(updateStatement.u)) { + throw new error_1.MongoInvalidArgumentError("Replacement document must not use atomic operators"); + } + return this.addToOperationsList(exports2.BatchType.UPDATE, updateStatement); + } + if ("updateOne" in op) { + if ("q" in op.updateOne) { + throw new error_1.MongoInvalidArgumentError("Raw operations are not allowed"); + } + const updateStatement = (0, update_1.makeUpdateStatement)(op.updateOne.filter, op.updateOne.update, { + ...op.updateOne, + multi: false + }); + if (!(0, utils_1.hasAtomicOperators)(updateStatement.u, this.bsonOptions)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + return this.addToOperationsList(exports2.BatchType.UPDATE, updateStatement); + } + if ("updateMany" in op) { + if ("q" in op.updateMany) { + throw new error_1.MongoInvalidArgumentError("Raw operations are not allowed"); + } + const updateStatement = (0, update_1.makeUpdateStatement)(op.updateMany.filter, op.updateMany.update, { + ...op.updateMany, + multi: true + }); + if (!(0, utils_1.hasAtomicOperators)(updateStatement.u, this.bsonOptions)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + return this.addToOperationsList(exports2.BatchType.UPDATE, updateStatement); + } + } + if ("deleteOne" in op) { + if ("q" in op.deleteOne) { + throw new error_1.MongoInvalidArgumentError("Raw operations are not allowed"); + } + return this.addToOperationsList(exports2.BatchType.DELETE, (0, delete_1.makeDeleteStatement)(op.deleteOne.filter, { ...op.deleteOne, limit: 1 })); + } + if ("deleteMany" in op) { + if ("q" in op.deleteMany) { + throw new error_1.MongoInvalidArgumentError("Raw operations are not allowed"); + } + return this.addToOperationsList(exports2.BatchType.DELETE, (0, delete_1.makeDeleteStatement)(op.deleteMany.filter, { ...op.deleteMany, limit: 0 })); + } + throw new error_1.MongoInvalidArgumentError("bulkWrite only supports insertOne, updateOne, updateMany, deleteOne, deleteMany"); + } + get length() { + return this.s.currentIndex; + } + get bsonOptions() { + return this.s.bsonOptions; + } + get writeConcern() { + return this.s.writeConcern; + } + get batches() { + const batches = [...this.s.batches]; + if (this.isOrdered) { + if (this.s.currentBatch) + batches.push(this.s.currentBatch); + } else { + if (this.s.currentInsertBatch) + batches.push(this.s.currentInsertBatch); + if (this.s.currentUpdateBatch) + batches.push(this.s.currentUpdateBatch); + if (this.s.currentRemoveBatch) + batches.push(this.s.currentRemoveBatch); + } + return batches; + } + async execute(options = {}) { + if (this.s.executed) { + throw new error_1.MongoBatchReExecutionError(); + } + const writeConcern = write_concern_1.WriteConcern.fromOptions(options); + if (writeConcern) { + this.s.writeConcern = writeConcern; + } + if (this.isOrdered) { + if (this.s.currentBatch) + this.s.batches.push(this.s.currentBatch); + } else { + if (this.s.currentInsertBatch) + this.s.batches.push(this.s.currentInsertBatch); + if (this.s.currentUpdateBatch) + this.s.batches.push(this.s.currentUpdateBatch); + if (this.s.currentRemoveBatch) + this.s.batches.push(this.s.currentRemoveBatch); + } + if (this.s.batches.length === 0) { + throw new error_1.MongoInvalidArgumentError("Invalid BulkOperation, Batch cannot be empty"); + } + this.s.executed = true; + const finalOptions = (0, utils_1.resolveOptions)(this.collection, { ...this.s.options, ...options }); + finalOptions.timeoutContext ??= timeout_1.TimeoutContext.create({ + session: finalOptions.session, + timeoutMS: finalOptions.timeoutMS, + serverSelectionTimeoutMS: this.collection.client.s.options.serverSelectionTimeoutMS, + waitQueueTimeoutMS: this.collection.client.s.options.waitQueueTimeoutMS + }); + if (finalOptions.session == null) { + return await this.collection.client.withSession({ explicit: false }, async (session) => { + return await executeCommands(this, { ...finalOptions, session }); + }); + } + return await executeCommands(this, { ...finalOptions }); + } + /** + * Handles the write error before executing commands + * @internal + */ + handleWriteError(writeResult) { + if (this.s.bulkResult.writeErrors.length > 0) { + const msg = this.s.bulkResult.writeErrors[0].errmsg ? this.s.bulkResult.writeErrors[0].errmsg : "write operation failed"; + throw new MongoBulkWriteError({ + message: msg, + code: this.s.bulkResult.writeErrors[0].code, + writeErrors: this.s.bulkResult.writeErrors + }, writeResult); + } + const writeConcernError = writeResult.getWriteConcernError(); + if (writeConcernError) { + throw new MongoBulkWriteError(writeConcernError, writeResult); + } + } + shouldForceServerObjectId() { + return this.s.options.forceServerObjectId === true || this.s.collection.db.options?.forceServerObjectId === true; + } + }; + exports2.BulkOperationBase = BulkOperationBase; + function isInsertBatch(batch) { + return batch.batchType === exports2.BatchType.INSERT; + } + function isUpdateBatch(batch) { + return batch.batchType === exports2.BatchType.UPDATE; + } + function isDeleteBatch(batch) { + return batch.batchType === exports2.BatchType.DELETE; + } + function buildCurrentOp(bulkOp) { + let { currentOp } = bulkOp.s; + bulkOp.s.currentOp = void 0; + if (!currentOp) + currentOp = {}; + return currentOp; + } + } +}); + +// node_modules/mongodb/lib/bulk/ordered.js +var require_ordered = __commonJS({ + "node_modules/mongodb/lib/bulk/ordered.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.OrderedBulkOperation = void 0; + var BSON = require_bson2(); + var error_1 = require_error(); + var common_1 = require_common2(); + var OrderedBulkOperation = class extends common_1.BulkOperationBase { + /** @internal */ + constructor(collection, options) { + super(collection, options, true); + } + addToOperationsList(batchType, document) { + const bsonSize = BSON.calculateObjectSize(document, { + checkKeys: false, + // Since we don't know what the user selected for BSON options here, + // err on the safe side, and check the size with ignoreUndefined: false. + ignoreUndefined: false + }); + if (bsonSize >= this.s.maxBsonObjectSize) + throw new error_1.MongoInvalidArgumentError(`Document is larger than the maximum size ${this.s.maxBsonObjectSize}`); + if (this.s.currentBatch == null) { + this.s.currentBatch = new common_1.Batch(batchType, this.s.currentIndex); + } + const maxKeySize = this.s.maxKeySize; + if ( + // New batch if we exceed the max batch op size + this.s.currentBatchSize + 1 >= this.s.maxWriteBatchSize || // New batch if we exceed the maxBatchSizeBytes. Only matters if batch already has a doc, + // since we can't sent an empty batch + this.s.currentBatchSize > 0 && this.s.currentBatchSizeBytes + maxKeySize + bsonSize >= this.s.maxBatchSizeBytes || // New batch if the new op does not have the same op type as the current batch + this.s.currentBatch.batchType !== batchType + ) { + this.s.batches.push(this.s.currentBatch); + this.s.currentBatch = new common_1.Batch(batchType, this.s.currentIndex); + this.s.currentBatchSize = 0; + this.s.currentBatchSizeBytes = 0; + } + if (batchType === common_1.BatchType.INSERT) { + this.s.bulkResult.insertedIds.push({ + index: this.s.currentIndex, + _id: document._id + }); + } + if (Array.isArray(document)) { + throw new error_1.MongoInvalidArgumentError("Operation passed in cannot be an Array"); + } + this.s.currentBatch.originalIndexes.push(this.s.currentIndex); + this.s.currentBatch.operations.push(document); + this.s.currentBatchSize += 1; + this.s.currentBatchSizeBytes += maxKeySize + bsonSize; + this.s.currentIndex += 1; + return this; + } + }; + exports2.OrderedBulkOperation = OrderedBulkOperation; + } +}); + +// node_modules/mongodb/lib/bulk/unordered.js +var require_unordered = __commonJS({ + "node_modules/mongodb/lib/bulk/unordered.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.UnorderedBulkOperation = void 0; + var BSON = require_bson2(); + var error_1 = require_error(); + var common_1 = require_common2(); + var UnorderedBulkOperation = class extends common_1.BulkOperationBase { + /** @internal */ + constructor(collection, options) { + super(collection, options, false); + } + handleWriteError(writeResult) { + if (this.s.batches.length) { + return; + } + return super.handleWriteError(writeResult); + } + addToOperationsList(batchType, document) { + const bsonSize = BSON.calculateObjectSize(document, { + checkKeys: false, + // Since we don't know what the user selected for BSON options here, + // err on the safe side, and check the size with ignoreUndefined: false. + ignoreUndefined: false + }); + if (bsonSize >= this.s.maxBsonObjectSize) { + throw new error_1.MongoInvalidArgumentError(`Document is larger than the maximum size ${this.s.maxBsonObjectSize}`); + } + this.s.currentBatch = void 0; + if (batchType === common_1.BatchType.INSERT) { + this.s.currentBatch = this.s.currentInsertBatch; + } else if (batchType === common_1.BatchType.UPDATE) { + this.s.currentBatch = this.s.currentUpdateBatch; + } else if (batchType === common_1.BatchType.DELETE) { + this.s.currentBatch = this.s.currentRemoveBatch; + } + const maxKeySize = this.s.maxKeySize; + if (this.s.currentBatch == null) { + this.s.currentBatch = new common_1.Batch(batchType, this.s.currentIndex); + } + if ( + // New batch if we exceed the max batch op size + this.s.currentBatch.size + 1 >= this.s.maxWriteBatchSize || // New batch if we exceed the maxBatchSizeBytes. Only matters if batch already has a doc, + // since we can't sent an empty batch + this.s.currentBatch.size > 0 && this.s.currentBatch.sizeBytes + maxKeySize + bsonSize >= this.s.maxBatchSizeBytes || // New batch if the new op does not have the same op type as the current batch + this.s.currentBatch.batchType !== batchType + ) { + this.s.batches.push(this.s.currentBatch); + this.s.currentBatch = new common_1.Batch(batchType, this.s.currentIndex); + } + if (Array.isArray(document)) { + throw new error_1.MongoInvalidArgumentError("Operation passed in cannot be an Array"); + } + this.s.currentBatch.operations.push(document); + this.s.currentBatch.originalIndexes.push(this.s.currentIndex); + this.s.currentIndex = this.s.currentIndex + 1; + if (batchType === common_1.BatchType.INSERT) { + this.s.currentInsertBatch = this.s.currentBatch; + this.s.bulkResult.insertedIds.push({ + index: this.s.bulkResult.insertedIds.length, + _id: document._id + }); + } else if (batchType === common_1.BatchType.UPDATE) { + this.s.currentUpdateBatch = this.s.currentBatch; + } else if (batchType === common_1.BatchType.DELETE) { + this.s.currentRemoveBatch = this.s.currentBatch; + } + this.s.currentBatch.size += 1; + this.s.currentBatch.sizeBytes += maxKeySize + bsonSize; + return this; + } + }; + exports2.UnorderedBulkOperation = UnorderedBulkOperation; + } +}); + +// node_modules/mongodb/lib/mongo_logger.js +var require_mongo_logger = __commonJS({ + "node_modules/mongodb/lib/mongo_logger.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoLogger = exports2.MongoLoggableComponent = exports2.SEVERITY_LEVEL_MAP = exports2.DEFAULT_MAX_DOCUMENT_LENGTH = exports2.SeverityLevel = void 0; + exports2.parseSeverityFromString = parseSeverityFromString; + exports2.createStdioLogger = createStdioLogger; + exports2.stringifyWithMaxLen = stringifyWithMaxLen; + exports2.defaultLogTransform = defaultLogTransform; + var util_1 = require("util"); + var bson_1 = require_bson2(); + var constants_1 = require_constants2(); + var utils_1 = require_utils3(); + exports2.SeverityLevel = Object.freeze({ + EMERGENCY: "emergency", + ALERT: "alert", + CRITICAL: "critical", + ERROR: "error", + WARNING: "warn", + NOTICE: "notice", + INFORMATIONAL: "info", + DEBUG: "debug", + TRACE: "trace", + OFF: "off" + }); + exports2.DEFAULT_MAX_DOCUMENT_LENGTH = 1e3; + var SeverityLevelMap = class extends Map { + constructor(entries) { + const newEntries = []; + for (const [level, value] of entries) { + newEntries.push([value, level]); + } + newEntries.push(...entries); + super(newEntries); + } + getNumericSeverityLevel(severity) { + return this.get(severity); + } + getSeverityLevelName(level) { + return this.get(level); + } + }; + exports2.SEVERITY_LEVEL_MAP = new SeverityLevelMap([ + [exports2.SeverityLevel.OFF, -Infinity], + [exports2.SeverityLevel.EMERGENCY, 0], + [exports2.SeverityLevel.ALERT, 1], + [exports2.SeverityLevel.CRITICAL, 2], + [exports2.SeverityLevel.ERROR, 3], + [exports2.SeverityLevel.WARNING, 4], + [exports2.SeverityLevel.NOTICE, 5], + [exports2.SeverityLevel.INFORMATIONAL, 6], + [exports2.SeverityLevel.DEBUG, 7], + [exports2.SeverityLevel.TRACE, 8] + ]); + exports2.MongoLoggableComponent = Object.freeze({ + COMMAND: "command", + TOPOLOGY: "topology", + SERVER_SELECTION: "serverSelection", + CONNECTION: "connection", + CLIENT: "client" + }); + function parseSeverityFromString(s) { + const validSeverities = Object.values(exports2.SeverityLevel); + const lowerSeverity = s?.toLowerCase(); + if (lowerSeverity != null && validSeverities.includes(lowerSeverity)) { + return lowerSeverity; + } + return null; + } + function createStdioLogger(stream) { + return { + write: (0, util_1.promisify)((log2, cb) => { + const logLine = (0, util_1.inspect)(log2, { compact: true, breakLength: Infinity }); + stream.write(`${logLine} +`, "utf-8", cb); + return; + }) + }; + } + function resolveLogPath({ MONGODB_LOG_PATH }, { mongodbLogPath }) { + if (typeof mongodbLogPath === "string" && /^stderr$/i.test(mongodbLogPath)) { + return { mongodbLogPath: createStdioLogger(process.stderr), mongodbLogPathIsStdErr: true }; + } + if (typeof mongodbLogPath === "string" && /^stdout$/i.test(mongodbLogPath)) { + return { mongodbLogPath: createStdioLogger(process.stdout), mongodbLogPathIsStdErr: false }; + } + if (typeof mongodbLogPath === "object" && typeof mongodbLogPath?.write === "function") { + return { mongodbLogPath, mongodbLogPathIsStdErr: false }; + } + if (MONGODB_LOG_PATH && /^stderr$/i.test(MONGODB_LOG_PATH)) { + return { mongodbLogPath: createStdioLogger(process.stderr), mongodbLogPathIsStdErr: true }; + } + if (MONGODB_LOG_PATH && /^stdout$/i.test(MONGODB_LOG_PATH)) { + return { mongodbLogPath: createStdioLogger(process.stdout), mongodbLogPathIsStdErr: false }; + } + return { mongodbLogPath: createStdioLogger(process.stderr), mongodbLogPathIsStdErr: true }; + } + function resolveSeverityConfiguration(clientOption, environmentOption, defaultSeverity) { + return parseSeverityFromString(clientOption) ?? parseSeverityFromString(environmentOption) ?? defaultSeverity; + } + function compareSeverity(s0, s1) { + const s0Num = exports2.SEVERITY_LEVEL_MAP.getNumericSeverityLevel(s0); + const s1Num = exports2.SEVERITY_LEVEL_MAP.getNumericSeverityLevel(s1); + return s0Num < s1Num ? -1 : s0Num > s1Num ? 1 : 0; + } + function stringifyWithMaxLen(value, maxDocumentLength, options = {}) { + let strToTruncate = ""; + let currentLength = 0; + const maxDocumentLengthEnsurer = function maxDocumentLengthEnsurer2(key, value2) { + if (currentLength >= maxDocumentLength) { + return void 0; + } + if (key === "") { + currentLength += 1; + return value2; + } + currentLength += key.length + 4; + if (value2 == null) + return value2; + switch (typeof value2) { + case "string": + currentLength += value2.length + 2; + break; + case "number": + case "bigint": + currentLength += String(value2).length; + break; + case "boolean": + currentLength += value2 ? 4 : 5; + break; + case "object": + if ((0, utils_1.isUint8Array)(value2)) { + currentLength += 22 + value2.byteLength + value2.byteLength * 0.33 + 18 | 0; + } else if ("_bsontype" in value2) { + const v = value2; + switch (v._bsontype) { + case "Int32": + currentLength += String(v.value).length; + break; + case "Double": + currentLength += (v.value | 0) === v.value ? String(v.value).length + 2 : String(v.value).length; + break; + case "Long": + currentLength += v.toString().length; + break; + case "ObjectId": + currentLength += 35; + break; + case "MaxKey": + case "MinKey": + currentLength += 13; + break; + case "Binary": + currentLength += 22 + value2.position + value2.position * 0.33 + 18 | 0; + break; + case "Timestamp": + currentLength += 19 + String(v.t).length + 5 + String(v.i).length + 2; + break; + case "Code": + if (v.scope == null) { + currentLength += v.code.length + 10 + 2; + } else { + currentLength += v.code.length + 10 + 11; + } + break; + case "BSONRegExp": + currentLength += 34 + v.pattern.length + 13 + v.options.length + 3; + break; + } + } + } + return value2; + }; + if (typeof value === "string") { + strToTruncate = value; + } else if (typeof value === "function") { + strToTruncate = value.name; + } else { + try { + if (maxDocumentLength !== 0) { + strToTruncate = bson_1.EJSON.stringify(value, maxDocumentLengthEnsurer, 0, options); + } else { + strToTruncate = bson_1.EJSON.stringify(value, options); + } + } catch (e) { + strToTruncate = `Extended JSON serialization failed with: ${e.message}`; + } + } + if (maxDocumentLength !== 0 && strToTruncate.length > maxDocumentLength && strToTruncate.charCodeAt(maxDocumentLength - 1) !== strToTruncate.codePointAt(maxDocumentLength - 1)) { + maxDocumentLength--; + if (maxDocumentLength === 0) { + return ""; + } + } + return maxDocumentLength !== 0 && strToTruncate.length > maxDocumentLength ? `${strToTruncate.slice(0, maxDocumentLength)}...` : strToTruncate; + } + function isLogConvertible(obj) { + const objAsLogConvertible = obj; + return objAsLogConvertible.toLog !== void 0 && typeof objAsLogConvertible.toLog === "function"; + } + function attachServerSelectionFields(log2, serverSelectionEvent, maxDocumentLength = exports2.DEFAULT_MAX_DOCUMENT_LENGTH) { + const { selector, operation, topologyDescription, message } = serverSelectionEvent; + log2.selector = stringifyWithMaxLen(selector, maxDocumentLength); + log2.operation = operation; + log2.topologyDescription = stringifyWithMaxLen(topologyDescription, maxDocumentLength); + log2.message = message; + return log2; + } + function attachCommandFields(log2, commandEvent) { + log2.commandName = commandEvent.commandName; + log2.requestId = commandEvent.requestId; + log2.driverConnectionId = commandEvent.connectionId; + const { host, port } = utils_1.HostAddress.fromString(commandEvent.address).toHostPort(); + log2.serverHost = host; + log2.serverPort = port; + if (commandEvent?.serviceId) { + log2.serviceId = commandEvent.serviceId.toHexString(); + } + log2.databaseName = commandEvent.databaseName; + log2.serverConnectionId = commandEvent.serverConnectionId; + return log2; + } + function attachConnectionFields(log2, event) { + const { host, port } = utils_1.HostAddress.fromString(event.address).toHostPort(); + log2.serverHost = host; + log2.serverPort = port; + return log2; + } + function attachSDAMFields(log2, sdamEvent) { + log2.topologyId = sdamEvent.topologyId; + return log2; + } + function attachServerHeartbeatFields(log2, serverHeartbeatEvent) { + const { awaited, connectionId } = serverHeartbeatEvent; + log2.awaited = awaited; + log2.driverConnectionId = serverHeartbeatEvent.connectionId; + const { host, port } = utils_1.HostAddress.fromString(connectionId).toHostPort(); + log2.serverHost = host; + log2.serverPort = port; + return log2; + } + function defaultLogTransform(logObject, maxDocumentLength = exports2.DEFAULT_MAX_DOCUMENT_LENGTH) { + let log2 = /* @__PURE__ */ Object.create(null); + switch (logObject.name) { + case constants_1.SERVER_SELECTION_STARTED: + log2 = attachServerSelectionFields(log2, logObject, maxDocumentLength); + return log2; + case constants_1.SERVER_SELECTION_FAILED: + log2 = attachServerSelectionFields(log2, logObject, maxDocumentLength); + log2.failure = logObject.failure?.message; + return log2; + case constants_1.SERVER_SELECTION_SUCCEEDED: + log2 = attachServerSelectionFields(log2, logObject, maxDocumentLength); + log2.serverHost = logObject.serverHost; + log2.serverPort = logObject.serverPort; + return log2; + case constants_1.WAITING_FOR_SUITABLE_SERVER: + log2 = attachServerSelectionFields(log2, logObject, maxDocumentLength); + log2.remainingTimeMS = logObject.remainingTimeMS; + return log2; + case constants_1.COMMAND_STARTED: + log2 = attachCommandFields(log2, logObject); + log2.message = "Command started"; + log2.command = stringifyWithMaxLen(logObject.command, maxDocumentLength, { relaxed: true }); + log2.databaseName = logObject.databaseName; + return log2; + case constants_1.COMMAND_SUCCEEDED: + log2 = attachCommandFields(log2, logObject); + log2.message = "Command succeeded"; + log2.durationMS = logObject.duration; + log2.reply = stringifyWithMaxLen(logObject.reply, maxDocumentLength, { relaxed: true }); + return log2; + case constants_1.COMMAND_FAILED: + log2 = attachCommandFields(log2, logObject); + log2.message = "Command failed"; + log2.durationMS = logObject.duration; + log2.failure = logObject.failure?.message ?? "(redacted)"; + return log2; + case constants_1.CONNECTION_POOL_CREATED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection pool created"; + if (logObject.options) { + const { maxIdleTimeMS, minPoolSize, maxPoolSize, maxConnecting, waitQueueTimeoutMS } = logObject.options; + log2 = { + ...log2, + maxIdleTimeMS, + minPoolSize, + maxPoolSize, + maxConnecting, + waitQueueTimeoutMS + }; + } + return log2; + case constants_1.CONNECTION_POOL_READY: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection pool ready"; + return log2; + case constants_1.CONNECTION_POOL_CLEARED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection pool cleared"; + if (logObject.serviceId?._bsontype === "ObjectId") { + log2.serviceId = logObject.serviceId?.toHexString(); + } + return log2; + case constants_1.CONNECTION_POOL_CLOSED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection pool closed"; + return log2; + case constants_1.CONNECTION_CREATED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection created"; + log2.driverConnectionId = logObject.connectionId; + return log2; + case constants_1.CONNECTION_READY: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection ready"; + log2.driverConnectionId = logObject.connectionId; + log2.durationMS = logObject.durationMS; + return log2; + case constants_1.CONNECTION_CLOSED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection closed"; + log2.driverConnectionId = logObject.connectionId; + switch (logObject.reason) { + case "stale": + log2.reason = "Connection became stale because the pool was cleared"; + break; + case "idle": + log2.reason = "Connection has been available but unused for longer than the configured max idle time"; + break; + case "error": + log2.reason = "An error occurred while using the connection"; + if (logObject.error) { + log2.error = logObject.error; + } + break; + case "poolClosed": + log2.reason = "Connection pool was closed"; + break; + default: + log2.reason = `Unknown close reason: ${logObject.reason}`; + } + return log2; + case constants_1.CONNECTION_CHECK_OUT_STARTED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection checkout started"; + return log2; + case constants_1.CONNECTION_CHECK_OUT_FAILED: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection checkout failed"; + switch (logObject.reason) { + case "poolClosed": + log2.reason = "Connection pool was closed"; + break; + case "timeout": + log2.reason = "Wait queue timeout elapsed without a connection becoming available"; + break; + case "connectionError": + log2.reason = "An error occurred while trying to establish a new connection"; + if (logObject.error) { + log2.error = logObject.error; + } + break; + default: + log2.reason = `Unknown close reason: ${logObject.reason}`; + } + log2.durationMS = logObject.durationMS; + return log2; + case constants_1.CONNECTION_CHECKED_OUT: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection checked out"; + log2.driverConnectionId = logObject.connectionId; + log2.durationMS = logObject.durationMS; + return log2; + case constants_1.CONNECTION_CHECKED_IN: + log2 = attachConnectionFields(log2, logObject); + log2.message = "Connection checked in"; + log2.driverConnectionId = logObject.connectionId; + return log2; + case constants_1.SERVER_OPENING: + log2 = attachSDAMFields(log2, logObject); + log2 = attachConnectionFields(log2, logObject); + log2.message = "Starting server monitoring"; + return log2; + case constants_1.SERVER_CLOSED: + log2 = attachSDAMFields(log2, logObject); + log2 = attachConnectionFields(log2, logObject); + log2.message = "Stopped server monitoring"; + return log2; + case constants_1.SERVER_HEARTBEAT_STARTED: + log2 = attachSDAMFields(log2, logObject); + log2 = attachServerHeartbeatFields(log2, logObject); + log2.message = "Server heartbeat started"; + return log2; + case constants_1.SERVER_HEARTBEAT_SUCCEEDED: + log2 = attachSDAMFields(log2, logObject); + log2 = attachServerHeartbeatFields(log2, logObject); + log2.message = "Server heartbeat succeeded"; + log2.durationMS = logObject.duration; + log2.serverConnectionId = logObject.serverConnectionId; + log2.reply = stringifyWithMaxLen(logObject.reply, maxDocumentLength, { relaxed: true }); + return log2; + case constants_1.SERVER_HEARTBEAT_FAILED: + log2 = attachSDAMFields(log2, logObject); + log2 = attachServerHeartbeatFields(log2, logObject); + log2.message = "Server heartbeat failed"; + log2.durationMS = logObject.duration; + log2.failure = logObject.failure?.message; + return log2; + case constants_1.TOPOLOGY_OPENING: + log2 = attachSDAMFields(log2, logObject); + log2.message = "Starting topology monitoring"; + return log2; + case constants_1.TOPOLOGY_CLOSED: + log2 = attachSDAMFields(log2, logObject); + log2.message = "Stopped topology monitoring"; + return log2; + case constants_1.TOPOLOGY_DESCRIPTION_CHANGED: + log2 = attachSDAMFields(log2, logObject); + log2.message = "Topology description changed"; + log2.previousDescription = log2.reply = stringifyWithMaxLen(logObject.previousDescription, maxDocumentLength); + log2.newDescription = log2.reply = stringifyWithMaxLen(logObject.newDescription, maxDocumentLength); + return log2; + default: + for (const [key, value] of Object.entries(logObject)) { + if (value != null) + log2[key] = value; + } + } + return log2; + } + var MongoLogger = class { + constructor(options) { + this.pendingLog = null; + this.error = this.log.bind(this, "error"); + this.warn = this.log.bind(this, "warn"); + this.info = this.log.bind(this, "info"); + this.debug = this.log.bind(this, "debug"); + this.trace = this.log.bind(this, "trace"); + this.componentSeverities = options.componentSeverities; + this.maxDocumentLength = options.maxDocumentLength; + this.logDestination = options.logDestination; + this.logDestinationIsStdErr = options.logDestinationIsStdErr; + this.severities = this.createLoggingSeverities(); + } + createLoggingSeverities() { + const severities = Object(); + for (const component of Object.values(exports2.MongoLoggableComponent)) { + severities[component] = {}; + for (const severityLevel of Object.values(exports2.SeverityLevel)) { + severities[component][severityLevel] = compareSeverity(severityLevel, this.componentSeverities[component]) <= 0; + } + } + return severities; + } + turnOffSeverities() { + for (const component of Object.values(exports2.MongoLoggableComponent)) { + this.componentSeverities[component] = exports2.SeverityLevel.OFF; + for (const severityLevel of Object.values(exports2.SeverityLevel)) { + this.severities[component][severityLevel] = false; + } + } + } + logWriteFailureHandler(error) { + if (this.logDestinationIsStdErr) { + this.turnOffSeverities(); + this.clearPendingLog(); + return; + } + this.logDestination = createStdioLogger(process.stderr); + this.logDestinationIsStdErr = true; + this.clearPendingLog(); + this.error(exports2.MongoLoggableComponent.CLIENT, { + toLog: function() { + return { + message: "User input for mongodbLogPath is now invalid. Logging is halted.", + error: error.message + }; + } + }); + this.turnOffSeverities(); + this.clearPendingLog(); + } + clearPendingLog() { + this.pendingLog = null; + } + willLog(component, severity) { + if (severity === exports2.SeverityLevel.OFF) + return false; + return this.severities[component][severity]; + } + log(severity, component, message) { + if (!this.willLog(component, severity)) + return; + let logMessage = { t: /* @__PURE__ */ new Date(), c: component, s: severity }; + if (typeof message === "string") { + logMessage.message = message; + } else if (typeof message === "object") { + if (isLogConvertible(message)) { + logMessage = { ...logMessage, ...message.toLog() }; + } else { + logMessage = { ...logMessage, ...defaultLogTransform(message, this.maxDocumentLength) }; + } + } + if ((0, utils_1.isPromiseLike)(this.pendingLog)) { + this.pendingLog = this.pendingLog.then(() => this.logDestination.write(logMessage)).then(this.clearPendingLog.bind(this), this.logWriteFailureHandler.bind(this)); + return; + } + try { + const logResult = this.logDestination.write(logMessage); + if ((0, utils_1.isPromiseLike)(logResult)) { + this.pendingLog = logResult.then(this.clearPendingLog.bind(this), this.logWriteFailureHandler.bind(this)); + } + } catch (error) { + this.logWriteFailureHandler(error); + } + } + /** + * Merges options set through environment variables and the MongoClient, preferring environment + * variables when both are set, and substituting defaults for values not set. Options set in + * constructor take precedence over both environment variables and MongoClient options. + * + * @remarks + * When parsing component severity levels, invalid values are treated as unset and replaced with + * the default severity. + * + * @param envOptions - options set for the logger from the environment + * @param clientOptions - options set for the logger in the MongoClient options + * @returns a MongoLoggerOptions object to be used when instantiating a new MongoLogger + */ + static resolveOptions(envOptions, clientOptions) { + const resolvedLogPath = resolveLogPath(envOptions, clientOptions); + const combinedOptions = { + ...envOptions, + ...clientOptions, + mongodbLogPath: resolvedLogPath.mongodbLogPath, + mongodbLogPathIsStdErr: resolvedLogPath.mongodbLogPathIsStdErr + }; + const defaultSeverity = resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.default, combinedOptions.MONGODB_LOG_ALL, exports2.SeverityLevel.OFF); + return { + componentSeverities: { + command: resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.command, combinedOptions.MONGODB_LOG_COMMAND, defaultSeverity), + topology: resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.topology, combinedOptions.MONGODB_LOG_TOPOLOGY, defaultSeverity), + serverSelection: resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.serverSelection, combinedOptions.MONGODB_LOG_SERVER_SELECTION, defaultSeverity), + connection: resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.connection, combinedOptions.MONGODB_LOG_CONNECTION, defaultSeverity), + client: resolveSeverityConfiguration(combinedOptions.mongodbLogComponentSeverities?.client, combinedOptions.MONGODB_LOG_CLIENT, defaultSeverity), + default: defaultSeverity + }, + maxDocumentLength: combinedOptions.mongodbLogMaxDocumentLength ?? (0, utils_1.parseUnsignedInteger)(combinedOptions.MONGODB_LOG_MAX_DOCUMENT_LENGTH) ?? 1e3, + logDestination: combinedOptions.mongodbLogPath, + logDestinationIsStdErr: combinedOptions.mongodbLogPathIsStdErr + }; + } + }; + exports2.MongoLogger = MongoLogger; + } +}); + +// node_modules/mongodb/lib/mongo_types.js +var require_mongo_types = __commonJS({ + "node_modules/mongodb/lib/mongo_types.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CancellationToken = exports2.TypedEventEmitter = void 0; + var events_1 = require("events"); + var mongo_logger_1 = require_mongo_logger(); + var utils_1 = require_utils3(); + var TypedEventEmitter = class extends events_1.EventEmitter { + /** @internal */ + emitAndLog(event, ...args) { + this.emit(event, ...args); + if (this.component) + this.mongoLogger?.debug(this.component, args[0]); + } + /** @internal */ + emitAndLogHeartbeat(event, topologyId, serverConnectionId, ...args) { + this.emit(event, ...args); + if (this.component) { + const loggableHeartbeatEvent = { + topologyId, + serverConnectionId: serverConnectionId ?? null, + ...args[0] + }; + this.mongoLogger?.debug(this.component, loggableHeartbeatEvent); + } + } + /** @internal */ + emitAndLogCommand(monitorCommands, event, databaseName, connectionEstablished, ...args) { + if (monitorCommands) { + this.emit(event, ...args); + } + if (connectionEstablished) { + const loggableCommandEvent = { + databaseName, + ...args[0] + }; + this.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.COMMAND, loggableCommandEvent); + } + } + }; + exports2.TypedEventEmitter = TypedEventEmitter; + var CancellationToken = class extends TypedEventEmitter { + constructor(...args) { + super(...args); + this.on("error", utils_1.noop); + } + }; + exports2.CancellationToken = CancellationToken; + } +}); + +// node_modules/mongodb/lib/operations/get_more.js +var require_get_more = __commonJS({ + "node_modules/mongodb/lib/operations/get_more.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GetMoreOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var operation_1 = require_operation(); + var GetMoreOperation = class extends operation_1.AbstractOperation { + constructor(ns, cursorId, server, options) { + super(options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + this.options = options; + this.ns = ns; + this.cursorId = cursorId; + this.server = server; + } + get commandName() { + return "getMore"; + } + buildCommand(connection) { + if (this.cursorId == null || this.cursorId.isZero()) { + throw new error_1.MongoRuntimeError("Unable to iterate cursor with no id"); + } + const collection = this.ns.collection; + if (collection == null) { + throw new error_1.MongoRuntimeError("A collection name must be determined before getMore"); + } + const getMoreCmd = { + getMore: this.cursorId, + collection + }; + if (typeof this.options.batchSize === "number") { + getMoreCmd.batchSize = Math.abs(this.options.batchSize); + } + if (typeof this.options.maxAwaitTimeMS === "number") { + getMoreCmd.maxTimeMS = this.options.maxAwaitTimeMS; + } + if (this.options.comment !== void 0 && (0, utils_1.maxWireVersion)(connection) >= 9) { + getMoreCmd.comment = this.options.comment; + } + return getMoreCmd; + } + buildOptions(timeoutContext) { + return { + returnFieldSelector: null, + documentsReturnedIn: "nextBatch", + timeoutContext, + ...this.options + }; + } + handleOk(response) { + return response; + } + }; + exports2.GetMoreOperation = GetMoreOperation; + (0, operation_1.defineAspects)(GetMoreOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.MUST_SELECT_SAME_SERVER]); + } +}); + +// node_modules/mongodb/lib/operations/kill_cursors.js +var require_kill_cursors = __commonJS({ + "node_modules/mongodb/lib/operations/kill_cursors.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.KillCursorsOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var operation_1 = require_operation(); + var KillCursorsOperation = class extends operation_1.AbstractOperation { + constructor(cursorId, ns, server, options) { + super(options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.ns = ns; + this.cursorId = cursorId; + this.server = server; + } + get commandName() { + return "killCursors"; + } + buildCommand(_connection, _session) { + const killCursors = this.ns.collection; + if (killCursors == null) { + throw new error_1.MongoRuntimeError("A collection name must be determined before killCursors"); + } + const killCursorsCommand = { + killCursors, + cursors: [this.cursorId] + }; + return killCursorsCommand; + } + buildOptions(timeoutContext) { + return { + session: this.session, + timeoutContext + }; + } + handleError(_error) { + } + }; + exports2.KillCursorsOperation = KillCursorsOperation; + (0, operation_1.defineAspects)(KillCursorsOperation, [operation_1.Aspect.MUST_SELECT_SAME_SERVER]); + } +}); + +// node_modules/mongodb/lib/deps.js +var require_deps = __commonJS({ + "node_modules/mongodb/lib/deps.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.aws4 = void 0; + exports2.getKerberos = getKerberos; + exports2.getZstdLibrary = getZstdLibrary; + exports2.getAwsCredentialProvider = getAwsCredentialProvider; + exports2.getGcpMetadata = getGcpMetadata; + exports2.getSnappy = getSnappy; + exports2.getSocks = getSocks; + exports2.getMongoDBClientEncryption = getMongoDBClientEncryption; + var error_1 = require_error(); + function makeErrorModule(error) { + const props = error ? { kModuleError: error } : {}; + return new Proxy(props, { + get: (_, key) => { + if (key === "kModuleError") { + return error; + } + throw error; + }, + set: () => { + throw error; + } + }); + } + function getKerberos() { + let kerberos; + try { + kerberos = require("kerberos"); + } catch (error) { + kerberos = makeErrorModule(new error_1.MongoMissingDependencyError("Optional module `kerberos` not found. Please install it to enable kerberos authentication", { cause: error, dependencyName: "kerberos" })); + } + return kerberos; + } + function getZstdLibrary() { + let ZStandard; + try { + ZStandard = require("@mongodb-js/zstd"); + } catch (error) { + ZStandard = makeErrorModule(new error_1.MongoMissingDependencyError("Optional module `@mongodb-js/zstd` not found. Please install it to enable zstd compression", { cause: error, dependencyName: "zstd" })); + } + return ZStandard; + } + function getAwsCredentialProvider() { + try { + const credentialProvider = require("@aws-sdk/credential-providers"); + return credentialProvider; + } catch (error) { + return makeErrorModule(new error_1.MongoMissingDependencyError("Optional module `@aws-sdk/credential-providers` not found. Please install it to enable getting aws credentials via the official sdk.", { cause: error, dependencyName: "@aws-sdk/credential-providers" })); + } + } + function getGcpMetadata() { + try { + const credentialProvider = require("gcp-metadata"); + return credentialProvider; + } catch (error) { + return makeErrorModule(new error_1.MongoMissingDependencyError("Optional module `gcp-metadata` not found. Please install it to enable getting gcp credentials via the official sdk.", { cause: error, dependencyName: "gcp-metadata" })); + } + } + function getSnappy() { + try { + const value = require("snappy"); + return value; + } catch (error) { + const kModuleError = new error_1.MongoMissingDependencyError("Optional module `snappy` not found. Please install it to enable snappy compression", { cause: error, dependencyName: "snappy" }); + return { kModuleError }; + } + } + function getSocks() { + try { + const value = require("socks"); + return value; + } catch (error) { + const kModuleError = new error_1.MongoMissingDependencyError("Optional module `socks` not found. Please install it to connections over a SOCKS5 proxy", { cause: error, dependencyName: "socks" }); + return { kModuleError }; + } + } + exports2.aws4 = loadAws4(); + function loadAws4() { + let aws4; + try { + aws4 = require("aws4"); + } catch (error) { + aws4 = makeErrorModule(new error_1.MongoMissingDependencyError("Optional module `aws4` not found. Please install it to enable AWS authentication", { cause: error, dependencyName: "aws4" })); + } + return aws4; + } + function getMongoDBClientEncryption() { + let mongodbClientEncryption = null; + try { + mongodbClientEncryption = require("mongodb-client-encryption"); + } catch (error) { + const kModuleError = new error_1.MongoMissingDependencyError("Optional module `mongodb-client-encryption` not found. Please install it to use auto encryption or ClientEncryption.", { cause: error, dependencyName: "mongodb-client-encryption" }); + return { kModuleError }; + } + return mongodbClientEncryption; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/auth_provider.js +var require_auth_provider = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/auth_provider.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AuthProvider = exports2.AuthContext = void 0; + var error_1 = require_error(); + var AuthContext = class { + constructor(connection, credentials, options) { + this.reauthenticating = false; + this.connection = connection; + this.credentials = credentials; + this.options = options; + } + }; + exports2.AuthContext = AuthContext; + var AuthProvider = class { + /** + * Prepare the handshake document before the initial handshake. + * + * @param handshakeDoc - The document used for the initial handshake on a connection + * @param authContext - Context for authentication flow + */ + async prepare(handshakeDoc, _authContext) { + return handshakeDoc; + } + /** + * Reauthenticate. + * @param context - The shared auth context. + */ + async reauth(context) { + if (context.reauthenticating) { + throw new error_1.MongoRuntimeError("Reauthentication already in progress."); + } + try { + context.reauthenticating = true; + await this.auth(context); + } finally { + context.reauthenticating = false; + } + } + }; + exports2.AuthProvider = AuthProvider; + } +}); + +// node_modules/mongodb/lib/cmap/auth/gssapi.js +var require_gssapi = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/gssapi.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GSSAPI = exports2.GSSAPICanonicalizationValue = void 0; + exports2.performGSSAPICanonicalizeHostName = performGSSAPICanonicalizeHostName; + exports2.resolveCname = resolveCname; + var dns = require("dns"); + var deps_1 = require_deps(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + exports2.GSSAPICanonicalizationValue = Object.freeze({ + on: true, + off: false, + none: "none", + forward: "forward", + forwardAndReverse: "forwardAndReverse" + }); + async function externalCommand(connection, command) { + const response = await connection.command((0, utils_1.ns)("$external.$cmd"), command); + return response; + } + var krb; + var GSSAPI = class extends auth_provider_1.AuthProvider { + async auth(authContext) { + const { connection, credentials } = authContext; + if (credentials == null) { + throw new error_1.MongoMissingCredentialsError("Credentials required for GSSAPI authentication"); + } + const { username } = credentials; + const client = await makeKerberosClient(authContext); + const payload = await client.step(""); + const saslStartResponse = await externalCommand(connection, saslStart(payload)); + const negotiatedPayload = await negotiate(client, 10, saslStartResponse.payload); + const saslContinueResponse = await externalCommand(connection, saslContinue(negotiatedPayload, saslStartResponse.conversationId)); + const finalizePayload = await finalize(client, username, saslContinueResponse.payload); + await externalCommand(connection, { + saslContinue: 1, + conversationId: saslContinueResponse.conversationId, + payload: finalizePayload + }); + } + }; + exports2.GSSAPI = GSSAPI; + async function makeKerberosClient(authContext) { + const { hostAddress } = authContext.options; + const { credentials } = authContext; + if (!hostAddress || typeof hostAddress.host !== "string" || !credentials) { + throw new error_1.MongoInvalidArgumentError("Connection must have host and port and credentials defined."); + } + loadKrb(); + if ("kModuleError" in krb) { + throw krb["kModuleError"]; + } + const { initializeClient } = krb; + const { username, password } = credentials; + const mechanismProperties = credentials.mechanismProperties; + const serviceName = mechanismProperties.SERVICE_NAME ?? "mongodb"; + const host = await performGSSAPICanonicalizeHostName(hostAddress.host, mechanismProperties); + const initOptions = {}; + if (password != null) { + Object.assign(initOptions, { user: username, password }); + } + const spnHost = mechanismProperties.SERVICE_HOST ?? host; + let spn = `${serviceName}${process.platform === "win32" ? "/" : "@"}${spnHost}`; + if ("SERVICE_REALM" in mechanismProperties) { + spn = `${spn}@${mechanismProperties.SERVICE_REALM}`; + } + return await initializeClient(spn, initOptions); + } + function saslStart(payload) { + return { + saslStart: 1, + mechanism: "GSSAPI", + payload, + autoAuthorize: 1 + }; + } + function saslContinue(payload, conversationId) { + return { + saslContinue: 1, + conversationId, + payload + }; + } + async function negotiate(client, retries, payload) { + try { + const response = await client.step(payload); + return response || ""; + } catch (error) { + if (retries === 0) { + throw error; + } + return await negotiate(client, retries - 1, payload); + } + } + async function finalize(client, user, payload) { + const response = await client.unwrap(payload); + return await client.wrap(response || "", { user }); + } + async function performGSSAPICanonicalizeHostName(host, mechanismProperties) { + const mode = mechanismProperties.CANONICALIZE_HOST_NAME; + if (!mode || mode === exports2.GSSAPICanonicalizationValue.none) { + return host; + } + if (mode === exports2.GSSAPICanonicalizationValue.on || mode === exports2.GSSAPICanonicalizationValue.forwardAndReverse) { + const { address } = await dns.promises.lookup(host); + try { + const results = await dns.promises.resolvePtr(address); + return results.length > 0 ? results[0] : host; + } catch { + return await resolveCname(host); + } + } else { + return await resolveCname(host); + } + } + async function resolveCname(host) { + try { + const results = await dns.promises.resolveCname(host); + return results.length > 0 ? results[0] : host; + } catch { + return host; + } + } + function loadKrb() { + if (!krb) { + krb = (0, deps_1.getKerberos)(); + } + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/providers.js +var require_providers = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/providers.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AUTH_MECHS_AUTH_SRC_EXTERNAL = exports2.AuthMechanism = void 0; + exports2.AuthMechanism = Object.freeze({ + MONGODB_AWS: "MONGODB-AWS", + MONGODB_CR: "MONGODB-CR", + MONGODB_DEFAULT: "DEFAULT", + MONGODB_GSSAPI: "GSSAPI", + MONGODB_PLAIN: "PLAIN", + MONGODB_SCRAM_SHA1: "SCRAM-SHA-1", + MONGODB_SCRAM_SHA256: "SCRAM-SHA-256", + MONGODB_X509: "MONGODB-X509", + MONGODB_OIDC: "MONGODB-OIDC" + }); + exports2.AUTH_MECHS_AUTH_SRC_EXTERNAL = /* @__PURE__ */ new Set([ + exports2.AuthMechanism.MONGODB_GSSAPI, + exports2.AuthMechanism.MONGODB_AWS, + exports2.AuthMechanism.MONGODB_OIDC, + exports2.AuthMechanism.MONGODB_X509 + ]); + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongo_credentials.js +var require_mongo_credentials = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongo_credentials.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoCredentials = exports2.DEFAULT_ALLOWED_HOSTS = void 0; + var error_1 = require_error(); + var gssapi_1 = require_gssapi(); + var providers_1 = require_providers(); + function getDefaultAuthMechanism(hello) { + if (hello) { + if (Array.isArray(hello.saslSupportedMechs)) { + return hello.saslSupportedMechs.includes(providers_1.AuthMechanism.MONGODB_SCRAM_SHA256) ? providers_1.AuthMechanism.MONGODB_SCRAM_SHA256 : providers_1.AuthMechanism.MONGODB_SCRAM_SHA1; + } + } + return providers_1.AuthMechanism.MONGODB_SCRAM_SHA256; + } + var ALLOWED_ENVIRONMENT_NAMES = [ + "test", + "azure", + "gcp", + "k8s" + ]; + var ALLOWED_HOSTS_ERROR = "Auth mechanism property ALLOWED_HOSTS must be an array of strings."; + exports2.DEFAULT_ALLOWED_HOSTS = [ + "*.mongodb.net", + "*.mongodb-qa.net", + "*.mongodb-dev.net", + "*.mongodbgov.net", + "localhost", + "127.0.0.1", + "::1" + ]; + var TOKEN_RESOURCE_MISSING_ERROR = "TOKEN_RESOURCE must be set in the auth mechanism properties when ENVIRONMENT is azure or gcp."; + var MongoCredentials = class _MongoCredentials { + constructor(options) { + this.username = options.username ?? ""; + this.password = options.password; + this.source = options.source; + if (!this.source && options.db) { + this.source = options.db; + } + this.mechanism = options.mechanism || providers_1.AuthMechanism.MONGODB_DEFAULT; + this.mechanismProperties = options.mechanismProperties || {}; + if (this.mechanism.match(/MONGODB-AWS/i)) { + if (!this.username && process.env.AWS_ACCESS_KEY_ID) { + this.username = process.env.AWS_ACCESS_KEY_ID; + } + if (!this.password && process.env.AWS_SECRET_ACCESS_KEY) { + this.password = process.env.AWS_SECRET_ACCESS_KEY; + } + if (this.mechanismProperties.AWS_SESSION_TOKEN == null && process.env.AWS_SESSION_TOKEN != null) { + this.mechanismProperties = { + ...this.mechanismProperties, + AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN + }; + } + } + if (this.mechanism === providers_1.AuthMechanism.MONGODB_OIDC && !this.mechanismProperties.ALLOWED_HOSTS) { + this.mechanismProperties = { + ...this.mechanismProperties, + ALLOWED_HOSTS: exports2.DEFAULT_ALLOWED_HOSTS + }; + } + Object.freeze(this.mechanismProperties); + Object.freeze(this); + } + /** Determines if two MongoCredentials objects are equivalent */ + equals(other) { + return this.mechanism === other.mechanism && this.username === other.username && this.password === other.password && this.source === other.source; + } + /** + * If the authentication mechanism is set to "default", resolves the authMechanism + * based on the server version and server supported sasl mechanisms. + * + * @param hello - A hello response from the server + */ + resolveAuthMechanism(hello) { + if (this.mechanism.match(/DEFAULT/i)) { + return new _MongoCredentials({ + username: this.username, + password: this.password, + source: this.source, + mechanism: getDefaultAuthMechanism(hello), + mechanismProperties: this.mechanismProperties + }); + } + return this; + } + validate() { + if ((this.mechanism === providers_1.AuthMechanism.MONGODB_GSSAPI || this.mechanism === providers_1.AuthMechanism.MONGODB_PLAIN || this.mechanism === providers_1.AuthMechanism.MONGODB_SCRAM_SHA1 || this.mechanism === providers_1.AuthMechanism.MONGODB_SCRAM_SHA256) && !this.username) { + throw new error_1.MongoMissingCredentialsError(`Username required for mechanism '${this.mechanism}'`); + } + if (this.mechanism === providers_1.AuthMechanism.MONGODB_OIDC) { + if (this.username && this.mechanismProperties.ENVIRONMENT && this.mechanismProperties.ENVIRONMENT !== "azure") { + throw new error_1.MongoInvalidArgumentError(`username and ENVIRONMENT '${this.mechanismProperties.ENVIRONMENT}' may not be used together for mechanism '${this.mechanism}'.`); + } + if (this.username && this.password) { + throw new error_1.MongoInvalidArgumentError(`No password is allowed in ENVIRONMENT '${this.mechanismProperties.ENVIRONMENT}' for '${this.mechanism}'.`); + } + if ((this.mechanismProperties.ENVIRONMENT === "azure" || this.mechanismProperties.ENVIRONMENT === "gcp") && !this.mechanismProperties.TOKEN_RESOURCE) { + throw new error_1.MongoInvalidArgumentError(TOKEN_RESOURCE_MISSING_ERROR); + } + if (this.mechanismProperties.ENVIRONMENT && !ALLOWED_ENVIRONMENT_NAMES.includes(this.mechanismProperties.ENVIRONMENT)) { + throw new error_1.MongoInvalidArgumentError(`Currently only a ENVIRONMENT in ${ALLOWED_ENVIRONMENT_NAMES.join(",")} is supported for mechanism '${this.mechanism}'.`); + } + if (!this.mechanismProperties.ENVIRONMENT && !this.mechanismProperties.OIDC_CALLBACK && !this.mechanismProperties.OIDC_HUMAN_CALLBACK) { + throw new error_1.MongoInvalidArgumentError(`Either a ENVIRONMENT, OIDC_CALLBACK, or OIDC_HUMAN_CALLBACK must be specified for mechanism '${this.mechanism}'.`); + } + if (this.mechanismProperties.ALLOWED_HOSTS) { + const hosts = this.mechanismProperties.ALLOWED_HOSTS; + if (!Array.isArray(hosts)) { + throw new error_1.MongoInvalidArgumentError(ALLOWED_HOSTS_ERROR); + } + for (const host of hosts) { + if (typeof host !== "string") { + throw new error_1.MongoInvalidArgumentError(ALLOWED_HOSTS_ERROR); + } + } + } + } + if (providers_1.AUTH_MECHS_AUTH_SRC_EXTERNAL.has(this.mechanism)) { + if (this.source != null && this.source !== "$external") { + throw new error_1.MongoAPIError(`Invalid source '${this.source}' for mechanism '${this.mechanism}' specified.`); + } + } + if (this.mechanism === providers_1.AuthMechanism.MONGODB_PLAIN && this.source == null) { + throw new error_1.MongoAPIError("PLAIN Authentication Mechanism needs an auth source"); + } + if (this.mechanism === providers_1.AuthMechanism.MONGODB_X509 && this.password != null) { + if (this.password === "") { + Reflect.set(this, "password", void 0); + return; + } + throw new error_1.MongoAPIError(`Password not allowed for mechanism MONGODB-X509`); + } + const canonicalization = this.mechanismProperties.CANONICALIZE_HOST_NAME ?? false; + if (!Object.values(gssapi_1.GSSAPICanonicalizationValue).includes(canonicalization)) { + throw new error_1.MongoAPIError(`Invalid CANONICALIZE_HOST_NAME value: ${canonicalization}`); + } + } + static merge(creds, options) { + return new _MongoCredentials({ + username: options.username ?? creds?.username ?? "", + password: options.password ?? creds?.password ?? "", + mechanism: options.mechanism ?? creds?.mechanism ?? providers_1.AuthMechanism.MONGODB_DEFAULT, + mechanismProperties: options.mechanismProperties ?? creds?.mechanismProperties ?? {}, + source: options.source ?? options.db ?? creds?.source ?? "admin" + }); + } + }; + exports2.MongoCredentials = MongoCredentials; + } +}); + +// node_modules/mongodb/package.json +var require_package2 = __commonJS({ + "node_modules/mongodb/package.json"(exports2, module2) { + module2.exports = { + name: "mongodb", + version: "6.22.0", + description: "The official MongoDB driver for Node.js", + main: "lib/index.js", + files: [ + "lib", + "src", + "etc/prepare.js", + "mongodb.d.ts", + "tsconfig.json" + ], + types: "mongodb.d.ts", + repository: { + type: "git", + url: "git@github.com:mongodb/node-mongodb-native.git" + }, + keywords: [ + "mongodb", + "driver", + "official" + ], + author: { + name: "The MongoDB NodeJS Team", + email: "dbx-node@mongodb.com" + }, + dependencies: { + "@mongodb-js/saslprep": "^1.3.0", + bson: "^6.10.4", + "mongodb-connection-string-url": "^3.0.2" + }, + peerDependencies: { + "@aws-sdk/credential-providers": "^3.188.0", + "@mongodb-js/zstd": "^1.1.0 || ^2.0.0", + "gcp-metadata": "^5.2.0", + kerberos: "^2.0.1", + "mongodb-client-encryption": ">=6.0.0 <7", + snappy: "^7.3.2", + socks: "^2.7.1" + }, + peerDependenciesMeta: { + "@aws-sdk/credential-providers": { + optional: true + }, + "@mongodb-js/zstd": { + optional: true + }, + kerberos: { + optional: true + }, + snappy: { + optional: true + }, + "mongodb-client-encryption": { + optional: true + }, + "gcp-metadata": { + optional: true + }, + socks: { + optional: true + } + }, + devDependencies: { + "@aws-sdk/credential-providers": "^3.876.0", + "@iarna/toml": "^2.2.5", + "@istanbuljs/nyc-config-typescript": "^1.0.2", + "@microsoft/api-extractor": "^7.52.11", + "@microsoft/tsdoc-config": "^0.17.1", + "@mongodb-js/zstd": "^2.0.1", + "@types/chai": "^4.3.17", + "@types/chai-subset": "^1.3.5", + "@types/express": "^5.0.3", + "@types/kerberos": "^1.1.5", + "@types/mocha": "^10.0.9", + "@types/node": "^22.15.3", + "@types/saslprep": "^1.0.3", + "@types/semver": "^7.7.0", + "@types/sinon": "^17.0.4", + "@types/sinon-chai": "^4.0.0", + "@types/whatwg-url": "^13.0.0", + "@typescript-eslint/eslint-plugin": "^8.41.0", + "@typescript-eslint/parser": "^8.31.1", + chai: "^4.4.1", + "chai-subset": "^1.6.0", + chalk: "^4.1.2", + eslint: "^9.34.0", + "eslint-config-prettier": "^10.1.8", + "eslint-plugin-mocha": "^10.4.1", + "eslint-plugin-prettier": "^5.5.4", + "eslint-plugin-simple-import-sort": "^12.1.1", + "eslint-plugin-tsdoc": "^0.4.0", + "eslint-plugin-unused-imports": "^4.2.0", + express: "^5.1.0", + "gcp-metadata": "^5.3.0", + "js-yaml": "^4.1.0", + mocha: "^11.7.1", + "mocha-sinon": "^2.1.2", + "mongodb-client-encryption": "^6.5.0", + "mongodb-legacy": "^6.1.3", + nyc: "^15.1.0", + prettier: "^3.6.2", + semver: "^7.7.2", + sinon: "^18.0.1", + "sinon-chai": "^3.7.0", + snappy: "^7.3.2", + socks: "^2.8.7", + "source-map-support": "^0.5.21", + "ts-node": "^10.9.2", + tsd: "^0.33.0", + typescript: "5.8.3", + "typescript-cached-transpile": "^0.0.6", + "v8-heapsnapshot": "^1.3.1", + yargs: "^18.0.0" + }, + license: "Apache-2.0", + engines: { + node: ">=16.20.1" + }, + bugs: { + url: "https://jira.mongodb.org/projects/NODE/issues/" + }, + homepage: "https://github.com/mongodb/node-mongodb-native", + scripts: { + "build:evergreen": "node .evergreen/generate_evergreen_tasks.js", + "build:ts": "node ./node_modules/typescript/bin/tsc", + "build:dts": "npm run build:ts && api-extractor run && node etc/clean_definition_files.cjs && ESLINT_USE_FLAT_CONFIG=false eslint --no-ignore --fix mongodb.d.ts lib/beta.d.ts", + "build:docs": "./etc/docs/build.ts", + "build:typedoc": "typedoc", + "build:nightly": "node ./.github/scripts/nightly.mjs", + "check:bench": "npm --prefix test/benchmarks/driver_bench start", + "check:coverage": "nyc npm run test:all", + "check:integration-coverage": "nyc npm run check:test", + "check:lambda": "nyc mocha --config test/mocha_lambda.js test/integration/node-specific/examples/handler.test.js", + "check:lambda:aws": "nyc mocha --config test/mocha_lambda.js test/integration/node-specific/examples/aws_handler.test.js", + "check:lint": "npm run build:dts && npm run check:dts && npm run check:eslint && npm run check:tsd", + "check:eslint": "npm run build:dts && ESLINT_USE_FLAT_CONFIG=false eslint -v && ESLINT_USE_FLAT_CONFIG=false eslint --max-warnings=0 --ext '.js,.ts' src test", + "check:tsd": "tsd --version && tsd", + "check:dependencies": "mocha test/action/dependency.test.ts", + "check:dts": "node ./node_modules/typescript/bin/tsc --noEmit mongodb.d.ts && tsd", + "check:search-indexes": "nyc mocha --config test/mocha_mongodb.js test/manual/search-index-management.prose.test.ts", + "check:test": "mocha --config test/mocha_mongodb.js test/integration", + "check:unit": "nyc mocha test/unit", + "check:ts": "node ./node_modules/typescript/bin/tsc -v && node ./node_modules/typescript/bin/tsc --noEmit", + "check:atlas": "nyc mocha --config test/manual/mocharc.js test/manual/atlas_connectivity.test.ts", + "check:resource-management": "nyc mocha --config test/manual/mocharc.js test/manual/resource_management.test.ts", + "check:drivers-atlas-testing": "nyc mocha --config test/mocha_mongodb.js test/atlas/drivers_atlas_testing.test.ts", + "check:adl": "nyc mocha --config test/mocha_mongodb.js test/manual/atlas-data-lake-testing", + "check:aws": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/mongodb_aws.test.ts", + "check:oidc-auth": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/auth.spec.test.ts", + "check:oidc-test": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/mongodb_oidc.prose.test.ts", + "check:oidc-azure": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/mongodb_oidc_azure.prose.05.test.ts", + "check:oidc-gcp": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/mongodb_oidc_gcp.prose.06.test.ts", + "check:oidc-k8s": "nyc mocha --config test/mocha_mongodb.js test/integration/auth/mongodb_oidc_k8s.prose.07.test.ts", + "check:kerberos": "nyc mocha --config test/manual/mocharc.js test/manual/kerberos.test.ts", + "check:tls": "nyc mocha --config test/manual/mocharc.js test/manual/tls_support.test.ts", + "check:ldap": "nyc mocha --config test/manual/mocharc.js test/manual/ldap.test.ts", + "check:socks5": "nyc mocha --config test/manual/mocharc.js test/manual/socks5.test.ts", + "check:csfle": "nyc mocha --config test/mocha_mongodb.js test/integration/client-side-encryption", + "check:snappy": "nyc mocha test/unit/assorted/snappy.test.js", + "check:x509": "nyc mocha test/manual/x509_auth.test.ts", + "fix:eslint": "npm run check:eslint -- --fix", + prepare: "node etc/prepare.js", + "preview:docs": "ts-node etc/docs/preview.ts", + test: "npm run check:lint && npm run test:all", + "test:all": "npm run check:unit && npm run check:test", + "update:docs": "npm run build:docs -- --yes" + }, + tsd: { + directory: "test/types", + compilerOptions: { + strict: true, + target: "esnext", + module: "commonjs", + moduleResolution: "node" + } + } + }; + } +}); + +// node_modules/mongodb/lib/cmap/handshake/client_metadata.js +var require_client_metadata = __commonJS({ + "node_modules/mongodb/lib/cmap/handshake/client_metadata.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.LimitedSizeDocument = void 0; + exports2.isDriverInfoEqual = isDriverInfoEqual; + exports2.makeClientMetadata = makeClientMetadata; + exports2.addContainerMetadata = addContainerMetadata; + exports2.getFAASEnv = getFAASEnv; + var os = require("os"); + var process2 = require("process"); + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var NODE_DRIVER_VERSION = require_package2().version; + function isDriverInfoEqual(info1, info2) { + const nonEmptyCmp = (s1, s2) => { + s1 ||= void 0; + s2 ||= void 0; + return s1 === s2; + }; + return nonEmptyCmp(info1.name, info2.name) && nonEmptyCmp(info1.platform, info2.platform) && nonEmptyCmp(info1.version, info2.version); + } + var LimitedSizeDocument = class { + constructor(maxSize) { + this.document = /* @__PURE__ */ new Map(); + this.documentSize = 5; + this.maxSize = maxSize; + } + /** Only adds key/value if the bsonByteLength is less than MAX_SIZE */ + ifItFitsItSits(key, value) { + const newElementSize = bson_1.BSON.serialize((/* @__PURE__ */ new Map()).set(key, value)).byteLength - 5; + if (newElementSize + this.documentSize > this.maxSize) { + return false; + } + this.documentSize += newElementSize; + this.document.set(key, value); + return true; + } + toObject() { + return bson_1.BSON.deserialize(bson_1.BSON.serialize(this.document), { + promoteLongs: false, + promoteBuffers: false, + promoteValues: false, + useBigInt64: false + }); + } + }; + exports2.LimitedSizeDocument = LimitedSizeDocument; + function makeClientMetadata(driverInfoList, { appName = "" }) { + const metadataDocument = new LimitedSizeDocument(512); + if (appName.length > 0) { + const name = Buffer.byteLength(appName, "utf8") <= 128 ? appName : Buffer.from(appName, "utf8").subarray(0, 128).toString("utf8"); + metadataDocument.ifItFitsItSits("application", { name }); + } + const driverInfo = { + name: "nodejs", + version: NODE_DRIVER_VERSION + }; + for (const { name: n = "", version: v = "" } of driverInfoList) { + if (n.length > 0) { + driverInfo.name = `${driverInfo.name}|${n}`; + } + if (v.length > 0) { + driverInfo.version = `${driverInfo.version}|${v}`; + } + } + if (!metadataDocument.ifItFitsItSits("driver", driverInfo)) { + throw new error_1.MongoInvalidArgumentError("Unable to include driverInfo name and version, metadata cannot exceed 512 bytes"); + } + let runtimeInfo = getRuntimeInfo(); + for (const { platform = "" } of driverInfoList) { + if (platform.length > 0) { + runtimeInfo = `${runtimeInfo}|${platform}`; + } + } + if (!metadataDocument.ifItFitsItSits("platform", runtimeInfo)) { + throw new error_1.MongoInvalidArgumentError("Unable to include driverInfo platform, metadata cannot exceed 512 bytes"); + } + const osInfo = (/* @__PURE__ */ new Map()).set("name", process2.platform).set("architecture", process2.arch).set("version", os.release()).set("type", os.type()); + if (!metadataDocument.ifItFitsItSits("os", osInfo)) { + for (const key of osInfo.keys()) { + osInfo.delete(key); + if (osInfo.size === 0) + break; + if (metadataDocument.ifItFitsItSits("os", osInfo)) + break; + } + } + const faasEnv = getFAASEnv(); + if (faasEnv != null) { + if (!metadataDocument.ifItFitsItSits("env", faasEnv)) { + for (const key of faasEnv.keys()) { + faasEnv.delete(key); + if (faasEnv.size === 0) + break; + if (metadataDocument.ifItFitsItSits("env", faasEnv)) + break; + } + } + } + return metadataDocument.toObject(); + } + var dockerPromise; + async function getContainerMetadata() { + const containerMetadata = {}; + dockerPromise ??= (0, utils_1.fileIsAccessible)("/.dockerenv"); + const isDocker = await dockerPromise; + const { KUBERNETES_SERVICE_HOST = "" } = process2.env; + const isKubernetes = KUBERNETES_SERVICE_HOST.length > 0 ? true : false; + if (isDocker) + containerMetadata.runtime = "docker"; + if (isKubernetes) + containerMetadata.orchestrator = "kubernetes"; + return containerMetadata; + } + async function addContainerMetadata(originalMetadata) { + const containerMetadata = await getContainerMetadata(); + if (Object.keys(containerMetadata).length === 0) + return originalMetadata; + const extendedMetadata = new LimitedSizeDocument(512); + const extendedEnvMetadata = { ...originalMetadata?.env, container: containerMetadata }; + for (const [key, val] of Object.entries(originalMetadata)) { + if (key !== "env") { + extendedMetadata.ifItFitsItSits(key, val); + } else { + if (!extendedMetadata.ifItFitsItSits("env", extendedEnvMetadata)) { + extendedMetadata.ifItFitsItSits("env", val); + } + } + } + if (!("env" in originalMetadata)) { + extendedMetadata.ifItFitsItSits("env", extendedEnvMetadata); + } + return extendedMetadata.toObject(); + } + function getFAASEnv() { + const { AWS_EXECUTION_ENV = "", AWS_LAMBDA_RUNTIME_API = "", FUNCTIONS_WORKER_RUNTIME = "", K_SERVICE = "", FUNCTION_NAME = "", VERCEL = "", AWS_LAMBDA_FUNCTION_MEMORY_SIZE = "", AWS_REGION = "", FUNCTION_MEMORY_MB = "", FUNCTION_REGION = "", FUNCTION_TIMEOUT_SEC = "", VERCEL_REGION = "" } = process2.env; + const isAWSFaaS = AWS_EXECUTION_ENV.startsWith("AWS_Lambda_") || AWS_LAMBDA_RUNTIME_API.length > 0; + const isAzureFaaS = FUNCTIONS_WORKER_RUNTIME.length > 0; + const isGCPFaaS = K_SERVICE.length > 0 || FUNCTION_NAME.length > 0; + const isVercelFaaS = VERCEL.length > 0; + const faasEnv = /* @__PURE__ */ new Map(); + if (isVercelFaaS && !(isAzureFaaS || isGCPFaaS)) { + if (VERCEL_REGION.length > 0) { + faasEnv.set("region", VERCEL_REGION); + } + faasEnv.set("name", "vercel"); + return faasEnv; + } + if (isAWSFaaS && !(isAzureFaaS || isGCPFaaS || isVercelFaaS)) { + if (AWS_REGION.length > 0) { + faasEnv.set("region", AWS_REGION); + } + if (AWS_LAMBDA_FUNCTION_MEMORY_SIZE.length > 0 && Number.isInteger(+AWS_LAMBDA_FUNCTION_MEMORY_SIZE)) { + faasEnv.set("memory_mb", new bson_1.Int32(AWS_LAMBDA_FUNCTION_MEMORY_SIZE)); + } + faasEnv.set("name", "aws.lambda"); + return faasEnv; + } + if (isAzureFaaS && !(isGCPFaaS || isAWSFaaS || isVercelFaaS)) { + faasEnv.set("name", "azure.func"); + return faasEnv; + } + if (isGCPFaaS && !(isAzureFaaS || isAWSFaaS || isVercelFaaS)) { + if (FUNCTION_REGION.length > 0) { + faasEnv.set("region", FUNCTION_REGION); + } + if (FUNCTION_MEMORY_MB.length > 0 && Number.isInteger(+FUNCTION_MEMORY_MB)) { + faasEnv.set("memory_mb", new bson_1.Int32(FUNCTION_MEMORY_MB)); + } + if (FUNCTION_TIMEOUT_SEC.length > 0 && Number.isInteger(+FUNCTION_TIMEOUT_SEC)) { + faasEnv.set("timeout_sec", new bson_1.Int32(FUNCTION_TIMEOUT_SEC)); + } + faasEnv.set("name", "gcp.func"); + return faasEnv; + } + return null; + } + function getRuntimeInfo() { + if ("Deno" in globalThis) { + const version = typeof Deno?.version?.deno === "string" ? Deno?.version?.deno : "0.0.0-unknown"; + return `Deno v${version}, ${os.endianness()}`; + } + if ("Bun" in globalThis) { + const version = typeof Bun?.version === "string" ? Bun?.version : "0.0.0-unknown"; + return `Bun v${version}, ${os.endianness()}`; + } + return `Node.js ${process2.version}, ${os.endianness()}`; + } + } +}); + +// node_modules/webidl-conversions/lib/index.js +var require_lib7 = __commonJS({ + "node_modules/webidl-conversions/lib/index.js"(exports2) { + "use strict"; + function makeException(ErrorType, message, options) { + if (options.globals) { + ErrorType = options.globals[ErrorType.name]; + } + return new ErrorType(`${options.context ? options.context : "Value"} ${message}.`); + } + function toNumber(value, options) { + if (typeof value === "bigint") { + throw makeException(TypeError, "is a BigInt which cannot be converted to a number", options); + } + if (!options.globals) { + return Number(value); + } + return options.globals.Number(value); + } + function evenRound(x) { + if (x > 0 && x % 1 === 0.5 && (x & 1) === 0 || x < 0 && x % 1 === -0.5 && (x & 1) === 1) { + return censorNegativeZero(Math.floor(x)); + } + return censorNegativeZero(Math.round(x)); + } + function integerPart(n) { + return censorNegativeZero(Math.trunc(n)); + } + function sign(x) { + return x < 0 ? -1 : 1; + } + function modulo(x, y) { + const signMightNotMatch = x % y; + if (sign(y) !== sign(signMightNotMatch)) { + return signMightNotMatch + y; + } + return signMightNotMatch; + } + function censorNegativeZero(x) { + return x === 0 ? 0 : x; + } + function createIntegerConversion(bitLength, { unsigned }) { + let lowerBound, upperBound; + if (unsigned) { + lowerBound = 0; + upperBound = 2 ** bitLength - 1; + } else { + lowerBound = -(2 ** (bitLength - 1)); + upperBound = 2 ** (bitLength - 1) - 1; + } + const twoToTheBitLength = 2 ** bitLength; + const twoToOneLessThanTheBitLength = 2 ** (bitLength - 1); + return (value, options = {}) => { + let x = toNumber(value, options); + x = censorNegativeZero(x); + if (options.enforceRange) { + if (!Number.isFinite(x)) { + throw makeException(TypeError, "is not a finite number", options); + } + x = integerPart(x); + if (x < lowerBound || x > upperBound) { + throw makeException( + TypeError, + `is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`, + options + ); + } + return x; + } + if (!Number.isNaN(x) && options.clamp) { + x = Math.min(Math.max(x, lowerBound), upperBound); + x = evenRound(x); + return x; + } + if (!Number.isFinite(x) || x === 0) { + return 0; + } + x = integerPart(x); + if (x >= lowerBound && x <= upperBound) { + return x; + } + x = modulo(x, twoToTheBitLength); + if (!unsigned && x >= twoToOneLessThanTheBitLength) { + return x - twoToTheBitLength; + } + return x; + }; + } + function createLongLongConversion(bitLength, { unsigned }) { + const upperBound = Number.MAX_SAFE_INTEGER; + const lowerBound = unsigned ? 0 : Number.MIN_SAFE_INTEGER; + const asBigIntN = unsigned ? BigInt.asUintN : BigInt.asIntN; + return (value, options = {}) => { + let x = toNumber(value, options); + x = censorNegativeZero(x); + if (options.enforceRange) { + if (!Number.isFinite(x)) { + throw makeException(TypeError, "is not a finite number", options); + } + x = integerPart(x); + if (x < lowerBound || x > upperBound) { + throw makeException( + TypeError, + `is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`, + options + ); + } + return x; + } + if (!Number.isNaN(x) && options.clamp) { + x = Math.min(Math.max(x, lowerBound), upperBound); + x = evenRound(x); + return x; + } + if (!Number.isFinite(x) || x === 0) { + return 0; + } + let xBigInt = BigInt(integerPart(x)); + xBigInt = asBigIntN(bitLength, xBigInt); + return Number(xBigInt); + }; + } + exports2.any = (value) => { + return value; + }; + exports2.undefined = () => { + return void 0; + }; + exports2.boolean = (value) => { + return Boolean(value); + }; + exports2.byte = createIntegerConversion(8, { unsigned: false }); + exports2.octet = createIntegerConversion(8, { unsigned: true }); + exports2.short = createIntegerConversion(16, { unsigned: false }); + exports2["unsigned short"] = createIntegerConversion(16, { unsigned: true }); + exports2.long = createIntegerConversion(32, { unsigned: false }); + exports2["unsigned long"] = createIntegerConversion(32, { unsigned: true }); + exports2["long long"] = createLongLongConversion(64, { unsigned: false }); + exports2["unsigned long long"] = createLongLongConversion(64, { unsigned: true }); + exports2.double = (value, options = {}) => { + const x = toNumber(value, options); + if (!Number.isFinite(x)) { + throw makeException(TypeError, "is not a finite floating-point value", options); + } + return x; + }; + exports2["unrestricted double"] = (value, options = {}) => { + const x = toNumber(value, options); + return x; + }; + exports2.float = (value, options = {}) => { + const x = toNumber(value, options); + if (!Number.isFinite(x)) { + throw makeException(TypeError, "is not a finite floating-point value", options); + } + if (Object.is(x, -0)) { + return x; + } + const y = Math.fround(x); + if (!Number.isFinite(y)) { + throw makeException(TypeError, "is outside the range of a single-precision floating-point value", options); + } + return y; + }; + exports2["unrestricted float"] = (value, options = {}) => { + const x = toNumber(value, options); + if (isNaN(x)) { + return x; + } + if (Object.is(x, -0)) { + return x; + } + return Math.fround(x); + }; + exports2.DOMString = (value, options = {}) => { + if (options.treatNullAsEmptyString && value === null) { + return ""; + } + if (typeof value === "symbol") { + throw makeException(TypeError, "is a symbol, which cannot be converted to a string", options); + } + const StringCtor = options.globals ? options.globals.String : String; + return StringCtor(value); + }; + exports2.ByteString = (value, options = {}) => { + const x = exports2.DOMString(value, options); + let c; + for (let i = 0; (c = x.codePointAt(i)) !== void 0; ++i) { + if (c > 255) { + throw makeException(TypeError, "is not a valid ByteString", options); + } + } + return x; + }; + exports2.USVString = (value, options = {}) => { + const S = exports2.DOMString(value, options); + const n = S.length; + const U = []; + for (let i = 0; i < n; ++i) { + const c = S.charCodeAt(i); + if (c < 55296 || c > 57343) { + U.push(String.fromCodePoint(c)); + } else if (56320 <= c && c <= 57343) { + U.push(String.fromCodePoint(65533)); + } else if (i === n - 1) { + U.push(String.fromCodePoint(65533)); + } else { + const d = S.charCodeAt(i + 1); + if (56320 <= d && d <= 57343) { + const a = c & 1023; + const b = d & 1023; + U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b)); + ++i; + } else { + U.push(String.fromCodePoint(65533)); + } + } + } + return U.join(""); + }; + exports2.object = (value, options = {}) => { + if (value === null || typeof value !== "object" && typeof value !== "function") { + throw makeException(TypeError, "is not an object", options); + } + return value; + }; + var abByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get; + var sabByteLengthGetter = typeof SharedArrayBuffer === "function" ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get : null; + function isNonSharedArrayBuffer(value) { + try { + abByteLengthGetter.call(value); + return true; + } catch { + return false; + } + } + function isSharedArrayBuffer(value) { + try { + sabByteLengthGetter.call(value); + return true; + } catch { + return false; + } + } + function isArrayBufferDetached(value) { + try { + new Uint8Array(value); + return false; + } catch { + return true; + } + } + exports2.ArrayBuffer = (value, options = {}) => { + if (!isNonSharedArrayBuffer(value)) { + if (options.allowShared && !isSharedArrayBuffer(value)) { + throw makeException(TypeError, "is not an ArrayBuffer or SharedArrayBuffer", options); + } + throw makeException(TypeError, "is not an ArrayBuffer", options); + } + if (isArrayBufferDetached(value)) { + throw makeException(TypeError, "is a detached ArrayBuffer", options); + } + return value; + }; + var dvByteLengthGetter = Object.getOwnPropertyDescriptor(DataView.prototype, "byteLength").get; + exports2.DataView = (value, options = {}) => { + try { + dvByteLengthGetter.call(value); + } catch (e) { + throw makeException(TypeError, "is not a DataView", options); + } + if (!options.allowShared && isSharedArrayBuffer(value.buffer)) { + throw makeException(TypeError, "is backed by a SharedArrayBuffer, which is not allowed", options); + } + if (isArrayBufferDetached(value.buffer)) { + throw makeException(TypeError, "is backed by a detached ArrayBuffer", options); + } + return value; + }; + var typedArrayNameGetter = Object.getOwnPropertyDescriptor( + Object.getPrototypeOf(Uint8Array).prototype, + Symbol.toStringTag + ).get; + [ + Int8Array, + Int16Array, + Int32Array, + Uint8Array, + Uint16Array, + Uint32Array, + Uint8ClampedArray, + Float32Array, + Float64Array + ].forEach((func) => { + const { name } = func; + const article = /^[AEIOU]/u.test(name) ? "an" : "a"; + exports2[name] = (value, options = {}) => { + if (!ArrayBuffer.isView(value) || typedArrayNameGetter.call(value) !== name) { + throw makeException(TypeError, `is not ${article} ${name} object`, options); + } + if (!options.allowShared && isSharedArrayBuffer(value.buffer)) { + throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options); + } + if (isArrayBufferDetached(value.buffer)) { + throw makeException(TypeError, "is a view on a detached ArrayBuffer", options); + } + return value; + }; + }); + exports2.ArrayBufferView = (value, options = {}) => { + if (!ArrayBuffer.isView(value)) { + throw makeException(TypeError, "is not a view on an ArrayBuffer or SharedArrayBuffer", options); + } + if (!options.allowShared && isSharedArrayBuffer(value.buffer)) { + throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options); + } + if (isArrayBufferDetached(value.buffer)) { + throw makeException(TypeError, "is a view on a detached ArrayBuffer", options); + } + return value; + }; + exports2.BufferSource = (value, options = {}) => { + if (ArrayBuffer.isView(value)) { + if (!options.allowShared && isSharedArrayBuffer(value.buffer)) { + throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options); + } + if (isArrayBufferDetached(value.buffer)) { + throw makeException(TypeError, "is a view on a detached ArrayBuffer", options); + } + return value; + } + if (!options.allowShared && !isNonSharedArrayBuffer(value)) { + throw makeException(TypeError, "is not an ArrayBuffer or a view on one", options); + } + if (options.allowShared && !isSharedArrayBuffer(value) && !isNonSharedArrayBuffer(value)) { + throw makeException(TypeError, "is not an ArrayBuffer, SharedArrayBuffer, or a view on one", options); + } + if (isArrayBufferDetached(value)) { + throw makeException(TypeError, "is a detached ArrayBuffer", options); + } + return value; + }; + exports2.DOMTimeStamp = exports2["unsigned long long"]; + } +}); + +// node_modules/whatwg-url/lib/utils.js +var require_utils4 = __commonJS({ + "node_modules/whatwg-url/lib/utils.js"(exports2, module2) { + "use strict"; + function isObject(value) { + return typeof value === "object" && value !== null || typeof value === "function"; + } + var hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty); + function define2(target, source) { + for (const key of Reflect.ownKeys(source)) { + const descriptor = Reflect.getOwnPropertyDescriptor(source, key); + if (descriptor && !Reflect.defineProperty(target, key, descriptor)) { + throw new TypeError(`Cannot redefine property: ${String(key)}`); + } + } + } + function newObjectInRealm(globalObject, object) { + const ctorRegistry = initCtorRegistry(globalObject); + return Object.defineProperties( + Object.create(ctorRegistry["%Object.prototype%"]), + Object.getOwnPropertyDescriptors(object) + ); + } + var wrapperSymbol = /* @__PURE__ */ Symbol("wrapper"); + var implSymbol = /* @__PURE__ */ Symbol("impl"); + var sameObjectCaches = /* @__PURE__ */ Symbol("SameObject caches"); + var ctorRegistrySymbol = /* @__PURE__ */ Symbol.for("[webidl2js] constructor registry"); + var AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () { + }).prototype); + function initCtorRegistry(globalObject) { + if (hasOwn(globalObject, ctorRegistrySymbol)) { + return globalObject[ctorRegistrySymbol]; + } + const ctorRegistry = /* @__PURE__ */ Object.create(null); + ctorRegistry["%Object.prototype%"] = globalObject.Object.prototype; + ctorRegistry["%IteratorPrototype%"] = Object.getPrototypeOf( + Object.getPrototypeOf(new globalObject.Array()[Symbol.iterator]()) + ); + try { + ctorRegistry["%AsyncIteratorPrototype%"] = Object.getPrototypeOf( + Object.getPrototypeOf( + globalObject.eval("(async function* () {})").prototype + ) + ); + } catch { + ctorRegistry["%AsyncIteratorPrototype%"] = AsyncIteratorPrototype; + } + globalObject[ctorRegistrySymbol] = ctorRegistry; + return ctorRegistry; + } + function getSameObject(wrapper, prop, creator) { + if (!wrapper[sameObjectCaches]) { + wrapper[sameObjectCaches] = /* @__PURE__ */ Object.create(null); + } + if (prop in wrapper[sameObjectCaches]) { + return wrapper[sameObjectCaches][prop]; + } + wrapper[sameObjectCaches][prop] = creator(); + return wrapper[sameObjectCaches][prop]; + } + function wrapperForImpl(impl) { + return impl ? impl[wrapperSymbol] : null; + } + function implForWrapper(wrapper) { + return wrapper ? wrapper[implSymbol] : null; + } + function tryWrapperForImpl(impl) { + const wrapper = wrapperForImpl(impl); + return wrapper ? wrapper : impl; + } + function tryImplForWrapper(wrapper) { + const impl = implForWrapper(wrapper); + return impl ? impl : wrapper; + } + var iterInternalSymbol = /* @__PURE__ */ Symbol("internal"); + function isArrayIndexPropName(P) { + if (typeof P !== "string") { + return false; + } + const i = P >>> 0; + if (i === 2 ** 32 - 1) { + return false; + } + const s = `${i}`; + if (P !== s) { + return false; + } + return true; + } + var byteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get; + function isArrayBuffer(value) { + try { + byteLengthGetter.call(value); + return true; + } catch (e) { + return false; + } + } + function iteratorResult([key, value], kind) { + let result; + switch (kind) { + case "key": + result = key; + break; + case "value": + result = value; + break; + case "key+value": + result = [key, value]; + break; + } + return { value: result, done: false }; + } + var supportsPropertyIndex = /* @__PURE__ */ Symbol("supports property index"); + var supportedPropertyIndices = /* @__PURE__ */ Symbol("supported property indices"); + var supportsPropertyName = /* @__PURE__ */ Symbol("supports property name"); + var supportedPropertyNames = /* @__PURE__ */ Symbol("supported property names"); + var indexedGet = /* @__PURE__ */ Symbol("indexed property get"); + var indexedSetNew = /* @__PURE__ */ Symbol("indexed property set new"); + var indexedSetExisting = /* @__PURE__ */ Symbol("indexed property set existing"); + var namedGet = /* @__PURE__ */ Symbol("named property get"); + var namedSetNew = /* @__PURE__ */ Symbol("named property set new"); + var namedSetExisting = /* @__PURE__ */ Symbol("named property set existing"); + var namedDelete = /* @__PURE__ */ Symbol("named property delete"); + var asyncIteratorNext = /* @__PURE__ */ Symbol("async iterator get the next iteration result"); + var asyncIteratorReturn = /* @__PURE__ */ Symbol("async iterator return steps"); + var asyncIteratorInit = /* @__PURE__ */ Symbol("async iterator initialization steps"); + var asyncIteratorEOI = /* @__PURE__ */ Symbol("async iterator end of iteration"); + module2.exports = exports2 = { + isObject, + hasOwn, + define: define2, + newObjectInRealm, + wrapperSymbol, + implSymbol, + getSameObject, + ctorRegistrySymbol, + initCtorRegistry, + wrapperForImpl, + implForWrapper, + tryWrapperForImpl, + tryImplForWrapper, + iterInternalSymbol, + isArrayBuffer, + isArrayIndexPropName, + supportsPropertyIndex, + supportedPropertyIndices, + supportsPropertyName, + supportedPropertyNames, + indexedGet, + indexedSetNew, + indexedSetExisting, + namedGet, + namedSetNew, + namedSetExisting, + namedDelete, + asyncIteratorNext, + asyncIteratorReturn, + asyncIteratorInit, + asyncIteratorEOI, + iteratorResult + }; + } +}); + +// node_modules/punycode/punycode.js +var require_punycode = __commonJS({ + "node_modules/punycode/punycode.js"(exports2, module2) { + "use strict"; + var maxInt = 2147483647; + var base = 36; + var tMin = 1; + var tMax = 26; + var skew = 38; + var damp = 700; + var initialBias = 72; + var initialN = 128; + var delimiter = "-"; + var regexPunycode = /^xn--/; + var regexNonASCII = /[^\0-\x7F]/; + var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; + var errors = { + "overflow": "Overflow: input needs wider integers to process", + "not-basic": "Illegal input >= 0x80 (not a basic code point)", + "invalid-input": "Invalid input" + }; + var baseMinusTMin = base - tMin; + var floor = Math.floor; + var stringFromCharCode = String.fromCharCode; + function error(type) { + throw new RangeError(errors[type]); + } + function map(array, callback) { + const result = []; + let length = array.length; + while (length--) { + result[length] = callback(array[length]); + } + return result; + } + function mapDomain(domain, callback) { + const parts = domain.split("@"); + let result = ""; + if (parts.length > 1) { + result = parts[0] + "@"; + domain = parts[1]; + } + domain = domain.replace(regexSeparators, "."); + const labels = domain.split("."); + const encoded = map(labels, callback).join("."); + return result + encoded; + } + function ucs2decode(string) { + const output = []; + let counter = 0; + const length = string.length; + while (counter < length) { + const value = string.charCodeAt(counter++); + if (value >= 55296 && value <= 56319 && counter < length) { + const extra = string.charCodeAt(counter++); + if ((extra & 64512) == 56320) { + output.push(((value & 1023) << 10) + (extra & 1023) + 65536); + } else { + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints); + var basicToDigit = function(codePoint) { + if (codePoint >= 48 && codePoint < 58) { + return 26 + (codePoint - 48); + } + if (codePoint >= 65 && codePoint < 91) { + return codePoint - 65; + } + if (codePoint >= 97 && codePoint < 123) { + return codePoint - 97; + } + return base; + }; + var digitToBasic = function(digit, flag) { + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + }; + var adapt = function(delta, numPoints, firstTime) { + let k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + }; + var decode = function(input) { + const output = []; + const inputLength = input.length; + let i = 0; + let n = initialN; + let bias = initialBias; + let basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + for (let j = 0; j < basic; ++j) { + if (input.charCodeAt(j) >= 128) { + error("not-basic"); + } + output.push(input.charCodeAt(j)); + } + for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) { + const oldi = i; + for (let w = 1, k = base; ; k += base) { + if (index >= inputLength) { + error("invalid-input"); + } + const digit = basicToDigit(input.charCodeAt(index++)); + if (digit >= base) { + error("invalid-input"); + } + if (digit > floor((maxInt - i) / w)) { + error("overflow"); + } + i += digit * w; + const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (digit < t) { + break; + } + const baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error("overflow"); + } + w *= baseMinusT; + } + const out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + if (floor(i / out) > maxInt - n) { + error("overflow"); + } + n += floor(i / out); + i %= out; + output.splice(i++, 0, n); + } + return String.fromCodePoint(...output); + }; + var encode = function(input) { + const output = []; + input = ucs2decode(input); + const inputLength = input.length; + let n = initialN; + let delta = 0; + let bias = initialBias; + for (const currentValue of input) { + if (currentValue < 128) { + output.push(stringFromCharCode(currentValue)); + } + } + const basicLength = output.length; + let handledCPCount = basicLength; + if (basicLength) { + output.push(delimiter); + } + while (handledCPCount < inputLength) { + let m = maxInt; + for (const currentValue of input) { + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + const handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error("overflow"); + } + delta += (m - n) * handledCPCountPlusOne; + n = m; + for (const currentValue of input) { + if (currentValue < n && ++delta > maxInt) { + error("overflow"); + } + if (currentValue === n) { + let q = delta; + for (let k = base; ; k += base) { + const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (q < t) { + break; + } + const qMinusT = q - t; + const baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength); + delta = 0; + ++handledCPCount; + } + } + ++delta; + ++n; + } + return output.join(""); + }; + var toUnicode = function(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string; + }); + }; + var toASCII = function(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) ? "xn--" + encode(string) : string; + }); + }; + var punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + "version": "2.3.1", + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + "ucs2": { + "decode": ucs2decode, + "encode": ucs2encode + }, + "decode": decode, + "encode": encode, + "toASCII": toASCII, + "toUnicode": toUnicode + }; + module2.exports = punycode; + } +}); + +// node_modules/tr46/lib/regexes.js +var require_regexes = __commonJS({ + "node_modules/tr46/lib/regexes.js"(exports2, module2) { + "use strict"; + var combiningMarks = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CF3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\u{101FD}\u{102E0}\u{10376}-\u{1037A}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6D}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11000}-\u{11002}\u{11038}-\u{11046}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11082}\u{110B0}-\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{11134}\u{11145}\u{11146}\u{11173}\u{11180}-\u{11182}\u{111B3}-\u{111C0}\u{111C9}-\u{111CC}\u{111CE}\u{111CF}\u{1122C}-\u{11237}\u{1123E}\u{11241}\u{112DF}-\u{112EA}\u{11300}-\u{11303}\u{1133B}\u{1133C}\u{1133E}-\u{11344}\u{11347}\u{11348}\u{1134B}-\u{1134D}\u{11357}\u{11362}\u{11363}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113B8}-\u{113C0}\u{113C2}\u{113C5}\u{113C7}-\u{113CA}\u{113CC}-\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11435}-\u{11446}\u{1145E}\u{114B0}-\u{114C3}\u{115AF}-\u{115B5}\u{115B8}-\u{115C0}\u{115DC}\u{115DD}\u{11630}-\u{11640}\u{116AB}-\u{116B7}\u{1171D}-\u{1172B}\u{1182C}-\u{1183A}\u{11930}-\u{11935}\u{11937}\u{11938}\u{1193B}-\u{1193E}\u{11940}\u{11942}\u{11943}\u{119D1}-\u{119D7}\u{119DA}-\u{119E0}\u{119E4}\u{11A01}-\u{11A0A}\u{11A33}-\u{11A39}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A5B}\u{11A8A}-\u{11A99}\u{11C2F}-\u{11C36}\u{11C38}-\u{11C3F}\u{11C92}-\u{11CA7}\u{11CA9}-\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D8A}-\u{11D8E}\u{11D90}\u{11D91}\u{11D93}-\u{11D97}\u{11EF3}-\u{11EF6}\u{11F00}\u{11F01}\u{11F03}\u{11F34}-\u{11F3A}\u{11F3E}-\u{11F42}\u{11F5A}\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F51}-\u{16F87}\u{16F8F}-\u{16F92}\u{16FE4}\u{16FF0}\u{16FF1}\u{1BC9D}\u{1BC9E}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D165}-\u{1D169}\u{1D16D}-\u{1D172}\u{1D17B}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D242}-\u{1D244}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94A}\u{E0100}-\u{E01EF}]/u; + var combiningClassVirama = /[\u094D\u09CD\u0A4D\u0ACD\u0B4D\u0BCD\u0C4D\u0CCD\u0D3B\u0D3C\u0D4D\u0DCA\u0E3A\u0EBA\u0F84\u1039\u103A\u1714\u1715\u1734\u17D2\u1A60\u1B44\u1BAA\u1BAB\u1BF2\u1BF3\u2D7F\uA806\uA82C\uA8C4\uA953\uA9C0\uAAF6\uABED\u{10A3F}\u{11046}\u{11070}\u{1107F}\u{110B9}\u{11133}\u{11134}\u{111C0}\u{11235}\u{112EA}\u{1134D}\u{113CE}-\u{113D0}\u{11442}\u{114C2}\u{115BF}\u{1163F}\u{116B6}\u{1172B}\u{11839}\u{1193D}\u{1193E}\u{119E0}\u{11A34}\u{11A47}\u{11A99}\u{11C3F}\u{11D44}\u{11D45}\u{11D97}\u{11F41}\u{11F42}\u{1612F}]/u; + var validZWNJ = /[\u0620\u0626\u0628\u062A-\u062E\u0633-\u063F\u0641-\u0647\u0649\u064A\u066E\u066F\u0678-\u0687\u069A-\u06BF\u06C1\u06C2\u06CC\u06CE\u06D0\u06D1\u06FA-\u06FC\u06FF\u0712-\u0714\u071A-\u071D\u071F-\u0727\u0729\u072B\u072D\u072E\u074E-\u0758\u075C-\u076A\u076D-\u0770\u0772\u0775-\u0777\u077A-\u077F\u07CA-\u07EA\u0841-\u0845\u0848\u084A-\u0853\u0855\u0860\u0862-\u0865\u0868\u0886\u0889-\u088D\u08A0-\u08A9\u08AF\u08B0\u08B3-\u08B8\u08BA-\u08C8\u1807\u1820-\u1878\u1887-\u18A8\u18AA\uA840-\uA872\u{10AC0}-\u{10AC4}\u{10ACD}\u{10AD3}-\u{10ADC}\u{10ADE}-\u{10AE0}\u{10AEB}-\u{10AEE}\u{10B80}\u{10B82}\u{10B86}-\u{10B88}\u{10B8A}\u{10B8B}\u{10B8D}\u{10B90}\u{10BAD}\u{10BAE}\u{10D00}-\u{10D21}\u{10D23}\u{10EC3}\u{10EC4}\u{10F30}-\u{10F32}\u{10F34}-\u{10F44}\u{10F51}-\u{10F53}\u{10F70}-\u{10F73}\u{10F76}-\u{10F81}\u{10FB0}\u{10FB2}\u{10FB3}\u{10FB8}\u{10FBB}\u{10FBC}\u{10FBE}\u{10FBF}\u{10FC1}\u{10FC4}\u{10FCA}\u{10FCB}\u{1E900}-\u{1E943}][\xAD\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u061C\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u070F\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3C\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732\u1733\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DFF\u200B\u200E\u200F\u202A-\u202E\u2060-\u2064\u206A-\u206F\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFEFF\uFFF9-\uFFFB\u{101FD}\u{102E0}\u{10376}-\u{1037A}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6D}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11001}\u{11038}-\u{11046}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11081}\u{110B3}-\u{110B6}\u{110B9}\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{1112B}\u{1112D}-\u{11134}\u{11173}\u{11180}\u{11181}\u{111B6}-\u{111BE}\u{111C9}-\u{111CC}\u{111CF}\u{1122F}-\u{11231}\u{11234}\u{11236}\u{11237}\u{1123E}\u{11241}\u{112DF}\u{112E3}-\u{112EA}\u{11300}\u{11301}\u{1133B}\u{1133C}\u{11340}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113BB}-\u{113C0}\u{113CE}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11438}-\u{1143F}\u{11442}-\u{11444}\u{11446}\u{1145E}\u{114B3}-\u{114B8}\u{114BA}\u{114BF}\u{114C0}\u{114C2}\u{114C3}\u{115B2}-\u{115B5}\u{115BC}\u{115BD}\u{115BF}\u{115C0}\u{115DC}\u{115DD}\u{11633}-\u{1163A}\u{1163D}\u{1163F}\u{11640}\u{116AB}\u{116AD}\u{116B0}-\u{116B5}\u{116B7}\u{1171D}\u{1171F}\u{11722}-\u{11725}\u{11727}-\u{1172B}\u{1182F}-\u{11837}\u{11839}\u{1183A}\u{1193B}\u{1193C}\u{1193E}\u{11943}\u{119D4}-\u{119D7}\u{119DA}\u{119DB}\u{119E0}\u{11A01}-\u{11A0A}\u{11A33}-\u{11A38}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A56}\u{11A59}-\u{11A5B}\u{11A8A}-\u{11A96}\u{11A98}\u{11A99}\u{11C30}-\u{11C36}\u{11C38}-\u{11C3D}\u{11C3F}\u{11C92}-\u{11CA7}\u{11CAA}-\u{11CB0}\u{11CB2}\u{11CB3}\u{11CB5}\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D90}\u{11D91}\u{11D95}\u{11D97}\u{11EF3}\u{11EF4}\u{11F00}\u{11F01}\u{11F36}-\u{11F3A}\u{11F40}\u{11F42}\u{11F5A}\u{13430}-\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{16129}\u{1612D}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F8F}-\u{16F92}\u{16FE4}\u{1BC9D}\u{1BC9E}\u{1BCA0}-\u{1BCA3}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D167}-\u{1D169}\u{1D173}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D242}-\u{1D244}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94B}\u{E0001}\u{E0020}-\u{E007F}\u{E0100}-\u{E01EF}]*\u200C[\xAD\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u061C\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u070F\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3C\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732\u1733\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DFF\u200B\u200E\u200F\u202A-\u202E\u2060-\u2064\u206A-\u206F\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\uFEFF\uFFF9-\uFFFB\u{101FD}\u{102E0}\u{10376}-\u{1037A}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6D}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11001}\u{11038}-\u{11046}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11081}\u{110B3}-\u{110B6}\u{110B9}\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{1112B}\u{1112D}-\u{11134}\u{11173}\u{11180}\u{11181}\u{111B6}-\u{111BE}\u{111C9}-\u{111CC}\u{111CF}\u{1122F}-\u{11231}\u{11234}\u{11236}\u{11237}\u{1123E}\u{11241}\u{112DF}\u{112E3}-\u{112EA}\u{11300}\u{11301}\u{1133B}\u{1133C}\u{11340}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113BB}-\u{113C0}\u{113CE}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11438}-\u{1143F}\u{11442}-\u{11444}\u{11446}\u{1145E}\u{114B3}-\u{114B8}\u{114BA}\u{114BF}\u{114C0}\u{114C2}\u{114C3}\u{115B2}-\u{115B5}\u{115BC}\u{115BD}\u{115BF}\u{115C0}\u{115DC}\u{115DD}\u{11633}-\u{1163A}\u{1163D}\u{1163F}\u{11640}\u{116AB}\u{116AD}\u{116B0}-\u{116B5}\u{116B7}\u{1171D}\u{1171F}\u{11722}-\u{11725}\u{11727}-\u{1172B}\u{1182F}-\u{11837}\u{11839}\u{1183A}\u{1193B}\u{1193C}\u{1193E}\u{11943}\u{119D4}-\u{119D7}\u{119DA}\u{119DB}\u{119E0}\u{11A01}-\u{11A0A}\u{11A33}-\u{11A38}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A56}\u{11A59}-\u{11A5B}\u{11A8A}-\u{11A96}\u{11A98}\u{11A99}\u{11C30}-\u{11C36}\u{11C38}-\u{11C3D}\u{11C3F}\u{11C92}-\u{11CA7}\u{11CAA}-\u{11CB0}\u{11CB2}\u{11CB3}\u{11CB5}\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D90}\u{11D91}\u{11D95}\u{11D97}\u{11EF3}\u{11EF4}\u{11F00}\u{11F01}\u{11F36}-\u{11F3A}\u{11F40}\u{11F42}\u{11F5A}\u{13430}-\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{16129}\u{1612D}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F8F}-\u{16F92}\u{16FE4}\u{1BC9D}\u{1BC9E}\u{1BCA0}-\u{1BCA3}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D167}-\u{1D169}\u{1D173}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D242}-\u{1D244}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94B}\u{E0001}\u{E0020}-\u{E007F}\u{E0100}-\u{E01EF}]*[\u0620\u0622-\u063F\u0641-\u064A\u066E\u066F\u0671-\u0673\u0675-\u06D3\u06D5\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u077F\u07CA-\u07EA\u0840-\u0858\u0860\u0862-\u0865\u0867-\u086A\u0870-\u0882\u0886\u0889-\u088E\u08A0-\u08AC\u08AE-\u08C8\u1807\u1820-\u1878\u1887-\u18A8\u18AA\uA840-\uA871\u{10AC0}-\u{10AC5}\u{10AC7}\u{10AC9}\u{10ACA}\u{10ACE}-\u{10AD6}\u{10AD8}-\u{10AE1}\u{10AE4}\u{10AEB}-\u{10AEF}\u{10B80}-\u{10B91}\u{10BA9}-\u{10BAE}\u{10D01}-\u{10D23}\u{10EC2}-\u{10EC4}\u{10F30}-\u{10F44}\u{10F51}-\u{10F54}\u{10F70}-\u{10F81}\u{10FB0}\u{10FB2}-\u{10FB6}\u{10FB8}-\u{10FBF}\u{10FC1}-\u{10FC4}\u{10FC9}\u{10FCA}\u{1E900}-\u{1E943}]/u; + var bidiDomain = /[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05EA\u05EF-\u05F4\u0600-\u0605\u0608\u060B\u060D\u061B-\u064A\u0660-\u0669\u066B-\u066F\u0671-\u06D5\u06DD\u06E5\u06E6\u06EE\u06EF\u06FA-\u070D\u070F\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u083E\u0840-\u0858\u085E\u0860-\u086A\u0870-\u088E\u0890\u0891\u08A0-\u08C9\u08E2\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBC2\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFC\uFE70-\uFE74\uFE76-\uFEFC\u{10800}-\u{10805}\u{10808}\u{1080A}-\u{10835}\u{10837}\u{10838}\u{1083C}\u{1083F}-\u{10855}\u{10857}-\u{1089E}\u{108A7}-\u{108AF}\u{108E0}-\u{108F2}\u{108F4}\u{108F5}\u{108FB}-\u{1091B}\u{10920}-\u{10939}\u{1093F}\u{10980}-\u{109B7}\u{109BC}-\u{109CF}\u{109D2}-\u{10A00}\u{10A10}-\u{10A13}\u{10A15}-\u{10A17}\u{10A19}-\u{10A35}\u{10A40}-\u{10A48}\u{10A50}-\u{10A58}\u{10A60}-\u{10A9F}\u{10AC0}-\u{10AE4}\u{10AEB}-\u{10AF6}\u{10B00}-\u{10B35}\u{10B40}-\u{10B55}\u{10B58}-\u{10B72}\u{10B78}-\u{10B91}\u{10B99}-\u{10B9C}\u{10BA9}-\u{10BAF}\u{10C00}-\u{10C48}\u{10C80}-\u{10CB2}\u{10CC0}-\u{10CF2}\u{10CFA}-\u{10D23}\u{10D30}-\u{10D39}\u{10D40}-\u{10D65}\u{10D6F}-\u{10D85}\u{10D8E}\u{10D8F}\u{10E60}-\u{10E7E}\u{10E80}-\u{10EA9}\u{10EAD}\u{10EB0}\u{10EB1}\u{10EC2}-\u{10EC4}\u{10F00}-\u{10F27}\u{10F30}-\u{10F45}\u{10F51}-\u{10F59}\u{10F70}-\u{10F81}\u{10F86}-\u{10F89}\u{10FB0}-\u{10FCB}\u{10FE0}-\u{10FF6}\u{1E800}-\u{1E8C4}\u{1E8C7}-\u{1E8CF}\u{1E900}-\u{1E943}\u{1E94B}\u{1E950}-\u{1E959}\u{1E95E}\u{1E95F}\u{1EC71}-\u{1ECB4}\u{1ED01}-\u{1ED3D}\u{1EE00}-\u{1EE03}\u{1EE05}-\u{1EE1F}\u{1EE21}\u{1EE22}\u{1EE24}\u{1EE27}\u{1EE29}-\u{1EE32}\u{1EE34}-\u{1EE37}\u{1EE39}\u{1EE3B}\u{1EE42}\u{1EE47}\u{1EE49}\u{1EE4B}\u{1EE4D}-\u{1EE4F}\u{1EE51}\u{1EE52}\u{1EE54}\u{1EE57}\u{1EE59}\u{1EE5B}\u{1EE5D}\u{1EE5F}\u{1EE61}\u{1EE62}\u{1EE64}\u{1EE67}-\u{1EE6A}\u{1EE6C}-\u{1EE72}\u{1EE74}-\u{1EE77}\u{1EE79}-\u{1EE7C}\u{1EE7E}\u{1EE80}-\u{1EE89}\u{1EE8B}-\u{1EE9B}\u{1EEA1}-\u{1EEA3}\u{1EEA5}-\u{1EEA9}\u{1EEAB}-\u{1EEBB}]/u; + var bidiS1LTR = /[A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02BB-\u02C1\u02D0\u02D1\u02E0-\u02E4\u02EE\u0370-\u0373\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0482\u048A-\u052F\u0531-\u0556\u0559-\u0589\u0903-\u0939\u093B\u093D-\u0940\u0949-\u094C\u094E-\u0950\u0958-\u0961\u0964-\u0980\u0982\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD-\u09C0\u09C7\u09C8\u09CB\u09CC\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09FA\u09FC\u09FD\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3E-\u0A40\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A76\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD-\u0AC0\u0AC9\u0ACB\u0ACC\u0AD0\u0AE0\u0AE1\u0AE6-\u0AF0\u0AF9\u0B02\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B3E\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0B57\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7\u0BE6-\u0BF2\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C41-\u0C44\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C77\u0C7F\u0C80\u0C82-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD-\u0CC4\u0CC6-\u0CC8\u0CCA\u0CCB\u0CD5\u0CD6\u0CDD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1-\u0CF3\u0D02-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D4F\u0D54-\u0D61\u0D66-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2-\u0DF4\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E4F-\u0E5B\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00-\u0F17\u0F1A-\u0F34\u0F36\u0F38\u0F3E-\u0F47\u0F49-\u0F6C\u0F7F\u0F85\u0F88-\u0F8C\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE-\u0FDA\u1000-\u102C\u1031\u1038\u103B\u103C\u103F-\u1057\u105A-\u105D\u1061-\u1070\u1075-\u1081\u1083\u1084\u1087-\u108C\u108E-\u109C\u109E-\u10C5\u10C7\u10CD\u10D0-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1360-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u167F\u1681-\u169A\u16A0-\u16F8\u1700-\u1711\u1715\u171F-\u1731\u1734-\u1736\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17B6\u17BE-\u17C5\u17C7\u17C8\u17D4-\u17DA\u17DC\u17E0-\u17E9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A19\u1A1A\u1A1E-\u1A55\u1A57\u1A61\u1A63\u1A64\u1A6D-\u1A72\u1A80-\u1A89\u1A90-\u1A99\u1AA0-\u1AAD\u1B04-\u1B33\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B4C\u1B4E-\u1B6A\u1B74-\u1B7F\u1B82-\u1BA1\u1BA6\u1BA7\u1BAA\u1BAE-\u1BE5\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1BFC-\u1C2B\u1C34\u1C35\u1C3B-\u1C49\u1C4D-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CC7\u1CD3\u1CE1\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5-\u1CF7\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200E\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u214F\u2160-\u2188\u2336-\u237A\u2395\u249C-\u24E9\u26AC\u2800-\u28FF\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D70\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u302E\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3190-\u31BF\u31F0-\u321C\u3220-\u324F\u3260-\u327B\u327F-\u32B0\u32C0-\u32CB\u32D0-\u3376\u337B-\u33DD\u33E0-\u33FE\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA60C\uA610-\uA62B\uA640-\uA66E\uA680-\uA69D\uA6A0-\uA6EF\uA6F2-\uA6F7\uA722-\uA787\uA789-\uA7CD\uA7D0\uA7D1\uA7D3\uA7D5-\uA7DC\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA824\uA827\uA830-\uA837\uA840-\uA873\uA880-\uA8C3\uA8CE-\uA8D9\uA8F2-\uA8FE\uA900-\uA925\uA92E-\uA946\uA952\uA953\uA95F-\uA97C\uA983-\uA9B2\uA9B4\uA9B5\uA9BA\uA9BB\uA9BE-\uA9CD\uA9CF-\uA9D9\uA9DE-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA2F\uAA30\uAA33\uAA34\uAA40-\uAA42\uAA44-\uAA4B\uAA4D\uAA50-\uAA59\uAA5C-\uAA7B\uAA7D-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAAEB\uAAEE-\uAAF5\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB69\uAB70-\uABE4\uABE6\uABE7\uABE9-\uABEC\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uD800-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC\u{10000}-\u{1000B}\u{1000D}-\u{10026}\u{10028}-\u{1003A}\u{1003C}\u{1003D}\u{1003F}-\u{1004D}\u{10050}-\u{1005D}\u{10080}-\u{100FA}\u{10100}\u{10102}\u{10107}-\u{10133}\u{10137}-\u{1013F}\u{1018D}\u{1018E}\u{101D0}-\u{101FC}\u{10280}-\u{1029C}\u{102A0}-\u{102D0}\u{10300}-\u{10323}\u{1032D}-\u{1034A}\u{10350}-\u{10375}\u{10380}-\u{1039D}\u{1039F}-\u{103C3}\u{103C8}-\u{103D5}\u{10400}-\u{1049D}\u{104A0}-\u{104A9}\u{104B0}-\u{104D3}\u{104D8}-\u{104FB}\u{10500}-\u{10527}\u{10530}-\u{10563}\u{1056F}-\u{1057A}\u{1057C}-\u{1058A}\u{1058C}-\u{10592}\u{10594}\u{10595}\u{10597}-\u{105A1}\u{105A3}-\u{105B1}\u{105B3}-\u{105B9}\u{105BB}\u{105BC}\u{105C0}-\u{105F3}\u{10600}-\u{10736}\u{10740}-\u{10755}\u{10760}-\u{10767}\u{10780}-\u{10785}\u{10787}-\u{107B0}\u{107B2}-\u{107BA}\u{11000}\u{11002}-\u{11037}\u{11047}-\u{1104D}\u{11066}-\u{1106F}\u{11071}\u{11072}\u{11075}\u{11082}-\u{110B2}\u{110B7}\u{110B8}\u{110BB}-\u{110C1}\u{110CD}\u{110D0}-\u{110E8}\u{110F0}-\u{110F9}\u{11103}-\u{11126}\u{1112C}\u{11136}-\u{11147}\u{11150}-\u{11172}\u{11174}-\u{11176}\u{11182}-\u{111B5}\u{111BF}-\u{111C8}\u{111CD}\u{111CE}\u{111D0}-\u{111DF}\u{111E1}-\u{111F4}\u{11200}-\u{11211}\u{11213}-\u{1122E}\u{11232}\u{11233}\u{11235}\u{11238}-\u{1123D}\u{1123F}\u{11240}\u{11280}-\u{11286}\u{11288}\u{1128A}-\u{1128D}\u{1128F}-\u{1129D}\u{1129F}-\u{112A9}\u{112B0}-\u{112DE}\u{112E0}-\u{112E2}\u{112F0}-\u{112F9}\u{11302}\u{11303}\u{11305}-\u{1130C}\u{1130F}\u{11310}\u{11313}-\u{11328}\u{1132A}-\u{11330}\u{11332}\u{11333}\u{11335}-\u{11339}\u{1133D}-\u{1133F}\u{11341}-\u{11344}\u{11347}\u{11348}\u{1134B}-\u{1134D}\u{11350}\u{11357}\u{1135D}-\u{11363}\u{11380}-\u{11389}\u{1138B}\u{1138E}\u{11390}-\u{113B5}\u{113B7}-\u{113BA}\u{113C2}\u{113C5}\u{113C7}-\u{113CA}\u{113CC}\u{113CD}\u{113CF}\u{113D1}\u{113D3}-\u{113D5}\u{113D7}\u{113D8}\u{11400}-\u{11437}\u{11440}\u{11441}\u{11445}\u{11447}-\u{1145B}\u{1145D}\u{1145F}-\u{11461}\u{11480}-\u{114B2}\u{114B9}\u{114BB}-\u{114BE}\u{114C1}\u{114C4}-\u{114C7}\u{114D0}-\u{114D9}\u{11580}-\u{115B1}\u{115B8}-\u{115BB}\u{115BE}\u{115C1}-\u{115DB}\u{11600}-\u{11632}\u{1163B}\u{1163C}\u{1163E}\u{11641}-\u{11644}\u{11650}-\u{11659}\u{11680}-\u{116AA}\u{116AC}\u{116AE}\u{116AF}\u{116B6}\u{116B8}\u{116B9}\u{116C0}-\u{116C9}\u{116D0}-\u{116E3}\u{11700}-\u{1171A}\u{1171E}\u{11720}\u{11721}\u{11726}\u{11730}-\u{11746}\u{11800}-\u{1182E}\u{11838}\u{1183B}\u{118A0}-\u{118F2}\u{118FF}-\u{11906}\u{11909}\u{1190C}-\u{11913}\u{11915}\u{11916}\u{11918}-\u{11935}\u{11937}\u{11938}\u{1193D}\u{1193F}-\u{11942}\u{11944}-\u{11946}\u{11950}-\u{11959}\u{119A0}-\u{119A7}\u{119AA}-\u{119D3}\u{119DC}-\u{119DF}\u{119E1}-\u{119E4}\u{11A00}\u{11A07}\u{11A08}\u{11A0B}-\u{11A32}\u{11A39}\u{11A3A}\u{11A3F}-\u{11A46}\u{11A50}\u{11A57}\u{11A58}\u{11A5C}-\u{11A89}\u{11A97}\u{11A9A}-\u{11AA2}\u{11AB0}-\u{11AF8}\u{11B00}-\u{11B09}\u{11BC0}-\u{11BE1}\u{11BF0}-\u{11BF9}\u{11C00}-\u{11C08}\u{11C0A}-\u{11C2F}\u{11C3E}-\u{11C45}\u{11C50}-\u{11C6C}\u{11C70}-\u{11C8F}\u{11CA9}\u{11CB1}\u{11CB4}\u{11D00}-\u{11D06}\u{11D08}\u{11D09}\u{11D0B}-\u{11D30}\u{11D46}\u{11D50}-\u{11D59}\u{11D60}-\u{11D65}\u{11D67}\u{11D68}\u{11D6A}-\u{11D8E}\u{11D93}\u{11D94}\u{11D96}\u{11D98}\u{11DA0}-\u{11DA9}\u{11EE0}-\u{11EF2}\u{11EF5}-\u{11EF8}\u{11F02}-\u{11F10}\u{11F12}-\u{11F35}\u{11F3E}\u{11F3F}\u{11F41}\u{11F43}-\u{11F59}\u{11FB0}\u{11FC0}-\u{11FD4}\u{11FFF}-\u{12399}\u{12400}-\u{1246E}\u{12470}-\u{12474}\u{12480}-\u{12543}\u{12F90}-\u{12FF2}\u{13000}-\u{1343F}\u{13441}-\u{13446}\u{13460}-\u{143FA}\u{14400}-\u{14646}\u{16100}-\u{1611D}\u{1612A}-\u{1612C}\u{16130}-\u{16139}\u{16800}-\u{16A38}\u{16A40}-\u{16A5E}\u{16A60}-\u{16A69}\u{16A6E}-\u{16ABE}\u{16AC0}-\u{16AC9}\u{16AD0}-\u{16AED}\u{16AF5}\u{16B00}-\u{16B2F}\u{16B37}-\u{16B45}\u{16B50}-\u{16B59}\u{16B5B}-\u{16B61}\u{16B63}-\u{16B77}\u{16B7D}-\u{16B8F}\u{16D40}-\u{16D79}\u{16E40}-\u{16E9A}\u{16F00}-\u{16F4A}\u{16F50}-\u{16F87}\u{16F93}-\u{16F9F}\u{16FE0}\u{16FE1}\u{16FE3}\u{16FF0}\u{16FF1}\u{17000}-\u{187F7}\u{18800}-\u{18CD5}\u{18CFF}-\u{18D08}\u{1AFF0}-\u{1AFF3}\u{1AFF5}-\u{1AFFB}\u{1AFFD}\u{1AFFE}\u{1B000}-\u{1B122}\u{1B132}\u{1B150}-\u{1B152}\u{1B155}\u{1B164}-\u{1B167}\u{1B170}-\u{1B2FB}\u{1BC00}-\u{1BC6A}\u{1BC70}-\u{1BC7C}\u{1BC80}-\u{1BC88}\u{1BC90}-\u{1BC99}\u{1BC9C}\u{1BC9F}\u{1CCD6}-\u{1CCEF}\u{1CF50}-\u{1CFC3}\u{1D000}-\u{1D0F5}\u{1D100}-\u{1D126}\u{1D129}-\u{1D166}\u{1D16A}-\u{1D172}\u{1D183}\u{1D184}\u{1D18C}-\u{1D1A9}\u{1D1AE}-\u{1D1E8}\u{1D2C0}-\u{1D2D3}\u{1D2E0}-\u{1D2F3}\u{1D360}-\u{1D378}\u{1D400}-\u{1D454}\u{1D456}-\u{1D49C}\u{1D49E}\u{1D49F}\u{1D4A2}\u{1D4A5}\u{1D4A6}\u{1D4A9}-\u{1D4AC}\u{1D4AE}-\u{1D4B9}\u{1D4BB}\u{1D4BD}-\u{1D4C3}\u{1D4C5}-\u{1D505}\u{1D507}-\u{1D50A}\u{1D50D}-\u{1D514}\u{1D516}-\u{1D51C}\u{1D51E}-\u{1D539}\u{1D53B}-\u{1D53E}\u{1D540}-\u{1D544}\u{1D546}\u{1D54A}-\u{1D550}\u{1D552}-\u{1D6A5}\u{1D6A8}-\u{1D6C0}\u{1D6C2}-\u{1D6DA}\u{1D6DC}-\u{1D6FA}\u{1D6FC}-\u{1D714}\u{1D716}-\u{1D734}\u{1D736}-\u{1D74E}\u{1D750}-\u{1D76E}\u{1D770}-\u{1D788}\u{1D78A}-\u{1D7A8}\u{1D7AA}-\u{1D7C2}\u{1D7C4}-\u{1D7CB}\u{1D800}-\u{1D9FF}\u{1DA37}-\u{1DA3A}\u{1DA6D}-\u{1DA74}\u{1DA76}-\u{1DA83}\u{1DA85}-\u{1DA8B}\u{1DF00}-\u{1DF1E}\u{1DF25}-\u{1DF2A}\u{1E030}-\u{1E06D}\u{1E100}-\u{1E12C}\u{1E137}-\u{1E13D}\u{1E140}-\u{1E149}\u{1E14E}\u{1E14F}\u{1E290}-\u{1E2AD}\u{1E2C0}-\u{1E2EB}\u{1E2F0}-\u{1E2F9}\u{1E4D0}-\u{1E4EB}\u{1E4F0}-\u{1E4F9}\u{1E5D0}-\u{1E5ED}\u{1E5F0}-\u{1E5FA}\u{1E5FF}\u{1E7E0}-\u{1E7E6}\u{1E7E8}-\u{1E7EB}\u{1E7ED}\u{1E7EE}\u{1E7F0}-\u{1E7FE}\u{1F110}-\u{1F12E}\u{1F130}-\u{1F169}\u{1F170}-\u{1F1AC}\u{1F1E6}-\u{1F202}\u{1F210}-\u{1F23B}\u{1F240}-\u{1F248}\u{1F250}\u{1F251}\u{20000}-\u{2A6DF}\u{2A700}-\u{2B739}\u{2B740}-\u{2B81D}\u{2B820}-\u{2CEA1}\u{2CEB0}-\u{2EBE0}\u{2EBF0}-\u{2EE5D}\u{2F800}-\u{2FA1D}\u{30000}-\u{3134A}\u{31350}-\u{323AF}\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]/u; + var bidiS1RTL = /[\u05BE\u05C0\u05C3\u05C6\u05D0-\u05EA\u05EF-\u05F4\u0608\u060B\u060D\u061B-\u064A\u066D-\u066F\u0671-\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u070D\u070F\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u083E\u0840-\u0858\u085E\u0860-\u086A\u0870-\u088E\u08A0-\u08C9\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBC2\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFC\uFE70-\uFE74\uFE76-\uFEFC\u{10800}-\u{10805}\u{10808}\u{1080A}-\u{10835}\u{10837}\u{10838}\u{1083C}\u{1083F}-\u{10855}\u{10857}-\u{1089E}\u{108A7}-\u{108AF}\u{108E0}-\u{108F2}\u{108F4}\u{108F5}\u{108FB}-\u{1091B}\u{10920}-\u{10939}\u{1093F}\u{10980}-\u{109B7}\u{109BC}-\u{109CF}\u{109D2}-\u{10A00}\u{10A10}-\u{10A13}\u{10A15}-\u{10A17}\u{10A19}-\u{10A35}\u{10A40}-\u{10A48}\u{10A50}-\u{10A58}\u{10A60}-\u{10A9F}\u{10AC0}-\u{10AE4}\u{10AEB}-\u{10AF6}\u{10B00}-\u{10B35}\u{10B40}-\u{10B55}\u{10B58}-\u{10B72}\u{10B78}-\u{10B91}\u{10B99}-\u{10B9C}\u{10BA9}-\u{10BAF}\u{10C00}-\u{10C48}\u{10C80}-\u{10CB2}\u{10CC0}-\u{10CF2}\u{10CFA}-\u{10D23}\u{10D4A}-\u{10D65}\u{10D6F}-\u{10D85}\u{10D8E}\u{10D8F}\u{10E80}-\u{10EA9}\u{10EAD}\u{10EB0}\u{10EB1}\u{10EC2}-\u{10EC4}\u{10F00}-\u{10F27}\u{10F30}-\u{10F45}\u{10F51}-\u{10F59}\u{10F70}-\u{10F81}\u{10F86}-\u{10F89}\u{10FB0}-\u{10FCB}\u{10FE0}-\u{10FF6}\u{1E800}-\u{1E8C4}\u{1E8C7}-\u{1E8CF}\u{1E900}-\u{1E943}\u{1E94B}\u{1E950}-\u{1E959}\u{1E95E}\u{1E95F}\u{1EC71}-\u{1ECB4}\u{1ED01}-\u{1ED3D}\u{1EE00}-\u{1EE03}\u{1EE05}-\u{1EE1F}\u{1EE21}\u{1EE22}\u{1EE24}\u{1EE27}\u{1EE29}-\u{1EE32}\u{1EE34}-\u{1EE37}\u{1EE39}\u{1EE3B}\u{1EE42}\u{1EE47}\u{1EE49}\u{1EE4B}\u{1EE4D}-\u{1EE4F}\u{1EE51}\u{1EE52}\u{1EE54}\u{1EE57}\u{1EE59}\u{1EE5B}\u{1EE5D}\u{1EE5F}\u{1EE61}\u{1EE62}\u{1EE64}\u{1EE67}-\u{1EE6A}\u{1EE6C}-\u{1EE72}\u{1EE74}-\u{1EE77}\u{1EE79}-\u{1EE7C}\u{1EE7E}\u{1EE80}-\u{1EE89}\u{1EE8B}-\u{1EE9B}\u{1EEA1}-\u{1EEA3}\u{1EEA5}-\u{1EEA9}\u{1EEAB}-\u{1EEBB}]/u; + var bidiS2 = /^[\0-\x08\x0E-\x1B!-@\[-`\{-\x84\x86-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02B9\u02BA\u02C2-\u02CF\u02D2-\u02DF\u02E5-\u02ED\u02EF-\u036F\u0374\u0375\u037E\u0384\u0385\u0387\u03F6\u0483-\u0489\u058A\u058D-\u058F\u0591-\u05C7\u05D0-\u05EA\u05EF-\u05F4\u0600-\u070D\u070F-\u074A\u074D-\u07B1\u07C0-\u07FA\u07FD-\u082D\u0830-\u083E\u0840-\u085B\u085E\u0860-\u086A\u0870-\u088E\u0890\u0891\u0897-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09F2\u09F3\u09FB\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AF1\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0BF3-\u0BFA\u0C00\u0C04\u0C3C\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C78-\u0C7E\u0C81\u0CBC\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E3F\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39-\u0F3D\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1390-\u1399\u1400\u169B\u169C\u1712-\u1714\u1732\u1733\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DB\u17DD\u17F0-\u17F9\u1800-\u180F\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1940\u1944\u1945\u19DE-\u19FF\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DFF\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u200B-\u200D\u200F-\u2027\u202F-\u205E\u2060-\u2064\u206A-\u2070\u2074-\u207E\u2080-\u208E\u20A0-\u20C0\u20D0-\u20F0\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u2150-\u215F\u2189-\u218B\u2190-\u2335\u237B-\u2394\u2396-\u2429\u2440-\u244A\u2460-\u249B\u24EA-\u26AB\u26AD-\u27FF\u2900-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2CEF-\u2CF1\u2CF9-\u2CFF\u2D7F\u2DE0-\u2E5D\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3001-\u3004\u3008-\u3020\u302A-\u302D\u3030\u3036\u3037\u303D-\u303F\u3099-\u309C\u30A0\u30FB\u31C0-\u31E5\u31EF\u321D\u321E\u3250-\u325F\u327C-\u327E\u32B1-\u32BF\u32CC-\u32CF\u3377-\u337A\u33DE\u33DF\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA60D-\uA60F\uA66F-\uA67F\uA69E\uA69F\uA6F0\uA6F1\uA700-\uA721\uA788\uA802\uA806\uA80B\uA825\uA826\uA828-\uA82C\uA838\uA839\uA874-\uA877\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uAB6A\uAB6B\uABE5\uABE8\uABED\uFB1D-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBC2\uFBD3-\uFD8F\uFD92-\uFDC7\uFDCF\uFDF0-\uFE19\uFE20-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFE70-\uFE74\uFE76-\uFEFC\uFEFF\uFF01-\uFF20\uFF3B-\uFF40\uFF5B-\uFF65\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFF9-\uFFFD\u{10101}\u{10140}-\u{1018C}\u{10190}-\u{1019C}\u{101A0}\u{101FD}\u{102E0}-\u{102FB}\u{10376}-\u{1037A}\u{10800}-\u{10805}\u{10808}\u{1080A}-\u{10835}\u{10837}\u{10838}\u{1083C}\u{1083F}-\u{10855}\u{10857}-\u{1089E}\u{108A7}-\u{108AF}\u{108E0}-\u{108F2}\u{108F4}\u{108F5}\u{108FB}-\u{1091B}\u{1091F}-\u{10939}\u{1093F}\u{10980}-\u{109B7}\u{109BC}-\u{109CF}\u{109D2}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A13}\u{10A15}-\u{10A17}\u{10A19}-\u{10A35}\u{10A38}-\u{10A3A}\u{10A3F}-\u{10A48}\u{10A50}-\u{10A58}\u{10A60}-\u{10A9F}\u{10AC0}-\u{10AE6}\u{10AEB}-\u{10AF6}\u{10B00}-\u{10B35}\u{10B39}-\u{10B55}\u{10B58}-\u{10B72}\u{10B78}-\u{10B91}\u{10B99}-\u{10B9C}\u{10BA9}-\u{10BAF}\u{10C00}-\u{10C48}\u{10C80}-\u{10CB2}\u{10CC0}-\u{10CF2}\u{10CFA}-\u{10D27}\u{10D30}-\u{10D39}\u{10D40}-\u{10D65}\u{10D69}-\u{10D85}\u{10D8E}\u{10D8F}\u{10E60}-\u{10E7E}\u{10E80}-\u{10EA9}\u{10EAB}-\u{10EAD}\u{10EB0}\u{10EB1}\u{10EC2}-\u{10EC4}\u{10EFC}-\u{10F27}\u{10F30}-\u{10F59}\u{10F70}-\u{10F89}\u{10FB0}-\u{10FCB}\u{10FE0}-\u{10FF6}\u{11001}\u{11038}-\u{11046}\u{11052}-\u{11065}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11081}\u{110B3}-\u{110B6}\u{110B9}\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{1112B}\u{1112D}-\u{11134}\u{11173}\u{11180}\u{11181}\u{111B6}-\u{111BE}\u{111C9}-\u{111CC}\u{111CF}\u{1122F}-\u{11231}\u{11234}\u{11236}\u{11237}\u{1123E}\u{11241}\u{112DF}\u{112E3}-\u{112EA}\u{11300}\u{11301}\u{1133B}\u{1133C}\u{11340}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113BB}-\u{113C0}\u{113CE}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11438}-\u{1143F}\u{11442}-\u{11444}\u{11446}\u{1145E}\u{114B3}-\u{114B8}\u{114BA}\u{114BF}\u{114C0}\u{114C2}\u{114C3}\u{115B2}-\u{115B5}\u{115BC}\u{115BD}\u{115BF}\u{115C0}\u{115DC}\u{115DD}\u{11633}-\u{1163A}\u{1163D}\u{1163F}\u{11640}\u{11660}-\u{1166C}\u{116AB}\u{116AD}\u{116B0}-\u{116B5}\u{116B7}\u{1171D}\u{1171F}\u{11722}-\u{11725}\u{11727}-\u{1172B}\u{1182F}-\u{11837}\u{11839}\u{1183A}\u{1193B}\u{1193C}\u{1193E}\u{11943}\u{119D4}-\u{119D7}\u{119DA}\u{119DB}\u{119E0}\u{11A01}-\u{11A06}\u{11A09}\u{11A0A}\u{11A33}-\u{11A38}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A56}\u{11A59}-\u{11A5B}\u{11A8A}-\u{11A96}\u{11A98}\u{11A99}\u{11C30}-\u{11C36}\u{11C38}-\u{11C3D}\u{11C92}-\u{11CA7}\u{11CAA}-\u{11CB0}\u{11CB2}\u{11CB3}\u{11CB5}\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D90}\u{11D91}\u{11D95}\u{11D97}\u{11EF3}\u{11EF4}\u{11F00}\u{11F01}\u{11F36}-\u{11F3A}\u{11F40}\u{11F42}\u{11F5A}\u{11FD5}-\u{11FF1}\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{16129}\u{1612D}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F8F}-\u{16F92}\u{16FE2}\u{16FE4}\u{1BC9D}\u{1BC9E}\u{1BCA0}-\u{1BCA3}\u{1CC00}-\u{1CCD5}\u{1CCF0}-\u{1CCF9}\u{1CD00}-\u{1CEB3}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D167}-\u{1D169}\u{1D173}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D1E9}\u{1D1EA}\u{1D200}-\u{1D245}\u{1D300}-\u{1D356}\u{1D6C1}\u{1D6DB}\u{1D6FB}\u{1D715}\u{1D735}\u{1D74F}\u{1D76F}\u{1D789}\u{1D7A9}\u{1D7C3}\u{1D7CE}-\u{1D7FF}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E2FF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E800}-\u{1E8C4}\u{1E8C7}-\u{1E8D6}\u{1E900}-\u{1E94B}\u{1E950}-\u{1E959}\u{1E95E}\u{1E95F}\u{1EC71}-\u{1ECB4}\u{1ED01}-\u{1ED3D}\u{1EE00}-\u{1EE03}\u{1EE05}-\u{1EE1F}\u{1EE21}\u{1EE22}\u{1EE24}\u{1EE27}\u{1EE29}-\u{1EE32}\u{1EE34}-\u{1EE37}\u{1EE39}\u{1EE3B}\u{1EE42}\u{1EE47}\u{1EE49}\u{1EE4B}\u{1EE4D}-\u{1EE4F}\u{1EE51}\u{1EE52}\u{1EE54}\u{1EE57}\u{1EE59}\u{1EE5B}\u{1EE5D}\u{1EE5F}\u{1EE61}\u{1EE62}\u{1EE64}\u{1EE67}-\u{1EE6A}\u{1EE6C}-\u{1EE72}\u{1EE74}-\u{1EE77}\u{1EE79}-\u{1EE7C}\u{1EE7E}\u{1EE80}-\u{1EE89}\u{1EE8B}-\u{1EE9B}\u{1EEA1}-\u{1EEA3}\u{1EEA5}-\u{1EEA9}\u{1EEAB}-\u{1EEBB}\u{1EEF0}\u{1EEF1}\u{1F000}-\u{1F02B}\u{1F030}-\u{1F093}\u{1F0A0}-\u{1F0AE}\u{1F0B1}-\u{1F0BF}\u{1F0C1}-\u{1F0CF}\u{1F0D1}-\u{1F0F5}\u{1F100}-\u{1F10F}\u{1F12F}\u{1F16A}-\u{1F16F}\u{1F1AD}\u{1F260}-\u{1F265}\u{1F300}-\u{1F6D7}\u{1F6DC}-\u{1F6EC}\u{1F6F0}-\u{1F6FC}\u{1F700}-\u{1F776}\u{1F77B}-\u{1F7D9}\u{1F7E0}-\u{1F7EB}\u{1F7F0}\u{1F800}-\u{1F80B}\u{1F810}-\u{1F847}\u{1F850}-\u{1F859}\u{1F860}-\u{1F887}\u{1F890}-\u{1F8AD}\u{1F8B0}-\u{1F8BB}\u{1F8C0}\u{1F8C1}\u{1F900}-\u{1FA53}\u{1FA60}-\u{1FA6D}\u{1FA70}-\u{1FA7C}\u{1FA80}-\u{1FA89}\u{1FA8F}-\u{1FAC6}\u{1FACE}-\u{1FADC}\u{1FADF}-\u{1FAE9}\u{1FAF0}-\u{1FAF8}\u{1FB00}-\u{1FB92}\u{1FB94}-\u{1FBF9}\u{E0001}\u{E0020}-\u{E007F}\u{E0100}-\u{E01EF}]*$/u; + var bidiS3 = /[0-9\xB2\xB3\xB9\u05BE\u05C0\u05C3\u05C6\u05D0-\u05EA\u05EF-\u05F4\u0600-\u0605\u0608\u060B\u060D\u061B-\u064A\u0660-\u0669\u066B-\u066F\u0671-\u06D5\u06DD\u06E5\u06E6\u06EE-\u070D\u070F\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07C0-\u07EA\u07F4\u07F5\u07FA\u07FE-\u0815\u081A\u0824\u0828\u0830-\u083E\u0840-\u0858\u085E\u0860-\u086A\u0870-\u088E\u0890\u0891\u08A0-\u08C9\u08E2\u200F\u2070\u2074-\u2079\u2080-\u2089\u2488-\u249B\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBC2\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFC\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\u{102E1}-\u{102FB}\u{10800}-\u{10805}\u{10808}\u{1080A}-\u{10835}\u{10837}\u{10838}\u{1083C}\u{1083F}-\u{10855}\u{10857}-\u{1089E}\u{108A7}-\u{108AF}\u{108E0}-\u{108F2}\u{108F4}\u{108F5}\u{108FB}-\u{1091B}\u{10920}-\u{10939}\u{1093F}\u{10980}-\u{109B7}\u{109BC}-\u{109CF}\u{109D2}-\u{10A00}\u{10A10}-\u{10A13}\u{10A15}-\u{10A17}\u{10A19}-\u{10A35}\u{10A40}-\u{10A48}\u{10A50}-\u{10A58}\u{10A60}-\u{10A9F}\u{10AC0}-\u{10AE4}\u{10AEB}-\u{10AF6}\u{10B00}-\u{10B35}\u{10B40}-\u{10B55}\u{10B58}-\u{10B72}\u{10B78}-\u{10B91}\u{10B99}-\u{10B9C}\u{10BA9}-\u{10BAF}\u{10C00}-\u{10C48}\u{10C80}-\u{10CB2}\u{10CC0}-\u{10CF2}\u{10CFA}-\u{10D23}\u{10D30}-\u{10D39}\u{10D40}-\u{10D65}\u{10D6F}-\u{10D85}\u{10D8E}\u{10D8F}\u{10E60}-\u{10E7E}\u{10E80}-\u{10EA9}\u{10EAD}\u{10EB0}\u{10EB1}\u{10EC2}-\u{10EC4}\u{10F00}-\u{10F27}\u{10F30}-\u{10F45}\u{10F51}-\u{10F59}\u{10F70}-\u{10F81}\u{10F86}-\u{10F89}\u{10FB0}-\u{10FCB}\u{10FE0}-\u{10FF6}\u{1CCF0}-\u{1CCF9}\u{1D7CE}-\u{1D7FF}\u{1E800}-\u{1E8C4}\u{1E8C7}-\u{1E8CF}\u{1E900}-\u{1E943}\u{1E94B}\u{1E950}-\u{1E959}\u{1E95E}\u{1E95F}\u{1EC71}-\u{1ECB4}\u{1ED01}-\u{1ED3D}\u{1EE00}-\u{1EE03}\u{1EE05}-\u{1EE1F}\u{1EE21}\u{1EE22}\u{1EE24}\u{1EE27}\u{1EE29}-\u{1EE32}\u{1EE34}-\u{1EE37}\u{1EE39}\u{1EE3B}\u{1EE42}\u{1EE47}\u{1EE49}\u{1EE4B}\u{1EE4D}-\u{1EE4F}\u{1EE51}\u{1EE52}\u{1EE54}\u{1EE57}\u{1EE59}\u{1EE5B}\u{1EE5D}\u{1EE5F}\u{1EE61}\u{1EE62}\u{1EE64}\u{1EE67}-\u{1EE6A}\u{1EE6C}-\u{1EE72}\u{1EE74}-\u{1EE77}\u{1EE79}-\u{1EE7C}\u{1EE7E}\u{1EE80}-\u{1EE89}\u{1EE8B}-\u{1EE9B}\u{1EEA1}-\u{1EEA3}\u{1EEA5}-\u{1EEA9}\u{1EEAB}-\u{1EEBB}\u{1F100}-\u{1F10A}\u{1FBF0}-\u{1FBF9}][\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3C\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732\u1733\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\u{101FD}\u{102E0}\u{10376}-\u{1037A}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6D}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11001}\u{11038}-\u{11046}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11081}\u{110B3}-\u{110B6}\u{110B9}\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{1112B}\u{1112D}-\u{11134}\u{11173}\u{11180}\u{11181}\u{111B6}-\u{111BE}\u{111C9}-\u{111CC}\u{111CF}\u{1122F}-\u{11231}\u{11234}\u{11236}\u{11237}\u{1123E}\u{11241}\u{112DF}\u{112E3}-\u{112EA}\u{11300}\u{11301}\u{1133B}\u{1133C}\u{11340}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113BB}-\u{113C0}\u{113CE}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11438}-\u{1143F}\u{11442}-\u{11444}\u{11446}\u{1145E}\u{114B3}-\u{114B8}\u{114BA}\u{114BF}\u{114C0}\u{114C2}\u{114C3}\u{115B2}-\u{115B5}\u{115BC}\u{115BD}\u{115BF}\u{115C0}\u{115DC}\u{115DD}\u{11633}-\u{1163A}\u{1163D}\u{1163F}\u{11640}\u{116AB}\u{116AD}\u{116B0}-\u{116B5}\u{116B7}\u{1171D}\u{1171F}\u{11722}-\u{11725}\u{11727}-\u{1172B}\u{1182F}-\u{11837}\u{11839}\u{1183A}\u{1193B}\u{1193C}\u{1193E}\u{11943}\u{119D4}-\u{119D7}\u{119DA}\u{119DB}\u{119E0}\u{11A01}-\u{11A06}\u{11A09}\u{11A0A}\u{11A33}-\u{11A38}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A56}\u{11A59}-\u{11A5B}\u{11A8A}-\u{11A96}\u{11A98}\u{11A99}\u{11C30}-\u{11C36}\u{11C38}-\u{11C3D}\u{11C92}-\u{11CA7}\u{11CAA}-\u{11CB0}\u{11CB2}\u{11CB3}\u{11CB5}\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D90}\u{11D91}\u{11D95}\u{11D97}\u{11EF3}\u{11EF4}\u{11F00}\u{11F01}\u{11F36}-\u{11F3A}\u{11F40}\u{11F42}\u{11F5A}\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{16129}\u{1612D}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F8F}-\u{16F92}\u{16FE4}\u{1BC9D}\u{1BC9E}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D167}-\u{1D169}\u{1D17B}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D242}-\u{1D244}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94A}\u{E0100}-\u{E01EF}]*$/u; + var bidiS4EN = /[0-9\xB2\xB3\xB9\u06F0-\u06F9\u2070\u2074-\u2079\u2080-\u2089\u2488-\u249B\uFF10-\uFF19\u{102E1}-\u{102FB}\u{1CCF0}-\u{1CCF9}\u{1D7CE}-\u{1D7FF}\u{1F100}-\u{1F10A}\u{1FBF0}-\u{1FBF9}]/u; + var bidiS4AN = /[\u0600-\u0605\u0660-\u0669\u066B\u066C\u06DD\u0890\u0891\u08E2\u{10D30}-\u{10D39}\u{10D40}-\u{10D49}\u{10E60}-\u{10E7E}]/u; + var bidiS5 = /^[\0-\x08\x0E-\x1B!-\x84\x86-\u0377\u037A-\u037F\u0384-\u038A\u038C\u038E-\u03A1\u03A3-\u052F\u0531-\u0556\u0559-\u058A\u058D-\u058F\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0606\u0607\u0609\u060A\u060C\u060E-\u061A\u064B-\u065F\u066A\u0670\u06D6-\u06DC\u06DE-\u06E4\u06E7-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07F6-\u07F9\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09FE\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A76\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AF1\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B77\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BFA\u0C00-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3C-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C5D\u0C60-\u0C63\u0C66-\u0C6F\u0C77-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDD\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1-\u0CF3\u0D00-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4F\u0D54-\u0D63\u0D66-\u0D7F\u0D81-\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2-\u0DF4\u0E01-\u0E3A\u0E3F-\u0E5B\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECE\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00-\u0F47\u0F49-\u0F6C\u0F71-\u0F97\u0F99-\u0FBC\u0FBE-\u0FCC\u0FCE-\u0FDA\u1000-\u10C5\u10C7\u10CD\u10D0-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u137C\u1380-\u1399\u13A0-\u13F5\u13F8-\u13FD\u1400-\u167F\u1681-\u169C\u16A0-\u16F8\u1700-\u1715\u171F-\u1736\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17DD\u17E0-\u17E9\u17F0-\u17F9\u1800-\u1819\u1820-\u1878\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1940\u1944-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u19DE-\u1A1B\u1A1E-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA0-\u1AAD\u1AB0-\u1ACE\u1B00-\u1B4C\u1B4E-\u1BF3\u1BFC-\u1C37\u1C3B-\u1C49\u1C4D-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CC7\u1CD0-\u1CFA\u1D00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEF\u1FF2-\u1FF4\u1FF6-\u1FFE\u200B-\u200E\u2010-\u2027\u202F-\u205E\u2060-\u2064\u206A-\u2071\u2074-\u208E\u2090-\u209C\u20A0-\u20C0\u20D0-\u20F0\u2100-\u218B\u2190-\u2429\u2440-\u244A\u2460-\u2B73\u2B76-\u2B95\u2B97-\u2CF3\u2CF9-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D70\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2E5D\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFF\u3001-\u303F\u3041-\u3096\u3099-\u30FF\u3105-\u312F\u3131-\u318E\u3190-\u31E5\u31EF-\u321E\u3220-\uA48C\uA490-\uA4C6\uA4D0-\uA62B\uA640-\uA6F7\uA700-\uA7CD\uA7D0\uA7D1\uA7D3\uA7D5-\uA7DC\uA7F2-\uA82C\uA830-\uA839\uA840-\uA877\uA880-\uA8C5\uA8CE-\uA8D9\uA8E0-\uA953\uA95F-\uA97C\uA980-\uA9CD\uA9CF-\uA9D9\uA9DE-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA5C-\uAAC2\uAADB-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB6B\uAB70-\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uD800-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1E\uFB29\uFD3E-\uFD4F\uFDCF\uFDFD-\uFE19\uFE20-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFEFF\uFF01-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFF9-\uFFFD\u{10000}-\u{1000B}\u{1000D}-\u{10026}\u{10028}-\u{1003A}\u{1003C}\u{1003D}\u{1003F}-\u{1004D}\u{10050}-\u{1005D}\u{10080}-\u{100FA}\u{10100}-\u{10102}\u{10107}-\u{10133}\u{10137}-\u{1018E}\u{10190}-\u{1019C}\u{101A0}\u{101D0}-\u{101FD}\u{10280}-\u{1029C}\u{102A0}-\u{102D0}\u{102E0}-\u{102FB}\u{10300}-\u{10323}\u{1032D}-\u{1034A}\u{10350}-\u{1037A}\u{10380}-\u{1039D}\u{1039F}-\u{103C3}\u{103C8}-\u{103D5}\u{10400}-\u{1049D}\u{104A0}-\u{104A9}\u{104B0}-\u{104D3}\u{104D8}-\u{104FB}\u{10500}-\u{10527}\u{10530}-\u{10563}\u{1056F}-\u{1057A}\u{1057C}-\u{1058A}\u{1058C}-\u{10592}\u{10594}\u{10595}\u{10597}-\u{105A1}\u{105A3}-\u{105B1}\u{105B3}-\u{105B9}\u{105BB}\u{105BC}\u{105C0}-\u{105F3}\u{10600}-\u{10736}\u{10740}-\u{10755}\u{10760}-\u{10767}\u{10780}-\u{10785}\u{10787}-\u{107B0}\u{107B2}-\u{107BA}\u{1091F}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10B39}-\u{10B3F}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6E}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11000}-\u{1104D}\u{11052}-\u{11075}\u{1107F}-\u{110C2}\u{110CD}\u{110D0}-\u{110E8}\u{110F0}-\u{110F9}\u{11100}-\u{11134}\u{11136}-\u{11147}\u{11150}-\u{11176}\u{11180}-\u{111DF}\u{111E1}-\u{111F4}\u{11200}-\u{11211}\u{11213}-\u{11241}\u{11280}-\u{11286}\u{11288}\u{1128A}-\u{1128D}\u{1128F}-\u{1129D}\u{1129F}-\u{112A9}\u{112B0}-\u{112EA}\u{112F0}-\u{112F9}\u{11300}-\u{11303}\u{11305}-\u{1130C}\u{1130F}\u{11310}\u{11313}-\u{11328}\u{1132A}-\u{11330}\u{11332}\u{11333}\u{11335}-\u{11339}\u{1133B}-\u{11344}\u{11347}\u{11348}\u{1134B}-\u{1134D}\u{11350}\u{11357}\u{1135D}-\u{11363}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{11380}-\u{11389}\u{1138B}\u{1138E}\u{11390}-\u{113B5}\u{113B7}-\u{113C0}\u{113C2}\u{113C5}\u{113C7}-\u{113CA}\u{113CC}-\u{113D5}\u{113D7}\u{113D8}\u{113E1}\u{113E2}\u{11400}-\u{1145B}\u{1145D}-\u{11461}\u{11480}-\u{114C7}\u{114D0}-\u{114D9}\u{11580}-\u{115B5}\u{115B8}-\u{115DD}\u{11600}-\u{11644}\u{11650}-\u{11659}\u{11660}-\u{1166C}\u{11680}-\u{116B9}\u{116C0}-\u{116C9}\u{116D0}-\u{116E3}\u{11700}-\u{1171A}\u{1171D}-\u{1172B}\u{11730}-\u{11746}\u{11800}-\u{1183B}\u{118A0}-\u{118F2}\u{118FF}-\u{11906}\u{11909}\u{1190C}-\u{11913}\u{11915}\u{11916}\u{11918}-\u{11935}\u{11937}\u{11938}\u{1193B}-\u{11946}\u{11950}-\u{11959}\u{119A0}-\u{119A7}\u{119AA}-\u{119D7}\u{119DA}-\u{119E4}\u{11A00}-\u{11A47}\u{11A50}-\u{11AA2}\u{11AB0}-\u{11AF8}\u{11B00}-\u{11B09}\u{11BC0}-\u{11BE1}\u{11BF0}-\u{11BF9}\u{11C00}-\u{11C08}\u{11C0A}-\u{11C36}\u{11C38}-\u{11C45}\u{11C50}-\u{11C6C}\u{11C70}-\u{11C8F}\u{11C92}-\u{11CA7}\u{11CA9}-\u{11CB6}\u{11D00}-\u{11D06}\u{11D08}\u{11D09}\u{11D0B}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D47}\u{11D50}-\u{11D59}\u{11D60}-\u{11D65}\u{11D67}\u{11D68}\u{11D6A}-\u{11D8E}\u{11D90}\u{11D91}\u{11D93}-\u{11D98}\u{11DA0}-\u{11DA9}\u{11EE0}-\u{11EF8}\u{11F00}-\u{11F10}\u{11F12}-\u{11F3A}\u{11F3E}-\u{11F5A}\u{11FB0}\u{11FC0}-\u{11FF1}\u{11FFF}-\u{12399}\u{12400}-\u{1246E}\u{12470}-\u{12474}\u{12480}-\u{12543}\u{12F90}-\u{12FF2}\u{13000}-\u{13455}\u{13460}-\u{143FA}\u{14400}-\u{14646}\u{16100}-\u{16139}\u{16800}-\u{16A38}\u{16A40}-\u{16A5E}\u{16A60}-\u{16A69}\u{16A6E}-\u{16ABE}\u{16AC0}-\u{16AC9}\u{16AD0}-\u{16AED}\u{16AF0}-\u{16AF5}\u{16B00}-\u{16B45}\u{16B50}-\u{16B59}\u{16B5B}-\u{16B61}\u{16B63}-\u{16B77}\u{16B7D}-\u{16B8F}\u{16D40}-\u{16D79}\u{16E40}-\u{16E9A}\u{16F00}-\u{16F4A}\u{16F4F}-\u{16F87}\u{16F8F}-\u{16F9F}\u{16FE0}-\u{16FE4}\u{16FF0}\u{16FF1}\u{17000}-\u{187F7}\u{18800}-\u{18CD5}\u{18CFF}-\u{18D08}\u{1AFF0}-\u{1AFF3}\u{1AFF5}-\u{1AFFB}\u{1AFFD}\u{1AFFE}\u{1B000}-\u{1B122}\u{1B132}\u{1B150}-\u{1B152}\u{1B155}\u{1B164}-\u{1B167}\u{1B170}-\u{1B2FB}\u{1BC00}-\u{1BC6A}\u{1BC70}-\u{1BC7C}\u{1BC80}-\u{1BC88}\u{1BC90}-\u{1BC99}\u{1BC9C}-\u{1BCA3}\u{1CC00}-\u{1CCF9}\u{1CD00}-\u{1CEB3}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1CF50}-\u{1CFC3}\u{1D000}-\u{1D0F5}\u{1D100}-\u{1D126}\u{1D129}-\u{1D1EA}\u{1D200}-\u{1D245}\u{1D2C0}-\u{1D2D3}\u{1D2E0}-\u{1D2F3}\u{1D300}-\u{1D356}\u{1D360}-\u{1D378}\u{1D400}-\u{1D454}\u{1D456}-\u{1D49C}\u{1D49E}\u{1D49F}\u{1D4A2}\u{1D4A5}\u{1D4A6}\u{1D4A9}-\u{1D4AC}\u{1D4AE}-\u{1D4B9}\u{1D4BB}\u{1D4BD}-\u{1D4C3}\u{1D4C5}-\u{1D505}\u{1D507}-\u{1D50A}\u{1D50D}-\u{1D514}\u{1D516}-\u{1D51C}\u{1D51E}-\u{1D539}\u{1D53B}-\u{1D53E}\u{1D540}-\u{1D544}\u{1D546}\u{1D54A}-\u{1D550}\u{1D552}-\u{1D6A5}\u{1D6A8}-\u{1D7CB}\u{1D7CE}-\u{1DA8B}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1DF00}-\u{1DF1E}\u{1DF25}-\u{1DF2A}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E030}-\u{1E06D}\u{1E08F}\u{1E100}-\u{1E12C}\u{1E130}-\u{1E13D}\u{1E140}-\u{1E149}\u{1E14E}\u{1E14F}\u{1E290}-\u{1E2AE}\u{1E2C0}-\u{1E2F9}\u{1E2FF}\u{1E4D0}-\u{1E4F9}\u{1E5D0}-\u{1E5FA}\u{1E5FF}\u{1E7E0}-\u{1E7E6}\u{1E7E8}-\u{1E7EB}\u{1E7ED}\u{1E7EE}\u{1E7F0}-\u{1E7FE}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94A}\u{1EEF0}\u{1EEF1}\u{1F000}-\u{1F02B}\u{1F030}-\u{1F093}\u{1F0A0}-\u{1F0AE}\u{1F0B1}-\u{1F0BF}\u{1F0C1}-\u{1F0CF}\u{1F0D1}-\u{1F0F5}\u{1F100}-\u{1F1AD}\u{1F1E6}-\u{1F202}\u{1F210}-\u{1F23B}\u{1F240}-\u{1F248}\u{1F250}\u{1F251}\u{1F260}-\u{1F265}\u{1F300}-\u{1F6D7}\u{1F6DC}-\u{1F6EC}\u{1F6F0}-\u{1F6FC}\u{1F700}-\u{1F776}\u{1F77B}-\u{1F7D9}\u{1F7E0}-\u{1F7EB}\u{1F7F0}\u{1F800}-\u{1F80B}\u{1F810}-\u{1F847}\u{1F850}-\u{1F859}\u{1F860}-\u{1F887}\u{1F890}-\u{1F8AD}\u{1F8B0}-\u{1F8BB}\u{1F8C0}\u{1F8C1}\u{1F900}-\u{1FA53}\u{1FA60}-\u{1FA6D}\u{1FA70}-\u{1FA7C}\u{1FA80}-\u{1FA89}\u{1FA8F}-\u{1FAC6}\u{1FACE}-\u{1FADC}\u{1FADF}-\u{1FAE9}\u{1FAF0}-\u{1FAF8}\u{1FB00}-\u{1FB92}\u{1FB94}-\u{1FBF9}\u{20000}-\u{2A6DF}\u{2A700}-\u{2B739}\u{2B740}-\u{2B81D}\u{2B820}-\u{2CEA1}\u{2CEB0}-\u{2EBE0}\u{2EBF0}-\u{2EE5D}\u{2F800}-\u{2FA1D}\u{30000}-\u{3134A}\u{31350}-\u{323AF}\u{E0001}\u{E0020}-\u{E007F}\u{E0100}-\u{E01EF}\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]*$/u; + var bidiS6 = /[0-9A-Za-z\xAA\xB2\xB3\xB5\xB9\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02B8\u02BB-\u02C1\u02D0\u02D1\u02E0-\u02E4\u02EE\u0370-\u0373\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0482\u048A-\u052F\u0531-\u0556\u0559-\u0589\u06F0-\u06F9\u0903-\u0939\u093B\u093D-\u0940\u0949-\u094C\u094E-\u0950\u0958-\u0961\u0964-\u0980\u0982\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD-\u09C0\u09C7\u09C8\u09CB\u09CC\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E1\u09E6-\u09F1\u09F4-\u09FA\u09FC\u09FD\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3E-\u0A40\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F\u0A72-\u0A74\u0A76\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD-\u0AC0\u0AC9\u0ACB\u0ACC\u0AD0\u0AE0\u0AE1\u0AE6-\u0AF0\u0AF9\u0B02\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B3E\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0B57\u0B5C\u0B5D\u0B5F-\u0B61\u0B66-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7\u0BE6-\u0BF2\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C41-\u0C44\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C66-\u0C6F\u0C77\u0C7F\u0C80\u0C82-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD-\u0CC4\u0CC6-\u0CC8\u0CCA\u0CCB\u0CD5\u0CD6\u0CDD\u0CDE\u0CE0\u0CE1\u0CE6-\u0CEF\u0CF1-\u0CF3\u0D02-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D4F\u0D54-\u0D61\u0D66-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2-\u0DF4\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E4F-\u0E5B\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00-\u0F17\u0F1A-\u0F34\u0F36\u0F38\u0F3E-\u0F47\u0F49-\u0F6C\u0F7F\u0F85\u0F88-\u0F8C\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE-\u0FDA\u1000-\u102C\u1031\u1038\u103B\u103C\u103F-\u1057\u105A-\u105D\u1061-\u1070\u1075-\u1081\u1083\u1084\u1087-\u108C\u108E-\u109C\u109E-\u10C5\u10C7\u10CD\u10D0-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1360-\u137C\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u167F\u1681-\u169A\u16A0-\u16F8\u1700-\u1711\u1715\u171F-\u1731\u1734-\u1736\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17B6\u17BE-\u17C5\u17C7\u17C8\u17D4-\u17DA\u17DC\u17E0-\u17E9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A16\u1A19\u1A1A\u1A1E-\u1A55\u1A57\u1A61\u1A63\u1A64\u1A6D-\u1A72\u1A80-\u1A89\u1A90-\u1A99\u1AA0-\u1AAD\u1B04-\u1B33\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B4C\u1B4E-\u1B6A\u1B74-\u1B7F\u1B82-\u1BA1\u1BA6\u1BA7\u1BAA\u1BAE-\u1BE5\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1BFC-\u1C2B\u1C34\u1C35\u1C3B-\u1C49\u1C4D-\u1C8A\u1C90-\u1CBA\u1CBD-\u1CC7\u1CD3\u1CE1\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5-\u1CF7\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200E\u2070\u2071\u2074-\u2079\u207F-\u2089\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u214F\u2160-\u2188\u2336-\u237A\u2395\u2488-\u24E9\u26AC\u2800-\u28FF\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D70\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u302E\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u3190-\u31BF\u31F0-\u321C\u3220-\u324F\u3260-\u327B\u327F-\u32B0\u32C0-\u32CB\u32D0-\u3376\u337B-\u33DD\u33E0-\u33FE\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA60C\uA610-\uA62B\uA640-\uA66E\uA680-\uA69D\uA6A0-\uA6EF\uA6F2-\uA6F7\uA722-\uA787\uA789-\uA7CD\uA7D0\uA7D1\uA7D3\uA7D5-\uA7DC\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA824\uA827\uA830-\uA837\uA840-\uA873\uA880-\uA8C3\uA8CE-\uA8D9\uA8F2-\uA8FE\uA900-\uA925\uA92E-\uA946\uA952\uA953\uA95F-\uA97C\uA983-\uA9B2\uA9B4\uA9B5\uA9BA\uA9BB\uA9BE-\uA9CD\uA9CF-\uA9D9\uA9DE-\uA9E4\uA9E6-\uA9FE\uAA00-\uAA28\uAA2F\uAA30\uAA33\uAA34\uAA40-\uAA42\uAA44-\uAA4B\uAA4D\uAA50-\uAA59\uAA5C-\uAA7B\uAA7D-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAAEB\uAAEE-\uAAF5\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB69\uAB70-\uABE4\uABE6\uABE7\uABE9-\uABEC\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uD800-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC\u{10000}-\u{1000B}\u{1000D}-\u{10026}\u{10028}-\u{1003A}\u{1003C}\u{1003D}\u{1003F}-\u{1004D}\u{10050}-\u{1005D}\u{10080}-\u{100FA}\u{10100}\u{10102}\u{10107}-\u{10133}\u{10137}-\u{1013F}\u{1018D}\u{1018E}\u{101D0}-\u{101FC}\u{10280}-\u{1029C}\u{102A0}-\u{102D0}\u{102E1}-\u{102FB}\u{10300}-\u{10323}\u{1032D}-\u{1034A}\u{10350}-\u{10375}\u{10380}-\u{1039D}\u{1039F}-\u{103C3}\u{103C8}-\u{103D5}\u{10400}-\u{1049D}\u{104A0}-\u{104A9}\u{104B0}-\u{104D3}\u{104D8}-\u{104FB}\u{10500}-\u{10527}\u{10530}-\u{10563}\u{1056F}-\u{1057A}\u{1057C}-\u{1058A}\u{1058C}-\u{10592}\u{10594}\u{10595}\u{10597}-\u{105A1}\u{105A3}-\u{105B1}\u{105B3}-\u{105B9}\u{105BB}\u{105BC}\u{105C0}-\u{105F3}\u{10600}-\u{10736}\u{10740}-\u{10755}\u{10760}-\u{10767}\u{10780}-\u{10785}\u{10787}-\u{107B0}\u{107B2}-\u{107BA}\u{11000}\u{11002}-\u{11037}\u{11047}-\u{1104D}\u{11066}-\u{1106F}\u{11071}\u{11072}\u{11075}\u{11082}-\u{110B2}\u{110B7}\u{110B8}\u{110BB}-\u{110C1}\u{110CD}\u{110D0}-\u{110E8}\u{110F0}-\u{110F9}\u{11103}-\u{11126}\u{1112C}\u{11136}-\u{11147}\u{11150}-\u{11172}\u{11174}-\u{11176}\u{11182}-\u{111B5}\u{111BF}-\u{111C8}\u{111CD}\u{111CE}\u{111D0}-\u{111DF}\u{111E1}-\u{111F4}\u{11200}-\u{11211}\u{11213}-\u{1122E}\u{11232}\u{11233}\u{11235}\u{11238}-\u{1123D}\u{1123F}\u{11240}\u{11280}-\u{11286}\u{11288}\u{1128A}-\u{1128D}\u{1128F}-\u{1129D}\u{1129F}-\u{112A9}\u{112B0}-\u{112DE}\u{112E0}-\u{112E2}\u{112F0}-\u{112F9}\u{11302}\u{11303}\u{11305}-\u{1130C}\u{1130F}\u{11310}\u{11313}-\u{11328}\u{1132A}-\u{11330}\u{11332}\u{11333}\u{11335}-\u{11339}\u{1133D}-\u{1133F}\u{11341}-\u{11344}\u{11347}\u{11348}\u{1134B}-\u{1134D}\u{11350}\u{11357}\u{1135D}-\u{11363}\u{11380}-\u{11389}\u{1138B}\u{1138E}\u{11390}-\u{113B5}\u{113B7}-\u{113BA}\u{113C2}\u{113C5}\u{113C7}-\u{113CA}\u{113CC}\u{113CD}\u{113CF}\u{113D1}\u{113D3}-\u{113D5}\u{113D7}\u{113D8}\u{11400}-\u{11437}\u{11440}\u{11441}\u{11445}\u{11447}-\u{1145B}\u{1145D}\u{1145F}-\u{11461}\u{11480}-\u{114B2}\u{114B9}\u{114BB}-\u{114BE}\u{114C1}\u{114C4}-\u{114C7}\u{114D0}-\u{114D9}\u{11580}-\u{115B1}\u{115B8}-\u{115BB}\u{115BE}\u{115C1}-\u{115DB}\u{11600}-\u{11632}\u{1163B}\u{1163C}\u{1163E}\u{11641}-\u{11644}\u{11650}-\u{11659}\u{11680}-\u{116AA}\u{116AC}\u{116AE}\u{116AF}\u{116B6}\u{116B8}\u{116B9}\u{116C0}-\u{116C9}\u{116D0}-\u{116E3}\u{11700}-\u{1171A}\u{1171E}\u{11720}\u{11721}\u{11726}\u{11730}-\u{11746}\u{11800}-\u{1182E}\u{11838}\u{1183B}\u{118A0}-\u{118F2}\u{118FF}-\u{11906}\u{11909}\u{1190C}-\u{11913}\u{11915}\u{11916}\u{11918}-\u{11935}\u{11937}\u{11938}\u{1193D}\u{1193F}-\u{11942}\u{11944}-\u{11946}\u{11950}-\u{11959}\u{119A0}-\u{119A7}\u{119AA}-\u{119D3}\u{119DC}-\u{119DF}\u{119E1}-\u{119E4}\u{11A00}\u{11A07}\u{11A08}\u{11A0B}-\u{11A32}\u{11A39}\u{11A3A}\u{11A3F}-\u{11A46}\u{11A50}\u{11A57}\u{11A58}\u{11A5C}-\u{11A89}\u{11A97}\u{11A9A}-\u{11AA2}\u{11AB0}-\u{11AF8}\u{11B00}-\u{11B09}\u{11BC0}-\u{11BE1}\u{11BF0}-\u{11BF9}\u{11C00}-\u{11C08}\u{11C0A}-\u{11C2F}\u{11C3E}-\u{11C45}\u{11C50}-\u{11C6C}\u{11C70}-\u{11C8F}\u{11CA9}\u{11CB1}\u{11CB4}\u{11D00}-\u{11D06}\u{11D08}\u{11D09}\u{11D0B}-\u{11D30}\u{11D46}\u{11D50}-\u{11D59}\u{11D60}-\u{11D65}\u{11D67}\u{11D68}\u{11D6A}-\u{11D8E}\u{11D93}\u{11D94}\u{11D96}\u{11D98}\u{11DA0}-\u{11DA9}\u{11EE0}-\u{11EF2}\u{11EF5}-\u{11EF8}\u{11F02}-\u{11F10}\u{11F12}-\u{11F35}\u{11F3E}\u{11F3F}\u{11F41}\u{11F43}-\u{11F59}\u{11FB0}\u{11FC0}-\u{11FD4}\u{11FFF}-\u{12399}\u{12400}-\u{1246E}\u{12470}-\u{12474}\u{12480}-\u{12543}\u{12F90}-\u{12FF2}\u{13000}-\u{1343F}\u{13441}-\u{13446}\u{13460}-\u{143FA}\u{14400}-\u{14646}\u{16100}-\u{1611D}\u{1612A}-\u{1612C}\u{16130}-\u{16139}\u{16800}-\u{16A38}\u{16A40}-\u{16A5E}\u{16A60}-\u{16A69}\u{16A6E}-\u{16ABE}\u{16AC0}-\u{16AC9}\u{16AD0}-\u{16AED}\u{16AF5}\u{16B00}-\u{16B2F}\u{16B37}-\u{16B45}\u{16B50}-\u{16B59}\u{16B5B}-\u{16B61}\u{16B63}-\u{16B77}\u{16B7D}-\u{16B8F}\u{16D40}-\u{16D79}\u{16E40}-\u{16E9A}\u{16F00}-\u{16F4A}\u{16F50}-\u{16F87}\u{16F93}-\u{16F9F}\u{16FE0}\u{16FE1}\u{16FE3}\u{16FF0}\u{16FF1}\u{17000}-\u{187F7}\u{18800}-\u{18CD5}\u{18CFF}-\u{18D08}\u{1AFF0}-\u{1AFF3}\u{1AFF5}-\u{1AFFB}\u{1AFFD}\u{1AFFE}\u{1B000}-\u{1B122}\u{1B132}\u{1B150}-\u{1B152}\u{1B155}\u{1B164}-\u{1B167}\u{1B170}-\u{1B2FB}\u{1BC00}-\u{1BC6A}\u{1BC70}-\u{1BC7C}\u{1BC80}-\u{1BC88}\u{1BC90}-\u{1BC99}\u{1BC9C}\u{1BC9F}\u{1CCD6}-\u{1CCF9}\u{1CF50}-\u{1CFC3}\u{1D000}-\u{1D0F5}\u{1D100}-\u{1D126}\u{1D129}-\u{1D166}\u{1D16A}-\u{1D172}\u{1D183}\u{1D184}\u{1D18C}-\u{1D1A9}\u{1D1AE}-\u{1D1E8}\u{1D2C0}-\u{1D2D3}\u{1D2E0}-\u{1D2F3}\u{1D360}-\u{1D378}\u{1D400}-\u{1D454}\u{1D456}-\u{1D49C}\u{1D49E}\u{1D49F}\u{1D4A2}\u{1D4A5}\u{1D4A6}\u{1D4A9}-\u{1D4AC}\u{1D4AE}-\u{1D4B9}\u{1D4BB}\u{1D4BD}-\u{1D4C3}\u{1D4C5}-\u{1D505}\u{1D507}-\u{1D50A}\u{1D50D}-\u{1D514}\u{1D516}-\u{1D51C}\u{1D51E}-\u{1D539}\u{1D53B}-\u{1D53E}\u{1D540}-\u{1D544}\u{1D546}\u{1D54A}-\u{1D550}\u{1D552}-\u{1D6A5}\u{1D6A8}-\u{1D6C0}\u{1D6C2}-\u{1D6DA}\u{1D6DC}-\u{1D6FA}\u{1D6FC}-\u{1D714}\u{1D716}-\u{1D734}\u{1D736}-\u{1D74E}\u{1D750}-\u{1D76E}\u{1D770}-\u{1D788}\u{1D78A}-\u{1D7A8}\u{1D7AA}-\u{1D7C2}\u{1D7C4}-\u{1D7CB}\u{1D7CE}-\u{1D9FF}\u{1DA37}-\u{1DA3A}\u{1DA6D}-\u{1DA74}\u{1DA76}-\u{1DA83}\u{1DA85}-\u{1DA8B}\u{1DF00}-\u{1DF1E}\u{1DF25}-\u{1DF2A}\u{1E030}-\u{1E06D}\u{1E100}-\u{1E12C}\u{1E137}-\u{1E13D}\u{1E140}-\u{1E149}\u{1E14E}\u{1E14F}\u{1E290}-\u{1E2AD}\u{1E2C0}-\u{1E2EB}\u{1E2F0}-\u{1E2F9}\u{1E4D0}-\u{1E4EB}\u{1E4F0}-\u{1E4F9}\u{1E5D0}-\u{1E5ED}\u{1E5F0}-\u{1E5FA}\u{1E5FF}\u{1E7E0}-\u{1E7E6}\u{1E7E8}-\u{1E7EB}\u{1E7ED}\u{1E7EE}\u{1E7F0}-\u{1E7FE}\u{1F100}-\u{1F10A}\u{1F110}-\u{1F12E}\u{1F130}-\u{1F169}\u{1F170}-\u{1F1AC}\u{1F1E6}-\u{1F202}\u{1F210}-\u{1F23B}\u{1F240}-\u{1F248}\u{1F250}\u{1F251}\u{1FBF0}-\u{1FBF9}\u{20000}-\u{2A6DF}\u{2A700}-\u{2B739}\u{2B740}-\u{2B81D}\u{2B820}-\u{2CEA1}\u{2CEB0}-\u{2EBE0}\u{2EBF0}-\u{2EE5D}\u{2F800}-\u{2FA1D}\u{30000}-\u{3134A}\u{31350}-\u{323AF}\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}][\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0897-\u089F\u08CA-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3C\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECE\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732\u1733\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F\u{101FD}\u{102E0}\u{10376}-\u{1037A}\u{10A01}-\u{10A03}\u{10A05}\u{10A06}\u{10A0C}-\u{10A0F}\u{10A38}-\u{10A3A}\u{10A3F}\u{10AE5}\u{10AE6}\u{10D24}-\u{10D27}\u{10D69}-\u{10D6D}\u{10EAB}\u{10EAC}\u{10EFC}-\u{10EFF}\u{10F46}-\u{10F50}\u{10F82}-\u{10F85}\u{11001}\u{11038}-\u{11046}\u{11070}\u{11073}\u{11074}\u{1107F}-\u{11081}\u{110B3}-\u{110B6}\u{110B9}\u{110BA}\u{110C2}\u{11100}-\u{11102}\u{11127}-\u{1112B}\u{1112D}-\u{11134}\u{11173}\u{11180}\u{11181}\u{111B6}-\u{111BE}\u{111C9}-\u{111CC}\u{111CF}\u{1122F}-\u{11231}\u{11234}\u{11236}\u{11237}\u{1123E}\u{11241}\u{112DF}\u{112E3}-\u{112EA}\u{11300}\u{11301}\u{1133B}\u{1133C}\u{11340}\u{11366}-\u{1136C}\u{11370}-\u{11374}\u{113BB}-\u{113C0}\u{113CE}\u{113D0}\u{113D2}\u{113E1}\u{113E2}\u{11438}-\u{1143F}\u{11442}-\u{11444}\u{11446}\u{1145E}\u{114B3}-\u{114B8}\u{114BA}\u{114BF}\u{114C0}\u{114C2}\u{114C3}\u{115B2}-\u{115B5}\u{115BC}\u{115BD}\u{115BF}\u{115C0}\u{115DC}\u{115DD}\u{11633}-\u{1163A}\u{1163D}\u{1163F}\u{11640}\u{116AB}\u{116AD}\u{116B0}-\u{116B5}\u{116B7}\u{1171D}\u{1171F}\u{11722}-\u{11725}\u{11727}-\u{1172B}\u{1182F}-\u{11837}\u{11839}\u{1183A}\u{1193B}\u{1193C}\u{1193E}\u{11943}\u{119D4}-\u{119D7}\u{119DA}\u{119DB}\u{119E0}\u{11A01}-\u{11A06}\u{11A09}\u{11A0A}\u{11A33}-\u{11A38}\u{11A3B}-\u{11A3E}\u{11A47}\u{11A51}-\u{11A56}\u{11A59}-\u{11A5B}\u{11A8A}-\u{11A96}\u{11A98}\u{11A99}\u{11C30}-\u{11C36}\u{11C38}-\u{11C3D}\u{11C92}-\u{11CA7}\u{11CAA}-\u{11CB0}\u{11CB2}\u{11CB3}\u{11CB5}\u{11CB6}\u{11D31}-\u{11D36}\u{11D3A}\u{11D3C}\u{11D3D}\u{11D3F}-\u{11D45}\u{11D47}\u{11D90}\u{11D91}\u{11D95}\u{11D97}\u{11EF3}\u{11EF4}\u{11F00}\u{11F01}\u{11F36}-\u{11F3A}\u{11F40}\u{11F42}\u{11F5A}\u{13440}\u{13447}-\u{13455}\u{1611E}-\u{16129}\u{1612D}-\u{1612F}\u{16AF0}-\u{16AF4}\u{16B30}-\u{16B36}\u{16F4F}\u{16F8F}-\u{16F92}\u{16FE4}\u{1BC9D}\u{1BC9E}\u{1CF00}-\u{1CF2D}\u{1CF30}-\u{1CF46}\u{1D167}-\u{1D169}\u{1D17B}-\u{1D182}\u{1D185}-\u{1D18B}\u{1D1AA}-\u{1D1AD}\u{1D242}-\u{1D244}\u{1DA00}-\u{1DA36}\u{1DA3B}-\u{1DA6C}\u{1DA75}\u{1DA84}\u{1DA9B}-\u{1DA9F}\u{1DAA1}-\u{1DAAF}\u{1E000}-\u{1E006}\u{1E008}-\u{1E018}\u{1E01B}-\u{1E021}\u{1E023}\u{1E024}\u{1E026}-\u{1E02A}\u{1E08F}\u{1E130}-\u{1E136}\u{1E2AE}\u{1E2EC}-\u{1E2EF}\u{1E4EC}-\u{1E4EF}\u{1E5EE}\u{1E5EF}\u{1E8D0}-\u{1E8D6}\u{1E944}-\u{1E94A}\u{E0100}-\u{E01EF}]*$/u; + module2.exports = { + combiningMarks, + combiningClassVirama, + validZWNJ, + bidiDomain, + bidiS1LTR, + bidiS1RTL, + bidiS2, + bidiS3, + bidiS4EN, + bidiS4AN, + bidiS5, + bidiS6 + }; + } +}); + +// node_modules/tr46/lib/mappingTable.json +var require_mappingTable = __commonJS({ + "node_modules/tr46/lib/mappingTable.json"(exports2, module2) { + module2.exports = [[[0, 44], 2], [[45, 46], 2], [47, 2], [[48, 57], 2], [[58, 64], 2], [65, 1, "a"], [66, 1, "b"], [67, 1, "c"], [68, 1, "d"], [69, 1, "e"], [70, 1, "f"], [71, 1, "g"], [72, 1, "h"], [73, 1, "i"], [74, 1, "j"], [75, 1, "k"], [76, 1, "l"], [77, 1, "m"], [78, 1, "n"], [79, 1, "o"], [80, 1, "p"], [81, 1, "q"], [82, 1, "r"], [83, 1, "s"], [84, 1, "t"], [85, 1, "u"], [86, 1, "v"], [87, 1, "w"], [88, 1, "x"], [89, 1, "y"], [90, 1, "z"], [[91, 96], 2], [[97, 122], 2], [[123, 127], 2], [[128, 159], 3], [160, 1, " "], [[161, 167], 2], [168, 1, " \u0308"], [169, 2], [170, 1, "a"], [[171, 172], 2], [173, 7], [174, 2], [175, 1, " \u0304"], [[176, 177], 2], [178, 1, "2"], [179, 1, "3"], [180, 1, " \u0301"], [181, 1, "\u03BC"], [182, 2], [183, 2], [184, 1, " \u0327"], [185, 1, "1"], [186, 1, "o"], [187, 2], [188, 1, "1\u20444"], [189, 1, "1\u20442"], [190, 1, "3\u20444"], [191, 2], [192, 1, "\xE0"], [193, 1, "\xE1"], [194, 1, "\xE2"], [195, 1, "\xE3"], [196, 1, "\xE4"], [197, 1, "\xE5"], [198, 1, "\xE6"], [199, 1, "\xE7"], [200, 1, "\xE8"], [201, 1, "\xE9"], [202, 1, "\xEA"], [203, 1, "\xEB"], [204, 1, "\xEC"], [205, 1, "\xED"], [206, 1, "\xEE"], [207, 1, "\xEF"], [208, 1, "\xF0"], [209, 1, "\xF1"], [210, 1, "\xF2"], [211, 1, "\xF3"], [212, 1, "\xF4"], [213, 1, "\xF5"], [214, 1, "\xF6"], [215, 2], [216, 1, "\xF8"], [217, 1, "\xF9"], [218, 1, "\xFA"], [219, 1, "\xFB"], [220, 1, "\xFC"], [221, 1, "\xFD"], [222, 1, "\xFE"], [223, 6, "ss"], [[224, 246], 2], [247, 2], [[248, 255], 2], [256, 1, "\u0101"], [257, 2], [258, 1, "\u0103"], [259, 2], [260, 1, "\u0105"], [261, 2], [262, 1, "\u0107"], [263, 2], [264, 1, "\u0109"], [265, 2], [266, 1, "\u010B"], [267, 2], [268, 1, "\u010D"], [269, 2], [270, 1, "\u010F"], [271, 2], [272, 1, "\u0111"], [273, 2], [274, 1, "\u0113"], [275, 2], [276, 1, "\u0115"], [277, 2], [278, 1, "\u0117"], [279, 2], [280, 1, "\u0119"], [281, 2], [282, 1, "\u011B"], [283, 2], [284, 1, "\u011D"], [285, 2], [286, 1, "\u011F"], [287, 2], [288, 1, "\u0121"], [289, 2], [290, 1, "\u0123"], [291, 2], [292, 1, "\u0125"], [293, 2], [294, 1, "\u0127"], [295, 2], [296, 1, "\u0129"], [297, 2], [298, 1, "\u012B"], [299, 2], [300, 1, "\u012D"], [301, 2], [302, 1, "\u012F"], [303, 2], [304, 1, "i\u0307"], [305, 2], [[306, 307], 1, "ij"], [308, 1, "\u0135"], [309, 2], [310, 1, "\u0137"], [[311, 312], 2], [313, 1, "\u013A"], [314, 2], [315, 1, "\u013C"], [316, 2], [317, 1, "\u013E"], [318, 2], [[319, 320], 1, "l\xB7"], [321, 1, "\u0142"], [322, 2], [323, 1, "\u0144"], [324, 2], [325, 1, "\u0146"], [326, 2], [327, 1, "\u0148"], [328, 2], [329, 1, "\u02BCn"], [330, 1, "\u014B"], [331, 2], [332, 1, "\u014D"], [333, 2], [334, 1, "\u014F"], [335, 2], [336, 1, "\u0151"], [337, 2], [338, 1, "\u0153"], [339, 2], [340, 1, "\u0155"], [341, 2], [342, 1, "\u0157"], [343, 2], [344, 1, "\u0159"], [345, 2], [346, 1, "\u015B"], [347, 2], [348, 1, "\u015D"], [349, 2], [350, 1, "\u015F"], [351, 2], [352, 1, "\u0161"], [353, 2], [354, 1, "\u0163"], [355, 2], [356, 1, "\u0165"], [357, 2], [358, 1, "\u0167"], [359, 2], [360, 1, "\u0169"], [361, 2], [362, 1, "\u016B"], [363, 2], [364, 1, "\u016D"], [365, 2], [366, 1, "\u016F"], [367, 2], [368, 1, "\u0171"], [369, 2], [370, 1, "\u0173"], [371, 2], [372, 1, "\u0175"], [373, 2], [374, 1, "\u0177"], [375, 2], [376, 1, "\xFF"], [377, 1, "\u017A"], [378, 2], [379, 1, "\u017C"], [380, 2], [381, 1, "\u017E"], [382, 2], [383, 1, "s"], [384, 2], [385, 1, "\u0253"], [386, 1, "\u0183"], [387, 2], [388, 1, "\u0185"], [389, 2], [390, 1, "\u0254"], [391, 1, "\u0188"], [392, 2], [393, 1, "\u0256"], [394, 1, "\u0257"], [395, 1, "\u018C"], [[396, 397], 2], [398, 1, "\u01DD"], [399, 1, "\u0259"], [400, 1, "\u025B"], [401, 1, "\u0192"], [402, 2], [403, 1, "\u0260"], [404, 1, "\u0263"], [405, 2], [406, 1, "\u0269"], [407, 1, "\u0268"], [408, 1, "\u0199"], [[409, 411], 2], [412, 1, "\u026F"], [413, 1, "\u0272"], [414, 2], [415, 1, "\u0275"], [416, 1, "\u01A1"], [417, 2], [418, 1, "\u01A3"], [419, 2], [420, 1, "\u01A5"], [421, 2], [422, 1, "\u0280"], [423, 1, "\u01A8"], [424, 2], [425, 1, "\u0283"], [[426, 427], 2], [428, 1, "\u01AD"], [429, 2], [430, 1, "\u0288"], [431, 1, "\u01B0"], [432, 2], [433, 1, "\u028A"], [434, 1, "\u028B"], [435, 1, "\u01B4"], [436, 2], [437, 1, "\u01B6"], [438, 2], [439, 1, "\u0292"], [440, 1, "\u01B9"], [[441, 443], 2], [444, 1, "\u01BD"], [[445, 451], 2], [[452, 454], 1, "d\u017E"], [[455, 457], 1, "lj"], [[458, 460], 1, "nj"], [461, 1, "\u01CE"], [462, 2], [463, 1, "\u01D0"], [464, 2], [465, 1, "\u01D2"], [466, 2], [467, 1, "\u01D4"], [468, 2], [469, 1, "\u01D6"], [470, 2], [471, 1, "\u01D8"], [472, 2], [473, 1, "\u01DA"], [474, 2], [475, 1, "\u01DC"], [[476, 477], 2], [478, 1, "\u01DF"], [479, 2], [480, 1, "\u01E1"], [481, 2], [482, 1, "\u01E3"], [483, 2], [484, 1, "\u01E5"], [485, 2], [486, 1, "\u01E7"], [487, 2], [488, 1, "\u01E9"], [489, 2], [490, 1, "\u01EB"], [491, 2], [492, 1, "\u01ED"], [493, 2], [494, 1, "\u01EF"], [[495, 496], 2], [[497, 499], 1, "dz"], [500, 1, "\u01F5"], [501, 2], [502, 1, "\u0195"], [503, 1, "\u01BF"], [504, 1, "\u01F9"], [505, 2], [506, 1, "\u01FB"], [507, 2], [508, 1, "\u01FD"], [509, 2], [510, 1, "\u01FF"], [511, 2], [512, 1, "\u0201"], [513, 2], [514, 1, "\u0203"], [515, 2], [516, 1, "\u0205"], [517, 2], [518, 1, "\u0207"], [519, 2], [520, 1, "\u0209"], [521, 2], [522, 1, "\u020B"], [523, 2], [524, 1, "\u020D"], [525, 2], [526, 1, "\u020F"], [527, 2], [528, 1, "\u0211"], [529, 2], [530, 1, "\u0213"], [531, 2], [532, 1, "\u0215"], [533, 2], [534, 1, "\u0217"], [535, 2], [536, 1, "\u0219"], [537, 2], [538, 1, "\u021B"], [539, 2], [540, 1, "\u021D"], [541, 2], [542, 1, "\u021F"], [543, 2], [544, 1, "\u019E"], [545, 2], [546, 1, "\u0223"], [547, 2], [548, 1, "\u0225"], [549, 2], [550, 1, "\u0227"], [551, 2], [552, 1, "\u0229"], [553, 2], [554, 1, "\u022B"], [555, 2], [556, 1, "\u022D"], [557, 2], [558, 1, "\u022F"], [559, 2], [560, 1, "\u0231"], [561, 2], [562, 1, "\u0233"], [563, 2], [[564, 566], 2], [[567, 569], 2], [570, 1, "\u2C65"], [571, 1, "\u023C"], [572, 2], [573, 1, "\u019A"], [574, 1, "\u2C66"], [[575, 576], 2], [577, 1, "\u0242"], [578, 2], [579, 1, "\u0180"], [580, 1, "\u0289"], [581, 1, "\u028C"], [582, 1, "\u0247"], [583, 2], [584, 1, "\u0249"], [585, 2], [586, 1, "\u024B"], [587, 2], [588, 1, "\u024D"], [589, 2], [590, 1, "\u024F"], [591, 2], [[592, 680], 2], [[681, 685], 2], [[686, 687], 2], [688, 1, "h"], [689, 1, "\u0266"], [690, 1, "j"], [691, 1, "r"], [692, 1, "\u0279"], [693, 1, "\u027B"], [694, 1, "\u0281"], [695, 1, "w"], [696, 1, "y"], [[697, 705], 2], [[706, 709], 2], [[710, 721], 2], [[722, 727], 2], [728, 1, " \u0306"], [729, 1, " \u0307"], [730, 1, " \u030A"], [731, 1, " \u0328"], [732, 1, " \u0303"], [733, 1, " \u030B"], [734, 2], [735, 2], [736, 1, "\u0263"], [737, 1, "l"], [738, 1, "s"], [739, 1, "x"], [740, 1, "\u0295"], [[741, 745], 2], [[746, 747], 2], [748, 2], [749, 2], [750, 2], [[751, 767], 2], [[768, 831], 2], [832, 1, "\u0300"], [833, 1, "\u0301"], [834, 2], [835, 1, "\u0313"], [836, 1, "\u0308\u0301"], [837, 1, "\u03B9"], [[838, 846], 2], [847, 7], [[848, 855], 2], [[856, 860], 2], [[861, 863], 2], [[864, 865], 2], [866, 2], [[867, 879], 2], [880, 1, "\u0371"], [881, 2], [882, 1, "\u0373"], [883, 2], [884, 1, "\u02B9"], [885, 2], [886, 1, "\u0377"], [887, 2], [[888, 889], 3], [890, 1, " \u03B9"], [[891, 893], 2], [894, 1, ";"], [895, 1, "\u03F3"], [[896, 899], 3], [900, 1, " \u0301"], [901, 1, " \u0308\u0301"], [902, 1, "\u03AC"], [903, 1, "\xB7"], [904, 1, "\u03AD"], [905, 1, "\u03AE"], [906, 1, "\u03AF"], [907, 3], [908, 1, "\u03CC"], [909, 3], [910, 1, "\u03CD"], [911, 1, "\u03CE"], [912, 2], [913, 1, "\u03B1"], [914, 1, "\u03B2"], [915, 1, "\u03B3"], [916, 1, "\u03B4"], [917, 1, "\u03B5"], [918, 1, "\u03B6"], [919, 1, "\u03B7"], [920, 1, "\u03B8"], [921, 1, "\u03B9"], [922, 1, "\u03BA"], [923, 1, "\u03BB"], [924, 1, "\u03BC"], [925, 1, "\u03BD"], [926, 1, "\u03BE"], [927, 1, "\u03BF"], [928, 1, "\u03C0"], [929, 1, "\u03C1"], [930, 3], [931, 1, "\u03C3"], [932, 1, "\u03C4"], [933, 1, "\u03C5"], [934, 1, "\u03C6"], [935, 1, "\u03C7"], [936, 1, "\u03C8"], [937, 1, "\u03C9"], [938, 1, "\u03CA"], [939, 1, "\u03CB"], [[940, 961], 2], [962, 6, "\u03C3"], [[963, 974], 2], [975, 1, "\u03D7"], [976, 1, "\u03B2"], [977, 1, "\u03B8"], [978, 1, "\u03C5"], [979, 1, "\u03CD"], [980, 1, "\u03CB"], [981, 1, "\u03C6"], [982, 1, "\u03C0"], [983, 2], [984, 1, "\u03D9"], [985, 2], [986, 1, "\u03DB"], [987, 2], [988, 1, "\u03DD"], [989, 2], [990, 1, "\u03DF"], [991, 2], [992, 1, "\u03E1"], [993, 2], [994, 1, "\u03E3"], [995, 2], [996, 1, "\u03E5"], [997, 2], [998, 1, "\u03E7"], [999, 2], [1e3, 1, "\u03E9"], [1001, 2], [1002, 1, "\u03EB"], [1003, 2], [1004, 1, "\u03ED"], [1005, 2], [1006, 1, "\u03EF"], [1007, 2], [1008, 1, "\u03BA"], [1009, 1, "\u03C1"], [1010, 1, "\u03C3"], [1011, 2], [1012, 1, "\u03B8"], [1013, 1, "\u03B5"], [1014, 2], [1015, 1, "\u03F8"], [1016, 2], [1017, 1, "\u03C3"], [1018, 1, "\u03FB"], [1019, 2], [1020, 2], [1021, 1, "\u037B"], [1022, 1, "\u037C"], [1023, 1, "\u037D"], [1024, 1, "\u0450"], [1025, 1, "\u0451"], [1026, 1, "\u0452"], [1027, 1, "\u0453"], [1028, 1, "\u0454"], [1029, 1, "\u0455"], [1030, 1, "\u0456"], [1031, 1, "\u0457"], [1032, 1, "\u0458"], [1033, 1, "\u0459"], [1034, 1, "\u045A"], [1035, 1, "\u045B"], [1036, 1, "\u045C"], [1037, 1, "\u045D"], [1038, 1, "\u045E"], [1039, 1, "\u045F"], [1040, 1, "\u0430"], [1041, 1, "\u0431"], [1042, 1, "\u0432"], [1043, 1, "\u0433"], [1044, 1, "\u0434"], [1045, 1, "\u0435"], [1046, 1, "\u0436"], [1047, 1, "\u0437"], [1048, 1, "\u0438"], [1049, 1, "\u0439"], [1050, 1, "\u043A"], [1051, 1, "\u043B"], [1052, 1, "\u043C"], [1053, 1, "\u043D"], [1054, 1, "\u043E"], [1055, 1, "\u043F"], [1056, 1, "\u0440"], [1057, 1, "\u0441"], [1058, 1, "\u0442"], [1059, 1, "\u0443"], [1060, 1, "\u0444"], [1061, 1, "\u0445"], [1062, 1, "\u0446"], [1063, 1, "\u0447"], [1064, 1, "\u0448"], [1065, 1, "\u0449"], [1066, 1, "\u044A"], [1067, 1, "\u044B"], [1068, 1, "\u044C"], [1069, 1, "\u044D"], [1070, 1, "\u044E"], [1071, 1, "\u044F"], [[1072, 1103], 2], [1104, 2], [[1105, 1116], 2], [1117, 2], [[1118, 1119], 2], [1120, 1, "\u0461"], [1121, 2], [1122, 1, "\u0463"], [1123, 2], [1124, 1, "\u0465"], [1125, 2], [1126, 1, "\u0467"], [1127, 2], [1128, 1, "\u0469"], [1129, 2], [1130, 1, "\u046B"], [1131, 2], [1132, 1, "\u046D"], [1133, 2], [1134, 1, "\u046F"], [1135, 2], [1136, 1, "\u0471"], [1137, 2], [1138, 1, "\u0473"], [1139, 2], [1140, 1, "\u0475"], [1141, 2], [1142, 1, "\u0477"], [1143, 2], [1144, 1, "\u0479"], [1145, 2], [1146, 1, "\u047B"], [1147, 2], [1148, 1, "\u047D"], [1149, 2], [1150, 1, "\u047F"], [1151, 2], [1152, 1, "\u0481"], [1153, 2], [1154, 2], [[1155, 1158], 2], [1159, 2], [[1160, 1161], 2], [1162, 1, "\u048B"], [1163, 2], [1164, 1, "\u048D"], [1165, 2], [1166, 1, "\u048F"], [1167, 2], [1168, 1, "\u0491"], [1169, 2], [1170, 1, "\u0493"], [1171, 2], [1172, 1, "\u0495"], [1173, 2], [1174, 1, "\u0497"], [1175, 2], [1176, 1, "\u0499"], [1177, 2], [1178, 1, "\u049B"], [1179, 2], [1180, 1, "\u049D"], [1181, 2], [1182, 1, "\u049F"], [1183, 2], [1184, 1, "\u04A1"], [1185, 2], [1186, 1, "\u04A3"], [1187, 2], [1188, 1, "\u04A5"], [1189, 2], [1190, 1, "\u04A7"], [1191, 2], [1192, 1, "\u04A9"], [1193, 2], [1194, 1, "\u04AB"], [1195, 2], [1196, 1, "\u04AD"], [1197, 2], [1198, 1, "\u04AF"], [1199, 2], [1200, 1, "\u04B1"], [1201, 2], [1202, 1, "\u04B3"], [1203, 2], [1204, 1, "\u04B5"], [1205, 2], [1206, 1, "\u04B7"], [1207, 2], [1208, 1, "\u04B9"], [1209, 2], [1210, 1, "\u04BB"], [1211, 2], [1212, 1, "\u04BD"], [1213, 2], [1214, 1, "\u04BF"], [1215, 2], [1216, 1, "\u04CF"], [1217, 1, "\u04C2"], [1218, 2], [1219, 1, "\u04C4"], [1220, 2], [1221, 1, "\u04C6"], [1222, 2], [1223, 1, "\u04C8"], [1224, 2], [1225, 1, "\u04CA"], [1226, 2], [1227, 1, "\u04CC"], [1228, 2], [1229, 1, "\u04CE"], [1230, 2], [1231, 2], [1232, 1, "\u04D1"], [1233, 2], [1234, 1, "\u04D3"], [1235, 2], [1236, 1, "\u04D5"], [1237, 2], [1238, 1, "\u04D7"], [1239, 2], [1240, 1, "\u04D9"], [1241, 2], [1242, 1, "\u04DB"], [1243, 2], [1244, 1, "\u04DD"], [1245, 2], [1246, 1, "\u04DF"], [1247, 2], [1248, 1, "\u04E1"], [1249, 2], [1250, 1, "\u04E3"], [1251, 2], [1252, 1, "\u04E5"], [1253, 2], [1254, 1, "\u04E7"], [1255, 2], [1256, 1, "\u04E9"], [1257, 2], [1258, 1, "\u04EB"], [1259, 2], [1260, 1, "\u04ED"], [1261, 2], [1262, 1, "\u04EF"], [1263, 2], [1264, 1, "\u04F1"], [1265, 2], [1266, 1, "\u04F3"], [1267, 2], [1268, 1, "\u04F5"], [1269, 2], [1270, 1, "\u04F7"], [1271, 2], [1272, 1, "\u04F9"], [1273, 2], [1274, 1, "\u04FB"], [1275, 2], [1276, 1, "\u04FD"], [1277, 2], [1278, 1, "\u04FF"], [1279, 2], [1280, 1, "\u0501"], [1281, 2], [1282, 1, "\u0503"], [1283, 2], [1284, 1, "\u0505"], [1285, 2], [1286, 1, "\u0507"], [1287, 2], [1288, 1, "\u0509"], [1289, 2], [1290, 1, "\u050B"], [1291, 2], [1292, 1, "\u050D"], [1293, 2], [1294, 1, "\u050F"], [1295, 2], [1296, 1, "\u0511"], [1297, 2], [1298, 1, "\u0513"], [1299, 2], [1300, 1, "\u0515"], [1301, 2], [1302, 1, "\u0517"], [1303, 2], [1304, 1, "\u0519"], [1305, 2], [1306, 1, "\u051B"], [1307, 2], [1308, 1, "\u051D"], [1309, 2], [1310, 1, "\u051F"], [1311, 2], [1312, 1, "\u0521"], [1313, 2], [1314, 1, "\u0523"], [1315, 2], [1316, 1, "\u0525"], [1317, 2], [1318, 1, "\u0527"], [1319, 2], [1320, 1, "\u0529"], [1321, 2], [1322, 1, "\u052B"], [1323, 2], [1324, 1, "\u052D"], [1325, 2], [1326, 1, "\u052F"], [1327, 2], [1328, 3], [1329, 1, "\u0561"], [1330, 1, "\u0562"], [1331, 1, "\u0563"], [1332, 1, "\u0564"], [1333, 1, "\u0565"], [1334, 1, "\u0566"], [1335, 1, "\u0567"], [1336, 1, "\u0568"], [1337, 1, "\u0569"], [1338, 1, "\u056A"], [1339, 1, "\u056B"], [1340, 1, "\u056C"], [1341, 1, "\u056D"], [1342, 1, "\u056E"], [1343, 1, "\u056F"], [1344, 1, "\u0570"], [1345, 1, "\u0571"], [1346, 1, "\u0572"], [1347, 1, "\u0573"], [1348, 1, "\u0574"], [1349, 1, "\u0575"], [1350, 1, "\u0576"], [1351, 1, "\u0577"], [1352, 1, "\u0578"], [1353, 1, "\u0579"], [1354, 1, "\u057A"], [1355, 1, "\u057B"], [1356, 1, "\u057C"], [1357, 1, "\u057D"], [1358, 1, "\u057E"], [1359, 1, "\u057F"], [1360, 1, "\u0580"], [1361, 1, "\u0581"], [1362, 1, "\u0582"], [1363, 1, "\u0583"], [1364, 1, "\u0584"], [1365, 1, "\u0585"], [1366, 1, "\u0586"], [[1367, 1368], 3], [1369, 2], [[1370, 1375], 2], [1376, 2], [[1377, 1414], 2], [1415, 1, "\u0565\u0582"], [1416, 2], [1417, 2], [1418, 2], [[1419, 1420], 3], [[1421, 1422], 2], [1423, 2], [1424, 3], [[1425, 1441], 2], [1442, 2], [[1443, 1455], 2], [[1456, 1465], 2], [1466, 2], [[1467, 1469], 2], [1470, 2], [1471, 2], [1472, 2], [[1473, 1474], 2], [1475, 2], [1476, 2], [1477, 2], [1478, 2], [1479, 2], [[1480, 1487], 3], [[1488, 1514], 2], [[1515, 1518], 3], [1519, 2], [[1520, 1524], 2], [[1525, 1535], 3], [[1536, 1539], 3], [1540, 3], [1541, 3], [[1542, 1546], 2], [1547, 2], [1548, 2], [[1549, 1551], 2], [[1552, 1557], 2], [[1558, 1562], 2], [1563, 2], [1564, 3], [1565, 2], [1566, 2], [1567, 2], [1568, 2], [[1569, 1594], 2], [[1595, 1599], 2], [1600, 2], [[1601, 1618], 2], [[1619, 1621], 2], [[1622, 1624], 2], [[1625, 1630], 2], [1631, 2], [[1632, 1641], 2], [[1642, 1645], 2], [[1646, 1647], 2], [[1648, 1652], 2], [1653, 1, "\u0627\u0674"], [1654, 1, "\u0648\u0674"], [1655, 1, "\u06C7\u0674"], [1656, 1, "\u064A\u0674"], [[1657, 1719], 2], [[1720, 1721], 2], [[1722, 1726], 2], [1727, 2], [[1728, 1742], 2], [1743, 2], [[1744, 1747], 2], [1748, 2], [[1749, 1756], 2], [1757, 3], [1758, 2], [[1759, 1768], 2], [1769, 2], [[1770, 1773], 2], [[1774, 1775], 2], [[1776, 1785], 2], [[1786, 1790], 2], [1791, 2], [[1792, 1805], 2], [1806, 3], [1807, 3], [[1808, 1836], 2], [[1837, 1839], 2], [[1840, 1866], 2], [[1867, 1868], 3], [[1869, 1871], 2], [[1872, 1901], 2], [[1902, 1919], 2], [[1920, 1968], 2], [1969, 2], [[1970, 1983], 3], [[1984, 2037], 2], [[2038, 2042], 2], [[2043, 2044], 3], [2045, 2], [[2046, 2047], 2], [[2048, 2093], 2], [[2094, 2095], 3], [[2096, 2110], 2], [2111, 3], [[2112, 2139], 2], [[2140, 2141], 3], [2142, 2], [2143, 3], [[2144, 2154], 2], [[2155, 2159], 3], [[2160, 2183], 2], [2184, 2], [[2185, 2190], 2], [2191, 3], [[2192, 2193], 3], [[2194, 2198], 3], [2199, 2], [[2200, 2207], 2], [2208, 2], [2209, 2], [[2210, 2220], 2], [[2221, 2226], 2], [[2227, 2228], 2], [2229, 2], [[2230, 2237], 2], [[2238, 2247], 2], [[2248, 2258], 2], [2259, 2], [[2260, 2273], 2], [2274, 3], [2275, 2], [[2276, 2302], 2], [2303, 2], [2304, 2], [[2305, 2307], 2], [2308, 2], [[2309, 2361], 2], [[2362, 2363], 2], [[2364, 2381], 2], [2382, 2], [2383, 2], [[2384, 2388], 2], [2389, 2], [[2390, 2391], 2], [2392, 1, "\u0915\u093C"], [2393, 1, "\u0916\u093C"], [2394, 1, "\u0917\u093C"], [2395, 1, "\u091C\u093C"], [2396, 1, "\u0921\u093C"], [2397, 1, "\u0922\u093C"], [2398, 1, "\u092B\u093C"], [2399, 1, "\u092F\u093C"], [[2400, 2403], 2], [[2404, 2405], 2], [[2406, 2415], 2], [2416, 2], [[2417, 2418], 2], [[2419, 2423], 2], [2424, 2], [[2425, 2426], 2], [[2427, 2428], 2], [2429, 2], [[2430, 2431], 2], [2432, 2], [[2433, 2435], 2], [2436, 3], [[2437, 2444], 2], [[2445, 2446], 3], [[2447, 2448], 2], [[2449, 2450], 3], [[2451, 2472], 2], [2473, 3], [[2474, 2480], 2], [2481, 3], [2482, 2], [[2483, 2485], 3], [[2486, 2489], 2], [[2490, 2491], 3], [2492, 2], [2493, 2], [[2494, 2500], 2], [[2501, 2502], 3], [[2503, 2504], 2], [[2505, 2506], 3], [[2507, 2509], 2], [2510, 2], [[2511, 2518], 3], [2519, 2], [[2520, 2523], 3], [2524, 1, "\u09A1\u09BC"], [2525, 1, "\u09A2\u09BC"], [2526, 3], [2527, 1, "\u09AF\u09BC"], [[2528, 2531], 2], [[2532, 2533], 3], [[2534, 2545], 2], [[2546, 2554], 2], [2555, 2], [2556, 2], [2557, 2], [2558, 2], [[2559, 2560], 3], [2561, 2], [2562, 2], [2563, 2], [2564, 3], [[2565, 2570], 2], [[2571, 2574], 3], [[2575, 2576], 2], [[2577, 2578], 3], [[2579, 2600], 2], [2601, 3], [[2602, 2608], 2], [2609, 3], [2610, 2], [2611, 1, "\u0A32\u0A3C"], [2612, 3], [2613, 2], [2614, 1, "\u0A38\u0A3C"], [2615, 3], [[2616, 2617], 2], [[2618, 2619], 3], [2620, 2], [2621, 3], [[2622, 2626], 2], [[2627, 2630], 3], [[2631, 2632], 2], [[2633, 2634], 3], [[2635, 2637], 2], [[2638, 2640], 3], [2641, 2], [[2642, 2648], 3], [2649, 1, "\u0A16\u0A3C"], [2650, 1, "\u0A17\u0A3C"], [2651, 1, "\u0A1C\u0A3C"], [2652, 2], [2653, 3], [2654, 1, "\u0A2B\u0A3C"], [[2655, 2661], 3], [[2662, 2676], 2], [2677, 2], [2678, 2], [[2679, 2688], 3], [[2689, 2691], 2], [2692, 3], [[2693, 2699], 2], [2700, 2], [2701, 2], [2702, 3], [[2703, 2705], 2], [2706, 3], [[2707, 2728], 2], [2729, 3], [[2730, 2736], 2], [2737, 3], [[2738, 2739], 2], [2740, 3], [[2741, 2745], 2], [[2746, 2747], 3], [[2748, 2757], 2], [2758, 3], [[2759, 2761], 2], [2762, 3], [[2763, 2765], 2], [[2766, 2767], 3], [2768, 2], [[2769, 2783], 3], [2784, 2], [[2785, 2787], 2], [[2788, 2789], 3], [[2790, 2799], 2], [2800, 2], [2801, 2], [[2802, 2808], 3], [2809, 2], [[2810, 2815], 2], [2816, 3], [[2817, 2819], 2], [2820, 3], [[2821, 2828], 2], [[2829, 2830], 3], [[2831, 2832], 2], [[2833, 2834], 3], [[2835, 2856], 2], [2857, 3], [[2858, 2864], 2], [2865, 3], [[2866, 2867], 2], [2868, 3], [2869, 2], [[2870, 2873], 2], [[2874, 2875], 3], [[2876, 2883], 2], [2884, 2], [[2885, 2886], 3], [[2887, 2888], 2], [[2889, 2890], 3], [[2891, 2893], 2], [[2894, 2900], 3], [2901, 2], [[2902, 2903], 2], [[2904, 2907], 3], [2908, 1, "\u0B21\u0B3C"], [2909, 1, "\u0B22\u0B3C"], [2910, 3], [[2911, 2913], 2], [[2914, 2915], 2], [[2916, 2917], 3], [[2918, 2927], 2], [2928, 2], [2929, 2], [[2930, 2935], 2], [[2936, 2945], 3], [[2946, 2947], 2], [2948, 3], [[2949, 2954], 2], [[2955, 2957], 3], [[2958, 2960], 2], [2961, 3], [[2962, 2965], 2], [[2966, 2968], 3], [[2969, 2970], 2], [2971, 3], [2972, 2], [2973, 3], [[2974, 2975], 2], [[2976, 2978], 3], [[2979, 2980], 2], [[2981, 2983], 3], [[2984, 2986], 2], [[2987, 2989], 3], [[2990, 2997], 2], [2998, 2], [[2999, 3001], 2], [[3002, 3005], 3], [[3006, 3010], 2], [[3011, 3013], 3], [[3014, 3016], 2], [3017, 3], [[3018, 3021], 2], [[3022, 3023], 3], [3024, 2], [[3025, 3030], 3], [3031, 2], [[3032, 3045], 3], [3046, 2], [[3047, 3055], 2], [[3056, 3058], 2], [[3059, 3066], 2], [[3067, 3071], 3], [3072, 2], [[3073, 3075], 2], [3076, 2], [[3077, 3084], 2], [3085, 3], [[3086, 3088], 2], [3089, 3], [[3090, 3112], 2], [3113, 3], [[3114, 3123], 2], [3124, 2], [[3125, 3129], 2], [[3130, 3131], 3], [3132, 2], [3133, 2], [[3134, 3140], 2], [3141, 3], [[3142, 3144], 2], [3145, 3], [[3146, 3149], 2], [[3150, 3156], 3], [[3157, 3158], 2], [3159, 3], [[3160, 3161], 2], [3162, 2], [[3163, 3164], 3], [3165, 2], [[3166, 3167], 3], [[3168, 3169], 2], [[3170, 3171], 2], [[3172, 3173], 3], [[3174, 3183], 2], [[3184, 3190], 3], [3191, 2], [[3192, 3199], 2], [3200, 2], [3201, 2], [[3202, 3203], 2], [3204, 2], [[3205, 3212], 2], [3213, 3], [[3214, 3216], 2], [3217, 3], [[3218, 3240], 2], [3241, 3], [[3242, 3251], 2], [3252, 3], [[3253, 3257], 2], [[3258, 3259], 3], [[3260, 3261], 2], [[3262, 3268], 2], [3269, 3], [[3270, 3272], 2], [3273, 3], [[3274, 3277], 2], [[3278, 3284], 3], [[3285, 3286], 2], [[3287, 3292], 3], [3293, 2], [3294, 2], [3295, 3], [[3296, 3297], 2], [[3298, 3299], 2], [[3300, 3301], 3], [[3302, 3311], 2], [3312, 3], [[3313, 3314], 2], [3315, 2], [[3316, 3327], 3], [3328, 2], [3329, 2], [[3330, 3331], 2], [3332, 2], [[3333, 3340], 2], [3341, 3], [[3342, 3344], 2], [3345, 3], [[3346, 3368], 2], [3369, 2], [[3370, 3385], 2], [3386, 2], [[3387, 3388], 2], [3389, 2], [[3390, 3395], 2], [3396, 2], [3397, 3], [[3398, 3400], 2], [3401, 3], [[3402, 3405], 2], [3406, 2], [3407, 2], [[3408, 3411], 3], [[3412, 3414], 2], [3415, 2], [[3416, 3422], 2], [3423, 2], [[3424, 3425], 2], [[3426, 3427], 2], [[3428, 3429], 3], [[3430, 3439], 2], [[3440, 3445], 2], [[3446, 3448], 2], [3449, 2], [[3450, 3455], 2], [3456, 3], [3457, 2], [[3458, 3459], 2], [3460, 3], [[3461, 3478], 2], [[3479, 3481], 3], [[3482, 3505], 2], [3506, 3], [[3507, 3515], 2], [3516, 3], [3517, 2], [[3518, 3519], 3], [[3520, 3526], 2], [[3527, 3529], 3], [3530, 2], [[3531, 3534], 3], [[3535, 3540], 2], [3541, 3], [3542, 2], [3543, 3], [[3544, 3551], 2], [[3552, 3557], 3], [[3558, 3567], 2], [[3568, 3569], 3], [[3570, 3571], 2], [3572, 2], [[3573, 3584], 3], [[3585, 3634], 2], [3635, 1, "\u0E4D\u0E32"], [[3636, 3642], 2], [[3643, 3646], 3], [3647, 2], [[3648, 3662], 2], [3663, 2], [[3664, 3673], 2], [[3674, 3675], 2], [[3676, 3712], 3], [[3713, 3714], 2], [3715, 3], [3716, 2], [3717, 3], [3718, 2], [[3719, 3720], 2], [3721, 2], [3722, 2], [3723, 3], [3724, 2], [3725, 2], [[3726, 3731], 2], [[3732, 3735], 2], [3736, 2], [[3737, 3743], 2], [3744, 2], [[3745, 3747], 2], [3748, 3], [3749, 2], [3750, 3], [3751, 2], [[3752, 3753], 2], [[3754, 3755], 2], [3756, 2], [[3757, 3762], 2], [3763, 1, "\u0ECD\u0EB2"], [[3764, 3769], 2], [3770, 2], [[3771, 3773], 2], [[3774, 3775], 3], [[3776, 3780], 2], [3781, 3], [3782, 2], [3783, 3], [[3784, 3789], 2], [3790, 2], [3791, 3], [[3792, 3801], 2], [[3802, 3803], 3], [3804, 1, "\u0EAB\u0E99"], [3805, 1, "\u0EAB\u0EA1"], [[3806, 3807], 2], [[3808, 3839], 3], [3840, 2], [[3841, 3850], 2], [3851, 2], [3852, 1, "\u0F0B"], [[3853, 3863], 2], [[3864, 3865], 2], [[3866, 3871], 2], [[3872, 3881], 2], [[3882, 3892], 2], [3893, 2], [3894, 2], [3895, 2], [3896, 2], [3897, 2], [[3898, 3901], 2], [[3902, 3906], 2], [3907, 1, "\u0F42\u0FB7"], [[3908, 3911], 2], [3912, 3], [[3913, 3916], 2], [3917, 1, "\u0F4C\u0FB7"], [[3918, 3921], 2], [3922, 1, "\u0F51\u0FB7"], [[3923, 3926], 2], [3927, 1, "\u0F56\u0FB7"], [[3928, 3931], 2], [3932, 1, "\u0F5B\u0FB7"], [[3933, 3944], 2], [3945, 1, "\u0F40\u0FB5"], [3946, 2], [[3947, 3948], 2], [[3949, 3952], 3], [[3953, 3954], 2], [3955, 1, "\u0F71\u0F72"], [3956, 2], [3957, 1, "\u0F71\u0F74"], [3958, 1, "\u0FB2\u0F80"], [3959, 1, "\u0FB2\u0F71\u0F80"], [3960, 1, "\u0FB3\u0F80"], [3961, 1, "\u0FB3\u0F71\u0F80"], [[3962, 3968], 2], [3969, 1, "\u0F71\u0F80"], [[3970, 3972], 2], [3973, 2], [[3974, 3979], 2], [[3980, 3983], 2], [[3984, 3986], 2], [3987, 1, "\u0F92\u0FB7"], [[3988, 3989], 2], [3990, 2], [3991, 2], [3992, 3], [[3993, 3996], 2], [3997, 1, "\u0F9C\u0FB7"], [[3998, 4001], 2], [4002, 1, "\u0FA1\u0FB7"], [[4003, 4006], 2], [4007, 1, "\u0FA6\u0FB7"], [[4008, 4011], 2], [4012, 1, "\u0FAB\u0FB7"], [4013, 2], [[4014, 4016], 2], [[4017, 4023], 2], [4024, 2], [4025, 1, "\u0F90\u0FB5"], [[4026, 4028], 2], [4029, 3], [[4030, 4037], 2], [4038, 2], [[4039, 4044], 2], [4045, 3], [4046, 2], [4047, 2], [[4048, 4049], 2], [[4050, 4052], 2], [[4053, 4056], 2], [[4057, 4058], 2], [[4059, 4095], 3], [[4096, 4129], 2], [4130, 2], [[4131, 4135], 2], [4136, 2], [[4137, 4138], 2], [4139, 2], [[4140, 4146], 2], [[4147, 4149], 2], [[4150, 4153], 2], [[4154, 4159], 2], [[4160, 4169], 2], [[4170, 4175], 2], [[4176, 4185], 2], [[4186, 4249], 2], [[4250, 4253], 2], [[4254, 4255], 2], [4256, 1, "\u2D00"], [4257, 1, "\u2D01"], [4258, 1, "\u2D02"], [4259, 1, "\u2D03"], [4260, 1, "\u2D04"], [4261, 1, "\u2D05"], [4262, 1, "\u2D06"], [4263, 1, "\u2D07"], [4264, 1, "\u2D08"], [4265, 1, "\u2D09"], [4266, 1, "\u2D0A"], [4267, 1, "\u2D0B"], [4268, 1, "\u2D0C"], [4269, 1, "\u2D0D"], [4270, 1, "\u2D0E"], [4271, 1, "\u2D0F"], [4272, 1, "\u2D10"], [4273, 1, "\u2D11"], [4274, 1, "\u2D12"], [4275, 1, "\u2D13"], [4276, 1, "\u2D14"], [4277, 1, "\u2D15"], [4278, 1, "\u2D16"], [4279, 1, "\u2D17"], [4280, 1, "\u2D18"], [4281, 1, "\u2D19"], [4282, 1, "\u2D1A"], [4283, 1, "\u2D1B"], [4284, 1, "\u2D1C"], [4285, 1, "\u2D1D"], [4286, 1, "\u2D1E"], [4287, 1, "\u2D1F"], [4288, 1, "\u2D20"], [4289, 1, "\u2D21"], [4290, 1, "\u2D22"], [4291, 1, "\u2D23"], [4292, 1, "\u2D24"], [4293, 1, "\u2D25"], [4294, 3], [4295, 1, "\u2D27"], [[4296, 4300], 3], [4301, 1, "\u2D2D"], [[4302, 4303], 3], [[4304, 4342], 2], [[4343, 4344], 2], [[4345, 4346], 2], [4347, 2], [4348, 1, "\u10DC"], [[4349, 4351], 2], [[4352, 4441], 2], [[4442, 4446], 2], [[4447, 4448], 7], [[4449, 4514], 2], [[4515, 4519], 2], [[4520, 4601], 2], [[4602, 4607], 2], [[4608, 4614], 2], [4615, 2], [[4616, 4678], 2], [4679, 2], [4680, 2], [4681, 3], [[4682, 4685], 2], [[4686, 4687], 3], [[4688, 4694], 2], [4695, 3], [4696, 2], [4697, 3], [[4698, 4701], 2], [[4702, 4703], 3], [[4704, 4742], 2], [4743, 2], [4744, 2], [4745, 3], [[4746, 4749], 2], [[4750, 4751], 3], [[4752, 4782], 2], [4783, 2], [4784, 2], [4785, 3], [[4786, 4789], 2], [[4790, 4791], 3], [[4792, 4798], 2], [4799, 3], [4800, 2], [4801, 3], [[4802, 4805], 2], [[4806, 4807], 3], [[4808, 4814], 2], [4815, 2], [[4816, 4822], 2], [4823, 3], [[4824, 4846], 2], [4847, 2], [[4848, 4878], 2], [4879, 2], [4880, 2], [4881, 3], [[4882, 4885], 2], [[4886, 4887], 3], [[4888, 4894], 2], [4895, 2], [[4896, 4934], 2], [4935, 2], [[4936, 4954], 2], [[4955, 4956], 3], [[4957, 4958], 2], [4959, 2], [4960, 2], [[4961, 4988], 2], [[4989, 4991], 3], [[4992, 5007], 2], [[5008, 5017], 2], [[5018, 5023], 3], [[5024, 5108], 2], [5109, 2], [[5110, 5111], 3], [5112, 1, "\u13F0"], [5113, 1, "\u13F1"], [5114, 1, "\u13F2"], [5115, 1, "\u13F3"], [5116, 1, "\u13F4"], [5117, 1, "\u13F5"], [[5118, 5119], 3], [5120, 2], [[5121, 5740], 2], [[5741, 5742], 2], [[5743, 5750], 2], [[5751, 5759], 2], [5760, 3], [[5761, 5786], 2], [[5787, 5788], 2], [[5789, 5791], 3], [[5792, 5866], 2], [[5867, 5872], 2], [[5873, 5880], 2], [[5881, 5887], 3], [[5888, 5900], 2], [5901, 2], [[5902, 5908], 2], [5909, 2], [[5910, 5918], 3], [5919, 2], [[5920, 5940], 2], [[5941, 5942], 2], [[5943, 5951], 3], [[5952, 5971], 2], [[5972, 5983], 3], [[5984, 5996], 2], [5997, 3], [[5998, 6e3], 2], [6001, 3], [[6002, 6003], 2], [[6004, 6015], 3], [[6016, 6067], 2], [[6068, 6069], 7], [[6070, 6099], 2], [[6100, 6102], 2], [6103, 2], [[6104, 6107], 2], [6108, 2], [6109, 2], [[6110, 6111], 3], [[6112, 6121], 2], [[6122, 6127], 3], [[6128, 6137], 2], [[6138, 6143], 3], [[6144, 6154], 2], [[6155, 6158], 7], [6159, 7], [[6160, 6169], 2], [[6170, 6175], 3], [[6176, 6263], 2], [6264, 2], [[6265, 6271], 3], [[6272, 6313], 2], [6314, 2], [[6315, 6319], 3], [[6320, 6389], 2], [[6390, 6399], 3], [[6400, 6428], 2], [[6429, 6430], 2], [6431, 3], [[6432, 6443], 2], [[6444, 6447], 3], [[6448, 6459], 2], [[6460, 6463], 3], [6464, 2], [[6465, 6467], 3], [[6468, 6469], 2], [[6470, 6509], 2], [[6510, 6511], 3], [[6512, 6516], 2], [[6517, 6527], 3], [[6528, 6569], 2], [[6570, 6571], 2], [[6572, 6575], 3], [[6576, 6601], 2], [[6602, 6607], 3], [[6608, 6617], 2], [6618, 2], [[6619, 6621], 3], [[6622, 6623], 2], [[6624, 6655], 2], [[6656, 6683], 2], [[6684, 6685], 3], [[6686, 6687], 2], [[6688, 6750], 2], [6751, 3], [[6752, 6780], 2], [[6781, 6782], 3], [[6783, 6793], 2], [[6794, 6799], 3], [[6800, 6809], 2], [[6810, 6815], 3], [[6816, 6822], 2], [6823, 2], [[6824, 6829], 2], [[6830, 6831], 3], [[6832, 6845], 2], [6846, 2], [[6847, 6848], 2], [[6849, 6862], 2], [[6863, 6911], 3], [[6912, 6987], 2], [6988, 2], [6989, 3], [[6990, 6991], 2], [[6992, 7001], 2], [[7002, 7018], 2], [[7019, 7027], 2], [[7028, 7036], 2], [[7037, 7038], 2], [7039, 2], [[7040, 7082], 2], [[7083, 7085], 2], [[7086, 7097], 2], [[7098, 7103], 2], [[7104, 7155], 2], [[7156, 7163], 3], [[7164, 7167], 2], [[7168, 7223], 2], [[7224, 7226], 3], [[7227, 7231], 2], [[7232, 7241], 2], [[7242, 7244], 3], [[7245, 7293], 2], [[7294, 7295], 2], [7296, 1, "\u0432"], [7297, 1, "\u0434"], [7298, 1, "\u043E"], [7299, 1, "\u0441"], [[7300, 7301], 1, "\u0442"], [7302, 1, "\u044A"], [7303, 1, "\u0463"], [7304, 1, "\uA64B"], [7305, 1, "\u1C8A"], [7306, 2], [[7307, 7311], 3], [7312, 1, "\u10D0"], [7313, 1, "\u10D1"], [7314, 1, "\u10D2"], [7315, 1, "\u10D3"], [7316, 1, "\u10D4"], [7317, 1, "\u10D5"], [7318, 1, "\u10D6"], [7319, 1, "\u10D7"], [7320, 1, "\u10D8"], [7321, 1, "\u10D9"], [7322, 1, "\u10DA"], [7323, 1, "\u10DB"], [7324, 1, "\u10DC"], [7325, 1, "\u10DD"], [7326, 1, "\u10DE"], [7327, 1, "\u10DF"], [7328, 1, "\u10E0"], [7329, 1, "\u10E1"], [7330, 1, "\u10E2"], [7331, 1, "\u10E3"], [7332, 1, "\u10E4"], [7333, 1, "\u10E5"], [7334, 1, "\u10E6"], [7335, 1, "\u10E7"], [7336, 1, "\u10E8"], [7337, 1, "\u10E9"], [7338, 1, "\u10EA"], [7339, 1, "\u10EB"], [7340, 1, "\u10EC"], [7341, 1, "\u10ED"], [7342, 1, "\u10EE"], [7343, 1, "\u10EF"], [7344, 1, "\u10F0"], [7345, 1, "\u10F1"], [7346, 1, "\u10F2"], [7347, 1, "\u10F3"], [7348, 1, "\u10F4"], [7349, 1, "\u10F5"], [7350, 1, "\u10F6"], [7351, 1, "\u10F7"], [7352, 1, "\u10F8"], [7353, 1, "\u10F9"], [7354, 1, "\u10FA"], [[7355, 7356], 3], [7357, 1, "\u10FD"], [7358, 1, "\u10FE"], [7359, 1, "\u10FF"], [[7360, 7367], 2], [[7368, 7375], 3], [[7376, 7378], 2], [7379, 2], [[7380, 7410], 2], [[7411, 7414], 2], [7415, 2], [[7416, 7417], 2], [7418, 2], [[7419, 7423], 3], [[7424, 7467], 2], [7468, 1, "a"], [7469, 1, "\xE6"], [7470, 1, "b"], [7471, 2], [7472, 1, "d"], [7473, 1, "e"], [7474, 1, "\u01DD"], [7475, 1, "g"], [7476, 1, "h"], [7477, 1, "i"], [7478, 1, "j"], [7479, 1, "k"], [7480, 1, "l"], [7481, 1, "m"], [7482, 1, "n"], [7483, 2], [7484, 1, "o"], [7485, 1, "\u0223"], [7486, 1, "p"], [7487, 1, "r"], [7488, 1, "t"], [7489, 1, "u"], [7490, 1, "w"], [7491, 1, "a"], [7492, 1, "\u0250"], [7493, 1, "\u0251"], [7494, 1, "\u1D02"], [7495, 1, "b"], [7496, 1, "d"], [7497, 1, "e"], [7498, 1, "\u0259"], [7499, 1, "\u025B"], [7500, 1, "\u025C"], [7501, 1, "g"], [7502, 2], [7503, 1, "k"], [7504, 1, "m"], [7505, 1, "\u014B"], [7506, 1, "o"], [7507, 1, "\u0254"], [7508, 1, "\u1D16"], [7509, 1, "\u1D17"], [7510, 1, "p"], [7511, 1, "t"], [7512, 1, "u"], [7513, 1, "\u1D1D"], [7514, 1, "\u026F"], [7515, 1, "v"], [7516, 1, "\u1D25"], [7517, 1, "\u03B2"], [7518, 1, "\u03B3"], [7519, 1, "\u03B4"], [7520, 1, "\u03C6"], [7521, 1, "\u03C7"], [7522, 1, "i"], [7523, 1, "r"], [7524, 1, "u"], [7525, 1, "v"], [7526, 1, "\u03B2"], [7527, 1, "\u03B3"], [7528, 1, "\u03C1"], [7529, 1, "\u03C6"], [7530, 1, "\u03C7"], [7531, 2], [[7532, 7543], 2], [7544, 1, "\u043D"], [[7545, 7578], 2], [7579, 1, "\u0252"], [7580, 1, "c"], [7581, 1, "\u0255"], [7582, 1, "\xF0"], [7583, 1, "\u025C"], [7584, 1, "f"], [7585, 1, "\u025F"], [7586, 1, "\u0261"], [7587, 1, "\u0265"], [7588, 1, "\u0268"], [7589, 1, "\u0269"], [7590, 1, "\u026A"], [7591, 1, "\u1D7B"], [7592, 1, "\u029D"], [7593, 1, "\u026D"], [7594, 1, "\u1D85"], [7595, 1, "\u029F"], [7596, 1, "\u0271"], [7597, 1, "\u0270"], [7598, 1, "\u0272"], [7599, 1, "\u0273"], [7600, 1, "\u0274"], [7601, 1, "\u0275"], [7602, 1, "\u0278"], [7603, 1, "\u0282"], [7604, 1, "\u0283"], [7605, 1, "\u01AB"], [7606, 1, "\u0289"], [7607, 1, "\u028A"], [7608, 1, "\u1D1C"], [7609, 1, "\u028B"], [7610, 1, "\u028C"], [7611, 1, "z"], [7612, 1, "\u0290"], [7613, 1, "\u0291"], [7614, 1, "\u0292"], [7615, 1, "\u03B8"], [[7616, 7619], 2], [[7620, 7626], 2], [[7627, 7654], 2], [[7655, 7669], 2], [[7670, 7673], 2], [7674, 2], [7675, 2], [7676, 2], [7677, 2], [[7678, 7679], 2], [7680, 1, "\u1E01"], [7681, 2], [7682, 1, "\u1E03"], [7683, 2], [7684, 1, "\u1E05"], [7685, 2], [7686, 1, "\u1E07"], [7687, 2], [7688, 1, "\u1E09"], [7689, 2], [7690, 1, "\u1E0B"], [7691, 2], [7692, 1, "\u1E0D"], [7693, 2], [7694, 1, "\u1E0F"], [7695, 2], [7696, 1, "\u1E11"], [7697, 2], [7698, 1, "\u1E13"], [7699, 2], [7700, 1, "\u1E15"], [7701, 2], [7702, 1, "\u1E17"], [7703, 2], [7704, 1, "\u1E19"], [7705, 2], [7706, 1, "\u1E1B"], [7707, 2], [7708, 1, "\u1E1D"], [7709, 2], [7710, 1, "\u1E1F"], [7711, 2], [7712, 1, "\u1E21"], [7713, 2], [7714, 1, "\u1E23"], [7715, 2], [7716, 1, "\u1E25"], [7717, 2], [7718, 1, "\u1E27"], [7719, 2], [7720, 1, "\u1E29"], [7721, 2], [7722, 1, "\u1E2B"], [7723, 2], [7724, 1, "\u1E2D"], [7725, 2], [7726, 1, "\u1E2F"], [7727, 2], [7728, 1, "\u1E31"], [7729, 2], [7730, 1, "\u1E33"], [7731, 2], [7732, 1, "\u1E35"], [7733, 2], [7734, 1, "\u1E37"], [7735, 2], [7736, 1, "\u1E39"], [7737, 2], [7738, 1, "\u1E3B"], [7739, 2], [7740, 1, "\u1E3D"], [7741, 2], [7742, 1, "\u1E3F"], [7743, 2], [7744, 1, "\u1E41"], [7745, 2], [7746, 1, "\u1E43"], [7747, 2], [7748, 1, "\u1E45"], [7749, 2], [7750, 1, "\u1E47"], [7751, 2], [7752, 1, "\u1E49"], [7753, 2], [7754, 1, "\u1E4B"], [7755, 2], [7756, 1, "\u1E4D"], [7757, 2], [7758, 1, "\u1E4F"], [7759, 2], [7760, 1, "\u1E51"], [7761, 2], [7762, 1, "\u1E53"], [7763, 2], [7764, 1, "\u1E55"], [7765, 2], [7766, 1, "\u1E57"], [7767, 2], [7768, 1, "\u1E59"], [7769, 2], [7770, 1, "\u1E5B"], [7771, 2], [7772, 1, "\u1E5D"], [7773, 2], [7774, 1, "\u1E5F"], [7775, 2], [7776, 1, "\u1E61"], [7777, 2], [7778, 1, "\u1E63"], [7779, 2], [7780, 1, "\u1E65"], [7781, 2], [7782, 1, "\u1E67"], [7783, 2], [7784, 1, "\u1E69"], [7785, 2], [7786, 1, "\u1E6B"], [7787, 2], [7788, 1, "\u1E6D"], [7789, 2], [7790, 1, "\u1E6F"], [7791, 2], [7792, 1, "\u1E71"], [7793, 2], [7794, 1, "\u1E73"], [7795, 2], [7796, 1, "\u1E75"], [7797, 2], [7798, 1, "\u1E77"], [7799, 2], [7800, 1, "\u1E79"], [7801, 2], [7802, 1, "\u1E7B"], [7803, 2], [7804, 1, "\u1E7D"], [7805, 2], [7806, 1, "\u1E7F"], [7807, 2], [7808, 1, "\u1E81"], [7809, 2], [7810, 1, "\u1E83"], [7811, 2], [7812, 1, "\u1E85"], [7813, 2], [7814, 1, "\u1E87"], [7815, 2], [7816, 1, "\u1E89"], [7817, 2], [7818, 1, "\u1E8B"], [7819, 2], [7820, 1, "\u1E8D"], [7821, 2], [7822, 1, "\u1E8F"], [7823, 2], [7824, 1, "\u1E91"], [7825, 2], [7826, 1, "\u1E93"], [7827, 2], [7828, 1, "\u1E95"], [[7829, 7833], 2], [7834, 1, "a\u02BE"], [7835, 1, "\u1E61"], [[7836, 7837], 2], [7838, 1, "\xDF"], [7839, 2], [7840, 1, "\u1EA1"], [7841, 2], [7842, 1, "\u1EA3"], [7843, 2], [7844, 1, "\u1EA5"], [7845, 2], [7846, 1, "\u1EA7"], [7847, 2], [7848, 1, "\u1EA9"], [7849, 2], [7850, 1, "\u1EAB"], [7851, 2], [7852, 1, "\u1EAD"], [7853, 2], [7854, 1, "\u1EAF"], [7855, 2], [7856, 1, "\u1EB1"], [7857, 2], [7858, 1, "\u1EB3"], [7859, 2], [7860, 1, "\u1EB5"], [7861, 2], [7862, 1, "\u1EB7"], [7863, 2], [7864, 1, "\u1EB9"], [7865, 2], [7866, 1, "\u1EBB"], [7867, 2], [7868, 1, "\u1EBD"], [7869, 2], [7870, 1, "\u1EBF"], [7871, 2], [7872, 1, "\u1EC1"], [7873, 2], [7874, 1, "\u1EC3"], [7875, 2], [7876, 1, "\u1EC5"], [7877, 2], [7878, 1, "\u1EC7"], [7879, 2], [7880, 1, "\u1EC9"], [7881, 2], [7882, 1, "\u1ECB"], [7883, 2], [7884, 1, "\u1ECD"], [7885, 2], [7886, 1, "\u1ECF"], [7887, 2], [7888, 1, "\u1ED1"], [7889, 2], [7890, 1, "\u1ED3"], [7891, 2], [7892, 1, "\u1ED5"], [7893, 2], [7894, 1, "\u1ED7"], [7895, 2], [7896, 1, "\u1ED9"], [7897, 2], [7898, 1, "\u1EDB"], [7899, 2], [7900, 1, "\u1EDD"], [7901, 2], [7902, 1, "\u1EDF"], [7903, 2], [7904, 1, "\u1EE1"], [7905, 2], [7906, 1, "\u1EE3"], [7907, 2], [7908, 1, "\u1EE5"], [7909, 2], [7910, 1, "\u1EE7"], [7911, 2], [7912, 1, "\u1EE9"], [7913, 2], [7914, 1, "\u1EEB"], [7915, 2], [7916, 1, "\u1EED"], [7917, 2], [7918, 1, "\u1EEF"], [7919, 2], [7920, 1, "\u1EF1"], [7921, 2], [7922, 1, "\u1EF3"], [7923, 2], [7924, 1, "\u1EF5"], [7925, 2], [7926, 1, "\u1EF7"], [7927, 2], [7928, 1, "\u1EF9"], [7929, 2], [7930, 1, "\u1EFB"], [7931, 2], [7932, 1, "\u1EFD"], [7933, 2], [7934, 1, "\u1EFF"], [7935, 2], [[7936, 7943], 2], [7944, 1, "\u1F00"], [7945, 1, "\u1F01"], [7946, 1, "\u1F02"], [7947, 1, "\u1F03"], [7948, 1, "\u1F04"], [7949, 1, "\u1F05"], [7950, 1, "\u1F06"], [7951, 1, "\u1F07"], [[7952, 7957], 2], [[7958, 7959], 3], [7960, 1, "\u1F10"], [7961, 1, "\u1F11"], [7962, 1, "\u1F12"], [7963, 1, "\u1F13"], [7964, 1, "\u1F14"], [7965, 1, "\u1F15"], [[7966, 7967], 3], [[7968, 7975], 2], [7976, 1, "\u1F20"], [7977, 1, "\u1F21"], [7978, 1, "\u1F22"], [7979, 1, "\u1F23"], [7980, 1, "\u1F24"], [7981, 1, "\u1F25"], [7982, 1, "\u1F26"], [7983, 1, "\u1F27"], [[7984, 7991], 2], [7992, 1, "\u1F30"], [7993, 1, "\u1F31"], [7994, 1, "\u1F32"], [7995, 1, "\u1F33"], [7996, 1, "\u1F34"], [7997, 1, "\u1F35"], [7998, 1, "\u1F36"], [7999, 1, "\u1F37"], [[8e3, 8005], 2], [[8006, 8007], 3], [8008, 1, "\u1F40"], [8009, 1, "\u1F41"], [8010, 1, "\u1F42"], [8011, 1, "\u1F43"], [8012, 1, "\u1F44"], [8013, 1, "\u1F45"], [[8014, 8015], 3], [[8016, 8023], 2], [8024, 3], [8025, 1, "\u1F51"], [8026, 3], [8027, 1, "\u1F53"], [8028, 3], [8029, 1, "\u1F55"], [8030, 3], [8031, 1, "\u1F57"], [[8032, 8039], 2], [8040, 1, "\u1F60"], [8041, 1, "\u1F61"], [8042, 1, "\u1F62"], [8043, 1, "\u1F63"], [8044, 1, "\u1F64"], [8045, 1, "\u1F65"], [8046, 1, "\u1F66"], [8047, 1, "\u1F67"], [8048, 2], [8049, 1, "\u03AC"], [8050, 2], [8051, 1, "\u03AD"], [8052, 2], [8053, 1, "\u03AE"], [8054, 2], [8055, 1, "\u03AF"], [8056, 2], [8057, 1, "\u03CC"], [8058, 2], [8059, 1, "\u03CD"], [8060, 2], [8061, 1, "\u03CE"], [[8062, 8063], 3], [8064, 1, "\u1F00\u03B9"], [8065, 1, "\u1F01\u03B9"], [8066, 1, "\u1F02\u03B9"], [8067, 1, "\u1F03\u03B9"], [8068, 1, "\u1F04\u03B9"], [8069, 1, "\u1F05\u03B9"], [8070, 1, "\u1F06\u03B9"], [8071, 1, "\u1F07\u03B9"], [8072, 1, "\u1F00\u03B9"], [8073, 1, "\u1F01\u03B9"], [8074, 1, "\u1F02\u03B9"], [8075, 1, "\u1F03\u03B9"], [8076, 1, "\u1F04\u03B9"], [8077, 1, "\u1F05\u03B9"], [8078, 1, "\u1F06\u03B9"], [8079, 1, "\u1F07\u03B9"], [8080, 1, "\u1F20\u03B9"], [8081, 1, "\u1F21\u03B9"], [8082, 1, "\u1F22\u03B9"], [8083, 1, "\u1F23\u03B9"], [8084, 1, "\u1F24\u03B9"], [8085, 1, "\u1F25\u03B9"], [8086, 1, "\u1F26\u03B9"], [8087, 1, "\u1F27\u03B9"], [8088, 1, "\u1F20\u03B9"], [8089, 1, "\u1F21\u03B9"], [8090, 1, "\u1F22\u03B9"], [8091, 1, "\u1F23\u03B9"], [8092, 1, "\u1F24\u03B9"], [8093, 1, "\u1F25\u03B9"], [8094, 1, "\u1F26\u03B9"], [8095, 1, "\u1F27\u03B9"], [8096, 1, "\u1F60\u03B9"], [8097, 1, "\u1F61\u03B9"], [8098, 1, "\u1F62\u03B9"], [8099, 1, "\u1F63\u03B9"], [8100, 1, "\u1F64\u03B9"], [8101, 1, "\u1F65\u03B9"], [8102, 1, "\u1F66\u03B9"], [8103, 1, "\u1F67\u03B9"], [8104, 1, "\u1F60\u03B9"], [8105, 1, "\u1F61\u03B9"], [8106, 1, "\u1F62\u03B9"], [8107, 1, "\u1F63\u03B9"], [8108, 1, "\u1F64\u03B9"], [8109, 1, "\u1F65\u03B9"], [8110, 1, "\u1F66\u03B9"], [8111, 1, "\u1F67\u03B9"], [[8112, 8113], 2], [8114, 1, "\u1F70\u03B9"], [8115, 1, "\u03B1\u03B9"], [8116, 1, "\u03AC\u03B9"], [8117, 3], [8118, 2], [8119, 1, "\u1FB6\u03B9"], [8120, 1, "\u1FB0"], [8121, 1, "\u1FB1"], [8122, 1, "\u1F70"], [8123, 1, "\u03AC"], [8124, 1, "\u03B1\u03B9"], [8125, 1, " \u0313"], [8126, 1, "\u03B9"], [8127, 1, " \u0313"], [8128, 1, " \u0342"], [8129, 1, " \u0308\u0342"], [8130, 1, "\u1F74\u03B9"], [8131, 1, "\u03B7\u03B9"], [8132, 1, "\u03AE\u03B9"], [8133, 3], [8134, 2], [8135, 1, "\u1FC6\u03B9"], [8136, 1, "\u1F72"], [8137, 1, "\u03AD"], [8138, 1, "\u1F74"], [8139, 1, "\u03AE"], [8140, 1, "\u03B7\u03B9"], [8141, 1, " \u0313\u0300"], [8142, 1, " \u0313\u0301"], [8143, 1, " \u0313\u0342"], [[8144, 8146], 2], [8147, 1, "\u0390"], [[8148, 8149], 3], [[8150, 8151], 2], [8152, 1, "\u1FD0"], [8153, 1, "\u1FD1"], [8154, 1, "\u1F76"], [8155, 1, "\u03AF"], [8156, 3], [8157, 1, " \u0314\u0300"], [8158, 1, " \u0314\u0301"], [8159, 1, " \u0314\u0342"], [[8160, 8162], 2], [8163, 1, "\u03B0"], [[8164, 8167], 2], [8168, 1, "\u1FE0"], [8169, 1, "\u1FE1"], [8170, 1, "\u1F7A"], [8171, 1, "\u03CD"], [8172, 1, "\u1FE5"], [8173, 1, " \u0308\u0300"], [8174, 1, " \u0308\u0301"], [8175, 1, "`"], [[8176, 8177], 3], [8178, 1, "\u1F7C\u03B9"], [8179, 1, "\u03C9\u03B9"], [8180, 1, "\u03CE\u03B9"], [8181, 3], [8182, 2], [8183, 1, "\u1FF6\u03B9"], [8184, 1, "\u1F78"], [8185, 1, "\u03CC"], [8186, 1, "\u1F7C"], [8187, 1, "\u03CE"], [8188, 1, "\u03C9\u03B9"], [8189, 1, " \u0301"], [8190, 1, " \u0314"], [8191, 3], [[8192, 8202], 1, " "], [8203, 7], [[8204, 8205], 6, ""], [[8206, 8207], 3], [8208, 2], [8209, 1, "\u2010"], [[8210, 8214], 2], [8215, 1, " \u0333"], [[8216, 8227], 2], [[8228, 8230], 3], [8231, 2], [[8232, 8238], 3], [8239, 1, " "], [[8240, 8242], 2], [8243, 1, "\u2032\u2032"], [8244, 1, "\u2032\u2032\u2032"], [8245, 2], [8246, 1, "\u2035\u2035"], [8247, 1, "\u2035\u2035\u2035"], [[8248, 8251], 2], [8252, 1, "!!"], [8253, 2], [8254, 1, " \u0305"], [[8255, 8262], 2], [8263, 1, "??"], [8264, 1, "?!"], [8265, 1, "!?"], [[8266, 8269], 2], [[8270, 8274], 2], [[8275, 8276], 2], [[8277, 8278], 2], [8279, 1, "\u2032\u2032\u2032\u2032"], [[8280, 8286], 2], [8287, 1, " "], [[8288, 8291], 7], [8292, 7], [8293, 3], [[8294, 8297], 3], [[8298, 8303], 7], [8304, 1, "0"], [8305, 1, "i"], [[8306, 8307], 3], [8308, 1, "4"], [8309, 1, "5"], [8310, 1, "6"], [8311, 1, "7"], [8312, 1, "8"], [8313, 1, "9"], [8314, 1, "+"], [8315, 1, "\u2212"], [8316, 1, "="], [8317, 1, "("], [8318, 1, ")"], [8319, 1, "n"], [8320, 1, "0"], [8321, 1, "1"], [8322, 1, "2"], [8323, 1, "3"], [8324, 1, "4"], [8325, 1, "5"], [8326, 1, "6"], [8327, 1, "7"], [8328, 1, "8"], [8329, 1, "9"], [8330, 1, "+"], [8331, 1, "\u2212"], [8332, 1, "="], [8333, 1, "("], [8334, 1, ")"], [8335, 3], [8336, 1, "a"], [8337, 1, "e"], [8338, 1, "o"], [8339, 1, "x"], [8340, 1, "\u0259"], [8341, 1, "h"], [8342, 1, "k"], [8343, 1, "l"], [8344, 1, "m"], [8345, 1, "n"], [8346, 1, "p"], [8347, 1, "s"], [8348, 1, "t"], [[8349, 8351], 3], [[8352, 8359], 2], [8360, 1, "rs"], [[8361, 8362], 2], [8363, 2], [8364, 2], [[8365, 8367], 2], [[8368, 8369], 2], [[8370, 8373], 2], [[8374, 8376], 2], [8377, 2], [8378, 2], [[8379, 8381], 2], [8382, 2], [8383, 2], [8384, 2], [[8385, 8399], 3], [[8400, 8417], 2], [[8418, 8419], 2], [[8420, 8426], 2], [8427, 2], [[8428, 8431], 2], [8432, 2], [[8433, 8447], 3], [8448, 1, "a/c"], [8449, 1, "a/s"], [8450, 1, "c"], [8451, 1, "\xB0c"], [8452, 2], [8453, 1, "c/o"], [8454, 1, "c/u"], [8455, 1, "\u025B"], [8456, 2], [8457, 1, "\xB0f"], [8458, 1, "g"], [[8459, 8462], 1, "h"], [8463, 1, "\u0127"], [[8464, 8465], 1, "i"], [[8466, 8467], 1, "l"], [8468, 2], [8469, 1, "n"], [8470, 1, "no"], [[8471, 8472], 2], [8473, 1, "p"], [8474, 1, "q"], [[8475, 8477], 1, "r"], [[8478, 8479], 2], [8480, 1, "sm"], [8481, 1, "tel"], [8482, 1, "tm"], [8483, 2], [8484, 1, "z"], [8485, 2], [8486, 1, "\u03C9"], [8487, 2], [8488, 1, "z"], [8489, 2], [8490, 1, "k"], [8491, 1, "\xE5"], [8492, 1, "b"], [8493, 1, "c"], [8494, 2], [[8495, 8496], 1, "e"], [8497, 1, "f"], [8498, 1, "\u214E"], [8499, 1, "m"], [8500, 1, "o"], [8501, 1, "\u05D0"], [8502, 1, "\u05D1"], [8503, 1, "\u05D2"], [8504, 1, "\u05D3"], [8505, 1, "i"], [8506, 2], [8507, 1, "fax"], [8508, 1, "\u03C0"], [[8509, 8510], 1, "\u03B3"], [8511, 1, "\u03C0"], [8512, 1, "\u2211"], [[8513, 8516], 2], [[8517, 8518], 1, "d"], [8519, 1, "e"], [8520, 1, "i"], [8521, 1, "j"], [[8522, 8523], 2], [8524, 2], [8525, 2], [8526, 2], [8527, 2], [8528, 1, "1\u20447"], [8529, 1, "1\u20449"], [8530, 1, "1\u204410"], [8531, 1, "1\u20443"], [8532, 1, "2\u20443"], [8533, 1, "1\u20445"], [8534, 1, "2\u20445"], [8535, 1, "3\u20445"], [8536, 1, "4\u20445"], [8537, 1, "1\u20446"], [8538, 1, "5\u20446"], [8539, 1, "1\u20448"], [8540, 1, "3\u20448"], [8541, 1, "5\u20448"], [8542, 1, "7\u20448"], [8543, 1, "1\u2044"], [8544, 1, "i"], [8545, 1, "ii"], [8546, 1, "iii"], [8547, 1, "iv"], [8548, 1, "v"], [8549, 1, "vi"], [8550, 1, "vii"], [8551, 1, "viii"], [8552, 1, "ix"], [8553, 1, "x"], [8554, 1, "xi"], [8555, 1, "xii"], [8556, 1, "l"], [8557, 1, "c"], [8558, 1, "d"], [8559, 1, "m"], [8560, 1, "i"], [8561, 1, "ii"], [8562, 1, "iii"], [8563, 1, "iv"], [8564, 1, "v"], [8565, 1, "vi"], [8566, 1, "vii"], [8567, 1, "viii"], [8568, 1, "ix"], [8569, 1, "x"], [8570, 1, "xi"], [8571, 1, "xii"], [8572, 1, "l"], [8573, 1, "c"], [8574, 1, "d"], [8575, 1, "m"], [[8576, 8578], 2], [8579, 1, "\u2184"], [8580, 2], [[8581, 8584], 2], [8585, 1, "0\u20443"], [[8586, 8587], 2], [[8588, 8591], 3], [[8592, 8682], 2], [[8683, 8691], 2], [[8692, 8703], 2], [[8704, 8747], 2], [8748, 1, "\u222B\u222B"], [8749, 1, "\u222B\u222B\u222B"], [8750, 2], [8751, 1, "\u222E\u222E"], [8752, 1, "\u222E\u222E\u222E"], [[8753, 8945], 2], [[8946, 8959], 2], [8960, 2], [8961, 2], [[8962, 9e3], 2], [9001, 1, "\u3008"], [9002, 1, "\u3009"], [[9003, 9082], 2], [9083, 2], [9084, 2], [[9085, 9114], 2], [[9115, 9166], 2], [[9167, 9168], 2], [[9169, 9179], 2], [[9180, 9191], 2], [9192, 2], [[9193, 9203], 2], [[9204, 9210], 2], [[9211, 9214], 2], [9215, 2], [[9216, 9252], 2], [[9253, 9254], 2], [[9255, 9257], 2], [[9258, 9279], 3], [[9280, 9290], 2], [[9291, 9311], 3], [9312, 1, "1"], [9313, 1, "2"], [9314, 1, "3"], [9315, 1, "4"], [9316, 1, "5"], [9317, 1, "6"], [9318, 1, "7"], [9319, 1, "8"], [9320, 1, "9"], [9321, 1, "10"], [9322, 1, "11"], [9323, 1, "12"], [9324, 1, "13"], [9325, 1, "14"], [9326, 1, "15"], [9327, 1, "16"], [9328, 1, "17"], [9329, 1, "18"], [9330, 1, "19"], [9331, 1, "20"], [9332, 1, "(1)"], [9333, 1, "(2)"], [9334, 1, "(3)"], [9335, 1, "(4)"], [9336, 1, "(5)"], [9337, 1, "(6)"], [9338, 1, "(7)"], [9339, 1, "(8)"], [9340, 1, "(9)"], [9341, 1, "(10)"], [9342, 1, "(11)"], [9343, 1, "(12)"], [9344, 1, "(13)"], [9345, 1, "(14)"], [9346, 1, "(15)"], [9347, 1, "(16)"], [9348, 1, "(17)"], [9349, 1, "(18)"], [9350, 1, "(19)"], [9351, 1, "(20)"], [[9352, 9371], 3], [9372, 1, "(a)"], [9373, 1, "(b)"], [9374, 1, "(c)"], [9375, 1, "(d)"], [9376, 1, "(e)"], [9377, 1, "(f)"], [9378, 1, "(g)"], [9379, 1, "(h)"], [9380, 1, "(i)"], [9381, 1, "(j)"], [9382, 1, "(k)"], [9383, 1, "(l)"], [9384, 1, "(m)"], [9385, 1, "(n)"], [9386, 1, "(o)"], [9387, 1, "(p)"], [9388, 1, "(q)"], [9389, 1, "(r)"], [9390, 1, "(s)"], [9391, 1, "(t)"], [9392, 1, "(u)"], [9393, 1, "(v)"], [9394, 1, "(w)"], [9395, 1, "(x)"], [9396, 1, "(y)"], [9397, 1, "(z)"], [9398, 1, "a"], [9399, 1, "b"], [9400, 1, "c"], [9401, 1, "d"], [9402, 1, "e"], [9403, 1, "f"], [9404, 1, "g"], [9405, 1, "h"], [9406, 1, "i"], [9407, 1, "j"], [9408, 1, "k"], [9409, 1, "l"], [9410, 1, "m"], [9411, 1, "n"], [9412, 1, "o"], [9413, 1, "p"], [9414, 1, "q"], [9415, 1, "r"], [9416, 1, "s"], [9417, 1, "t"], [9418, 1, "u"], [9419, 1, "v"], [9420, 1, "w"], [9421, 1, "x"], [9422, 1, "y"], [9423, 1, "z"], [9424, 1, "a"], [9425, 1, "b"], [9426, 1, "c"], [9427, 1, "d"], [9428, 1, "e"], [9429, 1, "f"], [9430, 1, "g"], [9431, 1, "h"], [9432, 1, "i"], [9433, 1, "j"], [9434, 1, "k"], [9435, 1, "l"], [9436, 1, "m"], [9437, 1, "n"], [9438, 1, "o"], [9439, 1, "p"], [9440, 1, "q"], [9441, 1, "r"], [9442, 1, "s"], [9443, 1, "t"], [9444, 1, "u"], [9445, 1, "v"], [9446, 1, "w"], [9447, 1, "x"], [9448, 1, "y"], [9449, 1, "z"], [9450, 1, "0"], [[9451, 9470], 2], [9471, 2], [[9472, 9621], 2], [[9622, 9631], 2], [[9632, 9711], 2], [[9712, 9719], 2], [[9720, 9727], 2], [[9728, 9747], 2], [[9748, 9749], 2], [[9750, 9751], 2], [9752, 2], [9753, 2], [[9754, 9839], 2], [[9840, 9841], 2], [[9842, 9853], 2], [[9854, 9855], 2], [[9856, 9865], 2], [[9866, 9873], 2], [[9874, 9884], 2], [9885, 2], [[9886, 9887], 2], [[9888, 9889], 2], [[9890, 9905], 2], [9906, 2], [[9907, 9916], 2], [[9917, 9919], 2], [[9920, 9923], 2], [[9924, 9933], 2], [9934, 2], [[9935, 9953], 2], [9954, 2], [9955, 2], [[9956, 9959], 2], [[9960, 9983], 2], [9984, 2], [[9985, 9988], 2], [9989, 2], [[9990, 9993], 2], [[9994, 9995], 2], [[9996, 10023], 2], [10024, 2], [[10025, 10059], 2], [10060, 2], [10061, 2], [10062, 2], [[10063, 10066], 2], [[10067, 10069], 2], [10070, 2], [10071, 2], [[10072, 10078], 2], [[10079, 10080], 2], [[10081, 10087], 2], [[10088, 10101], 2], [[10102, 10132], 2], [[10133, 10135], 2], [[10136, 10159], 2], [10160, 2], [[10161, 10174], 2], [10175, 2], [[10176, 10182], 2], [[10183, 10186], 2], [10187, 2], [10188, 2], [10189, 2], [[10190, 10191], 2], [[10192, 10219], 2], [[10220, 10223], 2], [[10224, 10239], 2], [[10240, 10495], 2], [[10496, 10763], 2], [10764, 1, "\u222B\u222B\u222B\u222B"], [[10765, 10867], 2], [10868, 1, "::="], [10869, 1, "=="], [10870, 1, "==="], [[10871, 10971], 2], [10972, 1, "\u2ADD\u0338"], [[10973, 11007], 2], [[11008, 11021], 2], [[11022, 11027], 2], [[11028, 11034], 2], [[11035, 11039], 2], [[11040, 11043], 2], [[11044, 11084], 2], [[11085, 11087], 2], [[11088, 11092], 2], [[11093, 11097], 2], [[11098, 11123], 2], [[11124, 11125], 3], [[11126, 11157], 2], [11158, 3], [11159, 2], [[11160, 11193], 2], [[11194, 11196], 2], [[11197, 11208], 2], [11209, 2], [[11210, 11217], 2], [11218, 2], [[11219, 11243], 2], [[11244, 11247], 2], [[11248, 11262], 2], [11263, 2], [11264, 1, "\u2C30"], [11265, 1, "\u2C31"], [11266, 1, "\u2C32"], [11267, 1, "\u2C33"], [11268, 1, "\u2C34"], [11269, 1, "\u2C35"], [11270, 1, "\u2C36"], [11271, 1, "\u2C37"], [11272, 1, "\u2C38"], [11273, 1, "\u2C39"], [11274, 1, "\u2C3A"], [11275, 1, "\u2C3B"], [11276, 1, "\u2C3C"], [11277, 1, "\u2C3D"], [11278, 1, "\u2C3E"], [11279, 1, "\u2C3F"], [11280, 1, "\u2C40"], [11281, 1, "\u2C41"], [11282, 1, "\u2C42"], [11283, 1, "\u2C43"], [11284, 1, "\u2C44"], [11285, 1, "\u2C45"], [11286, 1, "\u2C46"], [11287, 1, "\u2C47"], [11288, 1, "\u2C48"], [11289, 1, "\u2C49"], [11290, 1, "\u2C4A"], [11291, 1, "\u2C4B"], [11292, 1, "\u2C4C"], [11293, 1, "\u2C4D"], [11294, 1, "\u2C4E"], [11295, 1, "\u2C4F"], [11296, 1, "\u2C50"], [11297, 1, "\u2C51"], [11298, 1, "\u2C52"], [11299, 1, "\u2C53"], [11300, 1, "\u2C54"], [11301, 1, "\u2C55"], [11302, 1, "\u2C56"], [11303, 1, "\u2C57"], [11304, 1, "\u2C58"], [11305, 1, "\u2C59"], [11306, 1, "\u2C5A"], [11307, 1, "\u2C5B"], [11308, 1, "\u2C5C"], [11309, 1, "\u2C5D"], [11310, 1, "\u2C5E"], [11311, 1, "\u2C5F"], [[11312, 11358], 2], [11359, 2], [11360, 1, "\u2C61"], [11361, 2], [11362, 1, "\u026B"], [11363, 1, "\u1D7D"], [11364, 1, "\u027D"], [[11365, 11366], 2], [11367, 1, "\u2C68"], [11368, 2], [11369, 1, "\u2C6A"], [11370, 2], [11371, 1, "\u2C6C"], [11372, 2], [11373, 1, "\u0251"], [11374, 1, "\u0271"], [11375, 1, "\u0250"], [11376, 1, "\u0252"], [11377, 2], [11378, 1, "\u2C73"], [11379, 2], [11380, 2], [11381, 1, "\u2C76"], [[11382, 11383], 2], [[11384, 11387], 2], [11388, 1, "j"], [11389, 1, "v"], [11390, 1, "\u023F"], [11391, 1, "\u0240"], [11392, 1, "\u2C81"], [11393, 2], [11394, 1, "\u2C83"], [11395, 2], [11396, 1, "\u2C85"], [11397, 2], [11398, 1, "\u2C87"], [11399, 2], [11400, 1, "\u2C89"], [11401, 2], [11402, 1, "\u2C8B"], [11403, 2], [11404, 1, "\u2C8D"], [11405, 2], [11406, 1, "\u2C8F"], [11407, 2], [11408, 1, "\u2C91"], [11409, 2], [11410, 1, "\u2C93"], [11411, 2], [11412, 1, "\u2C95"], [11413, 2], [11414, 1, "\u2C97"], [11415, 2], [11416, 1, "\u2C99"], [11417, 2], [11418, 1, "\u2C9B"], [11419, 2], [11420, 1, "\u2C9D"], [11421, 2], [11422, 1, "\u2C9F"], [11423, 2], [11424, 1, "\u2CA1"], [11425, 2], [11426, 1, "\u2CA3"], [11427, 2], [11428, 1, "\u2CA5"], [11429, 2], [11430, 1, "\u2CA7"], [11431, 2], [11432, 1, "\u2CA9"], [11433, 2], [11434, 1, "\u2CAB"], [11435, 2], [11436, 1, "\u2CAD"], [11437, 2], [11438, 1, "\u2CAF"], [11439, 2], [11440, 1, "\u2CB1"], [11441, 2], [11442, 1, "\u2CB3"], [11443, 2], [11444, 1, "\u2CB5"], [11445, 2], [11446, 1, "\u2CB7"], [11447, 2], [11448, 1, "\u2CB9"], [11449, 2], [11450, 1, "\u2CBB"], [11451, 2], [11452, 1, "\u2CBD"], [11453, 2], [11454, 1, "\u2CBF"], [11455, 2], [11456, 1, "\u2CC1"], [11457, 2], [11458, 1, "\u2CC3"], [11459, 2], [11460, 1, "\u2CC5"], [11461, 2], [11462, 1, "\u2CC7"], [11463, 2], [11464, 1, "\u2CC9"], [11465, 2], [11466, 1, "\u2CCB"], [11467, 2], [11468, 1, "\u2CCD"], [11469, 2], [11470, 1, "\u2CCF"], [11471, 2], [11472, 1, "\u2CD1"], [11473, 2], [11474, 1, "\u2CD3"], [11475, 2], [11476, 1, "\u2CD5"], [11477, 2], [11478, 1, "\u2CD7"], [11479, 2], [11480, 1, "\u2CD9"], [11481, 2], [11482, 1, "\u2CDB"], [11483, 2], [11484, 1, "\u2CDD"], [11485, 2], [11486, 1, "\u2CDF"], [11487, 2], [11488, 1, "\u2CE1"], [11489, 2], [11490, 1, "\u2CE3"], [[11491, 11492], 2], [[11493, 11498], 2], [11499, 1, "\u2CEC"], [11500, 2], [11501, 1, "\u2CEE"], [[11502, 11505], 2], [11506, 1, "\u2CF3"], [11507, 2], [[11508, 11512], 3], [[11513, 11519], 2], [[11520, 11557], 2], [11558, 3], [11559, 2], [[11560, 11564], 3], [11565, 2], [[11566, 11567], 3], [[11568, 11621], 2], [[11622, 11623], 2], [[11624, 11630], 3], [11631, 1, "\u2D61"], [11632, 2], [[11633, 11646], 3], [11647, 2], [[11648, 11670], 2], [[11671, 11679], 3], [[11680, 11686], 2], [11687, 3], [[11688, 11694], 2], [11695, 3], [[11696, 11702], 2], [11703, 3], [[11704, 11710], 2], [11711, 3], [[11712, 11718], 2], [11719, 3], [[11720, 11726], 2], [11727, 3], [[11728, 11734], 2], [11735, 3], [[11736, 11742], 2], [11743, 3], [[11744, 11775], 2], [[11776, 11799], 2], [[11800, 11803], 2], [[11804, 11805], 2], [[11806, 11822], 2], [11823, 2], [11824, 2], [11825, 2], [[11826, 11835], 2], [[11836, 11842], 2], [[11843, 11844], 2], [[11845, 11849], 2], [[11850, 11854], 2], [11855, 2], [[11856, 11858], 2], [[11859, 11869], 2], [[11870, 11903], 3], [[11904, 11929], 2], [11930, 3], [[11931, 11934], 2], [11935, 1, "\u6BCD"], [[11936, 12018], 2], [12019, 1, "\u9F9F"], [[12020, 12031], 3], [12032, 1, "\u4E00"], [12033, 1, "\u4E28"], [12034, 1, "\u4E36"], [12035, 1, "\u4E3F"], [12036, 1, "\u4E59"], [12037, 1, "\u4E85"], [12038, 1, "\u4E8C"], [12039, 1, "\u4EA0"], [12040, 1, "\u4EBA"], [12041, 1, "\u513F"], [12042, 1, "\u5165"], [12043, 1, "\u516B"], [12044, 1, "\u5182"], [12045, 1, "\u5196"], [12046, 1, "\u51AB"], [12047, 1, "\u51E0"], [12048, 1, "\u51F5"], [12049, 1, "\u5200"], [12050, 1, "\u529B"], [12051, 1, "\u52F9"], [12052, 1, "\u5315"], [12053, 1, "\u531A"], [12054, 1, "\u5338"], [12055, 1, "\u5341"], [12056, 1, "\u535C"], [12057, 1, "\u5369"], [12058, 1, "\u5382"], [12059, 1, "\u53B6"], [12060, 1, "\u53C8"], [12061, 1, "\u53E3"], [12062, 1, "\u56D7"], [12063, 1, "\u571F"], [12064, 1, "\u58EB"], [12065, 1, "\u5902"], [12066, 1, "\u590A"], [12067, 1, "\u5915"], [12068, 1, "\u5927"], [12069, 1, "\u5973"], [12070, 1, "\u5B50"], [12071, 1, "\u5B80"], [12072, 1, "\u5BF8"], [12073, 1, "\u5C0F"], [12074, 1, "\u5C22"], [12075, 1, "\u5C38"], [12076, 1, "\u5C6E"], [12077, 1, "\u5C71"], [12078, 1, "\u5DDB"], [12079, 1, "\u5DE5"], [12080, 1, "\u5DF1"], [12081, 1, "\u5DFE"], [12082, 1, "\u5E72"], [12083, 1, "\u5E7A"], [12084, 1, "\u5E7F"], [12085, 1, "\u5EF4"], [12086, 1, "\u5EFE"], [12087, 1, "\u5F0B"], [12088, 1, "\u5F13"], [12089, 1, "\u5F50"], [12090, 1, "\u5F61"], [12091, 1, "\u5F73"], [12092, 1, "\u5FC3"], [12093, 1, "\u6208"], [12094, 1, "\u6236"], [12095, 1, "\u624B"], [12096, 1, "\u652F"], [12097, 1, "\u6534"], [12098, 1, "\u6587"], [12099, 1, "\u6597"], [12100, 1, "\u65A4"], [12101, 1, "\u65B9"], [12102, 1, "\u65E0"], [12103, 1, "\u65E5"], [12104, 1, "\u66F0"], [12105, 1, "\u6708"], [12106, 1, "\u6728"], [12107, 1, "\u6B20"], [12108, 1, "\u6B62"], [12109, 1, "\u6B79"], [12110, 1, "\u6BB3"], [12111, 1, "\u6BCB"], [12112, 1, "\u6BD4"], [12113, 1, "\u6BDB"], [12114, 1, "\u6C0F"], [12115, 1, "\u6C14"], [12116, 1, "\u6C34"], [12117, 1, "\u706B"], [12118, 1, "\u722A"], [12119, 1, "\u7236"], [12120, 1, "\u723B"], [12121, 1, "\u723F"], [12122, 1, "\u7247"], [12123, 1, "\u7259"], [12124, 1, "\u725B"], [12125, 1, "\u72AC"], [12126, 1, "\u7384"], [12127, 1, "\u7389"], [12128, 1, "\u74DC"], [12129, 1, "\u74E6"], [12130, 1, "\u7518"], [12131, 1, "\u751F"], [12132, 1, "\u7528"], [12133, 1, "\u7530"], [12134, 1, "\u758B"], [12135, 1, "\u7592"], [12136, 1, "\u7676"], [12137, 1, "\u767D"], [12138, 1, "\u76AE"], [12139, 1, "\u76BF"], [12140, 1, "\u76EE"], [12141, 1, "\u77DB"], [12142, 1, "\u77E2"], [12143, 1, "\u77F3"], [12144, 1, "\u793A"], [12145, 1, "\u79B8"], [12146, 1, "\u79BE"], [12147, 1, "\u7A74"], [12148, 1, "\u7ACB"], [12149, 1, "\u7AF9"], [12150, 1, "\u7C73"], [12151, 1, "\u7CF8"], [12152, 1, "\u7F36"], [12153, 1, "\u7F51"], [12154, 1, "\u7F8A"], [12155, 1, "\u7FBD"], [12156, 1, "\u8001"], [12157, 1, "\u800C"], [12158, 1, "\u8012"], [12159, 1, "\u8033"], [12160, 1, "\u807F"], [12161, 1, "\u8089"], [12162, 1, "\u81E3"], [12163, 1, "\u81EA"], [12164, 1, "\u81F3"], [12165, 1, "\u81FC"], [12166, 1, "\u820C"], [12167, 1, "\u821B"], [12168, 1, "\u821F"], [12169, 1, "\u826E"], [12170, 1, "\u8272"], [12171, 1, "\u8278"], [12172, 1, "\u864D"], [12173, 1, "\u866B"], [12174, 1, "\u8840"], [12175, 1, "\u884C"], [12176, 1, "\u8863"], [12177, 1, "\u897E"], [12178, 1, "\u898B"], [12179, 1, "\u89D2"], [12180, 1, "\u8A00"], [12181, 1, "\u8C37"], [12182, 1, "\u8C46"], [12183, 1, "\u8C55"], [12184, 1, "\u8C78"], [12185, 1, "\u8C9D"], [12186, 1, "\u8D64"], [12187, 1, "\u8D70"], [12188, 1, "\u8DB3"], [12189, 1, "\u8EAB"], [12190, 1, "\u8ECA"], [12191, 1, "\u8F9B"], [12192, 1, "\u8FB0"], [12193, 1, "\u8FB5"], [12194, 1, "\u9091"], [12195, 1, "\u9149"], [12196, 1, "\u91C6"], [12197, 1, "\u91CC"], [12198, 1, "\u91D1"], [12199, 1, "\u9577"], [12200, 1, "\u9580"], [12201, 1, "\u961C"], [12202, 1, "\u96B6"], [12203, 1, "\u96B9"], [12204, 1, "\u96E8"], [12205, 1, "\u9751"], [12206, 1, "\u975E"], [12207, 1, "\u9762"], [12208, 1, "\u9769"], [12209, 1, "\u97CB"], [12210, 1, "\u97ED"], [12211, 1, "\u97F3"], [12212, 1, "\u9801"], [12213, 1, "\u98A8"], [12214, 1, "\u98DB"], [12215, 1, "\u98DF"], [12216, 1, "\u9996"], [12217, 1, "\u9999"], [12218, 1, "\u99AC"], [12219, 1, "\u9AA8"], [12220, 1, "\u9AD8"], [12221, 1, "\u9ADF"], [12222, 1, "\u9B25"], [12223, 1, "\u9B2F"], [12224, 1, "\u9B32"], [12225, 1, "\u9B3C"], [12226, 1, "\u9B5A"], [12227, 1, "\u9CE5"], [12228, 1, "\u9E75"], [12229, 1, "\u9E7F"], [12230, 1, "\u9EA5"], [12231, 1, "\u9EBB"], [12232, 1, "\u9EC3"], [12233, 1, "\u9ECD"], [12234, 1, "\u9ED1"], [12235, 1, "\u9EF9"], [12236, 1, "\u9EFD"], [12237, 1, "\u9F0E"], [12238, 1, "\u9F13"], [12239, 1, "\u9F20"], [12240, 1, "\u9F3B"], [12241, 1, "\u9F4A"], [12242, 1, "\u9F52"], [12243, 1, "\u9F8D"], [12244, 1, "\u9F9C"], [12245, 1, "\u9FA0"], [[12246, 12271], 3], [[12272, 12283], 3], [[12284, 12287], 3], [12288, 1, " "], [12289, 2], [12290, 1, "."], [[12291, 12292], 2], [[12293, 12295], 2], [[12296, 12329], 2], [[12330, 12333], 2], [[12334, 12341], 2], [12342, 1, "\u3012"], [12343, 2], [12344, 1, "\u5341"], [12345, 1, "\u5344"], [12346, 1, "\u5345"], [12347, 2], [12348, 2], [12349, 2], [12350, 2], [12351, 2], [12352, 3], [[12353, 12436], 2], [[12437, 12438], 2], [[12439, 12440], 3], [[12441, 12442], 2], [12443, 1, " \u3099"], [12444, 1, " \u309A"], [[12445, 12446], 2], [12447, 1, "\u3088\u308A"], [12448, 2], [[12449, 12542], 2], [12543, 1, "\u30B3\u30C8"], [[12544, 12548], 3], [[12549, 12588], 2], [12589, 2], [12590, 2], [12591, 2], [12592, 3], [12593, 1, "\u1100"], [12594, 1, "\u1101"], [12595, 1, "\u11AA"], [12596, 1, "\u1102"], [12597, 1, "\u11AC"], [12598, 1, "\u11AD"], [12599, 1, "\u1103"], [12600, 1, "\u1104"], [12601, 1, "\u1105"], [12602, 1, "\u11B0"], [12603, 1, "\u11B1"], [12604, 1, "\u11B2"], [12605, 1, "\u11B3"], [12606, 1, "\u11B4"], [12607, 1, "\u11B5"], [12608, 1, "\u111A"], [12609, 1, "\u1106"], [12610, 1, "\u1107"], [12611, 1, "\u1108"], [12612, 1, "\u1121"], [12613, 1, "\u1109"], [12614, 1, "\u110A"], [12615, 1, "\u110B"], [12616, 1, "\u110C"], [12617, 1, "\u110D"], [12618, 1, "\u110E"], [12619, 1, "\u110F"], [12620, 1, "\u1110"], [12621, 1, "\u1111"], [12622, 1, "\u1112"], [12623, 1, "\u1161"], [12624, 1, "\u1162"], [12625, 1, "\u1163"], [12626, 1, "\u1164"], [12627, 1, "\u1165"], [12628, 1, "\u1166"], [12629, 1, "\u1167"], [12630, 1, "\u1168"], [12631, 1, "\u1169"], [12632, 1, "\u116A"], [12633, 1, "\u116B"], [12634, 1, "\u116C"], [12635, 1, "\u116D"], [12636, 1, "\u116E"], [12637, 1, "\u116F"], [12638, 1, "\u1170"], [12639, 1, "\u1171"], [12640, 1, "\u1172"], [12641, 1, "\u1173"], [12642, 1, "\u1174"], [12643, 1, "\u1175"], [12644, 7], [12645, 1, "\u1114"], [12646, 1, "\u1115"], [12647, 1, "\u11C7"], [12648, 1, "\u11C8"], [12649, 1, "\u11CC"], [12650, 1, "\u11CE"], [12651, 1, "\u11D3"], [12652, 1, "\u11D7"], [12653, 1, "\u11D9"], [12654, 1, "\u111C"], [12655, 1, "\u11DD"], [12656, 1, "\u11DF"], [12657, 1, "\u111D"], [12658, 1, "\u111E"], [12659, 1, "\u1120"], [12660, 1, "\u1122"], [12661, 1, "\u1123"], [12662, 1, "\u1127"], [12663, 1, "\u1129"], [12664, 1, "\u112B"], [12665, 1, "\u112C"], [12666, 1, "\u112D"], [12667, 1, "\u112E"], [12668, 1, "\u112F"], [12669, 1, "\u1132"], [12670, 1, "\u1136"], [12671, 1, "\u1140"], [12672, 1, "\u1147"], [12673, 1, "\u114C"], [12674, 1, "\u11F1"], [12675, 1, "\u11F2"], [12676, 1, "\u1157"], [12677, 1, "\u1158"], [12678, 1, "\u1159"], [12679, 1, "\u1184"], [12680, 1, "\u1185"], [12681, 1, "\u1188"], [12682, 1, "\u1191"], [12683, 1, "\u1192"], [12684, 1, "\u1194"], [12685, 1, "\u119E"], [12686, 1, "\u11A1"], [12687, 3], [[12688, 12689], 2], [12690, 1, "\u4E00"], [12691, 1, "\u4E8C"], [12692, 1, "\u4E09"], [12693, 1, "\u56DB"], [12694, 1, "\u4E0A"], [12695, 1, "\u4E2D"], [12696, 1, "\u4E0B"], [12697, 1, "\u7532"], [12698, 1, "\u4E59"], [12699, 1, "\u4E19"], [12700, 1, "\u4E01"], [12701, 1, "\u5929"], [12702, 1, "\u5730"], [12703, 1, "\u4EBA"], [[12704, 12727], 2], [[12728, 12730], 2], [[12731, 12735], 2], [[12736, 12751], 2], [[12752, 12771], 2], [[12772, 12773], 2], [[12774, 12782], 3], [12783, 3], [[12784, 12799], 2], [12800, 1, "(\u1100)"], [12801, 1, "(\u1102)"], [12802, 1, "(\u1103)"], [12803, 1, "(\u1105)"], [12804, 1, "(\u1106)"], [12805, 1, "(\u1107)"], [12806, 1, "(\u1109)"], [12807, 1, "(\u110B)"], [12808, 1, "(\u110C)"], [12809, 1, "(\u110E)"], [12810, 1, "(\u110F)"], [12811, 1, "(\u1110)"], [12812, 1, "(\u1111)"], [12813, 1, "(\u1112)"], [12814, 1, "(\uAC00)"], [12815, 1, "(\uB098)"], [12816, 1, "(\uB2E4)"], [12817, 1, "(\uB77C)"], [12818, 1, "(\uB9C8)"], [12819, 1, "(\uBC14)"], [12820, 1, "(\uC0AC)"], [12821, 1, "(\uC544)"], [12822, 1, "(\uC790)"], [12823, 1, "(\uCC28)"], [12824, 1, "(\uCE74)"], [12825, 1, "(\uD0C0)"], [12826, 1, "(\uD30C)"], [12827, 1, "(\uD558)"], [12828, 1, "(\uC8FC)"], [12829, 1, "(\uC624\uC804)"], [12830, 1, "(\uC624\uD6C4)"], [12831, 3], [12832, 1, "(\u4E00)"], [12833, 1, "(\u4E8C)"], [12834, 1, "(\u4E09)"], [12835, 1, "(\u56DB)"], [12836, 1, "(\u4E94)"], [12837, 1, "(\u516D)"], [12838, 1, "(\u4E03)"], [12839, 1, "(\u516B)"], [12840, 1, "(\u4E5D)"], [12841, 1, "(\u5341)"], [12842, 1, "(\u6708)"], [12843, 1, "(\u706B)"], [12844, 1, "(\u6C34)"], [12845, 1, "(\u6728)"], [12846, 1, "(\u91D1)"], [12847, 1, "(\u571F)"], [12848, 1, "(\u65E5)"], [12849, 1, "(\u682A)"], [12850, 1, "(\u6709)"], [12851, 1, "(\u793E)"], [12852, 1, "(\u540D)"], [12853, 1, "(\u7279)"], [12854, 1, "(\u8CA1)"], [12855, 1, "(\u795D)"], [12856, 1, "(\u52B4)"], [12857, 1, "(\u4EE3)"], [12858, 1, "(\u547C)"], [12859, 1, "(\u5B66)"], [12860, 1, "(\u76E3)"], [12861, 1, "(\u4F01)"], [12862, 1, "(\u8CC7)"], [12863, 1, "(\u5354)"], [12864, 1, "(\u796D)"], [12865, 1, "(\u4F11)"], [12866, 1, "(\u81EA)"], [12867, 1, "(\u81F3)"], [12868, 1, "\u554F"], [12869, 1, "\u5E7C"], [12870, 1, "\u6587"], [12871, 1, "\u7B8F"], [[12872, 12879], 2], [12880, 1, "pte"], [12881, 1, "21"], [12882, 1, "22"], [12883, 1, "23"], [12884, 1, "24"], [12885, 1, "25"], [12886, 1, "26"], [12887, 1, "27"], [12888, 1, "28"], [12889, 1, "29"], [12890, 1, "30"], [12891, 1, "31"], [12892, 1, "32"], [12893, 1, "33"], [12894, 1, "34"], [12895, 1, "35"], [12896, 1, "\u1100"], [12897, 1, "\u1102"], [12898, 1, "\u1103"], [12899, 1, "\u1105"], [12900, 1, "\u1106"], [12901, 1, "\u1107"], [12902, 1, "\u1109"], [12903, 1, "\u110B"], [12904, 1, "\u110C"], [12905, 1, "\u110E"], [12906, 1, "\u110F"], [12907, 1, "\u1110"], [12908, 1, "\u1111"], [12909, 1, "\u1112"], [12910, 1, "\uAC00"], [12911, 1, "\uB098"], [12912, 1, "\uB2E4"], [12913, 1, "\uB77C"], [12914, 1, "\uB9C8"], [12915, 1, "\uBC14"], [12916, 1, "\uC0AC"], [12917, 1, "\uC544"], [12918, 1, "\uC790"], [12919, 1, "\uCC28"], [12920, 1, "\uCE74"], [12921, 1, "\uD0C0"], [12922, 1, "\uD30C"], [12923, 1, "\uD558"], [12924, 1, "\uCC38\uACE0"], [12925, 1, "\uC8FC\uC758"], [12926, 1, "\uC6B0"], [12927, 2], [12928, 1, "\u4E00"], [12929, 1, "\u4E8C"], [12930, 1, "\u4E09"], [12931, 1, "\u56DB"], [12932, 1, "\u4E94"], [12933, 1, "\u516D"], [12934, 1, "\u4E03"], [12935, 1, "\u516B"], [12936, 1, "\u4E5D"], [12937, 1, "\u5341"], [12938, 1, "\u6708"], [12939, 1, "\u706B"], [12940, 1, "\u6C34"], [12941, 1, "\u6728"], [12942, 1, "\u91D1"], [12943, 1, "\u571F"], [12944, 1, "\u65E5"], [12945, 1, "\u682A"], [12946, 1, "\u6709"], [12947, 1, "\u793E"], [12948, 1, "\u540D"], [12949, 1, "\u7279"], [12950, 1, "\u8CA1"], [12951, 1, "\u795D"], [12952, 1, "\u52B4"], [12953, 1, "\u79D8"], [12954, 1, "\u7537"], [12955, 1, "\u5973"], [12956, 1, "\u9069"], [12957, 1, "\u512A"], [12958, 1, "\u5370"], [12959, 1, "\u6CE8"], [12960, 1, "\u9805"], [12961, 1, "\u4F11"], [12962, 1, "\u5199"], [12963, 1, "\u6B63"], [12964, 1, "\u4E0A"], [12965, 1, "\u4E2D"], [12966, 1, "\u4E0B"], [12967, 1, "\u5DE6"], [12968, 1, "\u53F3"], [12969, 1, "\u533B"], [12970, 1, "\u5B97"], [12971, 1, "\u5B66"], [12972, 1, "\u76E3"], [12973, 1, "\u4F01"], [12974, 1, "\u8CC7"], [12975, 1, "\u5354"], [12976, 1, "\u591C"], [12977, 1, "36"], [12978, 1, "37"], [12979, 1, "38"], [12980, 1, "39"], [12981, 1, "40"], [12982, 1, "41"], [12983, 1, "42"], [12984, 1, "43"], [12985, 1, "44"], [12986, 1, "45"], [12987, 1, "46"], [12988, 1, "47"], [12989, 1, "48"], [12990, 1, "49"], [12991, 1, "50"], [12992, 1, "1\u6708"], [12993, 1, "2\u6708"], [12994, 1, "3\u6708"], [12995, 1, "4\u6708"], [12996, 1, "5\u6708"], [12997, 1, "6\u6708"], [12998, 1, "7\u6708"], [12999, 1, "8\u6708"], [13e3, 1, "9\u6708"], [13001, 1, "10\u6708"], [13002, 1, "11\u6708"], [13003, 1, "12\u6708"], [13004, 1, "hg"], [13005, 1, "erg"], [13006, 1, "ev"], [13007, 1, "ltd"], [13008, 1, "\u30A2"], [13009, 1, "\u30A4"], [13010, 1, "\u30A6"], [13011, 1, "\u30A8"], [13012, 1, "\u30AA"], [13013, 1, "\u30AB"], [13014, 1, "\u30AD"], [13015, 1, "\u30AF"], [13016, 1, "\u30B1"], [13017, 1, "\u30B3"], [13018, 1, "\u30B5"], [13019, 1, "\u30B7"], [13020, 1, "\u30B9"], [13021, 1, "\u30BB"], [13022, 1, "\u30BD"], [13023, 1, "\u30BF"], [13024, 1, "\u30C1"], [13025, 1, "\u30C4"], [13026, 1, "\u30C6"], [13027, 1, "\u30C8"], [13028, 1, "\u30CA"], [13029, 1, "\u30CB"], [13030, 1, "\u30CC"], [13031, 1, "\u30CD"], [13032, 1, "\u30CE"], [13033, 1, "\u30CF"], [13034, 1, "\u30D2"], [13035, 1, "\u30D5"], [13036, 1, "\u30D8"], [13037, 1, "\u30DB"], [13038, 1, "\u30DE"], [13039, 1, "\u30DF"], [13040, 1, "\u30E0"], [13041, 1, "\u30E1"], [13042, 1, "\u30E2"], [13043, 1, "\u30E4"], [13044, 1, "\u30E6"], [13045, 1, "\u30E8"], [13046, 1, "\u30E9"], [13047, 1, "\u30EA"], [13048, 1, "\u30EB"], [13049, 1, "\u30EC"], [13050, 1, "\u30ED"], [13051, 1, "\u30EF"], [13052, 1, "\u30F0"], [13053, 1, "\u30F1"], [13054, 1, "\u30F2"], [13055, 1, "\u4EE4\u548C"], [13056, 1, "\u30A2\u30D1\u30FC\u30C8"], [13057, 1, "\u30A2\u30EB\u30D5\u30A1"], [13058, 1, "\u30A2\u30F3\u30DA\u30A2"], [13059, 1, "\u30A2\u30FC\u30EB"], [13060, 1, "\u30A4\u30CB\u30F3\u30B0"], [13061, 1, "\u30A4\u30F3\u30C1"], [13062, 1, "\u30A6\u30A9\u30F3"], [13063, 1, "\u30A8\u30B9\u30AF\u30FC\u30C9"], [13064, 1, "\u30A8\u30FC\u30AB\u30FC"], [13065, 1, "\u30AA\u30F3\u30B9"], [13066, 1, "\u30AA\u30FC\u30E0"], [13067, 1, "\u30AB\u30A4\u30EA"], [13068, 1, "\u30AB\u30E9\u30C3\u30C8"], [13069, 1, "\u30AB\u30ED\u30EA\u30FC"], [13070, 1, "\u30AC\u30ED\u30F3"], [13071, 1, "\u30AC\u30F3\u30DE"], [13072, 1, "\u30AE\u30AC"], [13073, 1, "\u30AE\u30CB\u30FC"], [13074, 1, "\u30AD\u30E5\u30EA\u30FC"], [13075, 1, "\u30AE\u30EB\u30C0\u30FC"], [13076, 1, "\u30AD\u30ED"], [13077, 1, "\u30AD\u30ED\u30B0\u30E9\u30E0"], [13078, 1, "\u30AD\u30ED\u30E1\u30FC\u30C8\u30EB"], [13079, 1, "\u30AD\u30ED\u30EF\u30C3\u30C8"], [13080, 1, "\u30B0\u30E9\u30E0"], [13081, 1, "\u30B0\u30E9\u30E0\u30C8\u30F3"], [13082, 1, "\u30AF\u30EB\u30BC\u30A4\u30ED"], [13083, 1, "\u30AF\u30ED\u30FC\u30CD"], [13084, 1, "\u30B1\u30FC\u30B9"], [13085, 1, "\u30B3\u30EB\u30CA"], [13086, 1, "\u30B3\u30FC\u30DD"], [13087, 1, "\u30B5\u30A4\u30AF\u30EB"], [13088, 1, "\u30B5\u30F3\u30C1\u30FC\u30E0"], [13089, 1, "\u30B7\u30EA\u30F3\u30B0"], [13090, 1, "\u30BB\u30F3\u30C1"], [13091, 1, "\u30BB\u30F3\u30C8"], [13092, 1, "\u30C0\u30FC\u30B9"], [13093, 1, "\u30C7\u30B7"], [13094, 1, "\u30C9\u30EB"], [13095, 1, "\u30C8\u30F3"], [13096, 1, "\u30CA\u30CE"], [13097, 1, "\u30CE\u30C3\u30C8"], [13098, 1, "\u30CF\u30A4\u30C4"], [13099, 1, "\u30D1\u30FC\u30BB\u30F3\u30C8"], [13100, 1, "\u30D1\u30FC\u30C4"], [13101, 1, "\u30D0\u30FC\u30EC\u30EB"], [13102, 1, "\u30D4\u30A2\u30B9\u30C8\u30EB"], [13103, 1, "\u30D4\u30AF\u30EB"], [13104, 1, "\u30D4\u30B3"], [13105, 1, "\u30D3\u30EB"], [13106, 1, "\u30D5\u30A1\u30E9\u30C3\u30C9"], [13107, 1, "\u30D5\u30A3\u30FC\u30C8"], [13108, 1, "\u30D6\u30C3\u30B7\u30A7\u30EB"], [13109, 1, "\u30D5\u30E9\u30F3"], [13110, 1, "\u30D8\u30AF\u30BF\u30FC\u30EB"], [13111, 1, "\u30DA\u30BD"], [13112, 1, "\u30DA\u30CB\u30D2"], [13113, 1, "\u30D8\u30EB\u30C4"], [13114, 1, "\u30DA\u30F3\u30B9"], [13115, 1, "\u30DA\u30FC\u30B8"], [13116, 1, "\u30D9\u30FC\u30BF"], [13117, 1, "\u30DD\u30A4\u30F3\u30C8"], [13118, 1, "\u30DC\u30EB\u30C8"], [13119, 1, "\u30DB\u30F3"], [13120, 1, "\u30DD\u30F3\u30C9"], [13121, 1, "\u30DB\u30FC\u30EB"], [13122, 1, "\u30DB\u30FC\u30F3"], [13123, 1, "\u30DE\u30A4\u30AF\u30ED"], [13124, 1, "\u30DE\u30A4\u30EB"], [13125, 1, "\u30DE\u30C3\u30CF"], [13126, 1, "\u30DE\u30EB\u30AF"], [13127, 1, "\u30DE\u30F3\u30B7\u30E7\u30F3"], [13128, 1, "\u30DF\u30AF\u30ED\u30F3"], [13129, 1, "\u30DF\u30EA"], [13130, 1, "\u30DF\u30EA\u30D0\u30FC\u30EB"], [13131, 1, "\u30E1\u30AC"], [13132, 1, "\u30E1\u30AC\u30C8\u30F3"], [13133, 1, "\u30E1\u30FC\u30C8\u30EB"], [13134, 1, "\u30E4\u30FC\u30C9"], [13135, 1, "\u30E4\u30FC\u30EB"], [13136, 1, "\u30E6\u30A2\u30F3"], [13137, 1, "\u30EA\u30C3\u30C8\u30EB"], [13138, 1, "\u30EA\u30E9"], [13139, 1, "\u30EB\u30D4\u30FC"], [13140, 1, "\u30EB\u30FC\u30D6\u30EB"], [13141, 1, "\u30EC\u30E0"], [13142, 1, "\u30EC\u30F3\u30C8\u30B2\u30F3"], [13143, 1, "\u30EF\u30C3\u30C8"], [13144, 1, "0\u70B9"], [13145, 1, "1\u70B9"], [13146, 1, "2\u70B9"], [13147, 1, "3\u70B9"], [13148, 1, "4\u70B9"], [13149, 1, "5\u70B9"], [13150, 1, "6\u70B9"], [13151, 1, "7\u70B9"], [13152, 1, "8\u70B9"], [13153, 1, "9\u70B9"], [13154, 1, "10\u70B9"], [13155, 1, "11\u70B9"], [13156, 1, "12\u70B9"], [13157, 1, "13\u70B9"], [13158, 1, "14\u70B9"], [13159, 1, "15\u70B9"], [13160, 1, "16\u70B9"], [13161, 1, "17\u70B9"], [13162, 1, "18\u70B9"], [13163, 1, "19\u70B9"], [13164, 1, "20\u70B9"], [13165, 1, "21\u70B9"], [13166, 1, "22\u70B9"], [13167, 1, "23\u70B9"], [13168, 1, "24\u70B9"], [13169, 1, "hpa"], [13170, 1, "da"], [13171, 1, "au"], [13172, 1, "bar"], [13173, 1, "ov"], [13174, 1, "pc"], [13175, 1, "dm"], [13176, 1, "dm2"], [13177, 1, "dm3"], [13178, 1, "iu"], [13179, 1, "\u5E73\u6210"], [13180, 1, "\u662D\u548C"], [13181, 1, "\u5927\u6B63"], [13182, 1, "\u660E\u6CBB"], [13183, 1, "\u682A\u5F0F\u4F1A\u793E"], [13184, 1, "pa"], [13185, 1, "na"], [13186, 1, "\u03BCa"], [13187, 1, "ma"], [13188, 1, "ka"], [13189, 1, "kb"], [13190, 1, "mb"], [13191, 1, "gb"], [13192, 1, "cal"], [13193, 1, "kcal"], [13194, 1, "pf"], [13195, 1, "nf"], [13196, 1, "\u03BCf"], [13197, 1, "\u03BCg"], [13198, 1, "mg"], [13199, 1, "kg"], [13200, 1, "hz"], [13201, 1, "khz"], [13202, 1, "mhz"], [13203, 1, "ghz"], [13204, 1, "thz"], [13205, 1, "\u03BCl"], [13206, 1, "ml"], [13207, 1, "dl"], [13208, 1, "kl"], [13209, 1, "fm"], [13210, 1, "nm"], [13211, 1, "\u03BCm"], [13212, 1, "mm"], [13213, 1, "cm"], [13214, 1, "km"], [13215, 1, "mm2"], [13216, 1, "cm2"], [13217, 1, "m2"], [13218, 1, "km2"], [13219, 1, "mm3"], [13220, 1, "cm3"], [13221, 1, "m3"], [13222, 1, "km3"], [13223, 1, "m\u2215s"], [13224, 1, "m\u2215s2"], [13225, 1, "pa"], [13226, 1, "kpa"], [13227, 1, "mpa"], [13228, 1, "gpa"], [13229, 1, "rad"], [13230, 1, "rad\u2215s"], [13231, 1, "rad\u2215s2"], [13232, 1, "ps"], [13233, 1, "ns"], [13234, 1, "\u03BCs"], [13235, 1, "ms"], [13236, 1, "pv"], [13237, 1, "nv"], [13238, 1, "\u03BCv"], [13239, 1, "mv"], [13240, 1, "kv"], [13241, 1, "mv"], [13242, 1, "pw"], [13243, 1, "nw"], [13244, 1, "\u03BCw"], [13245, 1, "mw"], [13246, 1, "kw"], [13247, 1, "mw"], [13248, 1, "k\u03C9"], [13249, 1, "m\u03C9"], [13250, 3], [13251, 1, "bq"], [13252, 1, "cc"], [13253, 1, "cd"], [13254, 1, "c\u2215kg"], [13255, 3], [13256, 1, "db"], [13257, 1, "gy"], [13258, 1, "ha"], [13259, 1, "hp"], [13260, 1, "in"], [13261, 1, "kk"], [13262, 1, "km"], [13263, 1, "kt"], [13264, 1, "lm"], [13265, 1, "ln"], [13266, 1, "log"], [13267, 1, "lx"], [13268, 1, "mb"], [13269, 1, "mil"], [13270, 1, "mol"], [13271, 1, "ph"], [13272, 3], [13273, 1, "ppm"], [13274, 1, "pr"], [13275, 1, "sr"], [13276, 1, "sv"], [13277, 1, "wb"], [13278, 1, "v\u2215m"], [13279, 1, "a\u2215m"], [13280, 1, "1\u65E5"], [13281, 1, "2\u65E5"], [13282, 1, "3\u65E5"], [13283, 1, "4\u65E5"], [13284, 1, "5\u65E5"], [13285, 1, "6\u65E5"], [13286, 1, "7\u65E5"], [13287, 1, "8\u65E5"], [13288, 1, "9\u65E5"], [13289, 1, "10\u65E5"], [13290, 1, "11\u65E5"], [13291, 1, "12\u65E5"], [13292, 1, "13\u65E5"], [13293, 1, "14\u65E5"], [13294, 1, "15\u65E5"], [13295, 1, "16\u65E5"], [13296, 1, "17\u65E5"], [13297, 1, "18\u65E5"], [13298, 1, "19\u65E5"], [13299, 1, "20\u65E5"], [13300, 1, "21\u65E5"], [13301, 1, "22\u65E5"], [13302, 1, "23\u65E5"], [13303, 1, "24\u65E5"], [13304, 1, "25\u65E5"], [13305, 1, "26\u65E5"], [13306, 1, "27\u65E5"], [13307, 1, "28\u65E5"], [13308, 1, "29\u65E5"], [13309, 1, "30\u65E5"], [13310, 1, "31\u65E5"], [13311, 1, "gal"], [[13312, 19893], 2], [[19894, 19903], 2], [[19904, 19967], 2], [[19968, 40869], 2], [[40870, 40891], 2], [[40892, 40899], 2], [[40900, 40907], 2], [40908, 2], [[40909, 40917], 2], [[40918, 40938], 2], [[40939, 40943], 2], [[40944, 40956], 2], [[40957, 40959], 2], [[40960, 42124], 2], [[42125, 42127], 3], [[42128, 42145], 2], [[42146, 42147], 2], [[42148, 42163], 2], [42164, 2], [[42165, 42176], 2], [42177, 2], [[42178, 42180], 2], [42181, 2], [42182, 2], [[42183, 42191], 3], [[42192, 42237], 2], [[42238, 42239], 2], [[42240, 42508], 2], [[42509, 42511], 2], [[42512, 42539], 2], [[42540, 42559], 3], [42560, 1, "\uA641"], [42561, 2], [42562, 1, "\uA643"], [42563, 2], [42564, 1, "\uA645"], [42565, 2], [42566, 1, "\uA647"], [42567, 2], [42568, 1, "\uA649"], [42569, 2], [42570, 1, "\uA64B"], [42571, 2], [42572, 1, "\uA64D"], [42573, 2], [42574, 1, "\uA64F"], [42575, 2], [42576, 1, "\uA651"], [42577, 2], [42578, 1, "\uA653"], [42579, 2], [42580, 1, "\uA655"], [42581, 2], [42582, 1, "\uA657"], [42583, 2], [42584, 1, "\uA659"], [42585, 2], [42586, 1, "\uA65B"], [42587, 2], [42588, 1, "\uA65D"], [42589, 2], [42590, 1, "\uA65F"], [42591, 2], [42592, 1, "\uA661"], [42593, 2], [42594, 1, "\uA663"], [42595, 2], [42596, 1, "\uA665"], [42597, 2], [42598, 1, "\uA667"], [42599, 2], [42600, 1, "\uA669"], [42601, 2], [42602, 1, "\uA66B"], [42603, 2], [42604, 1, "\uA66D"], [[42605, 42607], 2], [[42608, 42611], 2], [[42612, 42619], 2], [[42620, 42621], 2], [42622, 2], [42623, 2], [42624, 1, "\uA681"], [42625, 2], [42626, 1, "\uA683"], [42627, 2], [42628, 1, "\uA685"], [42629, 2], [42630, 1, "\uA687"], [42631, 2], [42632, 1, "\uA689"], [42633, 2], [42634, 1, "\uA68B"], [42635, 2], [42636, 1, "\uA68D"], [42637, 2], [42638, 1, "\uA68F"], [42639, 2], [42640, 1, "\uA691"], [42641, 2], [42642, 1, "\uA693"], [42643, 2], [42644, 1, "\uA695"], [42645, 2], [42646, 1, "\uA697"], [42647, 2], [42648, 1, "\uA699"], [42649, 2], [42650, 1, "\uA69B"], [42651, 2], [42652, 1, "\u044A"], [42653, 1, "\u044C"], [42654, 2], [42655, 2], [[42656, 42725], 2], [[42726, 42735], 2], [[42736, 42737], 2], [[42738, 42743], 2], [[42744, 42751], 3], [[42752, 42774], 2], [[42775, 42778], 2], [[42779, 42783], 2], [[42784, 42785], 2], [42786, 1, "\uA723"], [42787, 2], [42788, 1, "\uA725"], [42789, 2], [42790, 1, "\uA727"], [42791, 2], [42792, 1, "\uA729"], [42793, 2], [42794, 1, "\uA72B"], [42795, 2], [42796, 1, "\uA72D"], [42797, 2], [42798, 1, "\uA72F"], [[42799, 42801], 2], [42802, 1, "\uA733"], [42803, 2], [42804, 1, "\uA735"], [42805, 2], [42806, 1, "\uA737"], [42807, 2], [42808, 1, "\uA739"], [42809, 2], [42810, 1, "\uA73B"], [42811, 2], [42812, 1, "\uA73D"], [42813, 2], [42814, 1, "\uA73F"], [42815, 2], [42816, 1, "\uA741"], [42817, 2], [42818, 1, "\uA743"], [42819, 2], [42820, 1, "\uA745"], [42821, 2], [42822, 1, "\uA747"], [42823, 2], [42824, 1, "\uA749"], [42825, 2], [42826, 1, "\uA74B"], [42827, 2], [42828, 1, "\uA74D"], [42829, 2], [42830, 1, "\uA74F"], [42831, 2], [42832, 1, "\uA751"], [42833, 2], [42834, 1, "\uA753"], [42835, 2], [42836, 1, "\uA755"], [42837, 2], [42838, 1, "\uA757"], [42839, 2], [42840, 1, "\uA759"], [42841, 2], [42842, 1, "\uA75B"], [42843, 2], [42844, 1, "\uA75D"], [42845, 2], [42846, 1, "\uA75F"], [42847, 2], [42848, 1, "\uA761"], [42849, 2], [42850, 1, "\uA763"], [42851, 2], [42852, 1, "\uA765"], [42853, 2], [42854, 1, "\uA767"], [42855, 2], [42856, 1, "\uA769"], [42857, 2], [42858, 1, "\uA76B"], [42859, 2], [42860, 1, "\uA76D"], [42861, 2], [42862, 1, "\uA76F"], [42863, 2], [42864, 1, "\uA76F"], [[42865, 42872], 2], [42873, 1, "\uA77A"], [42874, 2], [42875, 1, "\uA77C"], [42876, 2], [42877, 1, "\u1D79"], [42878, 1, "\uA77F"], [42879, 2], [42880, 1, "\uA781"], [42881, 2], [42882, 1, "\uA783"], [42883, 2], [42884, 1, "\uA785"], [42885, 2], [42886, 1, "\uA787"], [[42887, 42888], 2], [[42889, 42890], 2], [42891, 1, "\uA78C"], [42892, 2], [42893, 1, "\u0265"], [42894, 2], [42895, 2], [42896, 1, "\uA791"], [42897, 2], [42898, 1, "\uA793"], [42899, 2], [[42900, 42901], 2], [42902, 1, "\uA797"], [42903, 2], [42904, 1, "\uA799"], [42905, 2], [42906, 1, "\uA79B"], [42907, 2], [42908, 1, "\uA79D"], [42909, 2], [42910, 1, "\uA79F"], [42911, 2], [42912, 1, "\uA7A1"], [42913, 2], [42914, 1, "\uA7A3"], [42915, 2], [42916, 1, "\uA7A5"], [42917, 2], [42918, 1, "\uA7A7"], [42919, 2], [42920, 1, "\uA7A9"], [42921, 2], [42922, 1, "\u0266"], [42923, 1, "\u025C"], [42924, 1, "\u0261"], [42925, 1, "\u026C"], [42926, 1, "\u026A"], [42927, 2], [42928, 1, "\u029E"], [42929, 1, "\u0287"], [42930, 1, "\u029D"], [42931, 1, "\uAB53"], [42932, 1, "\uA7B5"], [42933, 2], [42934, 1, "\uA7B7"], [42935, 2], [42936, 1, "\uA7B9"], [42937, 2], [42938, 1, "\uA7BB"], [42939, 2], [42940, 1, "\uA7BD"], [42941, 2], [42942, 1, "\uA7BF"], [42943, 2], [42944, 1, "\uA7C1"], [42945, 2], [42946, 1, "\uA7C3"], [42947, 2], [42948, 1, "\uA794"], [42949, 1, "\u0282"], [42950, 1, "\u1D8E"], [42951, 1, "\uA7C8"], [42952, 2], [42953, 1, "\uA7CA"], [42954, 2], [42955, 1, "\u0264"], [42956, 1, "\uA7CD"], [42957, 2], [[42958, 42959], 3], [42960, 1, "\uA7D1"], [42961, 2], [42962, 3], [42963, 2], [42964, 3], [42965, 2], [42966, 1, "\uA7D7"], [42967, 2], [42968, 1, "\uA7D9"], [42969, 2], [42970, 1, "\uA7DB"], [42971, 2], [42972, 1, "\u019B"], [[42973, 42993], 3], [42994, 1, "c"], [42995, 1, "f"], [42996, 1, "q"], [42997, 1, "\uA7F6"], [42998, 2], [42999, 2], [43e3, 1, "\u0127"], [43001, 1, "\u0153"], [43002, 2], [[43003, 43007], 2], [[43008, 43047], 2], [[43048, 43051], 2], [43052, 2], [[43053, 43055], 3], [[43056, 43065], 2], [[43066, 43071], 3], [[43072, 43123], 2], [[43124, 43127], 2], [[43128, 43135], 3], [[43136, 43204], 2], [43205, 2], [[43206, 43213], 3], [[43214, 43215], 2], [[43216, 43225], 2], [[43226, 43231], 3], [[43232, 43255], 2], [[43256, 43258], 2], [43259, 2], [43260, 2], [43261, 2], [[43262, 43263], 2], [[43264, 43309], 2], [[43310, 43311], 2], [[43312, 43347], 2], [[43348, 43358], 3], [43359, 2], [[43360, 43388], 2], [[43389, 43391], 3], [[43392, 43456], 2], [[43457, 43469], 2], [43470, 3], [[43471, 43481], 2], [[43482, 43485], 3], [[43486, 43487], 2], [[43488, 43518], 2], [43519, 3], [[43520, 43574], 2], [[43575, 43583], 3], [[43584, 43597], 2], [[43598, 43599], 3], [[43600, 43609], 2], [[43610, 43611], 3], [[43612, 43615], 2], [[43616, 43638], 2], [[43639, 43641], 2], [[43642, 43643], 2], [[43644, 43647], 2], [[43648, 43714], 2], [[43715, 43738], 3], [[43739, 43741], 2], [[43742, 43743], 2], [[43744, 43759], 2], [[43760, 43761], 2], [[43762, 43766], 2], [[43767, 43776], 3], [[43777, 43782], 2], [[43783, 43784], 3], [[43785, 43790], 2], [[43791, 43792], 3], [[43793, 43798], 2], [[43799, 43807], 3], [[43808, 43814], 2], [43815, 3], [[43816, 43822], 2], [43823, 3], [[43824, 43866], 2], [43867, 2], [43868, 1, "\uA727"], [43869, 1, "\uAB37"], [43870, 1, "\u026B"], [43871, 1, "\uAB52"], [[43872, 43875], 2], [[43876, 43877], 2], [[43878, 43879], 2], [43880, 2], [43881, 1, "\u028D"], [[43882, 43883], 2], [[43884, 43887], 3], [43888, 1, "\u13A0"], [43889, 1, "\u13A1"], [43890, 1, "\u13A2"], [43891, 1, "\u13A3"], [43892, 1, "\u13A4"], [43893, 1, "\u13A5"], [43894, 1, "\u13A6"], [43895, 1, "\u13A7"], [43896, 1, "\u13A8"], [43897, 1, "\u13A9"], [43898, 1, "\u13AA"], [43899, 1, "\u13AB"], [43900, 1, "\u13AC"], [43901, 1, "\u13AD"], [43902, 1, "\u13AE"], [43903, 1, "\u13AF"], [43904, 1, "\u13B0"], [43905, 1, "\u13B1"], [43906, 1, "\u13B2"], [43907, 1, "\u13B3"], [43908, 1, "\u13B4"], [43909, 1, "\u13B5"], [43910, 1, "\u13B6"], [43911, 1, "\u13B7"], [43912, 1, "\u13B8"], [43913, 1, "\u13B9"], [43914, 1, "\u13BA"], [43915, 1, "\u13BB"], [43916, 1, "\u13BC"], [43917, 1, "\u13BD"], [43918, 1, "\u13BE"], [43919, 1, "\u13BF"], [43920, 1, "\u13C0"], [43921, 1, "\u13C1"], [43922, 1, "\u13C2"], [43923, 1, "\u13C3"], [43924, 1, "\u13C4"], [43925, 1, "\u13C5"], [43926, 1, "\u13C6"], [43927, 1, "\u13C7"], [43928, 1, "\u13C8"], [43929, 1, "\u13C9"], [43930, 1, "\u13CA"], [43931, 1, "\u13CB"], [43932, 1, "\u13CC"], [43933, 1, "\u13CD"], [43934, 1, "\u13CE"], [43935, 1, "\u13CF"], [43936, 1, "\u13D0"], [43937, 1, "\u13D1"], [43938, 1, "\u13D2"], [43939, 1, "\u13D3"], [43940, 1, "\u13D4"], [43941, 1, "\u13D5"], [43942, 1, "\u13D6"], [43943, 1, "\u13D7"], [43944, 1, "\u13D8"], [43945, 1, "\u13D9"], [43946, 1, "\u13DA"], [43947, 1, "\u13DB"], [43948, 1, "\u13DC"], [43949, 1, "\u13DD"], [43950, 1, "\u13DE"], [43951, 1, "\u13DF"], [43952, 1, "\u13E0"], [43953, 1, "\u13E1"], [43954, 1, "\u13E2"], [43955, 1, "\u13E3"], [43956, 1, "\u13E4"], [43957, 1, "\u13E5"], [43958, 1, "\u13E6"], [43959, 1, "\u13E7"], [43960, 1, "\u13E8"], [43961, 1, "\u13E9"], [43962, 1, "\u13EA"], [43963, 1, "\u13EB"], [43964, 1, "\u13EC"], [43965, 1, "\u13ED"], [43966, 1, "\u13EE"], [43967, 1, "\u13EF"], [[43968, 44010], 2], [44011, 2], [[44012, 44013], 2], [[44014, 44015], 3], [[44016, 44025], 2], [[44026, 44031], 3], [[44032, 55203], 2], [[55204, 55215], 3], [[55216, 55238], 2], [[55239, 55242], 3], [[55243, 55291], 2], [[55292, 55295], 3], [[55296, 57343], 3], [[57344, 63743], 3], [63744, 1, "\u8C48"], [63745, 1, "\u66F4"], [63746, 1, "\u8ECA"], [63747, 1, "\u8CC8"], [63748, 1, "\u6ED1"], [63749, 1, "\u4E32"], [63750, 1, "\u53E5"], [[63751, 63752], 1, "\u9F9C"], [63753, 1, "\u5951"], [63754, 1, "\u91D1"], [63755, 1, "\u5587"], [63756, 1, "\u5948"], [63757, 1, "\u61F6"], [63758, 1, "\u7669"], [63759, 1, "\u7F85"], [63760, 1, "\u863F"], [63761, 1, "\u87BA"], [63762, 1, "\u88F8"], [63763, 1, "\u908F"], [63764, 1, "\u6A02"], [63765, 1, "\u6D1B"], [63766, 1, "\u70D9"], [63767, 1, "\u73DE"], [63768, 1, "\u843D"], [63769, 1, "\u916A"], [63770, 1, "\u99F1"], [63771, 1, "\u4E82"], [63772, 1, "\u5375"], [63773, 1, "\u6B04"], [63774, 1, "\u721B"], [63775, 1, "\u862D"], [63776, 1, "\u9E1E"], [63777, 1, "\u5D50"], [63778, 1, "\u6FEB"], [63779, 1, "\u85CD"], [63780, 1, "\u8964"], [63781, 1, "\u62C9"], [63782, 1, "\u81D8"], [63783, 1, "\u881F"], [63784, 1, "\u5ECA"], [63785, 1, "\u6717"], [63786, 1, "\u6D6A"], [63787, 1, "\u72FC"], [63788, 1, "\u90CE"], [63789, 1, "\u4F86"], [63790, 1, "\u51B7"], [63791, 1, "\u52DE"], [63792, 1, "\u64C4"], [63793, 1, "\u6AD3"], [63794, 1, "\u7210"], [63795, 1, "\u76E7"], [63796, 1, "\u8001"], [63797, 1, "\u8606"], [63798, 1, "\u865C"], [63799, 1, "\u8DEF"], [63800, 1, "\u9732"], [63801, 1, "\u9B6F"], [63802, 1, "\u9DFA"], [63803, 1, "\u788C"], [63804, 1, "\u797F"], [63805, 1, "\u7DA0"], [63806, 1, "\u83C9"], [63807, 1, "\u9304"], [63808, 1, "\u9E7F"], [63809, 1, "\u8AD6"], [63810, 1, "\u58DF"], [63811, 1, "\u5F04"], [63812, 1, "\u7C60"], [63813, 1, "\u807E"], [63814, 1, "\u7262"], [63815, 1, "\u78CA"], [63816, 1, "\u8CC2"], [63817, 1, "\u96F7"], [63818, 1, "\u58D8"], [63819, 1, "\u5C62"], [63820, 1, "\u6A13"], [63821, 1, "\u6DDA"], [63822, 1, "\u6F0F"], [63823, 1, "\u7D2F"], [63824, 1, "\u7E37"], [63825, 1, "\u964B"], [63826, 1, "\u52D2"], [63827, 1, "\u808B"], [63828, 1, "\u51DC"], [63829, 1, "\u51CC"], [63830, 1, "\u7A1C"], [63831, 1, "\u7DBE"], [63832, 1, "\u83F1"], [63833, 1, "\u9675"], [63834, 1, "\u8B80"], [63835, 1, "\u62CF"], [63836, 1, "\u6A02"], [63837, 1, "\u8AFE"], [63838, 1, "\u4E39"], [63839, 1, "\u5BE7"], [63840, 1, "\u6012"], [63841, 1, "\u7387"], [63842, 1, "\u7570"], [63843, 1, "\u5317"], [63844, 1, "\u78FB"], [63845, 1, "\u4FBF"], [63846, 1, "\u5FA9"], [63847, 1, "\u4E0D"], [63848, 1, "\u6CCC"], [63849, 1, "\u6578"], [63850, 1, "\u7D22"], [63851, 1, "\u53C3"], [63852, 1, "\u585E"], [63853, 1, "\u7701"], [63854, 1, "\u8449"], [63855, 1, "\u8AAA"], [63856, 1, "\u6BBA"], [63857, 1, "\u8FB0"], [63858, 1, "\u6C88"], [63859, 1, "\u62FE"], [63860, 1, "\u82E5"], [63861, 1, "\u63A0"], [63862, 1, "\u7565"], [63863, 1, "\u4EAE"], [63864, 1, "\u5169"], [63865, 1, "\u51C9"], [63866, 1, "\u6881"], [63867, 1, "\u7CE7"], [63868, 1, "\u826F"], [63869, 1, "\u8AD2"], [63870, 1, "\u91CF"], [63871, 1, "\u52F5"], [63872, 1, "\u5442"], [63873, 1, "\u5973"], [63874, 1, "\u5EEC"], [63875, 1, "\u65C5"], [63876, 1, "\u6FFE"], [63877, 1, "\u792A"], [63878, 1, "\u95AD"], [63879, 1, "\u9A6A"], [63880, 1, "\u9E97"], [63881, 1, "\u9ECE"], [63882, 1, "\u529B"], [63883, 1, "\u66C6"], [63884, 1, "\u6B77"], [63885, 1, "\u8F62"], [63886, 1, "\u5E74"], [63887, 1, "\u6190"], [63888, 1, "\u6200"], [63889, 1, "\u649A"], [63890, 1, "\u6F23"], [63891, 1, "\u7149"], [63892, 1, "\u7489"], [63893, 1, "\u79CA"], [63894, 1, "\u7DF4"], [63895, 1, "\u806F"], [63896, 1, "\u8F26"], [63897, 1, "\u84EE"], [63898, 1, "\u9023"], [63899, 1, "\u934A"], [63900, 1, "\u5217"], [63901, 1, "\u52A3"], [63902, 1, "\u54BD"], [63903, 1, "\u70C8"], [63904, 1, "\u88C2"], [63905, 1, "\u8AAA"], [63906, 1, "\u5EC9"], [63907, 1, "\u5FF5"], [63908, 1, "\u637B"], [63909, 1, "\u6BAE"], [63910, 1, "\u7C3E"], [63911, 1, "\u7375"], [63912, 1, "\u4EE4"], [63913, 1, "\u56F9"], [63914, 1, "\u5BE7"], [63915, 1, "\u5DBA"], [63916, 1, "\u601C"], [63917, 1, "\u73B2"], [63918, 1, "\u7469"], [63919, 1, "\u7F9A"], [63920, 1, "\u8046"], [63921, 1, "\u9234"], [63922, 1, "\u96F6"], [63923, 1, "\u9748"], [63924, 1, "\u9818"], [63925, 1, "\u4F8B"], [63926, 1, "\u79AE"], [63927, 1, "\u91B4"], [63928, 1, "\u96B8"], [63929, 1, "\u60E1"], [63930, 1, "\u4E86"], [63931, 1, "\u50DA"], [63932, 1, "\u5BEE"], [63933, 1, "\u5C3F"], [63934, 1, "\u6599"], [63935, 1, "\u6A02"], [63936, 1, "\u71CE"], [63937, 1, "\u7642"], [63938, 1, "\u84FC"], [63939, 1, "\u907C"], [63940, 1, "\u9F8D"], [63941, 1, "\u6688"], [63942, 1, "\u962E"], [63943, 1, "\u5289"], [63944, 1, "\u677B"], [63945, 1, "\u67F3"], [63946, 1, "\u6D41"], [63947, 1, "\u6E9C"], [63948, 1, "\u7409"], [63949, 1, "\u7559"], [63950, 1, "\u786B"], [63951, 1, "\u7D10"], [63952, 1, "\u985E"], [63953, 1, "\u516D"], [63954, 1, "\u622E"], [63955, 1, "\u9678"], [63956, 1, "\u502B"], [63957, 1, "\u5D19"], [63958, 1, "\u6DEA"], [63959, 1, "\u8F2A"], [63960, 1, "\u5F8B"], [63961, 1, "\u6144"], [63962, 1, "\u6817"], [63963, 1, "\u7387"], [63964, 1, "\u9686"], [63965, 1, "\u5229"], [63966, 1, "\u540F"], [63967, 1, "\u5C65"], [63968, 1, "\u6613"], [63969, 1, "\u674E"], [63970, 1, "\u68A8"], [63971, 1, "\u6CE5"], [63972, 1, "\u7406"], [63973, 1, "\u75E2"], [63974, 1, "\u7F79"], [63975, 1, "\u88CF"], [63976, 1, "\u88E1"], [63977, 1, "\u91CC"], [63978, 1, "\u96E2"], [63979, 1, "\u533F"], [63980, 1, "\u6EBA"], [63981, 1, "\u541D"], [63982, 1, "\u71D0"], [63983, 1, "\u7498"], [63984, 1, "\u85FA"], [63985, 1, "\u96A3"], [63986, 1, "\u9C57"], [63987, 1, "\u9E9F"], [63988, 1, "\u6797"], [63989, 1, "\u6DCB"], [63990, 1, "\u81E8"], [63991, 1, "\u7ACB"], [63992, 1, "\u7B20"], [63993, 1, "\u7C92"], [63994, 1, "\u72C0"], [63995, 1, "\u7099"], [63996, 1, "\u8B58"], [63997, 1, "\u4EC0"], [63998, 1, "\u8336"], [63999, 1, "\u523A"], [64e3, 1, "\u5207"], [64001, 1, "\u5EA6"], [64002, 1, "\u62D3"], [64003, 1, "\u7CD6"], [64004, 1, "\u5B85"], [64005, 1, "\u6D1E"], [64006, 1, "\u66B4"], [64007, 1, "\u8F3B"], [64008, 1, "\u884C"], [64009, 1, "\u964D"], [64010, 1, "\u898B"], [64011, 1, "\u5ED3"], [64012, 1, "\u5140"], [64013, 1, "\u55C0"], [[64014, 64015], 2], [64016, 1, "\u585A"], [64017, 2], [64018, 1, "\u6674"], [[64019, 64020], 2], [64021, 1, "\u51DE"], [64022, 1, "\u732A"], [64023, 1, "\u76CA"], [64024, 1, "\u793C"], [64025, 1, "\u795E"], [64026, 1, "\u7965"], [64027, 1, "\u798F"], [64028, 1, "\u9756"], [64029, 1, "\u7CBE"], [64030, 1, "\u7FBD"], [64031, 2], [64032, 1, "\u8612"], [64033, 2], [64034, 1, "\u8AF8"], [[64035, 64036], 2], [64037, 1, "\u9038"], [64038, 1, "\u90FD"], [[64039, 64041], 2], [64042, 1, "\u98EF"], [64043, 1, "\u98FC"], [64044, 1, "\u9928"], [64045, 1, "\u9DB4"], [64046, 1, "\u90DE"], [64047, 1, "\u96B7"], [64048, 1, "\u4FAE"], [64049, 1, "\u50E7"], [64050, 1, "\u514D"], [64051, 1, "\u52C9"], [64052, 1, "\u52E4"], [64053, 1, "\u5351"], [64054, 1, "\u559D"], [64055, 1, "\u5606"], [64056, 1, "\u5668"], [64057, 1, "\u5840"], [64058, 1, "\u58A8"], [64059, 1, "\u5C64"], [64060, 1, "\u5C6E"], [64061, 1, "\u6094"], [64062, 1, "\u6168"], [64063, 1, "\u618E"], [64064, 1, "\u61F2"], [64065, 1, "\u654F"], [64066, 1, "\u65E2"], [64067, 1, "\u6691"], [64068, 1, "\u6885"], [64069, 1, "\u6D77"], [64070, 1, "\u6E1A"], [64071, 1, "\u6F22"], [64072, 1, "\u716E"], [64073, 1, "\u722B"], [64074, 1, "\u7422"], [64075, 1, "\u7891"], [64076, 1, "\u793E"], [64077, 1, "\u7949"], [64078, 1, "\u7948"], [64079, 1, "\u7950"], [64080, 1, "\u7956"], [64081, 1, "\u795D"], [64082, 1, "\u798D"], [64083, 1, "\u798E"], [64084, 1, "\u7A40"], [64085, 1, "\u7A81"], [64086, 1, "\u7BC0"], [64087, 1, "\u7DF4"], [64088, 1, "\u7E09"], [64089, 1, "\u7E41"], [64090, 1, "\u7F72"], [64091, 1, "\u8005"], [64092, 1, "\u81ED"], [[64093, 64094], 1, "\u8279"], [64095, 1, "\u8457"], [64096, 1, "\u8910"], [64097, 1, "\u8996"], [64098, 1, "\u8B01"], [64099, 1, "\u8B39"], [64100, 1, "\u8CD3"], [64101, 1, "\u8D08"], [64102, 1, "\u8FB6"], [64103, 1, "\u9038"], [64104, 1, "\u96E3"], [64105, 1, "\u97FF"], [64106, 1, "\u983B"], [64107, 1, "\u6075"], [64108, 1, "\u{242EE}"], [64109, 1, "\u8218"], [[64110, 64111], 3], [64112, 1, "\u4E26"], [64113, 1, "\u51B5"], [64114, 1, "\u5168"], [64115, 1, "\u4F80"], [64116, 1, "\u5145"], [64117, 1, "\u5180"], [64118, 1, "\u52C7"], [64119, 1, "\u52FA"], [64120, 1, "\u559D"], [64121, 1, "\u5555"], [64122, 1, "\u5599"], [64123, 1, "\u55E2"], [64124, 1, "\u585A"], [64125, 1, "\u58B3"], [64126, 1, "\u5944"], [64127, 1, "\u5954"], [64128, 1, "\u5A62"], [64129, 1, "\u5B28"], [64130, 1, "\u5ED2"], [64131, 1, "\u5ED9"], [64132, 1, "\u5F69"], [64133, 1, "\u5FAD"], [64134, 1, "\u60D8"], [64135, 1, "\u614E"], [64136, 1, "\u6108"], [64137, 1, "\u618E"], [64138, 1, "\u6160"], [64139, 1, "\u61F2"], [64140, 1, "\u6234"], [64141, 1, "\u63C4"], [64142, 1, "\u641C"], [64143, 1, "\u6452"], [64144, 1, "\u6556"], [64145, 1, "\u6674"], [64146, 1, "\u6717"], [64147, 1, "\u671B"], [64148, 1, "\u6756"], [64149, 1, "\u6B79"], [64150, 1, "\u6BBA"], [64151, 1, "\u6D41"], [64152, 1, "\u6EDB"], [64153, 1, "\u6ECB"], [64154, 1, "\u6F22"], [64155, 1, "\u701E"], [64156, 1, "\u716E"], [64157, 1, "\u77A7"], [64158, 1, "\u7235"], [64159, 1, "\u72AF"], [64160, 1, "\u732A"], [64161, 1, "\u7471"], [64162, 1, "\u7506"], [64163, 1, "\u753B"], [64164, 1, "\u761D"], [64165, 1, "\u761F"], [64166, 1, "\u76CA"], [64167, 1, "\u76DB"], [64168, 1, "\u76F4"], [64169, 1, "\u774A"], [64170, 1, "\u7740"], [64171, 1, "\u78CC"], [64172, 1, "\u7AB1"], [64173, 1, "\u7BC0"], [64174, 1, "\u7C7B"], [64175, 1, "\u7D5B"], [64176, 1, "\u7DF4"], [64177, 1, "\u7F3E"], [64178, 1, "\u8005"], [64179, 1, "\u8352"], [64180, 1, "\u83EF"], [64181, 1, "\u8779"], [64182, 1, "\u8941"], [64183, 1, "\u8986"], [64184, 1, "\u8996"], [64185, 1, "\u8ABF"], [64186, 1, "\u8AF8"], [64187, 1, "\u8ACB"], [64188, 1, "\u8B01"], [64189, 1, "\u8AFE"], [64190, 1, "\u8AED"], [64191, 1, "\u8B39"], [64192, 1, "\u8B8A"], [64193, 1, "\u8D08"], [64194, 1, "\u8F38"], [64195, 1, "\u9072"], [64196, 1, "\u9199"], [64197, 1, "\u9276"], [64198, 1, "\u967C"], [64199, 1, "\u96E3"], [64200, 1, "\u9756"], [64201, 1, "\u97DB"], [64202, 1, "\u97FF"], [64203, 1, "\u980B"], [64204, 1, "\u983B"], [64205, 1, "\u9B12"], [64206, 1, "\u9F9C"], [64207, 1, "\u{2284A}"], [64208, 1, "\u{22844}"], [64209, 1, "\u{233D5}"], [64210, 1, "\u3B9D"], [64211, 1, "\u4018"], [64212, 1, "\u4039"], [64213, 1, "\u{25249}"], [64214, 1, "\u{25CD0}"], [64215, 1, "\u{27ED3}"], [64216, 1, "\u9F43"], [64217, 1, "\u9F8E"], [[64218, 64255], 3], [64256, 1, "ff"], [64257, 1, "fi"], [64258, 1, "fl"], [64259, 1, "ffi"], [64260, 1, "ffl"], [[64261, 64262], 1, "st"], [[64263, 64274], 3], [64275, 1, "\u0574\u0576"], [64276, 1, "\u0574\u0565"], [64277, 1, "\u0574\u056B"], [64278, 1, "\u057E\u0576"], [64279, 1, "\u0574\u056D"], [[64280, 64284], 3], [64285, 1, "\u05D9\u05B4"], [64286, 2], [64287, 1, "\u05F2\u05B7"], [64288, 1, "\u05E2"], [64289, 1, "\u05D0"], [64290, 1, "\u05D3"], [64291, 1, "\u05D4"], [64292, 1, "\u05DB"], [64293, 1, "\u05DC"], [64294, 1, "\u05DD"], [64295, 1, "\u05E8"], [64296, 1, "\u05EA"], [64297, 1, "+"], [64298, 1, "\u05E9\u05C1"], [64299, 1, "\u05E9\u05C2"], [64300, 1, "\u05E9\u05BC\u05C1"], [64301, 1, "\u05E9\u05BC\u05C2"], [64302, 1, "\u05D0\u05B7"], [64303, 1, "\u05D0\u05B8"], [64304, 1, "\u05D0\u05BC"], [64305, 1, "\u05D1\u05BC"], [64306, 1, "\u05D2\u05BC"], [64307, 1, "\u05D3\u05BC"], [64308, 1, "\u05D4\u05BC"], [64309, 1, "\u05D5\u05BC"], [64310, 1, "\u05D6\u05BC"], [64311, 3], [64312, 1, "\u05D8\u05BC"], [64313, 1, "\u05D9\u05BC"], [64314, 1, "\u05DA\u05BC"], [64315, 1, "\u05DB\u05BC"], [64316, 1, "\u05DC\u05BC"], [64317, 3], [64318, 1, "\u05DE\u05BC"], [64319, 3], [64320, 1, "\u05E0\u05BC"], [64321, 1, "\u05E1\u05BC"], [64322, 3], [64323, 1, "\u05E3\u05BC"], [64324, 1, "\u05E4\u05BC"], [64325, 3], [64326, 1, "\u05E6\u05BC"], [64327, 1, "\u05E7\u05BC"], [64328, 1, "\u05E8\u05BC"], [64329, 1, "\u05E9\u05BC"], [64330, 1, "\u05EA\u05BC"], [64331, 1, "\u05D5\u05B9"], [64332, 1, "\u05D1\u05BF"], [64333, 1, "\u05DB\u05BF"], [64334, 1, "\u05E4\u05BF"], [64335, 1, "\u05D0\u05DC"], [[64336, 64337], 1, "\u0671"], [[64338, 64341], 1, "\u067B"], [[64342, 64345], 1, "\u067E"], [[64346, 64349], 1, "\u0680"], [[64350, 64353], 1, "\u067A"], [[64354, 64357], 1, "\u067F"], [[64358, 64361], 1, "\u0679"], [[64362, 64365], 1, "\u06A4"], [[64366, 64369], 1, "\u06A6"], [[64370, 64373], 1, "\u0684"], [[64374, 64377], 1, "\u0683"], [[64378, 64381], 1, "\u0686"], [[64382, 64385], 1, "\u0687"], [[64386, 64387], 1, "\u068D"], [[64388, 64389], 1, "\u068C"], [[64390, 64391], 1, "\u068E"], [[64392, 64393], 1, "\u0688"], [[64394, 64395], 1, "\u0698"], [[64396, 64397], 1, "\u0691"], [[64398, 64401], 1, "\u06A9"], [[64402, 64405], 1, "\u06AF"], [[64406, 64409], 1, "\u06B3"], [[64410, 64413], 1, "\u06B1"], [[64414, 64415], 1, "\u06BA"], [[64416, 64419], 1, "\u06BB"], [[64420, 64421], 1, "\u06C0"], [[64422, 64425], 1, "\u06C1"], [[64426, 64429], 1, "\u06BE"], [[64430, 64431], 1, "\u06D2"], [[64432, 64433], 1, "\u06D3"], [[64434, 64449], 2], [64450, 2], [[64451, 64466], 3], [[64467, 64470], 1, "\u06AD"], [[64471, 64472], 1, "\u06C7"], [[64473, 64474], 1, "\u06C6"], [[64475, 64476], 1, "\u06C8"], [64477, 1, "\u06C7\u0674"], [[64478, 64479], 1, "\u06CB"], [[64480, 64481], 1, "\u06C5"], [[64482, 64483], 1, "\u06C9"], [[64484, 64487], 1, "\u06D0"], [[64488, 64489], 1, "\u0649"], [[64490, 64491], 1, "\u0626\u0627"], [[64492, 64493], 1, "\u0626\u06D5"], [[64494, 64495], 1, "\u0626\u0648"], [[64496, 64497], 1, "\u0626\u06C7"], [[64498, 64499], 1, "\u0626\u06C6"], [[64500, 64501], 1, "\u0626\u06C8"], [[64502, 64504], 1, "\u0626\u06D0"], [[64505, 64507], 1, "\u0626\u0649"], [[64508, 64511], 1, "\u06CC"], [64512, 1, "\u0626\u062C"], [64513, 1, "\u0626\u062D"], [64514, 1, "\u0626\u0645"], [64515, 1, "\u0626\u0649"], [64516, 1, "\u0626\u064A"], [64517, 1, "\u0628\u062C"], [64518, 1, "\u0628\u062D"], [64519, 1, "\u0628\u062E"], [64520, 1, "\u0628\u0645"], [64521, 1, "\u0628\u0649"], [64522, 1, "\u0628\u064A"], [64523, 1, "\u062A\u062C"], [64524, 1, "\u062A\u062D"], [64525, 1, "\u062A\u062E"], [64526, 1, "\u062A\u0645"], [64527, 1, "\u062A\u0649"], [64528, 1, "\u062A\u064A"], [64529, 1, "\u062B\u062C"], [64530, 1, "\u062B\u0645"], [64531, 1, "\u062B\u0649"], [64532, 1, "\u062B\u064A"], [64533, 1, "\u062C\u062D"], [64534, 1, "\u062C\u0645"], [64535, 1, "\u062D\u062C"], [64536, 1, "\u062D\u0645"], [64537, 1, "\u062E\u062C"], [64538, 1, "\u062E\u062D"], [64539, 1, "\u062E\u0645"], [64540, 1, "\u0633\u062C"], [64541, 1, "\u0633\u062D"], [64542, 1, "\u0633\u062E"], [64543, 1, "\u0633\u0645"], [64544, 1, "\u0635\u062D"], [64545, 1, "\u0635\u0645"], [64546, 1, "\u0636\u062C"], [64547, 1, "\u0636\u062D"], [64548, 1, "\u0636\u062E"], [64549, 1, "\u0636\u0645"], [64550, 1, "\u0637\u062D"], [64551, 1, "\u0637\u0645"], [64552, 1, "\u0638\u0645"], [64553, 1, "\u0639\u062C"], [64554, 1, "\u0639\u0645"], [64555, 1, "\u063A\u062C"], [64556, 1, "\u063A\u0645"], [64557, 1, "\u0641\u062C"], [64558, 1, "\u0641\u062D"], [64559, 1, "\u0641\u062E"], [64560, 1, "\u0641\u0645"], [64561, 1, "\u0641\u0649"], [64562, 1, "\u0641\u064A"], [64563, 1, "\u0642\u062D"], [64564, 1, "\u0642\u0645"], [64565, 1, "\u0642\u0649"], [64566, 1, "\u0642\u064A"], [64567, 1, "\u0643\u0627"], [64568, 1, "\u0643\u062C"], [64569, 1, "\u0643\u062D"], [64570, 1, "\u0643\u062E"], [64571, 1, "\u0643\u0644"], [64572, 1, "\u0643\u0645"], [64573, 1, "\u0643\u0649"], [64574, 1, "\u0643\u064A"], [64575, 1, "\u0644\u062C"], [64576, 1, "\u0644\u062D"], [64577, 1, "\u0644\u062E"], [64578, 1, "\u0644\u0645"], [64579, 1, "\u0644\u0649"], [64580, 1, "\u0644\u064A"], [64581, 1, "\u0645\u062C"], [64582, 1, "\u0645\u062D"], [64583, 1, "\u0645\u062E"], [64584, 1, "\u0645\u0645"], [64585, 1, "\u0645\u0649"], [64586, 1, "\u0645\u064A"], [64587, 1, "\u0646\u062C"], [64588, 1, "\u0646\u062D"], [64589, 1, "\u0646\u062E"], [64590, 1, "\u0646\u0645"], [64591, 1, "\u0646\u0649"], [64592, 1, "\u0646\u064A"], [64593, 1, "\u0647\u062C"], [64594, 1, "\u0647\u0645"], [64595, 1, "\u0647\u0649"], [64596, 1, "\u0647\u064A"], [64597, 1, "\u064A\u062C"], [64598, 1, "\u064A\u062D"], [64599, 1, "\u064A\u062E"], [64600, 1, "\u064A\u0645"], [64601, 1, "\u064A\u0649"], [64602, 1, "\u064A\u064A"], [64603, 1, "\u0630\u0670"], [64604, 1, "\u0631\u0670"], [64605, 1, "\u0649\u0670"], [64606, 1, " \u064C\u0651"], [64607, 1, " \u064D\u0651"], [64608, 1, " \u064E\u0651"], [64609, 1, " \u064F\u0651"], [64610, 1, " \u0650\u0651"], [64611, 1, " \u0651\u0670"], [64612, 1, "\u0626\u0631"], [64613, 1, "\u0626\u0632"], [64614, 1, "\u0626\u0645"], [64615, 1, "\u0626\u0646"], [64616, 1, "\u0626\u0649"], [64617, 1, "\u0626\u064A"], [64618, 1, "\u0628\u0631"], [64619, 1, "\u0628\u0632"], [64620, 1, "\u0628\u0645"], [64621, 1, "\u0628\u0646"], [64622, 1, "\u0628\u0649"], [64623, 1, "\u0628\u064A"], [64624, 1, "\u062A\u0631"], [64625, 1, "\u062A\u0632"], [64626, 1, "\u062A\u0645"], [64627, 1, "\u062A\u0646"], [64628, 1, "\u062A\u0649"], [64629, 1, "\u062A\u064A"], [64630, 1, "\u062B\u0631"], [64631, 1, "\u062B\u0632"], [64632, 1, "\u062B\u0645"], [64633, 1, "\u062B\u0646"], [64634, 1, "\u062B\u0649"], [64635, 1, "\u062B\u064A"], [64636, 1, "\u0641\u0649"], [64637, 1, "\u0641\u064A"], [64638, 1, "\u0642\u0649"], [64639, 1, "\u0642\u064A"], [64640, 1, "\u0643\u0627"], [64641, 1, "\u0643\u0644"], [64642, 1, "\u0643\u0645"], [64643, 1, "\u0643\u0649"], [64644, 1, "\u0643\u064A"], [64645, 1, "\u0644\u0645"], [64646, 1, "\u0644\u0649"], [64647, 1, "\u0644\u064A"], [64648, 1, "\u0645\u0627"], [64649, 1, "\u0645\u0645"], [64650, 1, "\u0646\u0631"], [64651, 1, "\u0646\u0632"], [64652, 1, "\u0646\u0645"], [64653, 1, "\u0646\u0646"], [64654, 1, "\u0646\u0649"], [64655, 1, "\u0646\u064A"], [64656, 1, "\u0649\u0670"], [64657, 1, "\u064A\u0631"], [64658, 1, "\u064A\u0632"], [64659, 1, "\u064A\u0645"], [64660, 1, "\u064A\u0646"], [64661, 1, "\u064A\u0649"], [64662, 1, "\u064A\u064A"], [64663, 1, "\u0626\u062C"], [64664, 1, "\u0626\u062D"], [64665, 1, "\u0626\u062E"], [64666, 1, "\u0626\u0645"], [64667, 1, "\u0626\u0647"], [64668, 1, "\u0628\u062C"], [64669, 1, "\u0628\u062D"], [64670, 1, "\u0628\u062E"], [64671, 1, "\u0628\u0645"], [64672, 1, "\u0628\u0647"], [64673, 1, "\u062A\u062C"], [64674, 1, "\u062A\u062D"], [64675, 1, "\u062A\u062E"], [64676, 1, "\u062A\u0645"], [64677, 1, "\u062A\u0647"], [64678, 1, "\u062B\u0645"], [64679, 1, "\u062C\u062D"], [64680, 1, "\u062C\u0645"], [64681, 1, "\u062D\u062C"], [64682, 1, "\u062D\u0645"], [64683, 1, "\u062E\u062C"], [64684, 1, "\u062E\u0645"], [64685, 1, "\u0633\u062C"], [64686, 1, "\u0633\u062D"], [64687, 1, "\u0633\u062E"], [64688, 1, "\u0633\u0645"], [64689, 1, "\u0635\u062D"], [64690, 1, "\u0635\u062E"], [64691, 1, "\u0635\u0645"], [64692, 1, "\u0636\u062C"], [64693, 1, "\u0636\u062D"], [64694, 1, "\u0636\u062E"], [64695, 1, "\u0636\u0645"], [64696, 1, "\u0637\u062D"], [64697, 1, "\u0638\u0645"], [64698, 1, "\u0639\u062C"], [64699, 1, "\u0639\u0645"], [64700, 1, "\u063A\u062C"], [64701, 1, "\u063A\u0645"], [64702, 1, "\u0641\u062C"], [64703, 1, "\u0641\u062D"], [64704, 1, "\u0641\u062E"], [64705, 1, "\u0641\u0645"], [64706, 1, "\u0642\u062D"], [64707, 1, "\u0642\u0645"], [64708, 1, "\u0643\u062C"], [64709, 1, "\u0643\u062D"], [64710, 1, "\u0643\u062E"], [64711, 1, "\u0643\u0644"], [64712, 1, "\u0643\u0645"], [64713, 1, "\u0644\u062C"], [64714, 1, "\u0644\u062D"], [64715, 1, "\u0644\u062E"], [64716, 1, "\u0644\u0645"], [64717, 1, "\u0644\u0647"], [64718, 1, "\u0645\u062C"], [64719, 1, "\u0645\u062D"], [64720, 1, "\u0645\u062E"], [64721, 1, "\u0645\u0645"], [64722, 1, "\u0646\u062C"], [64723, 1, "\u0646\u062D"], [64724, 1, "\u0646\u062E"], [64725, 1, "\u0646\u0645"], [64726, 1, "\u0646\u0647"], [64727, 1, "\u0647\u062C"], [64728, 1, "\u0647\u0645"], [64729, 1, "\u0647\u0670"], [64730, 1, "\u064A\u062C"], [64731, 1, "\u064A\u062D"], [64732, 1, "\u064A\u062E"], [64733, 1, "\u064A\u0645"], [64734, 1, "\u064A\u0647"], [64735, 1, "\u0626\u0645"], [64736, 1, "\u0626\u0647"], [64737, 1, "\u0628\u0645"], [64738, 1, "\u0628\u0647"], [64739, 1, "\u062A\u0645"], [64740, 1, "\u062A\u0647"], [64741, 1, "\u062B\u0645"], [64742, 1, "\u062B\u0647"], [64743, 1, "\u0633\u0645"], [64744, 1, "\u0633\u0647"], [64745, 1, "\u0634\u0645"], [64746, 1, "\u0634\u0647"], [64747, 1, "\u0643\u0644"], [64748, 1, "\u0643\u0645"], [64749, 1, "\u0644\u0645"], [64750, 1, "\u0646\u0645"], [64751, 1, "\u0646\u0647"], [64752, 1, "\u064A\u0645"], [64753, 1, "\u064A\u0647"], [64754, 1, "\u0640\u064E\u0651"], [64755, 1, "\u0640\u064F\u0651"], [64756, 1, "\u0640\u0650\u0651"], [64757, 1, "\u0637\u0649"], [64758, 1, "\u0637\u064A"], [64759, 1, "\u0639\u0649"], [64760, 1, "\u0639\u064A"], [64761, 1, "\u063A\u0649"], [64762, 1, "\u063A\u064A"], [64763, 1, "\u0633\u0649"], [64764, 1, "\u0633\u064A"], [64765, 1, "\u0634\u0649"], [64766, 1, "\u0634\u064A"], [64767, 1, "\u062D\u0649"], [64768, 1, "\u062D\u064A"], [64769, 1, "\u062C\u0649"], [64770, 1, "\u062C\u064A"], [64771, 1, "\u062E\u0649"], [64772, 1, "\u062E\u064A"], [64773, 1, "\u0635\u0649"], [64774, 1, "\u0635\u064A"], [64775, 1, "\u0636\u0649"], [64776, 1, "\u0636\u064A"], [64777, 1, "\u0634\u062C"], [64778, 1, "\u0634\u062D"], [64779, 1, "\u0634\u062E"], [64780, 1, "\u0634\u0645"], [64781, 1, "\u0634\u0631"], [64782, 1, "\u0633\u0631"], [64783, 1, "\u0635\u0631"], [64784, 1, "\u0636\u0631"], [64785, 1, "\u0637\u0649"], [64786, 1, "\u0637\u064A"], [64787, 1, "\u0639\u0649"], [64788, 1, "\u0639\u064A"], [64789, 1, "\u063A\u0649"], [64790, 1, "\u063A\u064A"], [64791, 1, "\u0633\u0649"], [64792, 1, "\u0633\u064A"], [64793, 1, "\u0634\u0649"], [64794, 1, "\u0634\u064A"], [64795, 1, "\u062D\u0649"], [64796, 1, "\u062D\u064A"], [64797, 1, "\u062C\u0649"], [64798, 1, "\u062C\u064A"], [64799, 1, "\u062E\u0649"], [64800, 1, "\u062E\u064A"], [64801, 1, "\u0635\u0649"], [64802, 1, "\u0635\u064A"], [64803, 1, "\u0636\u0649"], [64804, 1, "\u0636\u064A"], [64805, 1, "\u0634\u062C"], [64806, 1, "\u0634\u062D"], [64807, 1, "\u0634\u062E"], [64808, 1, "\u0634\u0645"], [64809, 1, "\u0634\u0631"], [64810, 1, "\u0633\u0631"], [64811, 1, "\u0635\u0631"], [64812, 1, "\u0636\u0631"], [64813, 1, "\u0634\u062C"], [64814, 1, "\u0634\u062D"], [64815, 1, "\u0634\u062E"], [64816, 1, "\u0634\u0645"], [64817, 1, "\u0633\u0647"], [64818, 1, "\u0634\u0647"], [64819, 1, "\u0637\u0645"], [64820, 1, "\u0633\u062C"], [64821, 1, "\u0633\u062D"], [64822, 1, "\u0633\u062E"], [64823, 1, "\u0634\u062C"], [64824, 1, "\u0634\u062D"], [64825, 1, "\u0634\u062E"], [64826, 1, "\u0637\u0645"], [64827, 1, "\u0638\u0645"], [[64828, 64829], 1, "\u0627\u064B"], [[64830, 64831], 2], [[64832, 64847], 2], [64848, 1, "\u062A\u062C\u0645"], [[64849, 64850], 1, "\u062A\u062D\u062C"], [64851, 1, "\u062A\u062D\u0645"], [64852, 1, "\u062A\u062E\u0645"], [64853, 1, "\u062A\u0645\u062C"], [64854, 1, "\u062A\u0645\u062D"], [64855, 1, "\u062A\u0645\u062E"], [[64856, 64857], 1, "\u062C\u0645\u062D"], [64858, 1, "\u062D\u0645\u064A"], [64859, 1, "\u062D\u0645\u0649"], [64860, 1, "\u0633\u062D\u062C"], [64861, 1, "\u0633\u062C\u062D"], [64862, 1, "\u0633\u062C\u0649"], [[64863, 64864], 1, "\u0633\u0645\u062D"], [64865, 1, "\u0633\u0645\u062C"], [[64866, 64867], 1, "\u0633\u0645\u0645"], [[64868, 64869], 1, "\u0635\u062D\u062D"], [64870, 1, "\u0635\u0645\u0645"], [[64871, 64872], 1, "\u0634\u062D\u0645"], [64873, 1, "\u0634\u062C\u064A"], [[64874, 64875], 1, "\u0634\u0645\u062E"], [[64876, 64877], 1, "\u0634\u0645\u0645"], [64878, 1, "\u0636\u062D\u0649"], [[64879, 64880], 1, "\u0636\u062E\u0645"], [[64881, 64882], 1, "\u0637\u0645\u062D"], [64883, 1, "\u0637\u0645\u0645"], [64884, 1, "\u0637\u0645\u064A"], [64885, 1, "\u0639\u062C\u0645"], [[64886, 64887], 1, "\u0639\u0645\u0645"], [64888, 1, "\u0639\u0645\u0649"], [64889, 1, "\u063A\u0645\u0645"], [64890, 1, "\u063A\u0645\u064A"], [64891, 1, "\u063A\u0645\u0649"], [[64892, 64893], 1, "\u0641\u062E\u0645"], [64894, 1, "\u0642\u0645\u062D"], [64895, 1, "\u0642\u0645\u0645"], [64896, 1, "\u0644\u062D\u0645"], [64897, 1, "\u0644\u062D\u064A"], [64898, 1, "\u0644\u062D\u0649"], [[64899, 64900], 1, "\u0644\u062C\u062C"], [[64901, 64902], 1, "\u0644\u062E\u0645"], [[64903, 64904], 1, "\u0644\u0645\u062D"], [64905, 1, "\u0645\u062D\u062C"], [64906, 1, "\u0645\u062D\u0645"], [64907, 1, "\u0645\u062D\u064A"], [64908, 1, "\u0645\u062C\u062D"], [64909, 1, "\u0645\u062C\u0645"], [64910, 1, "\u0645\u062E\u062C"], [64911, 1, "\u0645\u062E\u0645"], [[64912, 64913], 3], [64914, 1, "\u0645\u062C\u062E"], [64915, 1, "\u0647\u0645\u062C"], [64916, 1, "\u0647\u0645\u0645"], [64917, 1, "\u0646\u062D\u0645"], [64918, 1, "\u0646\u062D\u0649"], [[64919, 64920], 1, "\u0646\u062C\u0645"], [64921, 1, "\u0646\u062C\u0649"], [64922, 1, "\u0646\u0645\u064A"], [64923, 1, "\u0646\u0645\u0649"], [[64924, 64925], 1, "\u064A\u0645\u0645"], [64926, 1, "\u0628\u062E\u064A"], [64927, 1, "\u062A\u062C\u064A"], [64928, 1, "\u062A\u062C\u0649"], [64929, 1, "\u062A\u062E\u064A"], [64930, 1, "\u062A\u062E\u0649"], [64931, 1, "\u062A\u0645\u064A"], [64932, 1, "\u062A\u0645\u0649"], [64933, 1, "\u062C\u0645\u064A"], [64934, 1, "\u062C\u062D\u0649"], [64935, 1, "\u062C\u0645\u0649"], [64936, 1, "\u0633\u062E\u0649"], [64937, 1, "\u0635\u062D\u064A"], [64938, 1, "\u0634\u062D\u064A"], [64939, 1, "\u0636\u062D\u064A"], [64940, 1, "\u0644\u062C\u064A"], [64941, 1, "\u0644\u0645\u064A"], [64942, 1, "\u064A\u062D\u064A"], [64943, 1, "\u064A\u062C\u064A"], [64944, 1, "\u064A\u0645\u064A"], [64945, 1, "\u0645\u0645\u064A"], [64946, 1, "\u0642\u0645\u064A"], [64947, 1, "\u0646\u062D\u064A"], [64948, 1, "\u0642\u0645\u062D"], [64949, 1, "\u0644\u062D\u0645"], [64950, 1, "\u0639\u0645\u064A"], [64951, 1, "\u0643\u0645\u064A"], [64952, 1, "\u0646\u062C\u062D"], [64953, 1, "\u0645\u062E\u064A"], [64954, 1, "\u0644\u062C\u0645"], [64955, 1, "\u0643\u0645\u0645"], [64956, 1, "\u0644\u062C\u0645"], [64957, 1, "\u0646\u062C\u062D"], [64958, 1, "\u062C\u062D\u064A"], [64959, 1, "\u062D\u062C\u064A"], [64960, 1, "\u0645\u062C\u064A"], [64961, 1, "\u0641\u0645\u064A"], [64962, 1, "\u0628\u062D\u064A"], [64963, 1, "\u0643\u0645\u0645"], [64964, 1, "\u0639\u062C\u0645"], [64965, 1, "\u0635\u0645\u0645"], [64966, 1, "\u0633\u062E\u064A"], [64967, 1, "\u0646\u062C\u064A"], [[64968, 64974], 3], [64975, 2], [[64976, 65007], 3], [65008, 1, "\u0635\u0644\u06D2"], [65009, 1, "\u0642\u0644\u06D2"], [65010, 1, "\u0627\u0644\u0644\u0647"], [65011, 1, "\u0627\u0643\u0628\u0631"], [65012, 1, "\u0645\u062D\u0645\u062F"], [65013, 1, "\u0635\u0644\u0639\u0645"], [65014, 1, "\u0631\u0633\u0648\u0644"], [65015, 1, "\u0639\u0644\u064A\u0647"], [65016, 1, "\u0648\u0633\u0644\u0645"], [65017, 1, "\u0635\u0644\u0649"], [65018, 1, "\u0635\u0644\u0649 \u0627\u0644\u0644\u0647 \u0639\u0644\u064A\u0647 \u0648\u0633\u0644\u0645"], [65019, 1, "\u062C\u0644 \u062C\u0644\u0627\u0644\u0647"], [65020, 1, "\u0631\u06CC\u0627\u0644"], [65021, 2], [[65022, 65023], 2], [[65024, 65039], 7], [65040, 1, ","], [65041, 1, "\u3001"], [65042, 3], [65043, 1, ":"], [65044, 1, ";"], [65045, 1, "!"], [65046, 1, "?"], [65047, 1, "\u3016"], [65048, 1, "\u3017"], [65049, 3], [[65050, 65055], 3], [[65056, 65059], 2], [[65060, 65062], 2], [[65063, 65069], 2], [[65070, 65071], 2], [65072, 3], [65073, 1, "\u2014"], [65074, 1, "\u2013"], [[65075, 65076], 1, "_"], [65077, 1, "("], [65078, 1, ")"], [65079, 1, "{"], [65080, 1, "}"], [65081, 1, "\u3014"], [65082, 1, "\u3015"], [65083, 1, "\u3010"], [65084, 1, "\u3011"], [65085, 1, "\u300A"], [65086, 1, "\u300B"], [65087, 1, "\u3008"], [65088, 1, "\u3009"], [65089, 1, "\u300C"], [65090, 1, "\u300D"], [65091, 1, "\u300E"], [65092, 1, "\u300F"], [[65093, 65094], 2], [65095, 1, "["], [65096, 1, "]"], [[65097, 65100], 1, " \u0305"], [[65101, 65103], 1, "_"], [65104, 1, ","], [65105, 1, "\u3001"], [65106, 3], [65107, 3], [65108, 1, ";"], [65109, 1, ":"], [65110, 1, "?"], [65111, 1, "!"], [65112, 1, "\u2014"], [65113, 1, "("], [65114, 1, ")"], [65115, 1, "{"], [65116, 1, "}"], [65117, 1, "\u3014"], [65118, 1, "\u3015"], [65119, 1, "#"], [65120, 1, "&"], [65121, 1, "*"], [65122, 1, "+"], [65123, 1, "-"], [65124, 1, "<"], [65125, 1, ">"], [65126, 1, "="], [65127, 3], [65128, 1, "\\"], [65129, 1, "$"], [65130, 1, "%"], [65131, 1, "@"], [[65132, 65135], 3], [65136, 1, " \u064B"], [65137, 1, "\u0640\u064B"], [65138, 1, " \u064C"], [65139, 2], [65140, 1, " \u064D"], [65141, 3], [65142, 1, " \u064E"], [65143, 1, "\u0640\u064E"], [65144, 1, " \u064F"], [65145, 1, "\u0640\u064F"], [65146, 1, " \u0650"], [65147, 1, "\u0640\u0650"], [65148, 1, " \u0651"], [65149, 1, "\u0640\u0651"], [65150, 1, " \u0652"], [65151, 1, "\u0640\u0652"], [65152, 1, "\u0621"], [[65153, 65154], 1, "\u0622"], [[65155, 65156], 1, "\u0623"], [[65157, 65158], 1, "\u0624"], [[65159, 65160], 1, "\u0625"], [[65161, 65164], 1, "\u0626"], [[65165, 65166], 1, "\u0627"], [[65167, 65170], 1, "\u0628"], [[65171, 65172], 1, "\u0629"], [[65173, 65176], 1, "\u062A"], [[65177, 65180], 1, "\u062B"], [[65181, 65184], 1, "\u062C"], [[65185, 65188], 1, "\u062D"], [[65189, 65192], 1, "\u062E"], [[65193, 65194], 1, "\u062F"], [[65195, 65196], 1, "\u0630"], [[65197, 65198], 1, "\u0631"], [[65199, 65200], 1, "\u0632"], [[65201, 65204], 1, "\u0633"], [[65205, 65208], 1, "\u0634"], [[65209, 65212], 1, "\u0635"], [[65213, 65216], 1, "\u0636"], [[65217, 65220], 1, "\u0637"], [[65221, 65224], 1, "\u0638"], [[65225, 65228], 1, "\u0639"], [[65229, 65232], 1, "\u063A"], [[65233, 65236], 1, "\u0641"], [[65237, 65240], 1, "\u0642"], [[65241, 65244], 1, "\u0643"], [[65245, 65248], 1, "\u0644"], [[65249, 65252], 1, "\u0645"], [[65253, 65256], 1, "\u0646"], [[65257, 65260], 1, "\u0647"], [[65261, 65262], 1, "\u0648"], [[65263, 65264], 1, "\u0649"], [[65265, 65268], 1, "\u064A"], [[65269, 65270], 1, "\u0644\u0622"], [[65271, 65272], 1, "\u0644\u0623"], [[65273, 65274], 1, "\u0644\u0625"], [[65275, 65276], 1, "\u0644\u0627"], [[65277, 65278], 3], [65279, 7], [65280, 3], [65281, 1, "!"], [65282, 1, '"'], [65283, 1, "#"], [65284, 1, "$"], [65285, 1, "%"], [65286, 1, "&"], [65287, 1, "'"], [65288, 1, "("], [65289, 1, ")"], [65290, 1, "*"], [65291, 1, "+"], [65292, 1, ","], [65293, 1, "-"], [65294, 1, "."], [65295, 1, "/"], [65296, 1, "0"], [65297, 1, "1"], [65298, 1, "2"], [65299, 1, "3"], [65300, 1, "4"], [65301, 1, "5"], [65302, 1, "6"], [65303, 1, "7"], [65304, 1, "8"], [65305, 1, "9"], [65306, 1, ":"], [65307, 1, ";"], [65308, 1, "<"], [65309, 1, "="], [65310, 1, ">"], [65311, 1, "?"], [65312, 1, "@"], [65313, 1, "a"], [65314, 1, "b"], [65315, 1, "c"], [65316, 1, "d"], [65317, 1, "e"], [65318, 1, "f"], [65319, 1, "g"], [65320, 1, "h"], [65321, 1, "i"], [65322, 1, "j"], [65323, 1, "k"], [65324, 1, "l"], [65325, 1, "m"], [65326, 1, "n"], [65327, 1, "o"], [65328, 1, "p"], [65329, 1, "q"], [65330, 1, "r"], [65331, 1, "s"], [65332, 1, "t"], [65333, 1, "u"], [65334, 1, "v"], [65335, 1, "w"], [65336, 1, "x"], [65337, 1, "y"], [65338, 1, "z"], [65339, 1, "["], [65340, 1, "\\"], [65341, 1, "]"], [65342, 1, "^"], [65343, 1, "_"], [65344, 1, "`"], [65345, 1, "a"], [65346, 1, "b"], [65347, 1, "c"], [65348, 1, "d"], [65349, 1, "e"], [65350, 1, "f"], [65351, 1, "g"], [65352, 1, "h"], [65353, 1, "i"], [65354, 1, "j"], [65355, 1, "k"], [65356, 1, "l"], [65357, 1, "m"], [65358, 1, "n"], [65359, 1, "o"], [65360, 1, "p"], [65361, 1, "q"], [65362, 1, "r"], [65363, 1, "s"], [65364, 1, "t"], [65365, 1, "u"], [65366, 1, "v"], [65367, 1, "w"], [65368, 1, "x"], [65369, 1, "y"], [65370, 1, "z"], [65371, 1, "{"], [65372, 1, "|"], [65373, 1, "}"], [65374, 1, "~"], [65375, 1, "\u2985"], [65376, 1, "\u2986"], [65377, 1, "."], [65378, 1, "\u300C"], [65379, 1, "\u300D"], [65380, 1, "\u3001"], [65381, 1, "\u30FB"], [65382, 1, "\u30F2"], [65383, 1, "\u30A1"], [65384, 1, "\u30A3"], [65385, 1, "\u30A5"], [65386, 1, "\u30A7"], [65387, 1, "\u30A9"], [65388, 1, "\u30E3"], [65389, 1, "\u30E5"], [65390, 1, "\u30E7"], [65391, 1, "\u30C3"], [65392, 1, "\u30FC"], [65393, 1, "\u30A2"], [65394, 1, "\u30A4"], [65395, 1, "\u30A6"], [65396, 1, "\u30A8"], [65397, 1, "\u30AA"], [65398, 1, "\u30AB"], [65399, 1, "\u30AD"], [65400, 1, "\u30AF"], [65401, 1, "\u30B1"], [65402, 1, "\u30B3"], [65403, 1, "\u30B5"], [65404, 1, "\u30B7"], [65405, 1, "\u30B9"], [65406, 1, "\u30BB"], [65407, 1, "\u30BD"], [65408, 1, "\u30BF"], [65409, 1, "\u30C1"], [65410, 1, "\u30C4"], [65411, 1, "\u30C6"], [65412, 1, "\u30C8"], [65413, 1, "\u30CA"], [65414, 1, "\u30CB"], [65415, 1, "\u30CC"], [65416, 1, "\u30CD"], [65417, 1, "\u30CE"], [65418, 1, "\u30CF"], [65419, 1, "\u30D2"], [65420, 1, "\u30D5"], [65421, 1, "\u30D8"], [65422, 1, "\u30DB"], [65423, 1, "\u30DE"], [65424, 1, "\u30DF"], [65425, 1, "\u30E0"], [65426, 1, "\u30E1"], [65427, 1, "\u30E2"], [65428, 1, "\u30E4"], [65429, 1, "\u30E6"], [65430, 1, "\u30E8"], [65431, 1, "\u30E9"], [65432, 1, "\u30EA"], [65433, 1, "\u30EB"], [65434, 1, "\u30EC"], [65435, 1, "\u30ED"], [65436, 1, "\u30EF"], [65437, 1, "\u30F3"], [65438, 1, "\u3099"], [65439, 1, "\u309A"], [65440, 7], [65441, 1, "\u1100"], [65442, 1, "\u1101"], [65443, 1, "\u11AA"], [65444, 1, "\u1102"], [65445, 1, "\u11AC"], [65446, 1, "\u11AD"], [65447, 1, "\u1103"], [65448, 1, "\u1104"], [65449, 1, "\u1105"], [65450, 1, "\u11B0"], [65451, 1, "\u11B1"], [65452, 1, "\u11B2"], [65453, 1, "\u11B3"], [65454, 1, "\u11B4"], [65455, 1, "\u11B5"], [65456, 1, "\u111A"], [65457, 1, "\u1106"], [65458, 1, "\u1107"], [65459, 1, "\u1108"], [65460, 1, "\u1121"], [65461, 1, "\u1109"], [65462, 1, "\u110A"], [65463, 1, "\u110B"], [65464, 1, "\u110C"], [65465, 1, "\u110D"], [65466, 1, "\u110E"], [65467, 1, "\u110F"], [65468, 1, "\u1110"], [65469, 1, "\u1111"], [65470, 1, "\u1112"], [[65471, 65473], 3], [65474, 1, "\u1161"], [65475, 1, "\u1162"], [65476, 1, "\u1163"], [65477, 1, "\u1164"], [65478, 1, "\u1165"], [65479, 1, "\u1166"], [[65480, 65481], 3], [65482, 1, "\u1167"], [65483, 1, "\u1168"], [65484, 1, "\u1169"], [65485, 1, "\u116A"], [65486, 1, "\u116B"], [65487, 1, "\u116C"], [[65488, 65489], 3], [65490, 1, "\u116D"], [65491, 1, "\u116E"], [65492, 1, "\u116F"], [65493, 1, "\u1170"], [65494, 1, "\u1171"], [65495, 1, "\u1172"], [[65496, 65497], 3], [65498, 1, "\u1173"], [65499, 1, "\u1174"], [65500, 1, "\u1175"], [[65501, 65503], 3], [65504, 1, "\xA2"], [65505, 1, "\xA3"], [65506, 1, "\xAC"], [65507, 1, " \u0304"], [65508, 1, "\xA6"], [65509, 1, "\xA5"], [65510, 1, "\u20A9"], [65511, 3], [65512, 1, "\u2502"], [65513, 1, "\u2190"], [65514, 1, "\u2191"], [65515, 1, "\u2192"], [65516, 1, "\u2193"], [65517, 1, "\u25A0"], [65518, 1, "\u25CB"], [[65519, 65528], 3], [[65529, 65531], 3], [65532, 3], [65533, 3], [[65534, 65535], 3], [[65536, 65547], 2], [65548, 3], [[65549, 65574], 2], [65575, 3], [[65576, 65594], 2], [65595, 3], [[65596, 65597], 2], [65598, 3], [[65599, 65613], 2], [[65614, 65615], 3], [[65616, 65629], 2], [[65630, 65663], 3], [[65664, 65786], 2], [[65787, 65791], 3], [[65792, 65794], 2], [[65795, 65798], 3], [[65799, 65843], 2], [[65844, 65846], 3], [[65847, 65855], 2], [[65856, 65930], 2], [[65931, 65932], 2], [[65933, 65934], 2], [65935, 3], [[65936, 65947], 2], [65948, 2], [[65949, 65951], 3], [65952, 2], [[65953, 65999], 3], [[66e3, 66044], 2], [66045, 2], [[66046, 66175], 3], [[66176, 66204], 2], [[66205, 66207], 3], [[66208, 66256], 2], [[66257, 66271], 3], [66272, 2], [[66273, 66299], 2], [[66300, 66303], 3], [[66304, 66334], 2], [66335, 2], [[66336, 66339], 2], [[66340, 66348], 3], [[66349, 66351], 2], [[66352, 66368], 2], [66369, 2], [[66370, 66377], 2], [66378, 2], [[66379, 66383], 3], [[66384, 66426], 2], [[66427, 66431], 3], [[66432, 66461], 2], [66462, 3], [66463, 2], [[66464, 66499], 2], [[66500, 66503], 3], [[66504, 66511], 2], [[66512, 66517], 2], [[66518, 66559], 3], [66560, 1, "\u{10428}"], [66561, 1, "\u{10429}"], [66562, 1, "\u{1042A}"], [66563, 1, "\u{1042B}"], [66564, 1, "\u{1042C}"], [66565, 1, "\u{1042D}"], [66566, 1, "\u{1042E}"], [66567, 1, "\u{1042F}"], [66568, 1, "\u{10430}"], [66569, 1, "\u{10431}"], [66570, 1, "\u{10432}"], [66571, 1, "\u{10433}"], [66572, 1, "\u{10434}"], [66573, 1, "\u{10435}"], [66574, 1, "\u{10436}"], [66575, 1, "\u{10437}"], [66576, 1, "\u{10438}"], [66577, 1, "\u{10439}"], [66578, 1, "\u{1043A}"], [66579, 1, "\u{1043B}"], [66580, 1, "\u{1043C}"], [66581, 1, "\u{1043D}"], [66582, 1, "\u{1043E}"], [66583, 1, "\u{1043F}"], [66584, 1, "\u{10440}"], [66585, 1, "\u{10441}"], [66586, 1, "\u{10442}"], [66587, 1, "\u{10443}"], [66588, 1, "\u{10444}"], [66589, 1, "\u{10445}"], [66590, 1, "\u{10446}"], [66591, 1, "\u{10447}"], [66592, 1, "\u{10448}"], [66593, 1, "\u{10449}"], [66594, 1, "\u{1044A}"], [66595, 1, "\u{1044B}"], [66596, 1, "\u{1044C}"], [66597, 1, "\u{1044D}"], [66598, 1, "\u{1044E}"], [66599, 1, "\u{1044F}"], [[66600, 66637], 2], [[66638, 66717], 2], [[66718, 66719], 3], [[66720, 66729], 2], [[66730, 66735], 3], [66736, 1, "\u{104D8}"], [66737, 1, "\u{104D9}"], [66738, 1, "\u{104DA}"], [66739, 1, "\u{104DB}"], [66740, 1, "\u{104DC}"], [66741, 1, "\u{104DD}"], [66742, 1, "\u{104DE}"], [66743, 1, "\u{104DF}"], [66744, 1, "\u{104E0}"], [66745, 1, "\u{104E1}"], [66746, 1, "\u{104E2}"], [66747, 1, "\u{104E3}"], [66748, 1, "\u{104E4}"], [66749, 1, "\u{104E5}"], [66750, 1, "\u{104E6}"], [66751, 1, "\u{104E7}"], [66752, 1, "\u{104E8}"], [66753, 1, "\u{104E9}"], [66754, 1, "\u{104EA}"], [66755, 1, "\u{104EB}"], [66756, 1, "\u{104EC}"], [66757, 1, "\u{104ED}"], [66758, 1, "\u{104EE}"], [66759, 1, "\u{104EF}"], [66760, 1, "\u{104F0}"], [66761, 1, "\u{104F1}"], [66762, 1, "\u{104F2}"], [66763, 1, "\u{104F3}"], [66764, 1, "\u{104F4}"], [66765, 1, "\u{104F5}"], [66766, 1, "\u{104F6}"], [66767, 1, "\u{104F7}"], [66768, 1, "\u{104F8}"], [66769, 1, "\u{104F9}"], [66770, 1, "\u{104FA}"], [66771, 1, "\u{104FB}"], [[66772, 66775], 3], [[66776, 66811], 2], [[66812, 66815], 3], [[66816, 66855], 2], [[66856, 66863], 3], [[66864, 66915], 2], [[66916, 66926], 3], [66927, 2], [66928, 1, "\u{10597}"], [66929, 1, "\u{10598}"], [66930, 1, "\u{10599}"], [66931, 1, "\u{1059A}"], [66932, 1, "\u{1059B}"], [66933, 1, "\u{1059C}"], [66934, 1, "\u{1059D}"], [66935, 1, "\u{1059E}"], [66936, 1, "\u{1059F}"], [66937, 1, "\u{105A0}"], [66938, 1, "\u{105A1}"], [66939, 3], [66940, 1, "\u{105A3}"], [66941, 1, "\u{105A4}"], [66942, 1, "\u{105A5}"], [66943, 1, "\u{105A6}"], [66944, 1, "\u{105A7}"], [66945, 1, "\u{105A8}"], [66946, 1, "\u{105A9}"], [66947, 1, "\u{105AA}"], [66948, 1, "\u{105AB}"], [66949, 1, "\u{105AC}"], [66950, 1, "\u{105AD}"], [66951, 1, "\u{105AE}"], [66952, 1, "\u{105AF}"], [66953, 1, "\u{105B0}"], [66954, 1, "\u{105B1}"], [66955, 3], [66956, 1, "\u{105B3}"], [66957, 1, "\u{105B4}"], [66958, 1, "\u{105B5}"], [66959, 1, "\u{105B6}"], [66960, 1, "\u{105B7}"], [66961, 1, "\u{105B8}"], [66962, 1, "\u{105B9}"], [66963, 3], [66964, 1, "\u{105BB}"], [66965, 1, "\u{105BC}"], [66966, 3], [[66967, 66977], 2], [66978, 3], [[66979, 66993], 2], [66994, 3], [[66995, 67001], 2], [67002, 3], [[67003, 67004], 2], [[67005, 67007], 3], [[67008, 67059], 2], [[67060, 67071], 3], [[67072, 67382], 2], [[67383, 67391], 3], [[67392, 67413], 2], [[67414, 67423], 3], [[67424, 67431], 2], [[67432, 67455], 3], [67456, 2], [67457, 1, "\u02D0"], [67458, 1, "\u02D1"], [67459, 1, "\xE6"], [67460, 1, "\u0299"], [67461, 1, "\u0253"], [67462, 3], [67463, 1, "\u02A3"], [67464, 1, "\uAB66"], [67465, 1, "\u02A5"], [67466, 1, "\u02A4"], [67467, 1, "\u0256"], [67468, 1, "\u0257"], [67469, 1, "\u1D91"], [67470, 1, "\u0258"], [67471, 1, "\u025E"], [67472, 1, "\u02A9"], [67473, 1, "\u0264"], [67474, 1, "\u0262"], [67475, 1, "\u0260"], [67476, 1, "\u029B"], [67477, 1, "\u0127"], [67478, 1, "\u029C"], [67479, 1, "\u0267"], [67480, 1, "\u0284"], [67481, 1, "\u02AA"], [67482, 1, "\u02AB"], [67483, 1, "\u026C"], [67484, 1, "\u{1DF04}"], [67485, 1, "\uA78E"], [67486, 1, "\u026E"], [67487, 1, "\u{1DF05}"], [67488, 1, "\u028E"], [67489, 1, "\u{1DF06}"], [67490, 1, "\xF8"], [67491, 1, "\u0276"], [67492, 1, "\u0277"], [67493, 1, "q"], [67494, 1, "\u027A"], [67495, 1, "\u{1DF08}"], [67496, 1, "\u027D"], [67497, 1, "\u027E"], [67498, 1, "\u0280"], [67499, 1, "\u02A8"], [67500, 1, "\u02A6"], [67501, 1, "\uAB67"], [67502, 1, "\u02A7"], [67503, 1, "\u0288"], [67504, 1, "\u2C71"], [67505, 3], [67506, 1, "\u028F"], [67507, 1, "\u02A1"], [67508, 1, "\u02A2"], [67509, 1, "\u0298"], [67510, 1, "\u01C0"], [67511, 1, "\u01C1"], [67512, 1, "\u01C2"], [67513, 1, "\u{1DF0A}"], [67514, 1, "\u{1DF1E}"], [[67515, 67583], 3], [[67584, 67589], 2], [[67590, 67591], 3], [67592, 2], [67593, 3], [[67594, 67637], 2], [67638, 3], [[67639, 67640], 2], [[67641, 67643], 3], [67644, 2], [[67645, 67646], 3], [67647, 2], [[67648, 67669], 2], [67670, 3], [[67671, 67679], 2], [[67680, 67702], 2], [[67703, 67711], 2], [[67712, 67742], 2], [[67743, 67750], 3], [[67751, 67759], 2], [[67760, 67807], 3], [[67808, 67826], 2], [67827, 3], [[67828, 67829], 2], [[67830, 67834], 3], [[67835, 67839], 2], [[67840, 67861], 2], [[67862, 67865], 2], [[67866, 67867], 2], [[67868, 67870], 3], [67871, 2], [[67872, 67897], 2], [[67898, 67902], 3], [67903, 2], [[67904, 67967], 3], [[67968, 68023], 2], [[68024, 68027], 3], [[68028, 68029], 2], [[68030, 68031], 2], [[68032, 68047], 2], [[68048, 68049], 3], [[68050, 68095], 2], [[68096, 68099], 2], [68100, 3], [[68101, 68102], 2], [[68103, 68107], 3], [[68108, 68115], 2], [68116, 3], [[68117, 68119], 2], [68120, 3], [[68121, 68147], 2], [[68148, 68149], 2], [[68150, 68151], 3], [[68152, 68154], 2], [[68155, 68158], 3], [68159, 2], [[68160, 68167], 2], [68168, 2], [[68169, 68175], 3], [[68176, 68184], 2], [[68185, 68191], 3], [[68192, 68220], 2], [[68221, 68223], 2], [[68224, 68252], 2], [[68253, 68255], 2], [[68256, 68287], 3], [[68288, 68295], 2], [68296, 2], [[68297, 68326], 2], [[68327, 68330], 3], [[68331, 68342], 2], [[68343, 68351], 3], [[68352, 68405], 2], [[68406, 68408], 3], [[68409, 68415], 2], [[68416, 68437], 2], [[68438, 68439], 3], [[68440, 68447], 2], [[68448, 68466], 2], [[68467, 68471], 3], [[68472, 68479], 2], [[68480, 68497], 2], [[68498, 68504], 3], [[68505, 68508], 2], [[68509, 68520], 3], [[68521, 68527], 2], [[68528, 68607], 3], [[68608, 68680], 2], [[68681, 68735], 3], [68736, 1, "\u{10CC0}"], [68737, 1, "\u{10CC1}"], [68738, 1, "\u{10CC2}"], [68739, 1, "\u{10CC3}"], [68740, 1, "\u{10CC4}"], [68741, 1, "\u{10CC5}"], [68742, 1, "\u{10CC6}"], [68743, 1, "\u{10CC7}"], [68744, 1, "\u{10CC8}"], [68745, 1, "\u{10CC9}"], [68746, 1, "\u{10CCA}"], [68747, 1, "\u{10CCB}"], [68748, 1, "\u{10CCC}"], [68749, 1, "\u{10CCD}"], [68750, 1, "\u{10CCE}"], [68751, 1, "\u{10CCF}"], [68752, 1, "\u{10CD0}"], [68753, 1, "\u{10CD1}"], [68754, 1, "\u{10CD2}"], [68755, 1, "\u{10CD3}"], [68756, 1, "\u{10CD4}"], [68757, 1, "\u{10CD5}"], [68758, 1, "\u{10CD6}"], [68759, 1, "\u{10CD7}"], [68760, 1, "\u{10CD8}"], [68761, 1, "\u{10CD9}"], [68762, 1, "\u{10CDA}"], [68763, 1, "\u{10CDB}"], [68764, 1, "\u{10CDC}"], [68765, 1, "\u{10CDD}"], [68766, 1, "\u{10CDE}"], [68767, 1, "\u{10CDF}"], [68768, 1, "\u{10CE0}"], [68769, 1, "\u{10CE1}"], [68770, 1, "\u{10CE2}"], [68771, 1, "\u{10CE3}"], [68772, 1, "\u{10CE4}"], [68773, 1, "\u{10CE5}"], [68774, 1, "\u{10CE6}"], [68775, 1, "\u{10CE7}"], [68776, 1, "\u{10CE8}"], [68777, 1, "\u{10CE9}"], [68778, 1, "\u{10CEA}"], [68779, 1, "\u{10CEB}"], [68780, 1, "\u{10CEC}"], [68781, 1, "\u{10CED}"], [68782, 1, "\u{10CEE}"], [68783, 1, "\u{10CEF}"], [68784, 1, "\u{10CF0}"], [68785, 1, "\u{10CF1}"], [68786, 1, "\u{10CF2}"], [[68787, 68799], 3], [[68800, 68850], 2], [[68851, 68857], 3], [[68858, 68863], 2], [[68864, 68903], 2], [[68904, 68911], 3], [[68912, 68921], 2], [[68922, 68927], 3], [[68928, 68943], 2], [68944, 1, "\u{10D70}"], [68945, 1, "\u{10D71}"], [68946, 1, "\u{10D72}"], [68947, 1, "\u{10D73}"], [68948, 1, "\u{10D74}"], [68949, 1, "\u{10D75}"], [68950, 1, "\u{10D76}"], [68951, 1, "\u{10D77}"], [68952, 1, "\u{10D78}"], [68953, 1, "\u{10D79}"], [68954, 1, "\u{10D7A}"], [68955, 1, "\u{10D7B}"], [68956, 1, "\u{10D7C}"], [68957, 1, "\u{10D7D}"], [68958, 1, "\u{10D7E}"], [68959, 1, "\u{10D7F}"], [68960, 1, "\u{10D80}"], [68961, 1, "\u{10D81}"], [68962, 1, "\u{10D82}"], [68963, 1, "\u{10D83}"], [68964, 1, "\u{10D84}"], [68965, 1, "\u{10D85}"], [[68966, 68968], 3], [[68969, 68973], 2], [68974, 2], [[68975, 68997], 2], [[68998, 69005], 3], [[69006, 69007], 2], [[69008, 69215], 3], [[69216, 69246], 2], [69247, 3], [[69248, 69289], 2], [69290, 3], [[69291, 69292], 2], [69293, 2], [[69294, 69295], 3], [[69296, 69297], 2], [[69298, 69313], 3], [[69314, 69316], 2], [[69317, 69371], 3], [69372, 2], [[69373, 69375], 2], [[69376, 69404], 2], [[69405, 69414], 2], [69415, 2], [[69416, 69423], 3], [[69424, 69456], 2], [[69457, 69465], 2], [[69466, 69487], 3], [[69488, 69509], 2], [[69510, 69513], 2], [[69514, 69551], 3], [[69552, 69572], 2], [[69573, 69579], 2], [[69580, 69599], 3], [[69600, 69622], 2], [[69623, 69631], 3], [[69632, 69702], 2], [[69703, 69709], 2], [[69710, 69713], 3], [[69714, 69733], 2], [[69734, 69743], 2], [[69744, 69749], 2], [[69750, 69758], 3], [69759, 2], [[69760, 69818], 2], [[69819, 69820], 2], [69821, 3], [[69822, 69825], 2], [69826, 2], [[69827, 69836], 3], [69837, 3], [[69838, 69839], 3], [[69840, 69864], 2], [[69865, 69871], 3], [[69872, 69881], 2], [[69882, 69887], 3], [[69888, 69940], 2], [69941, 3], [[69942, 69951], 2], [[69952, 69955], 2], [[69956, 69958], 2], [69959, 2], [[69960, 69967], 3], [[69968, 70003], 2], [[70004, 70005], 2], [70006, 2], [[70007, 70015], 3], [[70016, 70084], 2], [[70085, 70088], 2], [[70089, 70092], 2], [70093, 2], [[70094, 70095], 2], [[70096, 70105], 2], [70106, 2], [70107, 2], [70108, 2], [[70109, 70111], 2], [70112, 3], [[70113, 70132], 2], [[70133, 70143], 3], [[70144, 70161], 2], [70162, 3], [[70163, 70199], 2], [[70200, 70205], 2], [70206, 2], [[70207, 70209], 2], [[70210, 70271], 3], [[70272, 70278], 2], [70279, 3], [70280, 2], [70281, 3], [[70282, 70285], 2], [70286, 3], [[70287, 70301], 2], [70302, 3], [[70303, 70312], 2], [70313, 2], [[70314, 70319], 3], [[70320, 70378], 2], [[70379, 70383], 3], [[70384, 70393], 2], [[70394, 70399], 3], [70400, 2], [[70401, 70403], 2], [70404, 3], [[70405, 70412], 2], [[70413, 70414], 3], [[70415, 70416], 2], [[70417, 70418], 3], [[70419, 70440], 2], [70441, 3], [[70442, 70448], 2], [70449, 3], [[70450, 70451], 2], [70452, 3], [[70453, 70457], 2], [70458, 3], [70459, 2], [[70460, 70468], 2], [[70469, 70470], 3], [[70471, 70472], 2], [[70473, 70474], 3], [[70475, 70477], 2], [[70478, 70479], 3], [70480, 2], [[70481, 70486], 3], [70487, 2], [[70488, 70492], 3], [[70493, 70499], 2], [[70500, 70501], 3], [[70502, 70508], 2], [[70509, 70511], 3], [[70512, 70516], 2], [[70517, 70527], 3], [[70528, 70537], 2], [70538, 3], [70539, 2], [[70540, 70541], 3], [70542, 2], [70543, 3], [[70544, 70581], 2], [70582, 3], [[70583, 70592], 2], [70593, 3], [70594, 2], [[70595, 70596], 3], [70597, 2], [70598, 3], [[70599, 70602], 2], [70603, 3], [[70604, 70611], 2], [[70612, 70613], 2], [70614, 3], [[70615, 70616], 2], [[70617, 70624], 3], [[70625, 70626], 2], [[70627, 70655], 3], [[70656, 70730], 2], [[70731, 70735], 2], [[70736, 70745], 2], [70746, 2], [70747, 2], [70748, 3], [70749, 2], [70750, 2], [70751, 2], [[70752, 70753], 2], [[70754, 70783], 3], [[70784, 70853], 2], [70854, 2], [70855, 2], [[70856, 70863], 3], [[70864, 70873], 2], [[70874, 71039], 3], [[71040, 71093], 2], [[71094, 71095], 3], [[71096, 71104], 2], [[71105, 71113], 2], [[71114, 71127], 2], [[71128, 71133], 2], [[71134, 71167], 3], [[71168, 71232], 2], [[71233, 71235], 2], [71236, 2], [[71237, 71247], 3], [[71248, 71257], 2], [[71258, 71263], 3], [[71264, 71276], 2], [[71277, 71295], 3], [[71296, 71351], 2], [71352, 2], [71353, 2], [[71354, 71359], 3], [[71360, 71369], 2], [[71370, 71375], 3], [[71376, 71395], 2], [[71396, 71423], 3], [[71424, 71449], 2], [71450, 2], [[71451, 71452], 3], [[71453, 71467], 2], [[71468, 71471], 3], [[71472, 71481], 2], [[71482, 71487], 2], [[71488, 71494], 2], [[71495, 71679], 3], [[71680, 71738], 2], [71739, 2], [[71740, 71839], 3], [71840, 1, "\u{118C0}"], [71841, 1, "\u{118C1}"], [71842, 1, "\u{118C2}"], [71843, 1, "\u{118C3}"], [71844, 1, "\u{118C4}"], [71845, 1, "\u{118C5}"], [71846, 1, "\u{118C6}"], [71847, 1, "\u{118C7}"], [71848, 1, "\u{118C8}"], [71849, 1, "\u{118C9}"], [71850, 1, "\u{118CA}"], [71851, 1, "\u{118CB}"], [71852, 1, "\u{118CC}"], [71853, 1, "\u{118CD}"], [71854, 1, "\u{118CE}"], [71855, 1, "\u{118CF}"], [71856, 1, "\u{118D0}"], [71857, 1, "\u{118D1}"], [71858, 1, "\u{118D2}"], [71859, 1, "\u{118D3}"], [71860, 1, "\u{118D4}"], [71861, 1, "\u{118D5}"], [71862, 1, "\u{118D6}"], [71863, 1, "\u{118D7}"], [71864, 1, "\u{118D8}"], [71865, 1, "\u{118D9}"], [71866, 1, "\u{118DA}"], [71867, 1, "\u{118DB}"], [71868, 1, "\u{118DC}"], [71869, 1, "\u{118DD}"], [71870, 1, "\u{118DE}"], [71871, 1, "\u{118DF}"], [[71872, 71913], 2], [[71914, 71922], 2], [[71923, 71934], 3], [71935, 2], [[71936, 71942], 2], [[71943, 71944], 3], [71945, 2], [[71946, 71947], 3], [[71948, 71955], 2], [71956, 3], [[71957, 71958], 2], [71959, 3], [[71960, 71989], 2], [71990, 3], [[71991, 71992], 2], [[71993, 71994], 3], [[71995, 72003], 2], [[72004, 72006], 2], [[72007, 72015], 3], [[72016, 72025], 2], [[72026, 72095], 3], [[72096, 72103], 2], [[72104, 72105], 3], [[72106, 72151], 2], [[72152, 72153], 3], [[72154, 72161], 2], [72162, 2], [[72163, 72164], 2], [[72165, 72191], 3], [[72192, 72254], 2], [[72255, 72262], 2], [72263, 2], [[72264, 72271], 3], [[72272, 72323], 2], [[72324, 72325], 2], [[72326, 72345], 2], [[72346, 72348], 2], [72349, 2], [[72350, 72354], 2], [[72355, 72367], 3], [[72368, 72383], 2], [[72384, 72440], 2], [[72441, 72447], 3], [[72448, 72457], 2], [[72458, 72639], 3], [[72640, 72672], 2], [72673, 2], [[72674, 72687], 3], [[72688, 72697], 2], [[72698, 72703], 3], [[72704, 72712], 2], [72713, 3], [[72714, 72758], 2], [72759, 3], [[72760, 72768], 2], [[72769, 72773], 2], [[72774, 72783], 3], [[72784, 72793], 2], [[72794, 72812], 2], [[72813, 72815], 3], [[72816, 72817], 2], [[72818, 72847], 2], [[72848, 72849], 3], [[72850, 72871], 2], [72872, 3], [[72873, 72886], 2], [[72887, 72959], 3], [[72960, 72966], 2], [72967, 3], [[72968, 72969], 2], [72970, 3], [[72971, 73014], 2], [[73015, 73017], 3], [73018, 2], [73019, 3], [[73020, 73021], 2], [73022, 3], [[73023, 73031], 2], [[73032, 73039], 3], [[73040, 73049], 2], [[73050, 73055], 3], [[73056, 73061], 2], [73062, 3], [[73063, 73064], 2], [73065, 3], [[73066, 73102], 2], [73103, 3], [[73104, 73105], 2], [73106, 3], [[73107, 73112], 2], [[73113, 73119], 3], [[73120, 73129], 2], [[73130, 73439], 3], [[73440, 73462], 2], [[73463, 73464], 2], [[73465, 73471], 3], [[73472, 73488], 2], [73489, 3], [[73490, 73530], 2], [[73531, 73533], 3], [[73534, 73538], 2], [[73539, 73551], 2], [[73552, 73561], 2], [73562, 2], [[73563, 73647], 3], [73648, 2], [[73649, 73663], 3], [[73664, 73713], 2], [[73714, 73726], 3], [73727, 2], [[73728, 74606], 2], [[74607, 74648], 2], [74649, 2], [[74650, 74751], 3], [[74752, 74850], 2], [[74851, 74862], 2], [74863, 3], [[74864, 74867], 2], [74868, 2], [[74869, 74879], 3], [[74880, 75075], 2], [[75076, 77711], 3], [[77712, 77808], 2], [[77809, 77810], 2], [[77811, 77823], 3], [[77824, 78894], 2], [78895, 2], [[78896, 78904], 3], [[78905, 78911], 3], [[78912, 78933], 2], [[78934, 78943], 3], [[78944, 82938], 2], [[82939, 82943], 3], [[82944, 83526], 2], [[83527, 90367], 3], [[90368, 90425], 2], [[90426, 92159], 3], [[92160, 92728], 2], [[92729, 92735], 3], [[92736, 92766], 2], [92767, 3], [[92768, 92777], 2], [[92778, 92781], 3], [[92782, 92783], 2], [[92784, 92862], 2], [92863, 3], [[92864, 92873], 2], [[92874, 92879], 3], [[92880, 92909], 2], [[92910, 92911], 3], [[92912, 92916], 2], [92917, 2], [[92918, 92927], 3], [[92928, 92982], 2], [[92983, 92991], 2], [[92992, 92995], 2], [[92996, 92997], 2], [[92998, 93007], 3], [[93008, 93017], 2], [93018, 3], [[93019, 93025], 2], [93026, 3], [[93027, 93047], 2], [[93048, 93052], 3], [[93053, 93071], 2], [[93072, 93503], 3], [[93504, 93548], 2], [[93549, 93551], 2], [[93552, 93561], 2], [[93562, 93759], 3], [93760, 1, "\u{16E60}"], [93761, 1, "\u{16E61}"], [93762, 1, "\u{16E62}"], [93763, 1, "\u{16E63}"], [93764, 1, "\u{16E64}"], [93765, 1, "\u{16E65}"], [93766, 1, "\u{16E66}"], [93767, 1, "\u{16E67}"], [93768, 1, "\u{16E68}"], [93769, 1, "\u{16E69}"], [93770, 1, "\u{16E6A}"], [93771, 1, "\u{16E6B}"], [93772, 1, "\u{16E6C}"], [93773, 1, "\u{16E6D}"], [93774, 1, "\u{16E6E}"], [93775, 1, "\u{16E6F}"], [93776, 1, "\u{16E70}"], [93777, 1, "\u{16E71}"], [93778, 1, "\u{16E72}"], [93779, 1, "\u{16E73}"], [93780, 1, "\u{16E74}"], [93781, 1, "\u{16E75}"], [93782, 1, "\u{16E76}"], [93783, 1, "\u{16E77}"], [93784, 1, "\u{16E78}"], [93785, 1, "\u{16E79}"], [93786, 1, "\u{16E7A}"], [93787, 1, "\u{16E7B}"], [93788, 1, "\u{16E7C}"], [93789, 1, "\u{16E7D}"], [93790, 1, "\u{16E7E}"], [93791, 1, "\u{16E7F}"], [[93792, 93823], 2], [[93824, 93850], 2], [[93851, 93951], 3], [[93952, 94020], 2], [[94021, 94026], 2], [[94027, 94030], 3], [94031, 2], [[94032, 94078], 2], [[94079, 94087], 2], [[94088, 94094], 3], [[94095, 94111], 2], [[94112, 94175], 3], [94176, 2], [94177, 2], [94178, 2], [94179, 2], [94180, 2], [[94181, 94191], 3], [[94192, 94193], 2], [[94194, 94207], 3], [[94208, 100332], 2], [[100333, 100337], 2], [[100338, 100343], 2], [[100344, 100351], 3], [[100352, 101106], 2], [[101107, 101589], 2], [[101590, 101630], 3], [101631, 2], [[101632, 101640], 2], [[101641, 110575], 3], [[110576, 110579], 2], [110580, 3], [[110581, 110587], 2], [110588, 3], [[110589, 110590], 2], [110591, 3], [[110592, 110593], 2], [[110594, 110878], 2], [[110879, 110882], 2], [[110883, 110897], 3], [110898, 2], [[110899, 110927], 3], [[110928, 110930], 2], [[110931, 110932], 3], [110933, 2], [[110934, 110947], 3], [[110948, 110951], 2], [[110952, 110959], 3], [[110960, 111355], 2], [[111356, 113663], 3], [[113664, 113770], 2], [[113771, 113775], 3], [[113776, 113788], 2], [[113789, 113791], 3], [[113792, 113800], 2], [[113801, 113807], 3], [[113808, 113817], 2], [[113818, 113819], 3], [113820, 2], [[113821, 113822], 2], [113823, 2], [[113824, 113827], 7], [[113828, 117759], 3], [[117760, 117973], 2], [117974, 1, "a"], [117975, 1, "b"], [117976, 1, "c"], [117977, 1, "d"], [117978, 1, "e"], [117979, 1, "f"], [117980, 1, "g"], [117981, 1, "h"], [117982, 1, "i"], [117983, 1, "j"], [117984, 1, "k"], [117985, 1, "l"], [117986, 1, "m"], [117987, 1, "n"], [117988, 1, "o"], [117989, 1, "p"], [117990, 1, "q"], [117991, 1, "r"], [117992, 1, "s"], [117993, 1, "t"], [117994, 1, "u"], [117995, 1, "v"], [117996, 1, "w"], [117997, 1, "x"], [117998, 1, "y"], [117999, 1, "z"], [118e3, 1, "0"], [118001, 1, "1"], [118002, 1, "2"], [118003, 1, "3"], [118004, 1, "4"], [118005, 1, "5"], [118006, 1, "6"], [118007, 1, "7"], [118008, 1, "8"], [118009, 1, "9"], [[118010, 118015], 3], [[118016, 118451], 2], [[118452, 118527], 3], [[118528, 118573], 2], [[118574, 118575], 3], [[118576, 118598], 2], [[118599, 118607], 3], [[118608, 118723], 2], [[118724, 118783], 3], [[118784, 119029], 2], [[119030, 119039], 3], [[119040, 119078], 2], [[119079, 119080], 3], [119081, 2], [[119082, 119133], 2], [119134, 1, "\u{1D157}\u{1D165}"], [119135, 1, "\u{1D158}\u{1D165}"], [119136, 1, "\u{1D158}\u{1D165}\u{1D16E}"], [119137, 1, "\u{1D158}\u{1D165}\u{1D16F}"], [119138, 1, "\u{1D158}\u{1D165}\u{1D170}"], [119139, 1, "\u{1D158}\u{1D165}\u{1D171}"], [119140, 1, "\u{1D158}\u{1D165}\u{1D172}"], [[119141, 119154], 2], [[119155, 119162], 7], [[119163, 119226], 2], [119227, 1, "\u{1D1B9}\u{1D165}"], [119228, 1, "\u{1D1BA}\u{1D165}"], [119229, 1, "\u{1D1B9}\u{1D165}\u{1D16E}"], [119230, 1, "\u{1D1BA}\u{1D165}\u{1D16E}"], [119231, 1, "\u{1D1B9}\u{1D165}\u{1D16F}"], [119232, 1, "\u{1D1BA}\u{1D165}\u{1D16F}"], [[119233, 119261], 2], [[119262, 119272], 2], [[119273, 119274], 2], [[119275, 119295], 3], [[119296, 119365], 2], [[119366, 119487], 3], [[119488, 119507], 2], [[119508, 119519], 3], [[119520, 119539], 2], [[119540, 119551], 3], [[119552, 119638], 2], [[119639, 119647], 3], [[119648, 119665], 2], [[119666, 119672], 2], [[119673, 119807], 3], [119808, 1, "a"], [119809, 1, "b"], [119810, 1, "c"], [119811, 1, "d"], [119812, 1, "e"], [119813, 1, "f"], [119814, 1, "g"], [119815, 1, "h"], [119816, 1, "i"], [119817, 1, "j"], [119818, 1, "k"], [119819, 1, "l"], [119820, 1, "m"], [119821, 1, "n"], [119822, 1, "o"], [119823, 1, "p"], [119824, 1, "q"], [119825, 1, "r"], [119826, 1, "s"], [119827, 1, "t"], [119828, 1, "u"], [119829, 1, "v"], [119830, 1, "w"], [119831, 1, "x"], [119832, 1, "y"], [119833, 1, "z"], [119834, 1, "a"], [119835, 1, "b"], [119836, 1, "c"], [119837, 1, "d"], [119838, 1, "e"], [119839, 1, "f"], [119840, 1, "g"], [119841, 1, "h"], [119842, 1, "i"], [119843, 1, "j"], [119844, 1, "k"], [119845, 1, "l"], [119846, 1, "m"], [119847, 1, "n"], [119848, 1, "o"], [119849, 1, "p"], [119850, 1, "q"], [119851, 1, "r"], [119852, 1, "s"], [119853, 1, "t"], [119854, 1, "u"], [119855, 1, "v"], [119856, 1, "w"], [119857, 1, "x"], [119858, 1, "y"], [119859, 1, "z"], [119860, 1, "a"], [119861, 1, "b"], [119862, 1, "c"], [119863, 1, "d"], [119864, 1, "e"], [119865, 1, "f"], [119866, 1, "g"], [119867, 1, "h"], [119868, 1, "i"], [119869, 1, "j"], [119870, 1, "k"], [119871, 1, "l"], [119872, 1, "m"], [119873, 1, "n"], [119874, 1, "o"], [119875, 1, "p"], [119876, 1, "q"], [119877, 1, "r"], [119878, 1, "s"], [119879, 1, "t"], [119880, 1, "u"], [119881, 1, "v"], [119882, 1, "w"], [119883, 1, "x"], [119884, 1, "y"], [119885, 1, "z"], [119886, 1, "a"], [119887, 1, "b"], [119888, 1, "c"], [119889, 1, "d"], [119890, 1, "e"], [119891, 1, "f"], [119892, 1, "g"], [119893, 3], [119894, 1, "i"], [119895, 1, "j"], [119896, 1, "k"], [119897, 1, "l"], [119898, 1, "m"], [119899, 1, "n"], [119900, 1, "o"], [119901, 1, "p"], [119902, 1, "q"], [119903, 1, "r"], [119904, 1, "s"], [119905, 1, "t"], [119906, 1, "u"], [119907, 1, "v"], [119908, 1, "w"], [119909, 1, "x"], [119910, 1, "y"], [119911, 1, "z"], [119912, 1, "a"], [119913, 1, "b"], [119914, 1, "c"], [119915, 1, "d"], [119916, 1, "e"], [119917, 1, "f"], [119918, 1, "g"], [119919, 1, "h"], [119920, 1, "i"], [119921, 1, "j"], [119922, 1, "k"], [119923, 1, "l"], [119924, 1, "m"], [119925, 1, "n"], [119926, 1, "o"], [119927, 1, "p"], [119928, 1, "q"], [119929, 1, "r"], [119930, 1, "s"], [119931, 1, "t"], [119932, 1, "u"], [119933, 1, "v"], [119934, 1, "w"], [119935, 1, "x"], [119936, 1, "y"], [119937, 1, "z"], [119938, 1, "a"], [119939, 1, "b"], [119940, 1, "c"], [119941, 1, "d"], [119942, 1, "e"], [119943, 1, "f"], [119944, 1, "g"], [119945, 1, "h"], [119946, 1, "i"], [119947, 1, "j"], [119948, 1, "k"], [119949, 1, "l"], [119950, 1, "m"], [119951, 1, "n"], [119952, 1, "o"], [119953, 1, "p"], [119954, 1, "q"], [119955, 1, "r"], [119956, 1, "s"], [119957, 1, "t"], [119958, 1, "u"], [119959, 1, "v"], [119960, 1, "w"], [119961, 1, "x"], [119962, 1, "y"], [119963, 1, "z"], [119964, 1, "a"], [119965, 3], [119966, 1, "c"], [119967, 1, "d"], [[119968, 119969], 3], [119970, 1, "g"], [[119971, 119972], 3], [119973, 1, "j"], [119974, 1, "k"], [[119975, 119976], 3], [119977, 1, "n"], [119978, 1, "o"], [119979, 1, "p"], [119980, 1, "q"], [119981, 3], [119982, 1, "s"], [119983, 1, "t"], [119984, 1, "u"], [119985, 1, "v"], [119986, 1, "w"], [119987, 1, "x"], [119988, 1, "y"], [119989, 1, "z"], [119990, 1, "a"], [119991, 1, "b"], [119992, 1, "c"], [119993, 1, "d"], [119994, 3], [119995, 1, "f"], [119996, 3], [119997, 1, "h"], [119998, 1, "i"], [119999, 1, "j"], [12e4, 1, "k"], [120001, 1, "l"], [120002, 1, "m"], [120003, 1, "n"], [120004, 3], [120005, 1, "p"], [120006, 1, "q"], [120007, 1, "r"], [120008, 1, "s"], [120009, 1, "t"], [120010, 1, "u"], [120011, 1, "v"], [120012, 1, "w"], [120013, 1, "x"], [120014, 1, "y"], [120015, 1, "z"], [120016, 1, "a"], [120017, 1, "b"], [120018, 1, "c"], [120019, 1, "d"], [120020, 1, "e"], [120021, 1, "f"], [120022, 1, "g"], [120023, 1, "h"], [120024, 1, "i"], [120025, 1, "j"], [120026, 1, "k"], [120027, 1, "l"], [120028, 1, "m"], [120029, 1, "n"], [120030, 1, "o"], [120031, 1, "p"], [120032, 1, "q"], [120033, 1, "r"], [120034, 1, "s"], [120035, 1, "t"], [120036, 1, "u"], [120037, 1, "v"], [120038, 1, "w"], [120039, 1, "x"], [120040, 1, "y"], [120041, 1, "z"], [120042, 1, "a"], [120043, 1, "b"], [120044, 1, "c"], [120045, 1, "d"], [120046, 1, "e"], [120047, 1, "f"], [120048, 1, "g"], [120049, 1, "h"], [120050, 1, "i"], [120051, 1, "j"], [120052, 1, "k"], [120053, 1, "l"], [120054, 1, "m"], [120055, 1, "n"], [120056, 1, "o"], [120057, 1, "p"], [120058, 1, "q"], [120059, 1, "r"], [120060, 1, "s"], [120061, 1, "t"], [120062, 1, "u"], [120063, 1, "v"], [120064, 1, "w"], [120065, 1, "x"], [120066, 1, "y"], [120067, 1, "z"], [120068, 1, "a"], [120069, 1, "b"], [120070, 3], [120071, 1, "d"], [120072, 1, "e"], [120073, 1, "f"], [120074, 1, "g"], [[120075, 120076], 3], [120077, 1, "j"], [120078, 1, "k"], [120079, 1, "l"], [120080, 1, "m"], [120081, 1, "n"], [120082, 1, "o"], [120083, 1, "p"], [120084, 1, "q"], [120085, 3], [120086, 1, "s"], [120087, 1, "t"], [120088, 1, "u"], [120089, 1, "v"], [120090, 1, "w"], [120091, 1, "x"], [120092, 1, "y"], [120093, 3], [120094, 1, "a"], [120095, 1, "b"], [120096, 1, "c"], [120097, 1, "d"], [120098, 1, "e"], [120099, 1, "f"], [120100, 1, "g"], [120101, 1, "h"], [120102, 1, "i"], [120103, 1, "j"], [120104, 1, "k"], [120105, 1, "l"], [120106, 1, "m"], [120107, 1, "n"], [120108, 1, "o"], [120109, 1, "p"], [120110, 1, "q"], [120111, 1, "r"], [120112, 1, "s"], [120113, 1, "t"], [120114, 1, "u"], [120115, 1, "v"], [120116, 1, "w"], [120117, 1, "x"], [120118, 1, "y"], [120119, 1, "z"], [120120, 1, "a"], [120121, 1, "b"], [120122, 3], [120123, 1, "d"], [120124, 1, "e"], [120125, 1, "f"], [120126, 1, "g"], [120127, 3], [120128, 1, "i"], [120129, 1, "j"], [120130, 1, "k"], [120131, 1, "l"], [120132, 1, "m"], [120133, 3], [120134, 1, "o"], [[120135, 120137], 3], [120138, 1, "s"], [120139, 1, "t"], [120140, 1, "u"], [120141, 1, "v"], [120142, 1, "w"], [120143, 1, "x"], [120144, 1, "y"], [120145, 3], [120146, 1, "a"], [120147, 1, "b"], [120148, 1, "c"], [120149, 1, "d"], [120150, 1, "e"], [120151, 1, "f"], [120152, 1, "g"], [120153, 1, "h"], [120154, 1, "i"], [120155, 1, "j"], [120156, 1, "k"], [120157, 1, "l"], [120158, 1, "m"], [120159, 1, "n"], [120160, 1, "o"], [120161, 1, "p"], [120162, 1, "q"], [120163, 1, "r"], [120164, 1, "s"], [120165, 1, "t"], [120166, 1, "u"], [120167, 1, "v"], [120168, 1, "w"], [120169, 1, "x"], [120170, 1, "y"], [120171, 1, "z"], [120172, 1, "a"], [120173, 1, "b"], [120174, 1, "c"], [120175, 1, "d"], [120176, 1, "e"], [120177, 1, "f"], [120178, 1, "g"], [120179, 1, "h"], [120180, 1, "i"], [120181, 1, "j"], [120182, 1, "k"], [120183, 1, "l"], [120184, 1, "m"], [120185, 1, "n"], [120186, 1, "o"], [120187, 1, "p"], [120188, 1, "q"], [120189, 1, "r"], [120190, 1, "s"], [120191, 1, "t"], [120192, 1, "u"], [120193, 1, "v"], [120194, 1, "w"], [120195, 1, "x"], [120196, 1, "y"], [120197, 1, "z"], [120198, 1, "a"], [120199, 1, "b"], [120200, 1, "c"], [120201, 1, "d"], [120202, 1, "e"], [120203, 1, "f"], [120204, 1, "g"], [120205, 1, "h"], [120206, 1, "i"], [120207, 1, "j"], [120208, 1, "k"], [120209, 1, "l"], [120210, 1, "m"], [120211, 1, "n"], [120212, 1, "o"], [120213, 1, "p"], [120214, 1, "q"], [120215, 1, "r"], [120216, 1, "s"], [120217, 1, "t"], [120218, 1, "u"], [120219, 1, "v"], [120220, 1, "w"], [120221, 1, "x"], [120222, 1, "y"], [120223, 1, "z"], [120224, 1, "a"], [120225, 1, "b"], [120226, 1, "c"], [120227, 1, "d"], [120228, 1, "e"], [120229, 1, "f"], [120230, 1, "g"], [120231, 1, "h"], [120232, 1, "i"], [120233, 1, "j"], [120234, 1, "k"], [120235, 1, "l"], [120236, 1, "m"], [120237, 1, "n"], [120238, 1, "o"], [120239, 1, "p"], [120240, 1, "q"], [120241, 1, "r"], [120242, 1, "s"], [120243, 1, "t"], [120244, 1, "u"], [120245, 1, "v"], [120246, 1, "w"], [120247, 1, "x"], [120248, 1, "y"], [120249, 1, "z"], [120250, 1, "a"], [120251, 1, "b"], [120252, 1, "c"], [120253, 1, "d"], [120254, 1, "e"], [120255, 1, "f"], [120256, 1, "g"], [120257, 1, "h"], [120258, 1, "i"], [120259, 1, "j"], [120260, 1, "k"], [120261, 1, "l"], [120262, 1, "m"], [120263, 1, "n"], [120264, 1, "o"], [120265, 1, "p"], [120266, 1, "q"], [120267, 1, "r"], [120268, 1, "s"], [120269, 1, "t"], [120270, 1, "u"], [120271, 1, "v"], [120272, 1, "w"], [120273, 1, "x"], [120274, 1, "y"], [120275, 1, "z"], [120276, 1, "a"], [120277, 1, "b"], [120278, 1, "c"], [120279, 1, "d"], [120280, 1, "e"], [120281, 1, "f"], [120282, 1, "g"], [120283, 1, "h"], [120284, 1, "i"], [120285, 1, "j"], [120286, 1, "k"], [120287, 1, "l"], [120288, 1, "m"], [120289, 1, "n"], [120290, 1, "o"], [120291, 1, "p"], [120292, 1, "q"], [120293, 1, "r"], [120294, 1, "s"], [120295, 1, "t"], [120296, 1, "u"], [120297, 1, "v"], [120298, 1, "w"], [120299, 1, "x"], [120300, 1, "y"], [120301, 1, "z"], [120302, 1, "a"], [120303, 1, "b"], [120304, 1, "c"], [120305, 1, "d"], [120306, 1, "e"], [120307, 1, "f"], [120308, 1, "g"], [120309, 1, "h"], [120310, 1, "i"], [120311, 1, "j"], [120312, 1, "k"], [120313, 1, "l"], [120314, 1, "m"], [120315, 1, "n"], [120316, 1, "o"], [120317, 1, "p"], [120318, 1, "q"], [120319, 1, "r"], [120320, 1, "s"], [120321, 1, "t"], [120322, 1, "u"], [120323, 1, "v"], [120324, 1, "w"], [120325, 1, "x"], [120326, 1, "y"], [120327, 1, "z"], [120328, 1, "a"], [120329, 1, "b"], [120330, 1, "c"], [120331, 1, "d"], [120332, 1, "e"], [120333, 1, "f"], [120334, 1, "g"], [120335, 1, "h"], [120336, 1, "i"], [120337, 1, "j"], [120338, 1, "k"], [120339, 1, "l"], [120340, 1, "m"], [120341, 1, "n"], [120342, 1, "o"], [120343, 1, "p"], [120344, 1, "q"], [120345, 1, "r"], [120346, 1, "s"], [120347, 1, "t"], [120348, 1, "u"], [120349, 1, "v"], [120350, 1, "w"], [120351, 1, "x"], [120352, 1, "y"], [120353, 1, "z"], [120354, 1, "a"], [120355, 1, "b"], [120356, 1, "c"], [120357, 1, "d"], [120358, 1, "e"], [120359, 1, "f"], [120360, 1, "g"], [120361, 1, "h"], [120362, 1, "i"], [120363, 1, "j"], [120364, 1, "k"], [120365, 1, "l"], [120366, 1, "m"], [120367, 1, "n"], [120368, 1, "o"], [120369, 1, "p"], [120370, 1, "q"], [120371, 1, "r"], [120372, 1, "s"], [120373, 1, "t"], [120374, 1, "u"], [120375, 1, "v"], [120376, 1, "w"], [120377, 1, "x"], [120378, 1, "y"], [120379, 1, "z"], [120380, 1, "a"], [120381, 1, "b"], [120382, 1, "c"], [120383, 1, "d"], [120384, 1, "e"], [120385, 1, "f"], [120386, 1, "g"], [120387, 1, "h"], [120388, 1, "i"], [120389, 1, "j"], [120390, 1, "k"], [120391, 1, "l"], [120392, 1, "m"], [120393, 1, "n"], [120394, 1, "o"], [120395, 1, "p"], [120396, 1, "q"], [120397, 1, "r"], [120398, 1, "s"], [120399, 1, "t"], [120400, 1, "u"], [120401, 1, "v"], [120402, 1, "w"], [120403, 1, "x"], [120404, 1, "y"], [120405, 1, "z"], [120406, 1, "a"], [120407, 1, "b"], [120408, 1, "c"], [120409, 1, "d"], [120410, 1, "e"], [120411, 1, "f"], [120412, 1, "g"], [120413, 1, "h"], [120414, 1, "i"], [120415, 1, "j"], [120416, 1, "k"], [120417, 1, "l"], [120418, 1, "m"], [120419, 1, "n"], [120420, 1, "o"], [120421, 1, "p"], [120422, 1, "q"], [120423, 1, "r"], [120424, 1, "s"], [120425, 1, "t"], [120426, 1, "u"], [120427, 1, "v"], [120428, 1, "w"], [120429, 1, "x"], [120430, 1, "y"], [120431, 1, "z"], [120432, 1, "a"], [120433, 1, "b"], [120434, 1, "c"], [120435, 1, "d"], [120436, 1, "e"], [120437, 1, "f"], [120438, 1, "g"], [120439, 1, "h"], [120440, 1, "i"], [120441, 1, "j"], [120442, 1, "k"], [120443, 1, "l"], [120444, 1, "m"], [120445, 1, "n"], [120446, 1, "o"], [120447, 1, "p"], [120448, 1, "q"], [120449, 1, "r"], [120450, 1, "s"], [120451, 1, "t"], [120452, 1, "u"], [120453, 1, "v"], [120454, 1, "w"], [120455, 1, "x"], [120456, 1, "y"], [120457, 1, "z"], [120458, 1, "a"], [120459, 1, "b"], [120460, 1, "c"], [120461, 1, "d"], [120462, 1, "e"], [120463, 1, "f"], [120464, 1, "g"], [120465, 1, "h"], [120466, 1, "i"], [120467, 1, "j"], [120468, 1, "k"], [120469, 1, "l"], [120470, 1, "m"], [120471, 1, "n"], [120472, 1, "o"], [120473, 1, "p"], [120474, 1, "q"], [120475, 1, "r"], [120476, 1, "s"], [120477, 1, "t"], [120478, 1, "u"], [120479, 1, "v"], [120480, 1, "w"], [120481, 1, "x"], [120482, 1, "y"], [120483, 1, "z"], [120484, 1, "\u0131"], [120485, 1, "\u0237"], [[120486, 120487], 3], [120488, 1, "\u03B1"], [120489, 1, "\u03B2"], [120490, 1, "\u03B3"], [120491, 1, "\u03B4"], [120492, 1, "\u03B5"], [120493, 1, "\u03B6"], [120494, 1, "\u03B7"], [120495, 1, "\u03B8"], [120496, 1, "\u03B9"], [120497, 1, "\u03BA"], [120498, 1, "\u03BB"], [120499, 1, "\u03BC"], [120500, 1, "\u03BD"], [120501, 1, "\u03BE"], [120502, 1, "\u03BF"], [120503, 1, "\u03C0"], [120504, 1, "\u03C1"], [120505, 1, "\u03B8"], [120506, 1, "\u03C3"], [120507, 1, "\u03C4"], [120508, 1, "\u03C5"], [120509, 1, "\u03C6"], [120510, 1, "\u03C7"], [120511, 1, "\u03C8"], [120512, 1, "\u03C9"], [120513, 1, "\u2207"], [120514, 1, "\u03B1"], [120515, 1, "\u03B2"], [120516, 1, "\u03B3"], [120517, 1, "\u03B4"], [120518, 1, "\u03B5"], [120519, 1, "\u03B6"], [120520, 1, "\u03B7"], [120521, 1, "\u03B8"], [120522, 1, "\u03B9"], [120523, 1, "\u03BA"], [120524, 1, "\u03BB"], [120525, 1, "\u03BC"], [120526, 1, "\u03BD"], [120527, 1, "\u03BE"], [120528, 1, "\u03BF"], [120529, 1, "\u03C0"], [120530, 1, "\u03C1"], [[120531, 120532], 1, "\u03C3"], [120533, 1, "\u03C4"], [120534, 1, "\u03C5"], [120535, 1, "\u03C6"], [120536, 1, "\u03C7"], [120537, 1, "\u03C8"], [120538, 1, "\u03C9"], [120539, 1, "\u2202"], [120540, 1, "\u03B5"], [120541, 1, "\u03B8"], [120542, 1, "\u03BA"], [120543, 1, "\u03C6"], [120544, 1, "\u03C1"], [120545, 1, "\u03C0"], [120546, 1, "\u03B1"], [120547, 1, "\u03B2"], [120548, 1, "\u03B3"], [120549, 1, "\u03B4"], [120550, 1, "\u03B5"], [120551, 1, "\u03B6"], [120552, 1, "\u03B7"], [120553, 1, "\u03B8"], [120554, 1, "\u03B9"], [120555, 1, "\u03BA"], [120556, 1, "\u03BB"], [120557, 1, "\u03BC"], [120558, 1, "\u03BD"], [120559, 1, "\u03BE"], [120560, 1, "\u03BF"], [120561, 1, "\u03C0"], [120562, 1, "\u03C1"], [120563, 1, "\u03B8"], [120564, 1, "\u03C3"], [120565, 1, "\u03C4"], [120566, 1, "\u03C5"], [120567, 1, "\u03C6"], [120568, 1, "\u03C7"], [120569, 1, "\u03C8"], [120570, 1, "\u03C9"], [120571, 1, "\u2207"], [120572, 1, "\u03B1"], [120573, 1, "\u03B2"], [120574, 1, "\u03B3"], [120575, 1, "\u03B4"], [120576, 1, "\u03B5"], [120577, 1, "\u03B6"], [120578, 1, "\u03B7"], [120579, 1, "\u03B8"], [120580, 1, "\u03B9"], [120581, 1, "\u03BA"], [120582, 1, "\u03BB"], [120583, 1, "\u03BC"], [120584, 1, "\u03BD"], [120585, 1, "\u03BE"], [120586, 1, "\u03BF"], [120587, 1, "\u03C0"], [120588, 1, "\u03C1"], [[120589, 120590], 1, "\u03C3"], [120591, 1, "\u03C4"], [120592, 1, "\u03C5"], [120593, 1, "\u03C6"], [120594, 1, "\u03C7"], [120595, 1, "\u03C8"], [120596, 1, "\u03C9"], [120597, 1, "\u2202"], [120598, 1, "\u03B5"], [120599, 1, "\u03B8"], [120600, 1, "\u03BA"], [120601, 1, "\u03C6"], [120602, 1, "\u03C1"], [120603, 1, "\u03C0"], [120604, 1, "\u03B1"], [120605, 1, "\u03B2"], [120606, 1, "\u03B3"], [120607, 1, "\u03B4"], [120608, 1, "\u03B5"], [120609, 1, "\u03B6"], [120610, 1, "\u03B7"], [120611, 1, "\u03B8"], [120612, 1, "\u03B9"], [120613, 1, "\u03BA"], [120614, 1, "\u03BB"], [120615, 1, "\u03BC"], [120616, 1, "\u03BD"], [120617, 1, "\u03BE"], [120618, 1, "\u03BF"], [120619, 1, "\u03C0"], [120620, 1, "\u03C1"], [120621, 1, "\u03B8"], [120622, 1, "\u03C3"], [120623, 1, "\u03C4"], [120624, 1, "\u03C5"], [120625, 1, "\u03C6"], [120626, 1, "\u03C7"], [120627, 1, "\u03C8"], [120628, 1, "\u03C9"], [120629, 1, "\u2207"], [120630, 1, "\u03B1"], [120631, 1, "\u03B2"], [120632, 1, "\u03B3"], [120633, 1, "\u03B4"], [120634, 1, "\u03B5"], [120635, 1, "\u03B6"], [120636, 1, "\u03B7"], [120637, 1, "\u03B8"], [120638, 1, "\u03B9"], [120639, 1, "\u03BA"], [120640, 1, "\u03BB"], [120641, 1, "\u03BC"], [120642, 1, "\u03BD"], [120643, 1, "\u03BE"], [120644, 1, "\u03BF"], [120645, 1, "\u03C0"], [120646, 1, "\u03C1"], [[120647, 120648], 1, "\u03C3"], [120649, 1, "\u03C4"], [120650, 1, "\u03C5"], [120651, 1, "\u03C6"], [120652, 1, "\u03C7"], [120653, 1, "\u03C8"], [120654, 1, "\u03C9"], [120655, 1, "\u2202"], [120656, 1, "\u03B5"], [120657, 1, "\u03B8"], [120658, 1, "\u03BA"], [120659, 1, "\u03C6"], [120660, 1, "\u03C1"], [120661, 1, "\u03C0"], [120662, 1, "\u03B1"], [120663, 1, "\u03B2"], [120664, 1, "\u03B3"], [120665, 1, "\u03B4"], [120666, 1, "\u03B5"], [120667, 1, "\u03B6"], [120668, 1, "\u03B7"], [120669, 1, "\u03B8"], [120670, 1, "\u03B9"], [120671, 1, "\u03BA"], [120672, 1, "\u03BB"], [120673, 1, "\u03BC"], [120674, 1, "\u03BD"], [120675, 1, "\u03BE"], [120676, 1, "\u03BF"], [120677, 1, "\u03C0"], [120678, 1, "\u03C1"], [120679, 1, "\u03B8"], [120680, 1, "\u03C3"], [120681, 1, "\u03C4"], [120682, 1, "\u03C5"], [120683, 1, "\u03C6"], [120684, 1, "\u03C7"], [120685, 1, "\u03C8"], [120686, 1, "\u03C9"], [120687, 1, "\u2207"], [120688, 1, "\u03B1"], [120689, 1, "\u03B2"], [120690, 1, "\u03B3"], [120691, 1, "\u03B4"], [120692, 1, "\u03B5"], [120693, 1, "\u03B6"], [120694, 1, "\u03B7"], [120695, 1, "\u03B8"], [120696, 1, "\u03B9"], [120697, 1, "\u03BA"], [120698, 1, "\u03BB"], [120699, 1, "\u03BC"], [120700, 1, "\u03BD"], [120701, 1, "\u03BE"], [120702, 1, "\u03BF"], [120703, 1, "\u03C0"], [120704, 1, "\u03C1"], [[120705, 120706], 1, "\u03C3"], [120707, 1, "\u03C4"], [120708, 1, "\u03C5"], [120709, 1, "\u03C6"], [120710, 1, "\u03C7"], [120711, 1, "\u03C8"], [120712, 1, "\u03C9"], [120713, 1, "\u2202"], [120714, 1, "\u03B5"], [120715, 1, "\u03B8"], [120716, 1, "\u03BA"], [120717, 1, "\u03C6"], [120718, 1, "\u03C1"], [120719, 1, "\u03C0"], [120720, 1, "\u03B1"], [120721, 1, "\u03B2"], [120722, 1, "\u03B3"], [120723, 1, "\u03B4"], [120724, 1, "\u03B5"], [120725, 1, "\u03B6"], [120726, 1, "\u03B7"], [120727, 1, "\u03B8"], [120728, 1, "\u03B9"], [120729, 1, "\u03BA"], [120730, 1, "\u03BB"], [120731, 1, "\u03BC"], [120732, 1, "\u03BD"], [120733, 1, "\u03BE"], [120734, 1, "\u03BF"], [120735, 1, "\u03C0"], [120736, 1, "\u03C1"], [120737, 1, "\u03B8"], [120738, 1, "\u03C3"], [120739, 1, "\u03C4"], [120740, 1, "\u03C5"], [120741, 1, "\u03C6"], [120742, 1, "\u03C7"], [120743, 1, "\u03C8"], [120744, 1, "\u03C9"], [120745, 1, "\u2207"], [120746, 1, "\u03B1"], [120747, 1, "\u03B2"], [120748, 1, "\u03B3"], [120749, 1, "\u03B4"], [120750, 1, "\u03B5"], [120751, 1, "\u03B6"], [120752, 1, "\u03B7"], [120753, 1, "\u03B8"], [120754, 1, "\u03B9"], [120755, 1, "\u03BA"], [120756, 1, "\u03BB"], [120757, 1, "\u03BC"], [120758, 1, "\u03BD"], [120759, 1, "\u03BE"], [120760, 1, "\u03BF"], [120761, 1, "\u03C0"], [120762, 1, "\u03C1"], [[120763, 120764], 1, "\u03C3"], [120765, 1, "\u03C4"], [120766, 1, "\u03C5"], [120767, 1, "\u03C6"], [120768, 1, "\u03C7"], [120769, 1, "\u03C8"], [120770, 1, "\u03C9"], [120771, 1, "\u2202"], [120772, 1, "\u03B5"], [120773, 1, "\u03B8"], [120774, 1, "\u03BA"], [120775, 1, "\u03C6"], [120776, 1, "\u03C1"], [120777, 1, "\u03C0"], [[120778, 120779], 1, "\u03DD"], [[120780, 120781], 3], [120782, 1, "0"], [120783, 1, "1"], [120784, 1, "2"], [120785, 1, "3"], [120786, 1, "4"], [120787, 1, "5"], [120788, 1, "6"], [120789, 1, "7"], [120790, 1, "8"], [120791, 1, "9"], [120792, 1, "0"], [120793, 1, "1"], [120794, 1, "2"], [120795, 1, "3"], [120796, 1, "4"], [120797, 1, "5"], [120798, 1, "6"], [120799, 1, "7"], [120800, 1, "8"], [120801, 1, "9"], [120802, 1, "0"], [120803, 1, "1"], [120804, 1, "2"], [120805, 1, "3"], [120806, 1, "4"], [120807, 1, "5"], [120808, 1, "6"], [120809, 1, "7"], [120810, 1, "8"], [120811, 1, "9"], [120812, 1, "0"], [120813, 1, "1"], [120814, 1, "2"], [120815, 1, "3"], [120816, 1, "4"], [120817, 1, "5"], [120818, 1, "6"], [120819, 1, "7"], [120820, 1, "8"], [120821, 1, "9"], [120822, 1, "0"], [120823, 1, "1"], [120824, 1, "2"], [120825, 1, "3"], [120826, 1, "4"], [120827, 1, "5"], [120828, 1, "6"], [120829, 1, "7"], [120830, 1, "8"], [120831, 1, "9"], [[120832, 121343], 2], [[121344, 121398], 2], [[121399, 121402], 2], [[121403, 121452], 2], [[121453, 121460], 2], [121461, 2], [[121462, 121475], 2], [121476, 2], [[121477, 121483], 2], [[121484, 121498], 3], [[121499, 121503], 2], [121504, 3], [[121505, 121519], 2], [[121520, 122623], 3], [[122624, 122654], 2], [[122655, 122660], 3], [[122661, 122666], 2], [[122667, 122879], 3], [[122880, 122886], 2], [122887, 3], [[122888, 122904], 2], [[122905, 122906], 3], [[122907, 122913], 2], [122914, 3], [[122915, 122916], 2], [122917, 3], [[122918, 122922], 2], [[122923, 122927], 3], [122928, 1, "\u0430"], [122929, 1, "\u0431"], [122930, 1, "\u0432"], [122931, 1, "\u0433"], [122932, 1, "\u0434"], [122933, 1, "\u0435"], [122934, 1, "\u0436"], [122935, 1, "\u0437"], [122936, 1, "\u0438"], [122937, 1, "\u043A"], [122938, 1, "\u043B"], [122939, 1, "\u043C"], [122940, 1, "\u043E"], [122941, 1, "\u043F"], [122942, 1, "\u0440"], [122943, 1, "\u0441"], [122944, 1, "\u0442"], [122945, 1, "\u0443"], [122946, 1, "\u0444"], [122947, 1, "\u0445"], [122948, 1, "\u0446"], [122949, 1, "\u0447"], [122950, 1, "\u0448"], [122951, 1, "\u044B"], [122952, 1, "\u044D"], [122953, 1, "\u044E"], [122954, 1, "\uA689"], [122955, 1, "\u04D9"], [122956, 1, "\u0456"], [122957, 1, "\u0458"], [122958, 1, "\u04E9"], [122959, 1, "\u04AF"], [122960, 1, "\u04CF"], [122961, 1, "\u0430"], [122962, 1, "\u0431"], [122963, 1, "\u0432"], [122964, 1, "\u0433"], [122965, 1, "\u0434"], [122966, 1, "\u0435"], [122967, 1, "\u0436"], [122968, 1, "\u0437"], [122969, 1, "\u0438"], [122970, 1, "\u043A"], [122971, 1, "\u043B"], [122972, 1, "\u043E"], [122973, 1, "\u043F"], [122974, 1, "\u0441"], [122975, 1, "\u0443"], [122976, 1, "\u0444"], [122977, 1, "\u0445"], [122978, 1, "\u0446"], [122979, 1, "\u0447"], [122980, 1, "\u0448"], [122981, 1, "\u044A"], [122982, 1, "\u044B"], [122983, 1, "\u0491"], [122984, 1, "\u0456"], [122985, 1, "\u0455"], [122986, 1, "\u045F"], [122987, 1, "\u04AB"], [122988, 1, "\uA651"], [122989, 1, "\u04B1"], [[122990, 123022], 3], [123023, 2], [[123024, 123135], 3], [[123136, 123180], 2], [[123181, 123183], 3], [[123184, 123197], 2], [[123198, 123199], 3], [[123200, 123209], 2], [[123210, 123213], 3], [123214, 2], [123215, 2], [[123216, 123535], 3], [[123536, 123566], 2], [[123567, 123583], 3], [[123584, 123641], 2], [[123642, 123646], 3], [123647, 2], [[123648, 124111], 3], [[124112, 124153], 2], [[124154, 124367], 3], [[124368, 124410], 2], [[124411, 124414], 3], [124415, 2], [[124416, 124895], 3], [[124896, 124902], 2], [124903, 3], [[124904, 124907], 2], [124908, 3], [[124909, 124910], 2], [124911, 3], [[124912, 124926], 2], [124927, 3], [[124928, 125124], 2], [[125125, 125126], 3], [[125127, 125135], 2], [[125136, 125142], 2], [[125143, 125183], 3], [125184, 1, "\u{1E922}"], [125185, 1, "\u{1E923}"], [125186, 1, "\u{1E924}"], [125187, 1, "\u{1E925}"], [125188, 1, "\u{1E926}"], [125189, 1, "\u{1E927}"], [125190, 1, "\u{1E928}"], [125191, 1, "\u{1E929}"], [125192, 1, "\u{1E92A}"], [125193, 1, "\u{1E92B}"], [125194, 1, "\u{1E92C}"], [125195, 1, "\u{1E92D}"], [125196, 1, "\u{1E92E}"], [125197, 1, "\u{1E92F}"], [125198, 1, "\u{1E930}"], [125199, 1, "\u{1E931}"], [125200, 1, "\u{1E932}"], [125201, 1, "\u{1E933}"], [125202, 1, "\u{1E934}"], [125203, 1, "\u{1E935}"], [125204, 1, "\u{1E936}"], [125205, 1, "\u{1E937}"], [125206, 1, "\u{1E938}"], [125207, 1, "\u{1E939}"], [125208, 1, "\u{1E93A}"], [125209, 1, "\u{1E93B}"], [125210, 1, "\u{1E93C}"], [125211, 1, "\u{1E93D}"], [125212, 1, "\u{1E93E}"], [125213, 1, "\u{1E93F}"], [125214, 1, "\u{1E940}"], [125215, 1, "\u{1E941}"], [125216, 1, "\u{1E942}"], [125217, 1, "\u{1E943}"], [[125218, 125258], 2], [125259, 2], [[125260, 125263], 3], [[125264, 125273], 2], [[125274, 125277], 3], [[125278, 125279], 2], [[125280, 126064], 3], [[126065, 126132], 2], [[126133, 126208], 3], [[126209, 126269], 2], [[126270, 126463], 3], [126464, 1, "\u0627"], [126465, 1, "\u0628"], [126466, 1, "\u062C"], [126467, 1, "\u062F"], [126468, 3], [126469, 1, "\u0648"], [126470, 1, "\u0632"], [126471, 1, "\u062D"], [126472, 1, "\u0637"], [126473, 1, "\u064A"], [126474, 1, "\u0643"], [126475, 1, "\u0644"], [126476, 1, "\u0645"], [126477, 1, "\u0646"], [126478, 1, "\u0633"], [126479, 1, "\u0639"], [126480, 1, "\u0641"], [126481, 1, "\u0635"], [126482, 1, "\u0642"], [126483, 1, "\u0631"], [126484, 1, "\u0634"], [126485, 1, "\u062A"], [126486, 1, "\u062B"], [126487, 1, "\u062E"], [126488, 1, "\u0630"], [126489, 1, "\u0636"], [126490, 1, "\u0638"], [126491, 1, "\u063A"], [126492, 1, "\u066E"], [126493, 1, "\u06BA"], [126494, 1, "\u06A1"], [126495, 1, "\u066F"], [126496, 3], [126497, 1, "\u0628"], [126498, 1, "\u062C"], [126499, 3], [126500, 1, "\u0647"], [[126501, 126502], 3], [126503, 1, "\u062D"], [126504, 3], [126505, 1, "\u064A"], [126506, 1, "\u0643"], [126507, 1, "\u0644"], [126508, 1, "\u0645"], [126509, 1, "\u0646"], [126510, 1, "\u0633"], [126511, 1, "\u0639"], [126512, 1, "\u0641"], [126513, 1, "\u0635"], [126514, 1, "\u0642"], [126515, 3], [126516, 1, "\u0634"], [126517, 1, "\u062A"], [126518, 1, "\u062B"], [126519, 1, "\u062E"], [126520, 3], [126521, 1, "\u0636"], [126522, 3], [126523, 1, "\u063A"], [[126524, 126529], 3], [126530, 1, "\u062C"], [[126531, 126534], 3], [126535, 1, "\u062D"], [126536, 3], [126537, 1, "\u064A"], [126538, 3], [126539, 1, "\u0644"], [126540, 3], [126541, 1, "\u0646"], [126542, 1, "\u0633"], [126543, 1, "\u0639"], [126544, 3], [126545, 1, "\u0635"], [126546, 1, "\u0642"], [126547, 3], [126548, 1, "\u0634"], [[126549, 126550], 3], [126551, 1, "\u062E"], [126552, 3], [126553, 1, "\u0636"], [126554, 3], [126555, 1, "\u063A"], [126556, 3], [126557, 1, "\u06BA"], [126558, 3], [126559, 1, "\u066F"], [126560, 3], [126561, 1, "\u0628"], [126562, 1, "\u062C"], [126563, 3], [126564, 1, "\u0647"], [[126565, 126566], 3], [126567, 1, "\u062D"], [126568, 1, "\u0637"], [126569, 1, "\u064A"], [126570, 1, "\u0643"], [126571, 3], [126572, 1, "\u0645"], [126573, 1, "\u0646"], [126574, 1, "\u0633"], [126575, 1, "\u0639"], [126576, 1, "\u0641"], [126577, 1, "\u0635"], [126578, 1, "\u0642"], [126579, 3], [126580, 1, "\u0634"], [126581, 1, "\u062A"], [126582, 1, "\u062B"], [126583, 1, "\u062E"], [126584, 3], [126585, 1, "\u0636"], [126586, 1, "\u0638"], [126587, 1, "\u063A"], [126588, 1, "\u066E"], [126589, 3], [126590, 1, "\u06A1"], [126591, 3], [126592, 1, "\u0627"], [126593, 1, "\u0628"], [126594, 1, "\u062C"], [126595, 1, "\u062F"], [126596, 1, "\u0647"], [126597, 1, "\u0648"], [126598, 1, "\u0632"], [126599, 1, "\u062D"], [126600, 1, "\u0637"], [126601, 1, "\u064A"], [126602, 3], [126603, 1, "\u0644"], [126604, 1, "\u0645"], [126605, 1, "\u0646"], [126606, 1, "\u0633"], [126607, 1, "\u0639"], [126608, 1, "\u0641"], [126609, 1, "\u0635"], [126610, 1, "\u0642"], [126611, 1, "\u0631"], [126612, 1, "\u0634"], [126613, 1, "\u062A"], [126614, 1, "\u062B"], [126615, 1, "\u062E"], [126616, 1, "\u0630"], [126617, 1, "\u0636"], [126618, 1, "\u0638"], [126619, 1, "\u063A"], [[126620, 126624], 3], [126625, 1, "\u0628"], [126626, 1, "\u062C"], [126627, 1, "\u062F"], [126628, 3], [126629, 1, "\u0648"], [126630, 1, "\u0632"], [126631, 1, "\u062D"], [126632, 1, "\u0637"], [126633, 1, "\u064A"], [126634, 3], [126635, 1, "\u0644"], [126636, 1, "\u0645"], [126637, 1, "\u0646"], [126638, 1, "\u0633"], [126639, 1, "\u0639"], [126640, 1, "\u0641"], [126641, 1, "\u0635"], [126642, 1, "\u0642"], [126643, 1, "\u0631"], [126644, 1, "\u0634"], [126645, 1, "\u062A"], [126646, 1, "\u062B"], [126647, 1, "\u062E"], [126648, 1, "\u0630"], [126649, 1, "\u0636"], [126650, 1, "\u0638"], [126651, 1, "\u063A"], [[126652, 126703], 3], [[126704, 126705], 2], [[126706, 126975], 3], [[126976, 127019], 2], [[127020, 127023], 3], [[127024, 127123], 2], [[127124, 127135], 3], [[127136, 127150], 2], [[127151, 127152], 3], [[127153, 127166], 2], [127167, 2], [127168, 3], [[127169, 127183], 2], [127184, 3], [[127185, 127199], 2], [[127200, 127221], 2], [[127222, 127231], 3], [127232, 3], [127233, 1, "0,"], [127234, 1, "1,"], [127235, 1, "2,"], [127236, 1, "3,"], [127237, 1, "4,"], [127238, 1, "5,"], [127239, 1, "6,"], [127240, 1, "7,"], [127241, 1, "8,"], [127242, 1, "9,"], [[127243, 127244], 2], [[127245, 127247], 2], [127248, 1, "(a)"], [127249, 1, "(b)"], [127250, 1, "(c)"], [127251, 1, "(d)"], [127252, 1, "(e)"], [127253, 1, "(f)"], [127254, 1, "(g)"], [127255, 1, "(h)"], [127256, 1, "(i)"], [127257, 1, "(j)"], [127258, 1, "(k)"], [127259, 1, "(l)"], [127260, 1, "(m)"], [127261, 1, "(n)"], [127262, 1, "(o)"], [127263, 1, "(p)"], [127264, 1, "(q)"], [127265, 1, "(r)"], [127266, 1, "(s)"], [127267, 1, "(t)"], [127268, 1, "(u)"], [127269, 1, "(v)"], [127270, 1, "(w)"], [127271, 1, "(x)"], [127272, 1, "(y)"], [127273, 1, "(z)"], [127274, 1, "\u3014s\u3015"], [127275, 1, "c"], [127276, 1, "r"], [127277, 1, "cd"], [127278, 1, "wz"], [127279, 2], [127280, 1, "a"], [127281, 1, "b"], [127282, 1, "c"], [127283, 1, "d"], [127284, 1, "e"], [127285, 1, "f"], [127286, 1, "g"], [127287, 1, "h"], [127288, 1, "i"], [127289, 1, "j"], [127290, 1, "k"], [127291, 1, "l"], [127292, 1, "m"], [127293, 1, "n"], [127294, 1, "o"], [127295, 1, "p"], [127296, 1, "q"], [127297, 1, "r"], [127298, 1, "s"], [127299, 1, "t"], [127300, 1, "u"], [127301, 1, "v"], [127302, 1, "w"], [127303, 1, "x"], [127304, 1, "y"], [127305, 1, "z"], [127306, 1, "hv"], [127307, 1, "mv"], [127308, 1, "sd"], [127309, 1, "ss"], [127310, 1, "ppv"], [127311, 1, "wc"], [[127312, 127318], 2], [127319, 2], [[127320, 127326], 2], [127327, 2], [[127328, 127337], 2], [127338, 1, "mc"], [127339, 1, "md"], [127340, 1, "mr"], [[127341, 127343], 2], [[127344, 127352], 2], [127353, 2], [127354, 2], [[127355, 127356], 2], [[127357, 127358], 2], [127359, 2], [[127360, 127369], 2], [[127370, 127373], 2], [[127374, 127375], 2], [127376, 1, "dj"], [[127377, 127386], 2], [[127387, 127404], 2], [127405, 2], [[127406, 127461], 3], [[127462, 127487], 2], [127488, 1, "\u307B\u304B"], [127489, 1, "\u30B3\u30B3"], [127490, 1, "\u30B5"], [[127491, 127503], 3], [127504, 1, "\u624B"], [127505, 1, "\u5B57"], [127506, 1, "\u53CC"], [127507, 1, "\u30C7"], [127508, 1, "\u4E8C"], [127509, 1, "\u591A"], [127510, 1, "\u89E3"], [127511, 1, "\u5929"], [127512, 1, "\u4EA4"], [127513, 1, "\u6620"], [127514, 1, "\u7121"], [127515, 1, "\u6599"], [127516, 1, "\u524D"], [127517, 1, "\u5F8C"], [127518, 1, "\u518D"], [127519, 1, "\u65B0"], [127520, 1, "\u521D"], [127521, 1, "\u7D42"], [127522, 1, "\u751F"], [127523, 1, "\u8CA9"], [127524, 1, "\u58F0"], [127525, 1, "\u5439"], [127526, 1, "\u6F14"], [127527, 1, "\u6295"], [127528, 1, "\u6355"], [127529, 1, "\u4E00"], [127530, 1, "\u4E09"], [127531, 1, "\u904A"], [127532, 1, "\u5DE6"], [127533, 1, "\u4E2D"], [127534, 1, "\u53F3"], [127535, 1, "\u6307"], [127536, 1, "\u8D70"], [127537, 1, "\u6253"], [127538, 1, "\u7981"], [127539, 1, "\u7A7A"], [127540, 1, "\u5408"], [127541, 1, "\u6E80"], [127542, 1, "\u6709"], [127543, 1, "\u6708"], [127544, 1, "\u7533"], [127545, 1, "\u5272"], [127546, 1, "\u55B6"], [127547, 1, "\u914D"], [[127548, 127551], 3], [127552, 1, "\u3014\u672C\u3015"], [127553, 1, "\u3014\u4E09\u3015"], [127554, 1, "\u3014\u4E8C\u3015"], [127555, 1, "\u3014\u5B89\u3015"], [127556, 1, "\u3014\u70B9\u3015"], [127557, 1, "\u3014\u6253\u3015"], [127558, 1, "\u3014\u76D7\u3015"], [127559, 1, "\u3014\u52DD\u3015"], [127560, 1, "\u3014\u6557\u3015"], [[127561, 127567], 3], [127568, 1, "\u5F97"], [127569, 1, "\u53EF"], [[127570, 127583], 3], [[127584, 127589], 2], [[127590, 127743], 3], [[127744, 127776], 2], [[127777, 127788], 2], [[127789, 127791], 2], [[127792, 127797], 2], [127798, 2], [[127799, 127868], 2], [127869, 2], [[127870, 127871], 2], [[127872, 127891], 2], [[127892, 127903], 2], [[127904, 127940], 2], [127941, 2], [[127942, 127946], 2], [[127947, 127950], 2], [[127951, 127955], 2], [[127956, 127967], 2], [[127968, 127984], 2], [[127985, 127991], 2], [[127992, 127999], 2], [[128e3, 128062], 2], [128063, 2], [128064, 2], [128065, 2], [[128066, 128247], 2], [128248, 2], [[128249, 128252], 2], [[128253, 128254], 2], [128255, 2], [[128256, 128317], 2], [[128318, 128319], 2], [[128320, 128323], 2], [[128324, 128330], 2], [[128331, 128335], 2], [[128336, 128359], 2], [[128360, 128377], 2], [128378, 2], [[128379, 128419], 2], [128420, 2], [[128421, 128506], 2], [[128507, 128511], 2], [128512, 2], [[128513, 128528], 2], [128529, 2], [[128530, 128532], 2], [128533, 2], [128534, 2], [128535, 2], [128536, 2], [128537, 2], [128538, 2], [128539, 2], [[128540, 128542], 2], [128543, 2], [[128544, 128549], 2], [[128550, 128551], 2], [[128552, 128555], 2], [128556, 2], [128557, 2], [[128558, 128559], 2], [[128560, 128563], 2], [128564, 2], [[128565, 128576], 2], [[128577, 128578], 2], [[128579, 128580], 2], [[128581, 128591], 2], [[128592, 128639], 2], [[128640, 128709], 2], [[128710, 128719], 2], [128720, 2], [[128721, 128722], 2], [[128723, 128724], 2], [128725, 2], [[128726, 128727], 2], [[128728, 128731], 3], [128732, 2], [[128733, 128735], 2], [[128736, 128748], 2], [[128749, 128751], 3], [[128752, 128755], 2], [[128756, 128758], 2], [[128759, 128760], 2], [128761, 2], [128762, 2], [[128763, 128764], 2], [[128765, 128767], 3], [[128768, 128883], 2], [[128884, 128886], 2], [[128887, 128890], 3], [[128891, 128895], 2], [[128896, 128980], 2], [[128981, 128984], 2], [128985, 2], [[128986, 128991], 3], [[128992, 129003], 2], [[129004, 129007], 3], [129008, 2], [[129009, 129023], 3], [[129024, 129035], 2], [[129036, 129039], 3], [[129040, 129095], 2], [[129096, 129103], 3], [[129104, 129113], 2], [[129114, 129119], 3], [[129120, 129159], 2], [[129160, 129167], 3], [[129168, 129197], 2], [[129198, 129199], 3], [[129200, 129201], 2], [[129202, 129211], 2], [[129212, 129215], 3], [[129216, 129217], 2], [[129218, 129279], 3], [[129280, 129291], 2], [129292, 2], [[129293, 129295], 2], [[129296, 129304], 2], [[129305, 129310], 2], [129311, 2], [[129312, 129319], 2], [[129320, 129327], 2], [129328, 2], [[129329, 129330], 2], [[129331, 129342], 2], [129343, 2], [[129344, 129355], 2], [129356, 2], [[129357, 129359], 2], [[129360, 129374], 2], [[129375, 129387], 2], [[129388, 129392], 2], [129393, 2], [129394, 2], [[129395, 129398], 2], [[129399, 129400], 2], [129401, 2], [129402, 2], [129403, 2], [[129404, 129407], 2], [[129408, 129412], 2], [[129413, 129425], 2], [[129426, 129431], 2], [[129432, 129442], 2], [[129443, 129444], 2], [[129445, 129450], 2], [[129451, 129453], 2], [[129454, 129455], 2], [[129456, 129465], 2], [[129466, 129471], 2], [129472, 2], [[129473, 129474], 2], [[129475, 129482], 2], [129483, 2], [129484, 2], [[129485, 129487], 2], [[129488, 129510], 2], [[129511, 129535], 2], [[129536, 129619], 2], [[129620, 129631], 3], [[129632, 129645], 2], [[129646, 129647], 3], [[129648, 129651], 2], [129652, 2], [[129653, 129655], 2], [[129656, 129658], 2], [[129659, 129660], 2], [[129661, 129663], 3], [[129664, 129666], 2], [[129667, 129670], 2], [[129671, 129672], 2], [129673, 2], [[129674, 129678], 3], [129679, 2], [[129680, 129685], 2], [[129686, 129704], 2], [[129705, 129708], 2], [[129709, 129711], 2], [[129712, 129718], 2], [[129719, 129722], 2], [[129723, 129725], 2], [129726, 2], [129727, 2], [[129728, 129730], 2], [[129731, 129733], 2], [129734, 2], [[129735, 129741], 3], [[129742, 129743], 2], [[129744, 129750], 2], [[129751, 129753], 2], [[129754, 129755], 2], [129756, 2], [[129757, 129758], 3], [129759, 2], [[129760, 129767], 2], [129768, 2], [129769, 2], [[129770, 129775], 3], [[129776, 129782], 2], [[129783, 129784], 2], [[129785, 129791], 3], [[129792, 129938], 2], [129939, 3], [[129940, 129994], 2], [[129995, 130031], 2], [130032, 1, "0"], [130033, 1, "1"], [130034, 1, "2"], [130035, 1, "3"], [130036, 1, "4"], [130037, 1, "5"], [130038, 1, "6"], [130039, 1, "7"], [130040, 1, "8"], [130041, 1, "9"], [[130042, 131069], 3], [[131070, 131071], 3], [[131072, 173782], 2], [[173783, 173789], 2], [[173790, 173791], 2], [[173792, 173823], 3], [[173824, 177972], 2], [[177973, 177976], 2], [177977, 2], [[177978, 177983], 3], [[177984, 178205], 2], [[178206, 178207], 3], [[178208, 183969], 2], [[183970, 183983], 3], [[183984, 191456], 2], [[191457, 191471], 3], [[191472, 192093], 2], [[192094, 194559], 3], [194560, 1, "\u4E3D"], [194561, 1, "\u4E38"], [194562, 1, "\u4E41"], [194563, 1, "\u{20122}"], [194564, 1, "\u4F60"], [194565, 1, "\u4FAE"], [194566, 1, "\u4FBB"], [194567, 1, "\u5002"], [194568, 1, "\u507A"], [194569, 1, "\u5099"], [194570, 1, "\u50E7"], [194571, 1, "\u50CF"], [194572, 1, "\u349E"], [194573, 1, "\u{2063A}"], [194574, 1, "\u514D"], [194575, 1, "\u5154"], [194576, 1, "\u5164"], [194577, 1, "\u5177"], [194578, 1, "\u{2051C}"], [194579, 1, "\u34B9"], [194580, 1, "\u5167"], [194581, 1, "\u518D"], [194582, 1, "\u{2054B}"], [194583, 1, "\u5197"], [194584, 1, "\u51A4"], [194585, 1, "\u4ECC"], [194586, 1, "\u51AC"], [194587, 1, "\u51B5"], [194588, 1, "\u{291DF}"], [194589, 1, "\u51F5"], [194590, 1, "\u5203"], [194591, 1, "\u34DF"], [194592, 1, "\u523B"], [194593, 1, "\u5246"], [194594, 1, "\u5272"], [194595, 1, "\u5277"], [194596, 1, "\u3515"], [194597, 1, "\u52C7"], [194598, 1, "\u52C9"], [194599, 1, "\u52E4"], [194600, 1, "\u52FA"], [194601, 1, "\u5305"], [194602, 1, "\u5306"], [194603, 1, "\u5317"], [194604, 1, "\u5349"], [194605, 1, "\u5351"], [194606, 1, "\u535A"], [194607, 1, "\u5373"], [194608, 1, "\u537D"], [[194609, 194611], 1, "\u537F"], [194612, 1, "\u{20A2C}"], [194613, 1, "\u7070"], [194614, 1, "\u53CA"], [194615, 1, "\u53DF"], [194616, 1, "\u{20B63}"], [194617, 1, "\u53EB"], [194618, 1, "\u53F1"], [194619, 1, "\u5406"], [194620, 1, "\u549E"], [194621, 1, "\u5438"], [194622, 1, "\u5448"], [194623, 1, "\u5468"], [194624, 1, "\u54A2"], [194625, 1, "\u54F6"], [194626, 1, "\u5510"], [194627, 1, "\u5553"], [194628, 1, "\u5563"], [[194629, 194630], 1, "\u5584"], [194631, 1, "\u5599"], [194632, 1, "\u55AB"], [194633, 1, "\u55B3"], [194634, 1, "\u55C2"], [194635, 1, "\u5716"], [194636, 1, "\u5606"], [194637, 1, "\u5717"], [194638, 1, "\u5651"], [194639, 1, "\u5674"], [194640, 1, "\u5207"], [194641, 1, "\u58EE"], [194642, 1, "\u57CE"], [194643, 1, "\u57F4"], [194644, 1, "\u580D"], [194645, 1, "\u578B"], [194646, 1, "\u5832"], [194647, 1, "\u5831"], [194648, 1, "\u58AC"], [194649, 1, "\u{214E4}"], [194650, 1, "\u58F2"], [194651, 1, "\u58F7"], [194652, 1, "\u5906"], [194653, 1, "\u591A"], [194654, 1, "\u5922"], [194655, 1, "\u5962"], [194656, 1, "\u{216A8}"], [194657, 1, "\u{216EA}"], [194658, 1, "\u59EC"], [194659, 1, "\u5A1B"], [194660, 1, "\u5A27"], [194661, 1, "\u59D8"], [194662, 1, "\u5A66"], [194663, 1, "\u36EE"], [194664, 1, "\u36FC"], [194665, 1, "\u5B08"], [[194666, 194667], 1, "\u5B3E"], [194668, 1, "\u{219C8}"], [194669, 1, "\u5BC3"], [194670, 1, "\u5BD8"], [194671, 1, "\u5BE7"], [194672, 1, "\u5BF3"], [194673, 1, "\u{21B18}"], [194674, 1, "\u5BFF"], [194675, 1, "\u5C06"], [194676, 1, "\u5F53"], [194677, 1, "\u5C22"], [194678, 1, "\u3781"], [194679, 1, "\u5C60"], [194680, 1, "\u5C6E"], [194681, 1, "\u5CC0"], [194682, 1, "\u5C8D"], [194683, 1, "\u{21DE4}"], [194684, 1, "\u5D43"], [194685, 1, "\u{21DE6}"], [194686, 1, "\u5D6E"], [194687, 1, "\u5D6B"], [194688, 1, "\u5D7C"], [194689, 1, "\u5DE1"], [194690, 1, "\u5DE2"], [194691, 1, "\u382F"], [194692, 1, "\u5DFD"], [194693, 1, "\u5E28"], [194694, 1, "\u5E3D"], [194695, 1, "\u5E69"], [194696, 1, "\u3862"], [194697, 1, "\u{22183}"], [194698, 1, "\u387C"], [194699, 1, "\u5EB0"], [194700, 1, "\u5EB3"], [194701, 1, "\u5EB6"], [194702, 1, "\u5ECA"], [194703, 1, "\u{2A392}"], [194704, 1, "\u5EFE"], [[194705, 194706], 1, "\u{22331}"], [194707, 1, "\u8201"], [[194708, 194709], 1, "\u5F22"], [194710, 1, "\u38C7"], [194711, 1, "\u{232B8}"], [194712, 1, "\u{261DA}"], [194713, 1, "\u5F62"], [194714, 1, "\u5F6B"], [194715, 1, "\u38E3"], [194716, 1, "\u5F9A"], [194717, 1, "\u5FCD"], [194718, 1, "\u5FD7"], [194719, 1, "\u5FF9"], [194720, 1, "\u6081"], [194721, 1, "\u393A"], [194722, 1, "\u391C"], [194723, 1, "\u6094"], [194724, 1, "\u{226D4}"], [194725, 1, "\u60C7"], [194726, 1, "\u6148"], [194727, 1, "\u614C"], [194728, 1, "\u614E"], [194729, 1, "\u614C"], [194730, 1, "\u617A"], [194731, 1, "\u618E"], [194732, 1, "\u61B2"], [194733, 1, "\u61A4"], [194734, 1, "\u61AF"], [194735, 1, "\u61DE"], [194736, 1, "\u61F2"], [194737, 1, "\u61F6"], [194738, 1, "\u6210"], [194739, 1, "\u621B"], [194740, 1, "\u625D"], [194741, 1, "\u62B1"], [194742, 1, "\u62D4"], [194743, 1, "\u6350"], [194744, 1, "\u{22B0C}"], [194745, 1, "\u633D"], [194746, 1, "\u62FC"], [194747, 1, "\u6368"], [194748, 1, "\u6383"], [194749, 1, "\u63E4"], [194750, 1, "\u{22BF1}"], [194751, 1, "\u6422"], [194752, 1, "\u63C5"], [194753, 1, "\u63A9"], [194754, 1, "\u3A2E"], [194755, 1, "\u6469"], [194756, 1, "\u647E"], [194757, 1, "\u649D"], [194758, 1, "\u6477"], [194759, 1, "\u3A6C"], [194760, 1, "\u654F"], [194761, 1, "\u656C"], [194762, 1, "\u{2300A}"], [194763, 1, "\u65E3"], [194764, 1, "\u66F8"], [194765, 1, "\u6649"], [194766, 1, "\u3B19"], [194767, 1, "\u6691"], [194768, 1, "\u3B08"], [194769, 1, "\u3AE4"], [194770, 1, "\u5192"], [194771, 1, "\u5195"], [194772, 1, "\u6700"], [194773, 1, "\u669C"], [194774, 1, "\u80AD"], [194775, 1, "\u43D9"], [194776, 1, "\u6717"], [194777, 1, "\u671B"], [194778, 1, "\u6721"], [194779, 1, "\u675E"], [194780, 1, "\u6753"], [194781, 1, "\u{233C3}"], [194782, 1, "\u3B49"], [194783, 1, "\u67FA"], [194784, 1, "\u6785"], [194785, 1, "\u6852"], [194786, 1, "\u6885"], [194787, 1, "\u{2346D}"], [194788, 1, "\u688E"], [194789, 1, "\u681F"], [194790, 1, "\u6914"], [194791, 1, "\u3B9D"], [194792, 1, "\u6942"], [194793, 1, "\u69A3"], [194794, 1, "\u69EA"], [194795, 1, "\u6AA8"], [194796, 1, "\u{236A3}"], [194797, 1, "\u6ADB"], [194798, 1, "\u3C18"], [194799, 1, "\u6B21"], [194800, 1, "\u{238A7}"], [194801, 1, "\u6B54"], [194802, 1, "\u3C4E"], [194803, 1, "\u6B72"], [194804, 1, "\u6B9F"], [194805, 1, "\u6BBA"], [194806, 1, "\u6BBB"], [194807, 1, "\u{23A8D}"], [194808, 1, "\u{21D0B}"], [194809, 1, "\u{23AFA}"], [194810, 1, "\u6C4E"], [194811, 1, "\u{23CBC}"], [194812, 1, "\u6CBF"], [194813, 1, "\u6CCD"], [194814, 1, "\u6C67"], [194815, 1, "\u6D16"], [194816, 1, "\u6D3E"], [194817, 1, "\u6D77"], [194818, 1, "\u6D41"], [194819, 1, "\u6D69"], [194820, 1, "\u6D78"], [194821, 1, "\u6D85"], [194822, 1, "\u{23D1E}"], [194823, 1, "\u6D34"], [194824, 1, "\u6E2F"], [194825, 1, "\u6E6E"], [194826, 1, "\u3D33"], [194827, 1, "\u6ECB"], [194828, 1, "\u6EC7"], [194829, 1, "\u{23ED1}"], [194830, 1, "\u6DF9"], [194831, 1, "\u6F6E"], [194832, 1, "\u{23F5E}"], [194833, 1, "\u{23F8E}"], [194834, 1, "\u6FC6"], [194835, 1, "\u7039"], [194836, 1, "\u701E"], [194837, 1, "\u701B"], [194838, 1, "\u3D96"], [194839, 1, "\u704A"], [194840, 1, "\u707D"], [194841, 1, "\u7077"], [194842, 1, "\u70AD"], [194843, 1, "\u{20525}"], [194844, 1, "\u7145"], [194845, 1, "\u{24263}"], [194846, 1, "\u719C"], [194847, 1, "\u{243AB}"], [194848, 1, "\u7228"], [194849, 1, "\u7235"], [194850, 1, "\u7250"], [194851, 1, "\u{24608}"], [194852, 1, "\u7280"], [194853, 1, "\u7295"], [194854, 1, "\u{24735}"], [194855, 1, "\u{24814}"], [194856, 1, "\u737A"], [194857, 1, "\u738B"], [194858, 1, "\u3EAC"], [194859, 1, "\u73A5"], [[194860, 194861], 1, "\u3EB8"], [194862, 1, "\u7447"], [194863, 1, "\u745C"], [194864, 1, "\u7471"], [194865, 1, "\u7485"], [194866, 1, "\u74CA"], [194867, 1, "\u3F1B"], [194868, 1, "\u7524"], [194869, 1, "\u{24C36}"], [194870, 1, "\u753E"], [194871, 1, "\u{24C92}"], [194872, 1, "\u7570"], [194873, 1, "\u{2219F}"], [194874, 1, "\u7610"], [194875, 1, "\u{24FA1}"], [194876, 1, "\u{24FB8}"], [194877, 1, "\u{25044}"], [194878, 1, "\u3FFC"], [194879, 1, "\u4008"], [194880, 1, "\u76F4"], [194881, 1, "\u{250F3}"], [194882, 1, "\u{250F2}"], [194883, 1, "\u{25119}"], [194884, 1, "\u{25133}"], [194885, 1, "\u771E"], [[194886, 194887], 1, "\u771F"], [194888, 1, "\u774A"], [194889, 1, "\u4039"], [194890, 1, "\u778B"], [194891, 1, "\u4046"], [194892, 1, "\u4096"], [194893, 1, "\u{2541D}"], [194894, 1, "\u784E"], [194895, 1, "\u788C"], [194896, 1, "\u78CC"], [194897, 1, "\u40E3"], [194898, 1, "\u{25626}"], [194899, 1, "\u7956"], [194900, 1, "\u{2569A}"], [194901, 1, "\u{256C5}"], [194902, 1, "\u798F"], [194903, 1, "\u79EB"], [194904, 1, "\u412F"], [194905, 1, "\u7A40"], [194906, 1, "\u7A4A"], [194907, 1, "\u7A4F"], [194908, 1, "\u{2597C}"], [[194909, 194910], 1, "\u{25AA7}"], [194911, 1, "\u7AEE"], [194912, 1, "\u4202"], [194913, 1, "\u{25BAB}"], [194914, 1, "\u7BC6"], [194915, 1, "\u7BC9"], [194916, 1, "\u4227"], [194917, 1, "\u{25C80}"], [194918, 1, "\u7CD2"], [194919, 1, "\u42A0"], [194920, 1, "\u7CE8"], [194921, 1, "\u7CE3"], [194922, 1, "\u7D00"], [194923, 1, "\u{25F86}"], [194924, 1, "\u7D63"], [194925, 1, "\u4301"], [194926, 1, "\u7DC7"], [194927, 1, "\u7E02"], [194928, 1, "\u7E45"], [194929, 1, "\u4334"], [194930, 1, "\u{26228}"], [194931, 1, "\u{26247}"], [194932, 1, "\u4359"], [194933, 1, "\u{262D9}"], [194934, 1, "\u7F7A"], [194935, 1, "\u{2633E}"], [194936, 1, "\u7F95"], [194937, 1, "\u7FFA"], [194938, 1, "\u8005"], [194939, 1, "\u{264DA}"], [194940, 1, "\u{26523}"], [194941, 1, "\u8060"], [194942, 1, "\u{265A8}"], [194943, 1, "\u8070"], [194944, 1, "\u{2335F}"], [194945, 1, "\u43D5"], [194946, 1, "\u80B2"], [194947, 1, "\u8103"], [194948, 1, "\u440B"], [194949, 1, "\u813E"], [194950, 1, "\u5AB5"], [194951, 1, "\u{267A7}"], [194952, 1, "\u{267B5}"], [194953, 1, "\u{23393}"], [194954, 1, "\u{2339C}"], [194955, 1, "\u8201"], [194956, 1, "\u8204"], [194957, 1, "\u8F9E"], [194958, 1, "\u446B"], [194959, 1, "\u8291"], [194960, 1, "\u828B"], [194961, 1, "\u829D"], [194962, 1, "\u52B3"], [194963, 1, "\u82B1"], [194964, 1, "\u82B3"], [194965, 1, "\u82BD"], [194966, 1, "\u82E6"], [194967, 1, "\u{26B3C}"], [194968, 1, "\u82E5"], [194969, 1, "\u831D"], [194970, 1, "\u8363"], [194971, 1, "\u83AD"], [194972, 1, "\u8323"], [194973, 1, "\u83BD"], [194974, 1, "\u83E7"], [194975, 1, "\u8457"], [194976, 1, "\u8353"], [194977, 1, "\u83CA"], [194978, 1, "\u83CC"], [194979, 1, "\u83DC"], [194980, 1, "\u{26C36}"], [194981, 1, "\u{26D6B}"], [194982, 1, "\u{26CD5}"], [194983, 1, "\u452B"], [194984, 1, "\u84F1"], [194985, 1, "\u84F3"], [194986, 1, "\u8516"], [194987, 1, "\u{273CA}"], [194988, 1, "\u8564"], [194989, 1, "\u{26F2C}"], [194990, 1, "\u455D"], [194991, 1, "\u4561"], [194992, 1, "\u{26FB1}"], [194993, 1, "\u{270D2}"], [194994, 1, "\u456B"], [194995, 1, "\u8650"], [194996, 1, "\u865C"], [194997, 1, "\u8667"], [194998, 1, "\u8669"], [194999, 1, "\u86A9"], [195e3, 1, "\u8688"], [195001, 1, "\u870E"], [195002, 1, "\u86E2"], [195003, 1, "\u8779"], [195004, 1, "\u8728"], [195005, 1, "\u876B"], [195006, 1, "\u8786"], [195007, 1, "\u45D7"], [195008, 1, "\u87E1"], [195009, 1, "\u8801"], [195010, 1, "\u45F9"], [195011, 1, "\u8860"], [195012, 1, "\u8863"], [195013, 1, "\u{27667}"], [195014, 1, "\u88D7"], [195015, 1, "\u88DE"], [195016, 1, "\u4635"], [195017, 1, "\u88FA"], [195018, 1, "\u34BB"], [195019, 1, "\u{278AE}"], [195020, 1, "\u{27966}"], [195021, 1, "\u46BE"], [195022, 1, "\u46C7"], [195023, 1, "\u8AA0"], [195024, 1, "\u8AED"], [195025, 1, "\u8B8A"], [195026, 1, "\u8C55"], [195027, 1, "\u{27CA8}"], [195028, 1, "\u8CAB"], [195029, 1, "\u8CC1"], [195030, 1, "\u8D1B"], [195031, 1, "\u8D77"], [195032, 1, "\u{27F2F}"], [195033, 1, "\u{20804}"], [195034, 1, "\u8DCB"], [195035, 1, "\u8DBC"], [195036, 1, "\u8DF0"], [195037, 1, "\u{208DE}"], [195038, 1, "\u8ED4"], [195039, 1, "\u8F38"], [195040, 1, "\u{285D2}"], [195041, 1, "\u{285ED}"], [195042, 1, "\u9094"], [195043, 1, "\u90F1"], [195044, 1, "\u9111"], [195045, 1, "\u{2872E}"], [195046, 1, "\u911B"], [195047, 1, "\u9238"], [195048, 1, "\u92D7"], [195049, 1, "\u92D8"], [195050, 1, "\u927C"], [195051, 1, "\u93F9"], [195052, 1, "\u9415"], [195053, 1, "\u{28BFA}"], [195054, 1, "\u958B"], [195055, 1, "\u4995"], [195056, 1, "\u95B7"], [195057, 1, "\u{28D77}"], [195058, 1, "\u49E6"], [195059, 1, "\u96C3"], [195060, 1, "\u5DB2"], [195061, 1, "\u9723"], [195062, 1, "\u{29145}"], [195063, 1, "\u{2921A}"], [195064, 1, "\u4A6E"], [195065, 1, "\u4A76"], [195066, 1, "\u97E0"], [195067, 1, "\u{2940A}"], [195068, 1, "\u4AB2"], [195069, 1, "\u{29496}"], [[195070, 195071], 1, "\u980B"], [195072, 1, "\u9829"], [195073, 1, "\u{295B6}"], [195074, 1, "\u98E2"], [195075, 1, "\u4B33"], [195076, 1, "\u9929"], [195077, 1, "\u99A7"], [195078, 1, "\u99C2"], [195079, 1, "\u99FE"], [195080, 1, "\u4BCE"], [195081, 1, "\u{29B30}"], [195082, 1, "\u9B12"], [195083, 1, "\u9C40"], [195084, 1, "\u9CFD"], [195085, 1, "\u4CCE"], [195086, 1, "\u4CED"], [195087, 1, "\u9D67"], [195088, 1, "\u{2A0CE}"], [195089, 1, "\u4CF8"], [195090, 1, "\u{2A105}"], [195091, 1, "\u{2A20E}"], [195092, 1, "\u{2A291}"], [195093, 1, "\u9EBB"], [195094, 1, "\u4D56"], [195095, 1, "\u9EF9"], [195096, 1, "\u9EFE"], [195097, 1, "\u9F05"], [195098, 1, "\u9F0F"], [195099, 1, "\u9F16"], [195100, 1, "\u9F3B"], [195101, 1, "\u{2A600}"], [[195102, 196605], 3], [[196606, 196607], 3], [[196608, 201546], 2], [[201547, 201551], 3], [[201552, 205743], 2], [[205744, 262141], 3], [[262142, 262143], 3], [[262144, 327677], 3], [[327678, 327679], 3], [[327680, 393213], 3], [[393214, 393215], 3], [[393216, 458749], 3], [[458750, 458751], 3], [[458752, 524285], 3], [[524286, 524287], 3], [[524288, 589821], 3], [[589822, 589823], 3], [[589824, 655357], 3], [[655358, 655359], 3], [[655360, 720893], 3], [[720894, 720895], 3], [[720896, 786429], 3], [[786430, 786431], 3], [[786432, 851965], 3], [[851966, 851967], 3], [[851968, 917501], 3], [[917502, 917503], 3], [917504, 3], [917505, 3], [[917506, 917535], 3], [[917536, 917631], 3], [[917632, 917759], 3], [[917760, 917999], 7], [[918e3, 983037], 3], [[983038, 983039], 3], [[983040, 1048573], 3], [[1048574, 1048575], 3], [[1048576, 1114109], 3], [[1114110, 1114111], 3]]; + } +}); + +// node_modules/tr46/lib/statusMapping.js +var require_statusMapping = __commonJS({ + "node_modules/tr46/lib/statusMapping.js"(exports2, module2) { + "use strict"; + module2.exports.STATUS_MAPPING = { + mapped: 1, + valid: 2, + disallowed: 3, + deviation: 6, + ignored: 7 + }; + } +}); + +// node_modules/tr46/index.js +var require_tr46 = __commonJS({ + "node_modules/tr46/index.js"(exports2, module2) { + "use strict"; + var punycode = require_punycode(); + var regexes = require_regexes(); + var mappingTable = require_mappingTable(); + var { STATUS_MAPPING } = require_statusMapping(); + function containsNonASCII(str) { + return /[^\x00-\x7F]/u.test(str); + } + function findStatus(val) { + let start = 0; + let end = mappingTable.length - 1; + while (start <= end) { + const mid = Math.floor((start + end) / 2); + const target = mappingTable[mid]; + const min = Array.isArray(target[0]) ? target[0][0] : target[0]; + const max = Array.isArray(target[0]) ? target[0][1] : target[0]; + if (min <= val && max >= val) { + return target.slice(1); + } else if (min > val) { + end = mid - 1; + } else { + start = mid + 1; + } + } + return null; + } + function mapChars(domainName, { transitionalProcessing }) { + let processed = ""; + for (const ch of domainName) { + const [status, mapping] = findStatus(ch.codePointAt(0)); + switch (status) { + case STATUS_MAPPING.disallowed: + processed += ch; + break; + case STATUS_MAPPING.ignored: + break; + case STATUS_MAPPING.mapped: + if (transitionalProcessing && ch === "\u1E9E") { + processed += "ss"; + } else { + processed += mapping; + } + break; + case STATUS_MAPPING.deviation: + if (transitionalProcessing) { + processed += mapping; + } else { + processed += ch; + } + break; + case STATUS_MAPPING.valid: + processed += ch; + break; + } + } + return processed; + } + function validateLabel(label, { + checkHyphens, + checkBidi, + checkJoiners, + transitionalProcessing, + useSTD3ASCIIRules, + isBidi + }) { + if (label.length === 0) { + return true; + } + if (label.normalize("NFC") !== label) { + return false; + } + const codePoints = Array.from(label); + if (checkHyphens) { + if (codePoints[2] === "-" && codePoints[3] === "-" || (label.startsWith("-") || label.endsWith("-"))) { + return false; + } + } + if (!checkHyphens) { + if (label.startsWith("xn--")) { + return false; + } + } + if (label.includes(".")) { + return false; + } + if (regexes.combiningMarks.test(codePoints[0])) { + return false; + } + for (const ch of codePoints) { + const codePoint = ch.codePointAt(0); + const [status] = findStatus(codePoint); + if (transitionalProcessing) { + if (status !== STATUS_MAPPING.valid) { + return false; + } + } else if (status !== STATUS_MAPPING.valid && status !== STATUS_MAPPING.deviation) { + return false; + } + if (useSTD3ASCIIRules && codePoint <= 127) { + if (!/^(?:[a-z]|[0-9]|-)$/u.test(ch)) { + return false; + } + } + } + if (checkJoiners) { + let last = 0; + for (const [i, ch] of codePoints.entries()) { + if (ch === "\u200C" || ch === "\u200D") { + if (i > 0) { + if (regexes.combiningClassVirama.test(codePoints[i - 1])) { + continue; + } + if (ch === "\u200C") { + const next = codePoints.indexOf("\u200C", i + 1); + const test = next < 0 ? codePoints.slice(last) : codePoints.slice(last, next); + if (regexes.validZWNJ.test(test.join(""))) { + last = i + 1; + continue; + } + } + } + return false; + } + } + } + if (checkBidi && isBidi) { + let rtl; + if (regexes.bidiS1LTR.test(codePoints[0])) { + rtl = false; + } else if (regexes.bidiS1RTL.test(codePoints[0])) { + rtl = true; + } else { + return false; + } + if (rtl) { + if (!regexes.bidiS2.test(label) || !regexes.bidiS3.test(label) || regexes.bidiS4EN.test(label) && regexes.bidiS4AN.test(label)) { + return false; + } + } else if (!regexes.bidiS5.test(label) || !regexes.bidiS6.test(label)) { + return false; + } + } + return true; + } + function isBidiDomain(labels) { + const domain = labels.map((label) => { + if (label.startsWith("xn--")) { + try { + return punycode.decode(label.substring(4)); + } catch { + return ""; + } + } + return label; + }).join("."); + return regexes.bidiDomain.test(domain); + } + function processing(domainName, options) { + let string = mapChars(domainName, options); + string = string.normalize("NFC"); + const labels = string.split("."); + const isBidi = isBidiDomain(labels); + let error = false; + for (const [i, origLabel] of labels.entries()) { + let label = origLabel; + let transitionalProcessingForThisLabel = options.transitionalProcessing; + if (label.startsWith("xn--")) { + if (containsNonASCII(label)) { + error = true; + continue; + } + try { + label = punycode.decode(label.substring(4)); + } catch { + if (!options.ignoreInvalidPunycode) { + error = true; + continue; + } + } + labels[i] = label; + if (label === "" || !containsNonASCII(label)) { + error = true; + } + transitionalProcessingForThisLabel = false; + } + if (error) { + continue; + } + const validation = validateLabel(label, { + ...options, + transitionalProcessing: transitionalProcessingForThisLabel, + isBidi + }); + if (!validation) { + error = true; + } + } + return { + string: labels.join("."), + error + }; + } + function toASCII(domainName, { + checkHyphens = false, + checkBidi = false, + checkJoiners = false, + useSTD3ASCIIRules = false, + verifyDNSLength = false, + transitionalProcessing = false, + ignoreInvalidPunycode = false + } = {}) { + const result = processing(domainName, { + checkHyphens, + checkBidi, + checkJoiners, + useSTD3ASCIIRules, + transitionalProcessing, + ignoreInvalidPunycode + }); + let labels = result.string.split("."); + labels = labels.map((l) => { + if (containsNonASCII(l)) { + try { + return `xn--${punycode.encode(l)}`; + } catch { + result.error = true; + } + } + return l; + }); + if (verifyDNSLength) { + const total = labels.join(".").length; + if (total > 253 || total === 0) { + result.error = true; + } + for (let i = 0; i < labels.length; ++i) { + if (labels[i].length > 63 || labels[i].length === 0) { + result.error = true; + break; + } + } + } + if (result.error) { + return null; + } + return labels.join("."); + } + function toUnicode(domainName, { + checkHyphens = false, + checkBidi = false, + checkJoiners = false, + useSTD3ASCIIRules = false, + transitionalProcessing = false, + ignoreInvalidPunycode = false + } = {}) { + const result = processing(domainName, { + checkHyphens, + checkBidi, + checkJoiners, + useSTD3ASCIIRules, + transitionalProcessing, + ignoreInvalidPunycode + }); + return { + domain: result.string, + error: result.error + }; + } + module2.exports = { + toASCII, + toUnicode + }; + } +}); + +// node_modules/whatwg-url/lib/infra.js +var require_infra = __commonJS({ + "node_modules/whatwg-url/lib/infra.js"(exports2, module2) { + "use strict"; + function isASCIIDigit(c) { + return c >= 48 && c <= 57; + } + function isASCIIAlpha(c) { + return c >= 65 && c <= 90 || c >= 97 && c <= 122; + } + function isASCIIAlphanumeric(c) { + return isASCIIAlpha(c) || isASCIIDigit(c); + } + function isASCIIHex(c) { + return isASCIIDigit(c) || c >= 65 && c <= 70 || c >= 97 && c <= 102; + } + module2.exports = { + isASCIIDigit, + isASCIIAlpha, + isASCIIAlphanumeric, + isASCIIHex + }; + } +}); + +// node_modules/whatwg-url/lib/encoding.js +var require_encoding = __commonJS({ + "node_modules/whatwg-url/lib/encoding.js"(exports2, module2) { + "use strict"; + var utf8Encoder = new TextEncoder(); + var utf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true }); + function utf8Encode(string) { + return utf8Encoder.encode(string); + } + function utf8DecodeWithoutBOM(bytes) { + return utf8Decoder.decode(bytes); + } + module2.exports = { + utf8Encode, + utf8DecodeWithoutBOM + }; + } +}); + +// node_modules/whatwg-url/lib/percent-encoding.js +var require_percent_encoding = __commonJS({ + "node_modules/whatwg-url/lib/percent-encoding.js"(exports2, module2) { + "use strict"; + var { isASCIIHex } = require_infra(); + var { utf8Encode } = require_encoding(); + function p(char) { + return char.codePointAt(0); + } + function percentEncode(c) { + let hex = c.toString(16).toUpperCase(); + if (hex.length === 1) { + hex = `0${hex}`; + } + return `%${hex}`; + } + function percentDecodeBytes(input) { + const output = new Uint8Array(input.byteLength); + let outputIndex = 0; + for (let i = 0; i < input.byteLength; ++i) { + const byte = input[i]; + if (byte !== 37) { + output[outputIndex++] = byte; + } else if (byte === 37 && (!isASCIIHex(input[i + 1]) || !isASCIIHex(input[i + 2]))) { + output[outputIndex++] = byte; + } else { + const bytePoint = parseInt(String.fromCodePoint(input[i + 1], input[i + 2]), 16); + output[outputIndex++] = bytePoint; + i += 2; + } + } + return output.slice(0, outputIndex); + } + function percentDecodeString(input) { + const bytes = utf8Encode(input); + return percentDecodeBytes(bytes); + } + function isC0ControlPercentEncode(c) { + return c <= 31 || c > 126; + } + var extraFragmentPercentEncodeSet = /* @__PURE__ */ new Set([p(" "), p('"'), p("<"), p(">"), p("`")]); + function isFragmentPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraFragmentPercentEncodeSet.has(c); + } + var extraQueryPercentEncodeSet = /* @__PURE__ */ new Set([p(" "), p('"'), p("#"), p("<"), p(">")]); + function isQueryPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraQueryPercentEncodeSet.has(c); + } + function isSpecialQueryPercentEncode(c) { + return isQueryPercentEncode(c) || c === p("'"); + } + var extraPathPercentEncodeSet = /* @__PURE__ */ new Set([p("?"), p("`"), p("{"), p("}"), p("^")]); + function isPathPercentEncode(c) { + return isQueryPercentEncode(c) || extraPathPercentEncodeSet.has(c); + } + var extraUserinfoPercentEncodeSet = /* @__PURE__ */ new Set([p("/"), p(":"), p(";"), p("="), p("@"), p("["), p("\\"), p("]"), p("|")]); + function isUserinfoPercentEncode(c) { + return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c); + } + var extraComponentPercentEncodeSet = /* @__PURE__ */ new Set([p("$"), p("%"), p("&"), p("+"), p(",")]); + function isComponentPercentEncode(c) { + return isUserinfoPercentEncode(c) || extraComponentPercentEncodeSet.has(c); + } + var extraURLEncodedPercentEncodeSet = /* @__PURE__ */ new Set([p("!"), p("'"), p("("), p(")"), p("~")]); + function isURLEncodedPercentEncode(c) { + return isComponentPercentEncode(c) || extraURLEncodedPercentEncodeSet.has(c); + } + function utf8PercentEncodeCodePointInternal(codePoint, percentEncodePredicate) { + const bytes = utf8Encode(codePoint); + let output = ""; + for (const byte of bytes) { + if (!percentEncodePredicate(byte)) { + output += String.fromCharCode(byte); + } else { + output += percentEncode(byte); + } + } + return output; + } + function utf8PercentEncodeCodePoint(codePoint, percentEncodePredicate) { + return utf8PercentEncodeCodePointInternal(String.fromCodePoint(codePoint), percentEncodePredicate); + } + function utf8PercentEncodeString(input, percentEncodePredicate, spaceAsPlus = false) { + let output = ""; + for (const codePoint of input) { + if (spaceAsPlus && codePoint === " ") { + output += "+"; + } else { + output += utf8PercentEncodeCodePointInternal(codePoint, percentEncodePredicate); + } + } + return output; + } + module2.exports = { + isC0ControlPercentEncode, + isFragmentPercentEncode, + isQueryPercentEncode, + isSpecialQueryPercentEncode, + isPathPercentEncode, + isUserinfoPercentEncode, + isURLEncodedPercentEncode, + percentDecodeString, + percentDecodeBytes, + utf8PercentEncodeString, + utf8PercentEncodeCodePoint + }; + } +}); + +// node_modules/whatwg-url/lib/url-state-machine.js +var require_url_state_machine = __commonJS({ + "node_modules/whatwg-url/lib/url-state-machine.js"(exports2, module2) { + "use strict"; + var tr46 = require_tr46(); + var infra = require_infra(); + var { utf8DecodeWithoutBOM } = require_encoding(); + var { + percentDecodeString, + utf8PercentEncodeCodePoint, + utf8PercentEncodeString, + isC0ControlPercentEncode, + isFragmentPercentEncode, + isQueryPercentEncode, + isSpecialQueryPercentEncode, + isPathPercentEncode, + isUserinfoPercentEncode + } = require_percent_encoding(); + function p(char) { + return char.codePointAt(0); + } + var specialSchemes = { + ftp: 21, + file: null, + http: 80, + https: 443, + ws: 80, + wss: 443 + }; + var failure = /* @__PURE__ */ Symbol("failure"); + function countSymbols(str) { + return [...str].length; + } + function at(input, idx) { + const c = input[idx]; + return isNaN(c) ? void 0 : String.fromCodePoint(c); + } + function isSingleDot(buffer) { + return buffer === "." || buffer.toLowerCase() === "%2e"; + } + function isDoubleDot(buffer) { + buffer = buffer.toLowerCase(); + return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e"; + } + function isWindowsDriveLetterCodePoints(cp1, cp2) { + return infra.isASCIIAlpha(cp1) && (cp2 === p(":") || cp2 === p("|")); + } + function isWindowsDriveLetterString(string) { + return string.length === 2 && infra.isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|"); + } + function isNormalizedWindowsDriveLetterString(string) { + return string.length === 2 && infra.isASCIIAlpha(string.codePointAt(0)) && string[1] === ":"; + } + function containsForbiddenHostCodePoint(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|<|>|\?|@|\[|\\|\]|\^|\|/u) !== -1; + } + function containsForbiddenDomainCodePoint(string) { + return containsForbiddenHostCodePoint(string) || string.search(/[\u0000-\u001F]|%|\u007F/u) !== -1; + } + function isSpecialScheme(scheme) { + return specialSchemes[scheme] !== void 0; + } + function isSpecial(url) { + return isSpecialScheme(url.scheme); + } + function isNotSpecial(url) { + return !isSpecialScheme(url.scheme); + } + function defaultPort(scheme) { + return specialSchemes[scheme]; + } + function parseIPv4Number(input) { + if (input === "") { + return failure; + } + let R = 10; + if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") { + input = input.substring(2); + R = 16; + } else if (input.length >= 2 && input.charAt(0) === "0") { + input = input.substring(1); + R = 8; + } + if (input === "") { + return 0; + } + let regex = /[^0-7]/u; + if (R === 10) { + regex = /[^0-9]/u; + } + if (R === 16) { + regex = /[^0-9A-Fa-f]/u; + } + if (regex.test(input)) { + return failure; + } + return parseInt(input, R); + } + function parseIPv4(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length > 1) { + parts.pop(); + } + } + if (parts.length > 4) { + return failure; + } + const numbers = []; + for (const part of parts) { + const n = parseIPv4Number(part); + if (n === failure) { + return failure; + } + numbers.push(n); + } + for (let i = 0; i < numbers.length - 1; ++i) { + if (numbers[i] > 255) { + return failure; + } + } + if (numbers[numbers.length - 1] >= 256 ** (5 - numbers.length)) { + return failure; + } + let ipv4 = numbers.pop(); + let counter = 0; + for (const n of numbers) { + ipv4 += n * 256 ** (3 - counter); + ++counter; + } + return ipv4; + } + function serializeIPv4(address) { + let output = ""; + let n = address; + for (let i = 1; i <= 4; ++i) { + output = String(n % 256) + output; + if (i !== 4) { + output = `.${output}`; + } + n = Math.floor(n / 256); + } + return output; + } + function parseIPv6(input) { + const address = [0, 0, 0, 0, 0, 0, 0, 0]; + let pieceIndex = 0; + let compress = null; + let pointer = 0; + input = Array.from(input, (c) => c.codePointAt(0)); + if (input[pointer] === p(":")) { + if (input[pointer + 1] !== p(":")) { + return failure; + } + pointer += 2; + ++pieceIndex; + compress = pieceIndex; + } + while (pointer < input.length) { + if (pieceIndex === 8) { + return failure; + } + if (input[pointer] === p(":")) { + if (compress !== null) { + return failure; + } + ++pointer; + ++pieceIndex; + compress = pieceIndex; + continue; + } + let value = 0; + let length = 0; + while (length < 4 && infra.isASCIIHex(input[pointer])) { + value = value * 16 + parseInt(at(input, pointer), 16); + ++pointer; + ++length; + } + if (input[pointer] === p(".")) { + if (length === 0) { + return failure; + } + pointer -= length; + if (pieceIndex > 6) { + return failure; + } + let numbersSeen = 0; + while (input[pointer] !== void 0) { + let ipv4Piece = null; + if (numbersSeen > 0) { + if (input[pointer] === p(".") && numbersSeen < 4) { + ++pointer; + } else { + return failure; + } + } + if (!infra.isASCIIDigit(input[pointer])) { + return failure; + } + while (infra.isASCIIDigit(input[pointer])) { + const number = parseInt(at(input, pointer)); + if (ipv4Piece === null) { + ipv4Piece = number; + } else if (ipv4Piece === 0) { + return failure; + } else { + ipv4Piece = ipv4Piece * 10 + number; + } + if (ipv4Piece > 255) { + return failure; + } + ++pointer; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + ++numbersSeen; + if (numbersSeen === 2 || numbersSeen === 4) { + ++pieceIndex; + } + } + if (numbersSeen !== 4) { + return failure; + } + break; + } else if (input[pointer] === p(":")) { + ++pointer; + if (input[pointer] === void 0) { + return failure; + } + } else if (input[pointer] !== void 0) { + return failure; + } + address[pieceIndex] = value; + ++pieceIndex; + } + if (compress !== null) { + let swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + const temp = address[compress + swaps - 1]; + address[compress + swaps - 1] = address[pieceIndex]; + address[pieceIndex] = temp; + --pieceIndex; + --swaps; + } + } else if (compress === null && pieceIndex !== 8) { + return failure; + } + return address; + } + function serializeIPv6(address) { + let output = ""; + const compress = findTheIPv6AddressCompressedPieceIndex(address); + let ignore0 = false; + for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) { + if (ignore0 && address[pieceIndex] === 0) { + continue; + } else if (ignore0) { + ignore0 = false; + } + if (compress === pieceIndex) { + const separator = pieceIndex === 0 ? "::" : ":"; + output += separator; + ignore0 = true; + continue; + } + output += address[pieceIndex].toString(16); + if (pieceIndex !== 7) { + output += ":"; + } + } + return output; + } + function parseHost(input, isOpaque = false) { + if (input[0] === "[") { + if (input[input.length - 1] !== "]") { + return failure; + } + return parseIPv6(input.substring(1, input.length - 1)); + } + if (isOpaque) { + return parseOpaqueHost(input); + } + const domain = utf8DecodeWithoutBOM(percentDecodeString(input)); + const asciiDomain = domainToASCII(domain); + if (asciiDomain === failure) { + return failure; + } + if (endsInANumber(asciiDomain)) { + return parseIPv4(asciiDomain); + } + return asciiDomain; + } + function endsInANumber(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length === 1) { + return false; + } + parts.pop(); + } + const last = parts[parts.length - 1]; + if (parseIPv4Number(last) !== failure) { + return true; + } + if (/^[0-9]+$/u.test(last)) { + return true; + } + return false; + } + function parseOpaqueHost(input) { + if (containsForbiddenHostCodePoint(input)) { + return failure; + } + return utf8PercentEncodeString(input, isC0ControlPercentEncode); + } + function findTheIPv6AddressCompressedPieceIndex(address) { + let longestIndex = null; + let longestSize = 1; + let foundIndex = null; + let foundSize = 0; + for (let pieceIndex = 0; pieceIndex < address.length; ++pieceIndex) { + if (address[pieceIndex] !== 0) { + if (foundSize > longestSize) { + longestIndex = foundIndex; + longestSize = foundSize; + } + foundIndex = null; + foundSize = 0; + } else { + if (foundIndex === null) { + foundIndex = pieceIndex; + } + ++foundSize; + } + } + if (foundSize > longestSize) { + return foundIndex; + } + return longestIndex; + } + function serializeHost(host) { + if (typeof host === "number") { + return serializeIPv4(host); + } + if (host instanceof Array) { + return `[${serializeIPv6(host)}]`; + } + return host; + } + function domainToASCII(domain, beStrict = false) { + const result = tr46.toASCII(domain, { + checkHyphens: beStrict, + checkBidi: true, + checkJoiners: true, + useSTD3ASCIIRules: beStrict, + transitionalProcessing: false, + verifyDNSLength: beStrict, + ignoreInvalidPunycode: false + }); + if (result === null) { + return failure; + } + if (!beStrict) { + if (result === "") { + return failure; + } + if (containsForbiddenDomainCodePoint(result)) { + return failure; + } + } + return result; + } + function trimControlChars(string) { + let start = 0; + let end = string.length; + for (; start < end; ++start) { + if (string.charCodeAt(start) > 32) { + break; + } + } + for (; end > start; --end) { + if (string.charCodeAt(end - 1) > 32) { + break; + } + } + return string.substring(start, end); + } + function trimTabAndNewline(url) { + return url.replace(/\u0009|\u000A|\u000D/ug, ""); + } + function shortenPath(url) { + const { path } = url; + if (path.length === 0) { + return; + } + if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) { + return; + } + path.pop(); + } + function includesCredentials(url) { + return url.username !== "" || url.password !== ""; + } + function cannotHaveAUsernamePasswordPort(url) { + return url.host === null || url.host === "" || url.scheme === "file"; + } + function hasAnOpaquePath(url) { + return typeof url.path === "string"; + } + function isNormalizedWindowsDriveLetter(string) { + return /^[A-Za-z]:$/u.test(string); + } + function URLStateMachine(input, base, encodingOverride, url, stateOverride) { + this.pointer = 0; + this.input = input; + this.base = base || null; + this.encodingOverride = encodingOverride || "utf-8"; + this.stateOverride = stateOverride; + this.url = url; + this.failure = false; + this.parseError = false; + if (!this.url) { + this.url = { + scheme: "", + username: "", + password: "", + host: null, + port: null, + path: [], + query: null, + fragment: null + }; + const res2 = trimControlChars(this.input); + if (res2 !== this.input) { + this.parseError = true; + } + this.input = res2; + } + const res = trimTabAndNewline(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + this.state = stateOverride || "scheme start"; + this.buffer = ""; + this.atFlag = false; + this.arrFlag = false; + this.passwordTokenSeenFlag = false; + this.input = Array.from(this.input, (c) => c.codePointAt(0)); + for (; this.pointer <= this.input.length; ++this.pointer) { + const c = this.input[this.pointer]; + const cStr = isNaN(c) ? void 0 : String.fromCodePoint(c); + const ret = this[`parse ${this.state}`](c, cStr); + if (!ret) { + break; + } else if (ret === failure) { + this.failure = true; + break; + } + } + } + URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) { + if (infra.isASCIIAlpha(c)) { + this.buffer += cStr.toLowerCase(); + this.state = "scheme"; + } else if (!this.stateOverride) { + this.state = "no scheme"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) { + if (infra.isASCIIAlphanumeric(c) || c === p("+") || c === p("-") || c === p(".")) { + this.buffer += cStr.toLowerCase(); + } else if (c === p(":")) { + if (this.stateOverride) { + if (isSpecial(this.url) && !isSpecialScheme(this.buffer)) { + return false; + } + if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) { + return false; + } + if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") { + return false; + } + if (this.url.scheme === "file" && this.url.host === "") { + return false; + } + } + this.url.scheme = this.buffer; + if (this.stateOverride) { + if (this.url.port === defaultPort(this.url.scheme)) { + this.url.port = null; + } + return false; + } + this.buffer = ""; + if (this.url.scheme === "file") { + if (this.input[this.pointer + 1] !== p("/") || this.input[this.pointer + 2] !== p("/")) { + this.parseError = true; + } + this.state = "file"; + } else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme) { + this.state = "special relative or authority"; + } else if (isSpecial(this.url)) { + this.state = "special authority slashes"; + } else if (this.input[this.pointer + 1] === p("/")) { + this.state = "path or authority"; + ++this.pointer; + } else { + this.url.path = ""; + this.state = "opaque path"; + } + } else if (!this.stateOverride) { + this.buffer = ""; + this.state = "no scheme"; + this.pointer = -1; + } else { + this.parseError = true; + return failure; + } + return true; + }; + URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) { + if (this.base === null || hasAnOpaquePath(this.base) && c !== p("#")) { + return failure; + } else if (hasAnOpaquePath(this.base) && c === p("#")) { + this.url.scheme = this.base.scheme; + this.url.path = this.base.path; + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else if (this.base.scheme === "file") { + this.state = "file"; + --this.pointer; + } else { + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) { + if (c === p("/") && this.input[this.pointer + 1] === p("/")) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "relative"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) { + if (c === p("/")) { + this.state = "authority"; + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse relative"] = function parseRelative(c) { + this.url.scheme = this.base.scheme; + if (c === p("/")) { + this.state = "relative slash"; + } else if (isSpecial(this.url) && c === p("\\")) { + this.parseError = true; + this.state = "relative slash"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + if (c === p("?")) { + this.url.query = ""; + this.state = "query"; + } else if (c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (!isNaN(c)) { + this.url.query = null; + this.url.path.pop(); + this.state = "path"; + --this.pointer; + } + } + return true; + }; + URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) { + if (isSpecial(this.url) && (c === p("/") || c === p("\\"))) { + if (c === p("\\")) { + this.parseError = true; + } + this.state = "special authority ignore slashes"; + } else if (c === p("/")) { + this.state = "authority"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) { + if (c === p("/") && this.input[this.pointer + 1] === p("/")) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "special authority ignore slashes"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) { + if (c !== p("/") && c !== p("\\")) { + this.state = "authority"; + --this.pointer; + } else { + this.parseError = true; + } + return true; + }; + URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) { + if (c === p("@")) { + this.parseError = true; + if (this.atFlag) { + this.buffer = `%40${this.buffer}`; + } + this.atFlag = true; + const len = countSymbols(this.buffer); + for (let pointer = 0; pointer < len; ++pointer) { + const codePoint = this.buffer.codePointAt(pointer); + if (codePoint === p(":") && !this.passwordTokenSeenFlag) { + this.passwordTokenSeenFlag = true; + continue; + } + const encodedCodePoints = utf8PercentEncodeCodePoint(codePoint, isUserinfoPercentEncode); + if (this.passwordTokenSeenFlag) { + this.url.password += encodedCodePoints; + } else { + this.url.username += encodedCodePoints; + } + } + this.buffer = ""; + } else if (isNaN(c) || c === p("/") || c === p("?") || c === p("#") || isSpecial(this.url) && c === p("\\")) { + if (this.atFlag && this.buffer === "") { + this.parseError = true; + return failure; + } + this.pointer -= countSymbols(this.buffer) + 1; + this.buffer = ""; + this.state = "host"; + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse hostname"] = URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) { + if (this.stateOverride && this.url.scheme === "file") { + --this.pointer; + this.state = "file host"; + } else if (c === p(":") && !this.arrFlag) { + if (this.buffer === "") { + this.parseError = true; + return failure; + } + if (this.stateOverride === "hostname") { + return false; + } + const host = parseHost(this.buffer, isNotSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "port"; + } else if (isNaN(c) || c === p("/") || c === p("?") || c === p("#") || isSpecial(this.url) && c === p("\\")) { + --this.pointer; + if (isSpecial(this.url) && this.buffer === "") { + this.parseError = true; + return failure; + } else if (this.stateOverride && this.buffer === "" && (includesCredentials(this.url) || this.url.port !== null)) { + this.parseError = true; + return false; + } + const host = parseHost(this.buffer, isNotSpecial(this.url)); + if (host === failure) { + return failure; + } + this.url.host = host; + this.buffer = ""; + this.state = "path start"; + if (this.stateOverride) { + return false; + } + } else { + if (c === p("[")) { + this.arrFlag = true; + } else if (c === p("]")) { + this.arrFlag = false; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) { + if (infra.isASCIIDigit(c)) { + this.buffer += cStr; + } else if (isNaN(c) || c === p("/") || c === p("?") || c === p("#") || isSpecial(this.url) && c === p("\\") || this.stateOverride) { + if (this.buffer !== "") { + const port = parseInt(this.buffer); + if (port > 2 ** 16 - 1) { + this.parseError = true; + return failure; + } + this.url.port = port === defaultPort(this.url.scheme) ? null : port; + this.buffer = ""; + } + if (this.stateOverride) { + return false; + } + this.state = "path start"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + return true; + }; + var fileOtherwiseCodePoints = /* @__PURE__ */ new Set([p("/"), p("\\"), p("?"), p("#")]); + function startsWithWindowsDriveLetter(input, pointer) { + const length = input.length - pointer; + return length >= 2 && isWindowsDriveLetterCodePoints(input[pointer], input[pointer + 1]) && (length === 2 || fileOtherwiseCodePoints.has(input[pointer + 2])); + } + URLStateMachine.prototype["parse file"] = function parseFile(c) { + this.url.scheme = "file"; + this.url.host = ""; + if (c === p("/") || c === p("\\")) { + if (c === p("\\")) { + this.parseError = true; + } + this.state = "file slash"; + } else if (this.base !== null && this.base.scheme === "file") { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + if (c === p("?")) { + this.url.query = ""; + this.state = "query"; + } else if (c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (!isNaN(c)) { + this.url.query = null; + if (!startsWithWindowsDriveLetter(this.input, this.pointer)) { + shortenPath(this.url); + } else { + this.parseError = true; + this.url.path = []; + } + this.state = "path"; + --this.pointer; + } + } else { + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) { + if (c === p("/") || c === p("\\")) { + if (c === p("\\")) { + this.parseError = true; + } + this.state = "file host"; + } else { + if (this.base !== null && this.base.scheme === "file") { + if (!startsWithWindowsDriveLetter(this.input, this.pointer) && isNormalizedWindowsDriveLetterString(this.base.path[0])) { + this.url.path.push(this.base.path[0]); + } + this.url.host = this.base.host; + } + this.state = "path"; + --this.pointer; + } + return true; + }; + URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) { + if (isNaN(c) || c === p("/") || c === p("\\") || c === p("?") || c === p("#")) { + --this.pointer; + if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) { + this.parseError = true; + this.state = "path"; + } else if (this.buffer === "") { + this.url.host = ""; + if (this.stateOverride) { + return false; + } + this.state = "path start"; + } else { + let host = parseHost(this.buffer, isNotSpecial(this.url)); + if (host === failure) { + return failure; + } + if (host === "localhost") { + host = ""; + } + this.url.host = host; + if (this.stateOverride) { + return false; + } + this.buffer = ""; + this.state = "path start"; + } + } else { + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse path start"] = function parsePathStart(c) { + if (isSpecial(this.url)) { + if (c === p("\\")) { + this.parseError = true; + } + this.state = "path"; + if (c !== p("/") && c !== p("\\")) { + --this.pointer; + } + } else if (!this.stateOverride && c === p("?")) { + this.url.query = ""; + this.state = "query"; + } else if (!this.stateOverride && c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c !== void 0) { + this.state = "path"; + if (c !== p("/")) { + --this.pointer; + } + } else if (this.stateOverride && this.url.host === null) { + this.url.path.push(""); + } + return true; + }; + URLStateMachine.prototype["parse path"] = function parsePath(c) { + if (isNaN(c) || c === p("/") || isSpecial(this.url) && c === p("\\") || !this.stateOverride && (c === p("?") || c === p("#"))) { + if (isSpecial(this.url) && c === p("\\")) { + this.parseError = true; + } + if (isDoubleDot(this.buffer)) { + shortenPath(this.url); + if (c !== p("/") && !(isSpecial(this.url) && c === p("\\"))) { + this.url.path.push(""); + } + } else if (isSingleDot(this.buffer) && c !== p("/") && !(isSpecial(this.url) && c === p("\\"))) { + this.url.path.push(""); + } else if (!isSingleDot(this.buffer)) { + if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) { + this.buffer = `${this.buffer[0]}:`; + } + this.url.path.push(this.buffer); + } + this.buffer = ""; + if (c === p("?")) { + this.url.query = ""; + this.state = "query"; + } + if (c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + if (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += utf8PercentEncodeCodePoint(c, isPathPercentEncode); + } + return true; + }; + URLStateMachine.prototype["parse opaque path"] = function parseOpaquePath(c) { + if (c === p("?")) { + this.url.query = ""; + this.state = "query"; + } else if (c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c === p(" ")) { + const remaining = this.input[this.pointer + 1]; + if (remaining === p("?") || remaining === p("#")) { + this.url.path += "%20"; + } else { + this.url.path += " "; + } + } else { + if (!isNaN(c) && c !== p("%")) { + this.parseError = true; + } + if (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + if (!isNaN(c)) { + this.url.path += utf8PercentEncodeCodePoint(c, isC0ControlPercentEncode); + } + } + return true; + }; + URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) { + if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss") { + this.encodingOverride = "utf-8"; + } + if (!this.stateOverride && c === p("#") || isNaN(c)) { + const queryPercentEncodePredicate = isSpecial(this.url) ? isSpecialQueryPercentEncode : isQueryPercentEncode; + this.url.query += utf8PercentEncodeString(this.buffer, queryPercentEncodePredicate); + this.buffer = ""; + if (c === p("#")) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else if (!isNaN(c)) { + if (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.buffer += cStr; + } + return true; + }; + URLStateMachine.prototype["parse fragment"] = function parseFragment(c) { + if (!isNaN(c)) { + if (c === p("%") && (!infra.isASCIIHex(this.input[this.pointer + 1]) || !infra.isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + this.url.fragment += utf8PercentEncodeCodePoint(c, isFragmentPercentEncode); + } + return true; + }; + function serializeURL(url, excludeFragment) { + let output = `${url.scheme}:`; + if (url.host !== null) { + output += "//"; + if (url.username !== "" || url.password !== "") { + output += url.username; + if (url.password !== "") { + output += `:${url.password}`; + } + output += "@"; + } + output += serializeHost(url.host); + if (url.port !== null) { + output += `:${url.port}`; + } + } + if (url.host === null && !hasAnOpaquePath(url) && url.path.length > 1 && url.path[0] === "") { + output += "/."; + } + output += serializePath(url); + if (url.query !== null) { + output += `?${url.query}`; + } + if (!excludeFragment && url.fragment !== null) { + output += `#${url.fragment}`; + } + return output; + } + function serializeOrigin(tuple) { + let result = `${tuple.scheme}://`; + result += serializeHost(tuple.host); + if (tuple.port !== null) { + result += `:${tuple.port}`; + } + return result; + } + function serializePath(url) { + if (hasAnOpaquePath(url)) { + return url.path; + } + let output = ""; + for (const segment of url.path) { + output += `/${segment}`; + } + return output; + } + module2.exports.serializeURL = serializeURL; + module2.exports.serializePath = serializePath; + module2.exports.serializeURLOrigin = function(url) { + switch (url.scheme) { + case "blob": { + const pathURL = module2.exports.parseURL(serializePath(url)); + if (pathURL === null) { + return "null"; + } + if (pathURL.scheme !== "http" && pathURL.scheme !== "https") { + return "null"; + } + return module2.exports.serializeURLOrigin(pathURL); + } + case "ftp": + case "http": + case "https": + case "ws": + case "wss": + return serializeOrigin({ + scheme: url.scheme, + host: url.host, + port: url.port + }); + case "file": + return "null"; + default: + return "null"; + } + }; + module2.exports.basicURLParse = function(input, options) { + if (options === void 0) { + options = {}; + } + const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride); + if (usm.failure) { + return null; + } + return usm.url; + }; + module2.exports.setTheUsername = function(url, username) { + url.username = utf8PercentEncodeString(username, isUserinfoPercentEncode); + }; + module2.exports.setThePassword = function(url, password) { + url.password = utf8PercentEncodeString(password, isUserinfoPercentEncode); + }; + module2.exports.serializeHost = serializeHost; + module2.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; + module2.exports.hasAnOpaquePath = hasAnOpaquePath; + module2.exports.serializeInteger = function(integer) { + return String(integer); + }; + module2.exports.parseURL = function(input, options) { + if (options === void 0) { + options = {}; + } + return module2.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride }); + }; + } +}); + +// node_modules/whatwg-url/lib/urlencoded.js +var require_urlencoded = __commonJS({ + "node_modules/whatwg-url/lib/urlencoded.js"(exports2, module2) { + "use strict"; + var { utf8Encode, utf8DecodeWithoutBOM } = require_encoding(); + var { percentDecodeBytes, utf8PercentEncodeString, isURLEncodedPercentEncode } = require_percent_encoding(); + function p(char) { + return char.codePointAt(0); + } + function parseUrlencoded(input) { + const sequences = strictlySplitByteSequence(input, p("&")); + const output = []; + for (const bytes of sequences) { + if (bytes.length === 0) { + continue; + } + let name, value; + const indexOfEqual = bytes.indexOf(p("=")); + if (indexOfEqual >= 0) { + name = bytes.slice(0, indexOfEqual); + value = bytes.slice(indexOfEqual + 1); + } else { + name = bytes; + value = new Uint8Array(0); + } + name = replaceByteInByteSequence(name, 43, 32); + value = replaceByteInByteSequence(value, 43, 32); + const nameString = utf8DecodeWithoutBOM(percentDecodeBytes(name)); + const valueString = utf8DecodeWithoutBOM(percentDecodeBytes(value)); + output.push([nameString, valueString]); + } + return output; + } + function parseUrlencodedString(input) { + return parseUrlencoded(utf8Encode(input)); + } + function serializeUrlencoded(tuples) { + let output = ""; + for (const [i, tuple] of tuples.entries()) { + const name = utf8PercentEncodeString(tuple[0], isURLEncodedPercentEncode, true); + const value = utf8PercentEncodeString(tuple[1], isURLEncodedPercentEncode, true); + if (i !== 0) { + output += "&"; + } + output += `${name}=${value}`; + } + return output; + } + function strictlySplitByteSequence(buf, cp) { + const list = []; + let last = 0; + let i = buf.indexOf(cp); + while (i >= 0) { + list.push(buf.slice(last, i)); + last = i + 1; + i = buf.indexOf(cp, last); + } + if (last !== buf.length) { + list.push(buf.slice(last)); + } + return list; + } + function replaceByteInByteSequence(buf, from, to) { + let i = buf.indexOf(from); + while (i >= 0) { + buf[i] = to; + i = buf.indexOf(from, i + 1); + } + return buf; + } + module2.exports = { + parseUrlencodedString, + serializeUrlencoded + }; + } +}); + +// node_modules/whatwg-url/lib/Function.js +var require_Function = __commonJS({ + "node_modules/whatwg-url/lib/Function.js"(exports2) { + "use strict"; + var conversions = require_lib7(); + var utils = require_utils4(); + exports2.convert = (globalObject, value, { context = "The provided value" } = {}) => { + if (typeof value !== "function") { + throw new globalObject.TypeError(context + " is not a function"); + } + function invokeTheCallbackFunction(...args) { + const thisArg = utils.tryWrapperForImpl(this); + let callResult; + for (let i = 0; i < args.length; i++) { + args[i] = utils.tryWrapperForImpl(args[i]); + } + callResult = Reflect.apply(value, thisArg, args); + callResult = conversions["any"](callResult, { context, globals: globalObject }); + return callResult; + } + invokeTheCallbackFunction.construct = (...args) => { + for (let i = 0; i < args.length; i++) { + args[i] = utils.tryWrapperForImpl(args[i]); + } + let callResult = Reflect.construct(value, args); + callResult = conversions["any"](callResult, { context, globals: globalObject }); + return callResult; + }; + invokeTheCallbackFunction[utils.wrapperSymbol] = value; + invokeTheCallbackFunction.objectReference = value; + return invokeTheCallbackFunction; + }; + } +}); + +// node_modules/whatwg-url/lib/URLSearchParams-impl.js +var require_URLSearchParams_impl = __commonJS({ + "node_modules/whatwg-url/lib/URLSearchParams-impl.js"(exports2) { + "use strict"; + var urlencoded = require_urlencoded(); + exports2.implementation = class URLSearchParamsImpl { + constructor(globalObject, constructorArgs, { doNotStripQMark = false }) { + let init = constructorArgs[0]; + this._list = []; + this._url = null; + if (!doNotStripQMark && typeof init === "string" && init[0] === "?") { + init = init.slice(1); + } + if (Array.isArray(init)) { + for (const pair of init) { + if (pair.length !== 2) { + throw new TypeError("Failed to construct 'URLSearchParams': parameter 1 sequence's element does not contain exactly two elements."); + } + this._list.push([pair[0], pair[1]]); + } + } else if (typeof init === "object" && Object.getPrototypeOf(init) === null) { + for (const name of Object.keys(init)) { + const value = init[name]; + this._list.push([name, value]); + } + } else { + this._list = urlencoded.parseUrlencodedString(init); + } + } + _updateSteps() { + if (this._url !== null) { + let serializedQuery = urlencoded.serializeUrlencoded(this._list); + if (serializedQuery === "") { + serializedQuery = null; + } + this._url._url.query = serializedQuery; + } + } + get size() { + return this._list.length; + } + append(name, value) { + this._list.push([name, value]); + this._updateSteps(); + } + delete(name, value) { + let i = 0; + while (i < this._list.length) { + if (this._list[i][0] === name && (value === void 0 || this._list[i][1] === value)) { + this._list.splice(i, 1); + } else { + i++; + } + } + this._updateSteps(); + } + get(name) { + for (const tuple of this._list) { + if (tuple[0] === name) { + return tuple[1]; + } + } + return null; + } + getAll(name) { + const output = []; + for (const tuple of this._list) { + if (tuple[0] === name) { + output.push(tuple[1]); + } + } + return output; + } + has(name, value) { + for (const tuple of this._list) { + if (tuple[0] === name && (value === void 0 || tuple[1] === value)) { + return true; + } + } + return false; + } + set(name, value) { + let found = false; + let i = 0; + while (i < this._list.length) { + if (this._list[i][0] === name) { + if (found) { + this._list.splice(i, 1); + } else { + found = true; + this._list[i][1] = value; + i++; + } + } else { + i++; + } + } + if (!found) { + this._list.push([name, value]); + } + this._updateSteps(); + } + sort() { + this._list.sort((a, b) => { + if (a[0] < b[0]) { + return -1; + } + if (a[0] > b[0]) { + return 1; + } + return 0; + }); + this._updateSteps(); + } + [Symbol.iterator]() { + return this._list[Symbol.iterator](); + } + toString() { + return urlencoded.serializeUrlencoded(this._list); + } + }; + } +}); + +// node_modules/whatwg-url/lib/URLSearchParams.js +var require_URLSearchParams = __commonJS({ + "node_modules/whatwg-url/lib/URLSearchParams.js"(exports2) { + "use strict"; + var conversions = require_lib7(); + var utils = require_utils4(); + var Function2 = require_Function(); + var newObjectInRealm = utils.newObjectInRealm; + var implSymbol = utils.implSymbol; + var ctorRegistrySymbol = utils.ctorRegistrySymbol; + var interfaceName = "URLSearchParams"; + exports2.is = (value) => { + return utils.isObject(value) && utils.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation; + }; + exports2.isImpl = (value) => { + return utils.isObject(value) && value instanceof Impl.implementation; + }; + exports2.convert = (globalObject, value, { context = "The provided value" } = {}) => { + if (exports2.is(value)) { + return utils.implForWrapper(value); + } + throw new globalObject.TypeError(`${context} is not of type 'URLSearchParams'.`); + }; + exports2.createDefaultIterator = (globalObject, target, kind) => { + const ctorRegistry = globalObject[ctorRegistrySymbol]; + const iteratorPrototype = ctorRegistry["URLSearchParams Iterator"]; + const iterator = Object.create(iteratorPrototype); + Object.defineProperty(iterator, utils.iterInternalSymbol, { + value: { target, kind, index: 0 }, + configurable: true + }); + return iterator; + }; + function makeWrapper(globalObject, newTarget) { + let proto; + if (newTarget !== void 0) { + proto = newTarget.prototype; + } + if (!utils.isObject(proto)) { + proto = globalObject[ctorRegistrySymbol]["URLSearchParams"].prototype; + } + return Object.create(proto); + } + exports2.create = (globalObject, constructorArgs, privateData) => { + const wrapper = makeWrapper(globalObject); + return exports2.setup(wrapper, globalObject, constructorArgs, privateData); + }; + exports2.createImpl = (globalObject, constructorArgs, privateData) => { + const wrapper = exports2.create(globalObject, constructorArgs, privateData); + return utils.implForWrapper(wrapper); + }; + exports2._internalSetup = (wrapper, globalObject) => { + }; + exports2.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => { + privateData.wrapper = wrapper; + exports2._internalSetup(wrapper, globalObject); + Object.defineProperty(wrapper, implSymbol, { + value: new Impl.implementation(globalObject, constructorArgs, privateData), + configurable: true + }); + wrapper[implSymbol][utils.wrapperSymbol] = wrapper; + if (Impl.init) { + Impl.init(wrapper[implSymbol]); + } + return wrapper; + }; + exports2.new = (globalObject, newTarget) => { + const wrapper = makeWrapper(globalObject, newTarget); + exports2._internalSetup(wrapper, globalObject); + Object.defineProperty(wrapper, implSymbol, { + value: Object.create(Impl.implementation.prototype), + configurable: true + }); + wrapper[implSymbol][utils.wrapperSymbol] = wrapper; + if (Impl.init) { + Impl.init(wrapper[implSymbol]); + } + return wrapper[implSymbol]; + }; + var exposed = /* @__PURE__ */ new Set(["Window", "Worker"]); + exports2.install = (globalObject, globalNames) => { + if (!globalNames.some((globalName) => exposed.has(globalName))) { + return; + } + const ctorRegistry = utils.initCtorRegistry(globalObject); + class URLSearchParams { + constructor() { + const args = []; + { + let curArg = arguments[0]; + if (curArg !== void 0) { + if (utils.isObject(curArg)) { + if (curArg[Symbol.iterator] !== void 0) { + if (!utils.isObject(curArg)) { + throw new globalObject.TypeError( + "Failed to construct 'URLSearchParams': parameter 1 sequence is not an iterable object." + ); + } else { + const V = []; + const tmp = curArg; + for (let nextItem of tmp) { + if (!utils.isObject(nextItem)) { + throw new globalObject.TypeError( + "Failed to construct 'URLSearchParams': parameter 1 sequence's element is not an iterable object." + ); + } else { + const V2 = []; + const tmp2 = nextItem; + for (let nextItem2 of tmp2) { + nextItem2 = conversions["USVString"](nextItem2, { + context: "Failed to construct 'URLSearchParams': parameter 1 sequence's element's element", + globals: globalObject + }); + V2.push(nextItem2); + } + nextItem = V2; + } + V.push(nextItem); + } + curArg = V; + } + } else { + if (!utils.isObject(curArg)) { + throw new globalObject.TypeError( + "Failed to construct 'URLSearchParams': parameter 1 record is not an object." + ); + } else { + const result = /* @__PURE__ */ Object.create(null); + for (const key of Reflect.ownKeys(curArg)) { + const desc = Object.getOwnPropertyDescriptor(curArg, key); + if (desc && desc.enumerable) { + let typedKey = key; + typedKey = conversions["USVString"](typedKey, { + context: "Failed to construct 'URLSearchParams': parameter 1 record's key", + globals: globalObject + }); + let typedValue = curArg[key]; + typedValue = conversions["USVString"](typedValue, { + context: "Failed to construct 'URLSearchParams': parameter 1 record's value", + globals: globalObject + }); + result[typedKey] = typedValue; + } + } + curArg = result; + } + } + } else { + curArg = conversions["USVString"](curArg, { + context: "Failed to construct 'URLSearchParams': parameter 1", + globals: globalObject + }); + } + } else { + curArg = ""; + } + args.push(curArg); + } + return exports2.setup(Object.create(new.target.prototype), globalObject, args); + } + append(name, value) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError( + "'append' called on an object that is not a valid instance of URLSearchParams." + ); + } + if (arguments.length < 2) { + throw new globalObject.TypeError( + `Failed to execute 'append' on 'URLSearchParams': 2 arguments required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'append' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'append' on 'URLSearchParams': parameter 2", + globals: globalObject + }); + args.push(curArg); + } + return utils.tryWrapperForImpl(esValue[implSymbol].append(...args)); + } + delete(name) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError( + "'delete' called on an object that is not a valid instance of URLSearchParams." + ); + } + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + if (curArg !== void 0) { + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'delete' on 'URLSearchParams': parameter 2", + globals: globalObject + }); + } + args.push(curArg); + } + return utils.tryWrapperForImpl(esValue[implSymbol].delete(...args)); + } + get(name) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get' called on an object that is not a valid instance of URLSearchParams."); + } + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'get' on 'URLSearchParams': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'get' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + return esValue[implSymbol].get(...args); + } + getAll(name) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError( + "'getAll' called on an object that is not a valid instance of URLSearchParams." + ); + } + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + return utils.tryWrapperForImpl(esValue[implSymbol].getAll(...args)); + } + has(name) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'has' called on an object that is not a valid instance of URLSearchParams."); + } + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'has' on 'URLSearchParams': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'has' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + if (curArg !== void 0) { + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'has' on 'URLSearchParams': parameter 2", + globals: globalObject + }); + } + args.push(curArg); + } + return esValue[implSymbol].has(...args); + } + set(name, value) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set' called on an object that is not a valid instance of URLSearchParams."); + } + if (arguments.length < 2) { + throw new globalObject.TypeError( + `Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'set' on 'URLSearchParams': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'set' on 'URLSearchParams': parameter 2", + globals: globalObject + }); + args.push(curArg); + } + return utils.tryWrapperForImpl(esValue[implSymbol].set(...args)); + } + sort() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'sort' called on an object that is not a valid instance of URLSearchParams."); + } + return utils.tryWrapperForImpl(esValue[implSymbol].sort()); + } + toString() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError( + "'toString' called on an object that is not a valid instance of URLSearchParams." + ); + } + return esValue[implSymbol].toString(); + } + keys() { + if (!exports2.is(this)) { + throw new globalObject.TypeError("'keys' called on an object that is not a valid instance of URLSearchParams."); + } + return exports2.createDefaultIterator(globalObject, this, "key"); + } + values() { + if (!exports2.is(this)) { + throw new globalObject.TypeError( + "'values' called on an object that is not a valid instance of URLSearchParams." + ); + } + return exports2.createDefaultIterator(globalObject, this, "value"); + } + entries() { + if (!exports2.is(this)) { + throw new globalObject.TypeError( + "'entries' called on an object that is not a valid instance of URLSearchParams." + ); + } + return exports2.createDefaultIterator(globalObject, this, "key+value"); + } + forEach(callback) { + if (!exports2.is(this)) { + throw new globalObject.TypeError( + "'forEach' called on an object that is not a valid instance of URLSearchParams." + ); + } + if (arguments.length < 1) { + throw new globalObject.TypeError( + "Failed to execute 'forEach' on 'iterable': 1 argument required, but only 0 present." + ); + } + callback = Function2.convert(globalObject, callback, { + context: "Failed to execute 'forEach' on 'iterable': The callback provided as parameter 1" + }); + const thisArg = arguments[1]; + let pairs = Array.from(this[implSymbol]); + let i = 0; + while (i < pairs.length) { + const [key, value] = pairs[i].map(utils.tryWrapperForImpl); + callback.call(thisArg, value, key, this); + pairs = Array.from(this[implSymbol]); + i++; + } + } + get size() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError( + "'get size' called on an object that is not a valid instance of URLSearchParams." + ); + } + return esValue[implSymbol]["size"]; + } + } + Object.defineProperties(URLSearchParams.prototype, { + append: { enumerable: true }, + delete: { enumerable: true }, + get: { enumerable: true }, + getAll: { enumerable: true }, + has: { enumerable: true }, + set: { enumerable: true }, + sort: { enumerable: true }, + toString: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true }, + forEach: { enumerable: true }, + size: { enumerable: true }, + [Symbol.toStringTag]: { value: "URLSearchParams", configurable: true }, + [Symbol.iterator]: { value: URLSearchParams.prototype.entries, configurable: true, writable: true } + }); + ctorRegistry[interfaceName] = URLSearchParams; + ctorRegistry["URLSearchParams Iterator"] = Object.create(ctorRegistry["%IteratorPrototype%"], { + [Symbol.toStringTag]: { + configurable: true, + value: "URLSearchParams Iterator" + } + }); + utils.define(ctorRegistry["URLSearchParams Iterator"], { + next() { + const internal = this && this[utils.iterInternalSymbol]; + if (!internal) { + throw new globalObject.TypeError("next() called on a value that is not a URLSearchParams iterator object"); + } + const { target, kind, index } = internal; + const values = Array.from(target[implSymbol]); + const len = values.length; + if (index >= len) { + return newObjectInRealm(globalObject, { value: void 0, done: true }); + } + const pair = values[index]; + internal.index = index + 1; + return newObjectInRealm(globalObject, utils.iteratorResult(pair.map(utils.tryWrapperForImpl), kind)); + } + }); + Object.defineProperty(globalObject, interfaceName, { + configurable: true, + writable: true, + value: URLSearchParams + }); + }; + var Impl = require_URLSearchParams_impl(); + } +}); + +// node_modules/whatwg-url/lib/URL-impl.js +var require_URL_impl = __commonJS({ + "node_modules/whatwg-url/lib/URL-impl.js"(exports2) { + "use strict"; + var usm = require_url_state_machine(); + var urlencoded = require_urlencoded(); + var URLSearchParams = require_URLSearchParams(); + exports2.implementation = class URLImpl { + // Unlike the spec, we duplicate some code between the constructor and canParse, because we want to give useful error + // messages in the constructor that distinguish between the different causes of failure. + constructor(globalObject, [url, base]) { + let parsedBase = null; + if (base !== void 0) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === null) { + throw new TypeError(`Invalid base URL: ${base}`); + } + } + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === null) { + throw new TypeError(`Invalid URL: ${url}`); + } + const query = parsedURL.query !== null ? parsedURL.query : ""; + this._url = parsedURL; + this._query = URLSearchParams.createImpl(globalObject, [query], { doNotStripQMark: true }); + this._query._url = this; + } + static parse(globalObject, input, base) { + try { + return new URLImpl(globalObject, [input, base]); + } catch { + return null; + } + } + static canParse(url, base) { + let parsedBase = null; + if (base !== void 0) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === null) { + return false; + } + } + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === null) { + return false; + } + return true; + } + get href() { + return usm.serializeURL(this._url); + } + set href(v) { + const parsedURL = usm.basicURLParse(v); + if (parsedURL === null) { + throw new TypeError(`Invalid URL: ${v}`); + } + this._url = parsedURL; + this._query._list.splice(0); + const { query } = parsedURL; + if (query !== null) { + this._query._list = urlencoded.parseUrlencodedString(query); + } + } + get origin() { + return usm.serializeURLOrigin(this._url); + } + get protocol() { + return `${this._url.scheme}:`; + } + set protocol(v) { + usm.basicURLParse(`${v}:`, { url: this._url, stateOverride: "scheme start" }); + } + get username() { + return this._url.username; + } + set username(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setTheUsername(this._url, v); + } + get password() { + return this._url.password; + } + set password(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + usm.setThePassword(this._url, v); + } + get host() { + const url = this._url; + if (url.host === null) { + return ""; + } + if (url.port === null) { + return usm.serializeHost(url.host); + } + return `${usm.serializeHost(url.host)}:${usm.serializeInteger(url.port)}`; + } + set host(v) { + if (usm.hasAnOpaquePath(this._url)) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "host" }); + } + get hostname() { + if (this._url.host === null) { + return ""; + } + return usm.serializeHost(this._url.host); + } + set hostname(v) { + if (usm.hasAnOpaquePath(this._url)) { + return; + } + usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" }); + } + get port() { + if (this._url.port === null) { + return ""; + } + return usm.serializeInteger(this._url.port); + } + set port(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + if (v === "") { + this._url.port = null; + } else { + usm.basicURLParse(v, { url: this._url, stateOverride: "port" }); + } + } + get pathname() { + return usm.serializePath(this._url); + } + set pathname(v) { + if (usm.hasAnOpaquePath(this._url)) { + return; + } + this._url.path = []; + usm.basicURLParse(v, { url: this._url, stateOverride: "path start" }); + } + get search() { + if (this._url.query === null || this._url.query === "") { + return ""; + } + return `?${this._url.query}`; + } + set search(v) { + const url = this._url; + if (v === "") { + url.query = null; + this._query._list = []; + return; + } + const input = v[0] === "?" ? v.substring(1) : v; + url.query = ""; + usm.basicURLParse(input, { url, stateOverride: "query" }); + this._query._list = urlencoded.parseUrlencodedString(input); + } + get searchParams() { + return this._query; + } + get hash() { + if (this._url.fragment === null || this._url.fragment === "") { + return ""; + } + return `#${this._url.fragment}`; + } + set hash(v) { + if (v === "") { + this._url.fragment = null; + return; + } + const input = v[0] === "#" ? v.substring(1) : v; + this._url.fragment = ""; + usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" }); + } + toJSON() { + return this.href; + } + }; + } +}); + +// node_modules/whatwg-url/lib/URL.js +var require_URL = __commonJS({ + "node_modules/whatwg-url/lib/URL.js"(exports2) { + "use strict"; + var conversions = require_lib7(); + var utils = require_utils4(); + var implSymbol = utils.implSymbol; + var ctorRegistrySymbol = utils.ctorRegistrySymbol; + var interfaceName = "URL"; + exports2.is = (value) => { + return utils.isObject(value) && utils.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation; + }; + exports2.isImpl = (value) => { + return utils.isObject(value) && value instanceof Impl.implementation; + }; + exports2.convert = (globalObject, value, { context = "The provided value" } = {}) => { + if (exports2.is(value)) { + return utils.implForWrapper(value); + } + throw new globalObject.TypeError(`${context} is not of type 'URL'.`); + }; + function makeWrapper(globalObject, newTarget) { + let proto; + if (newTarget !== void 0) { + proto = newTarget.prototype; + } + if (!utils.isObject(proto)) { + proto = globalObject[ctorRegistrySymbol]["URL"].prototype; + } + return Object.create(proto); + } + exports2.create = (globalObject, constructorArgs, privateData) => { + const wrapper = makeWrapper(globalObject); + return exports2.setup(wrapper, globalObject, constructorArgs, privateData); + }; + exports2.createImpl = (globalObject, constructorArgs, privateData) => { + const wrapper = exports2.create(globalObject, constructorArgs, privateData); + return utils.implForWrapper(wrapper); + }; + exports2._internalSetup = (wrapper, globalObject) => { + }; + exports2.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => { + privateData.wrapper = wrapper; + exports2._internalSetup(wrapper, globalObject); + Object.defineProperty(wrapper, implSymbol, { + value: new Impl.implementation(globalObject, constructorArgs, privateData), + configurable: true + }); + wrapper[implSymbol][utils.wrapperSymbol] = wrapper; + if (Impl.init) { + Impl.init(wrapper[implSymbol]); + } + return wrapper; + }; + exports2.new = (globalObject, newTarget) => { + const wrapper = makeWrapper(globalObject, newTarget); + exports2._internalSetup(wrapper, globalObject); + Object.defineProperty(wrapper, implSymbol, { + value: Object.create(Impl.implementation.prototype), + configurable: true + }); + wrapper[implSymbol][utils.wrapperSymbol] = wrapper; + if (Impl.init) { + Impl.init(wrapper[implSymbol]); + } + return wrapper[implSymbol]; + }; + var exposed = /* @__PURE__ */ new Set(["Window", "Worker"]); + exports2.install = (globalObject, globalNames) => { + if (!globalNames.some((globalName) => exposed.has(globalName))) { + return; + } + const ctorRegistry = utils.initCtorRegistry(globalObject); + class URL2 { + constructor(url) { + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to construct 'URL': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to construct 'URL': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + if (curArg !== void 0) { + curArg = conversions["USVString"](curArg, { + context: "Failed to construct 'URL': parameter 2", + globals: globalObject + }); + } + args.push(curArg); + } + return exports2.setup(Object.create(new.target.prototype), globalObject, args); + } + toJSON() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'toJSON' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol].toJSON(); + } + get href() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get href' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["href"]; + } + set href(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set href' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'href' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["href"] = V; + } + toString() { + const esValue = this; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'toString' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["href"]; + } + get origin() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get origin' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["origin"]; + } + get protocol() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get protocol' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["protocol"]; + } + set protocol(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set protocol' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'protocol' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["protocol"] = V; + } + get username() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get username' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["username"]; + } + set username(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set username' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'username' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["username"] = V; + } + get password() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get password' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["password"]; + } + set password(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set password' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'password' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["password"] = V; + } + get host() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get host' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["host"]; + } + set host(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set host' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'host' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["host"] = V; + } + get hostname() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get hostname' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["hostname"]; + } + set hostname(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set hostname' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'hostname' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["hostname"] = V; + } + get port() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get port' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["port"]; + } + set port(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set port' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'port' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["port"] = V; + } + get pathname() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get pathname' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["pathname"]; + } + set pathname(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set pathname' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'pathname' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["pathname"] = V; + } + get search() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get search' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["search"]; + } + set search(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set search' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'search' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["search"] = V; + } + get searchParams() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get searchParams' called on an object that is not a valid instance of URL."); + } + return utils.getSameObject(this, "searchParams", () => { + return utils.tryWrapperForImpl(esValue[implSymbol]["searchParams"]); + }); + } + get hash() { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'get hash' called on an object that is not a valid instance of URL."); + } + return esValue[implSymbol]["hash"]; + } + set hash(V) { + const esValue = this !== null && this !== void 0 ? this : globalObject; + if (!exports2.is(esValue)) { + throw new globalObject.TypeError("'set hash' called on an object that is not a valid instance of URL."); + } + V = conversions["USVString"](V, { + context: "Failed to set the 'hash' property on 'URL': The provided value", + globals: globalObject + }); + esValue[implSymbol]["hash"] = V; + } + static parse(url) { + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'parse' on 'URL': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'parse' on 'URL': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + if (curArg !== void 0) { + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'parse' on 'URL': parameter 2", + globals: globalObject + }); + } + args.push(curArg); + } + return utils.tryWrapperForImpl(Impl.implementation.parse(globalObject, ...args)); + } + static canParse(url) { + if (arguments.length < 1) { + throw new globalObject.TypeError( + `Failed to execute 'canParse' on 'URL': 1 argument required, but only ${arguments.length} present.` + ); + } + const args = []; + { + let curArg = arguments[0]; + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'canParse' on 'URL': parameter 1", + globals: globalObject + }); + args.push(curArg); + } + { + let curArg = arguments[1]; + if (curArg !== void 0) { + curArg = conversions["USVString"](curArg, { + context: "Failed to execute 'canParse' on 'URL': parameter 2", + globals: globalObject + }); + } + args.push(curArg); + } + return Impl.implementation.canParse(...args); + } + } + Object.defineProperties(URL2.prototype, { + toJSON: { enumerable: true }, + href: { enumerable: true }, + toString: { enumerable: true }, + origin: { enumerable: true }, + protocol: { enumerable: true }, + username: { enumerable: true }, + password: { enumerable: true }, + host: { enumerable: true }, + hostname: { enumerable: true }, + port: { enumerable: true }, + pathname: { enumerable: true }, + search: { enumerable: true }, + searchParams: { enumerable: true }, + hash: { enumerable: true }, + [Symbol.toStringTag]: { value: "URL", configurable: true } + }); + Object.defineProperties(URL2, { parse: { enumerable: true }, canParse: { enumerable: true } }); + ctorRegistry[interfaceName] = URL2; + Object.defineProperty(globalObject, interfaceName, { + configurable: true, + writable: true, + value: URL2 + }); + if (globalNames.includes("Window")) { + Object.defineProperty(globalObject, "webkitURL", { + configurable: true, + writable: true, + value: URL2 + }); + } + }; + var Impl = require_URL_impl(); + } +}); + +// node_modules/whatwg-url/webidl2js-wrapper.js +var require_webidl2js_wrapper = __commonJS({ + "node_modules/whatwg-url/webidl2js-wrapper.js"(exports2) { + "use strict"; + var URL2 = require_URL(); + var URLSearchParams = require_URLSearchParams(); + exports2.URL = URL2; + exports2.URLSearchParams = URLSearchParams; + } +}); + +// node_modules/whatwg-url/index.js +var require_whatwg_url = __commonJS({ + "node_modules/whatwg-url/index.js"(exports2) { + "use strict"; + var { URL: URL2, URLSearchParams } = require_webidl2js_wrapper(); + var urlStateMachine = require_url_state_machine(); + var percentEncoding = require_percent_encoding(); + var sharedGlobalObject = { Array, Object, Promise, String, TypeError }; + URL2.install(sharedGlobalObject, ["Window"]); + URLSearchParams.install(sharedGlobalObject, ["Window"]); + exports2.URL = sharedGlobalObject.URL; + exports2.URLSearchParams = sharedGlobalObject.URLSearchParams; + exports2.parseURL = urlStateMachine.parseURL; + exports2.basicURLParse = urlStateMachine.basicURLParse; + exports2.serializeURL = urlStateMachine.serializeURL; + exports2.serializePath = urlStateMachine.serializePath; + exports2.serializeHost = urlStateMachine.serializeHost; + exports2.serializeInteger = urlStateMachine.serializeInteger; + exports2.serializeURLOrigin = urlStateMachine.serializeURLOrigin; + exports2.setTheUsername = urlStateMachine.setTheUsername; + exports2.setThePassword = urlStateMachine.setThePassword; + exports2.cannotHaveAUsernamePasswordPort = urlStateMachine.cannotHaveAUsernamePasswordPort; + exports2.hasAnOpaquePath = urlStateMachine.hasAnOpaquePath; + exports2.percentDecodeString = percentEncoding.percentDecodeString; + exports2.percentDecodeBytes = percentEncoding.percentDecodeBytes; + } +}); + +// node_modules/mongodb-connection-string-url/lib/redact.js +var require_redact = __commonJS({ + "node_modules/mongodb-connection-string-url/lib/redact.js"(exports2) { + "use strict"; + var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports2 && exports2.__importStar || function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding2(result, mod, k); + } + __setModuleDefault2(result, mod); + return result; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.redactConnectionString = exports2.redactValidConnectionString = void 0; + var index_1 = __importStar2(require_lib8()); + function redactValidConnectionString(inputUrl, options) { + var _a, _b; + const url = inputUrl.clone(); + const replacementString = (_a = options === null || options === void 0 ? void 0 : options.replacementString) !== null && _a !== void 0 ? _a : "_credentials_"; + const redactUsernames = (_b = options === null || options === void 0 ? void 0 : options.redactUsernames) !== null && _b !== void 0 ? _b : true; + if ((url.username || url.password) && redactUsernames) { + url.username = replacementString; + url.password = ""; + } else if (url.password) { + url.password = replacementString; + } + if (url.searchParams.has("authMechanismProperties")) { + const props = new index_1.CommaAndColonSeparatedRecord(url.searchParams.get("authMechanismProperties")); + if (props.get("AWS_SESSION_TOKEN")) { + props.set("AWS_SESSION_TOKEN", replacementString); + url.searchParams.set("authMechanismProperties", props.toString()); + } + } + if (url.searchParams.has("tlsCertificateKeyFilePassword")) { + url.searchParams.set("tlsCertificateKeyFilePassword", replacementString); + } + if (url.searchParams.has("proxyUsername") && redactUsernames) { + url.searchParams.set("proxyUsername", replacementString); + } + if (url.searchParams.has("proxyPassword")) { + url.searchParams.set("proxyPassword", replacementString); + } + return url; + } + exports2.redactValidConnectionString = redactValidConnectionString; + function redactConnectionString(uri, options) { + var _a, _b; + const replacementString = (_a = options === null || options === void 0 ? void 0 : options.replacementString) !== null && _a !== void 0 ? _a : ""; + const redactUsernames = (_b = options === null || options === void 0 ? void 0 : options.redactUsernames) !== null && _b !== void 0 ? _b : true; + let parsed; + try { + parsed = new index_1.default(uri); + } catch (_c) { + } + if (parsed) { + options = { ...options, replacementString: "___credentials___" }; + return parsed.redact(options).toString().replace(/___credentials___/g, replacementString); + } + const R = replacementString; + const replacements = [ + (uri2) => uri2.replace(redactUsernames ? /(\/\/)(.*)(@)/g : /(\/\/[^@]*:)(.*)(@)/g, `$1${R}$3`), + (uri2) => uri2.replace(/(AWS_SESSION_TOKEN(:|%3A))([^,&]+)/gi, `$1${R}`), + (uri2) => uri2.replace(/(tlsCertificateKeyFilePassword=)([^&]+)/gi, `$1${R}`), + (uri2) => redactUsernames ? uri2.replace(/(proxyUsername=)([^&]+)/gi, `$1${R}`) : uri2, + (uri2) => uri2.replace(/(proxyPassword=)([^&]+)/gi, `$1${R}`) + ]; + for (const replacer of replacements) { + uri = replacer(uri); + } + return uri; + } + exports2.redactConnectionString = redactConnectionString; + } +}); + +// node_modules/mongodb-connection-string-url/lib/index.js +var require_lib8 = __commonJS({ + "node_modules/mongodb-connection-string-url/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CommaAndColonSeparatedRecord = exports2.ConnectionString = exports2.redactConnectionString = void 0; + var whatwg_url_1 = require_whatwg_url(); + var redact_1 = require_redact(); + Object.defineProperty(exports2, "redactConnectionString", { enumerable: true, get: function() { + return redact_1.redactConnectionString; + } }); + var DUMMY_HOSTNAME = "__this_is_a_placeholder__"; + function connectionStringHasValidScheme(connectionString) { + return connectionString.startsWith("mongodb://") || connectionString.startsWith("mongodb+srv://"); + } + var HOSTS_REGEX = /^(?[^/]+):\/\/(?:(?[^:@]*)(?::(?[^@]*))?@)?(?(?!:)[^/?@]*)(?.*)/; + var CaseInsensitiveMap = class extends Map { + delete(name) { + return super.delete(this._normalizeKey(name)); + } + get(name) { + return super.get(this._normalizeKey(name)); + } + has(name) { + return super.has(this._normalizeKey(name)); + } + set(name, value) { + return super.set(this._normalizeKey(name), value); + } + _normalizeKey(name) { + name = `${name}`; + for (const key of this.keys()) { + if (key.toLowerCase() === name.toLowerCase()) { + name = key; + break; + } + } + return name; + } + }; + function caseInsenstiveURLSearchParams(Ctor) { + return class CaseInsenstiveURLSearchParams extends Ctor { + append(name, value) { + return super.append(this._normalizeKey(name), value); + } + delete(name) { + return super.delete(this._normalizeKey(name)); + } + get(name) { + return super.get(this._normalizeKey(name)); + } + getAll(name) { + return super.getAll(this._normalizeKey(name)); + } + has(name) { + return super.has(this._normalizeKey(name)); + } + set(name, value) { + return super.set(this._normalizeKey(name), value); + } + keys() { + return super.keys(); + } + values() { + return super.values(); + } + entries() { + return super.entries(); + } + [Symbol.iterator]() { + return super[Symbol.iterator](); + } + _normalizeKey(name) { + return CaseInsensitiveMap.prototype._normalizeKey.call(this, name); + } + }; + } + var URLWithoutHost = class extends whatwg_url_1.URL { + }; + var MongoParseError = class extends Error { + get name() { + return "MongoParseError"; + } + }; + var ConnectionString = class _ConnectionString extends URLWithoutHost { + constructor(uri, options = {}) { + var _a; + const { looseValidation } = options; + if (!looseValidation && !connectionStringHasValidScheme(uri)) { + throw new MongoParseError('Invalid scheme, expected connection string to start with "mongodb://" or "mongodb+srv://"'); + } + const match = uri.match(HOSTS_REGEX); + if (!match) { + throw new MongoParseError(`Invalid connection string "${uri}"`); + } + const { protocol, username, password, hosts, rest } = (_a = match.groups) !== null && _a !== void 0 ? _a : {}; + if (!looseValidation) { + if (!protocol || !hosts) { + throw new MongoParseError(`Protocol and host list are required in "${uri}"`); + } + try { + decodeURIComponent(username !== null && username !== void 0 ? username : ""); + decodeURIComponent(password !== null && password !== void 0 ? password : ""); + } catch (err) { + throw new MongoParseError(err.message); + } + const illegalCharacters = /[:/?#[\]@]/gi; + if (username === null || username === void 0 ? void 0 : username.match(illegalCharacters)) { + throw new MongoParseError(`Username contains unescaped characters ${username}`); + } + if (!username || !password) { + const uriWithoutProtocol = uri.replace(`${protocol}://`, ""); + if (uriWithoutProtocol.startsWith("@") || uriWithoutProtocol.startsWith(":")) { + throw new MongoParseError("URI contained empty userinfo section"); + } + } + if (password === null || password === void 0 ? void 0 : password.match(illegalCharacters)) { + throw new MongoParseError("Password contains unescaped characters"); + } + } + let authString = ""; + if (typeof username === "string") + authString += username; + if (typeof password === "string") + authString += `:${password}`; + if (authString) + authString += "@"; + try { + super(`${protocol.toLowerCase()}://${authString}${DUMMY_HOSTNAME}${rest}`); + } catch (err) { + if (looseValidation) { + new _ConnectionString(uri, { + ...options, + looseValidation: false + }); + } + if (typeof err.message === "string") { + err.message = err.message.replace(DUMMY_HOSTNAME, hosts); + } + throw err; + } + this._hosts = hosts.split(","); + if (!looseValidation) { + if (this.isSRV && this.hosts.length !== 1) { + throw new MongoParseError("mongodb+srv URI cannot have multiple service names"); + } + if (this.isSRV && this.hosts.some((host) => host.includes(":"))) { + throw new MongoParseError("mongodb+srv URI cannot have port number"); + } + } + if (!this.pathname) { + this.pathname = "/"; + } + Object.setPrototypeOf(this.searchParams, caseInsenstiveURLSearchParams(this.searchParams.constructor).prototype); + } + get host() { + return DUMMY_HOSTNAME; + } + set host(_ignored) { + throw new Error("No single host for connection string"); + } + get hostname() { + return DUMMY_HOSTNAME; + } + set hostname(_ignored) { + throw new Error("No single host for connection string"); + } + get port() { + return ""; + } + set port(_ignored) { + throw new Error("No single host for connection string"); + } + get href() { + return this.toString(); + } + set href(_ignored) { + throw new Error("Cannot set href for connection strings"); + } + get isSRV() { + return this.protocol.includes("srv"); + } + get hosts() { + return this._hosts; + } + set hosts(list) { + this._hosts = list; + } + toString() { + return super.toString().replace(DUMMY_HOSTNAME, this.hosts.join(",")); + } + clone() { + return new _ConnectionString(this.toString(), { + looseValidation: true + }); + } + redact(options) { + return (0, redact_1.redactValidConnectionString)(this, options); + } + typedSearchParams() { + const sametype = false; + return this.searchParams; + } + [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() { + const { href, origin, protocol, username, password, hosts, pathname, search, searchParams, hash } = this; + return { href, origin, protocol, username, password, hosts, pathname, search, searchParams, hash }; + } + }; + exports2.ConnectionString = ConnectionString; + var CommaAndColonSeparatedRecord = class extends CaseInsensitiveMap { + constructor(from) { + super(); + for (const entry of (from !== null && from !== void 0 ? from : "").split(",")) { + if (!entry) + continue; + const colonIndex = entry.indexOf(":"); + if (colonIndex === -1) { + this.set(entry, ""); + } else { + this.set(entry.slice(0, colonIndex), entry.slice(colonIndex + 1)); + } + } + } + toString() { + return [...this].map((entry) => entry.join(":")).join(","); + } + }; + exports2.CommaAndColonSeparatedRecord = CommaAndColonSeparatedRecord; + exports2.default = ConnectionString; + } +}); + +// node_modules/mongodb/lib/cmap/commands.js +var require_commands3 = __commonJS({ + "node_modules/mongodb/lib/cmap/commands.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.OpCompressedRequest = exports2.OpMsgResponse = exports2.OpMsgRequest = exports2.DocumentSequence = exports2.OpReply = exports2.OpQueryRequest = void 0; + var BSON = require_bson2(); + var error_1 = require_error(); + var compression_1 = require_compression(); + var constants_1 = require_constants(); + var _requestId = 0; + var OPTS_TAILABLE_CURSOR = 2; + var OPTS_SECONDARY = 4; + var OPTS_OPLOG_REPLAY = 8; + var OPTS_NO_CURSOR_TIMEOUT = 16; + var OPTS_AWAIT_DATA = 32; + var OPTS_EXHAUST = 64; + var OPTS_PARTIAL = 128; + var CURSOR_NOT_FOUND = 1; + var QUERY_FAILURE = 2; + var SHARD_CONFIG_STALE = 4; + var AWAIT_CAPABLE = 8; + var encodeUTF8Into = BSON.BSON.onDemand.ByteUtils.encodeUTF8Into; + var OpQueryRequest = class _OpQueryRequest { + constructor(databaseName, query, options) { + this.moreToCome = false; + const ns = `${databaseName}.$cmd`; + if (typeof databaseName !== "string") { + throw new error_1.MongoRuntimeError("Database name must be a string for a query"); + } + if (query == null) + throw new error_1.MongoRuntimeError("A query document must be specified for query"); + if (ns.indexOf("\0") !== -1) { + throw new error_1.MongoRuntimeError("Namespace cannot contain a null character"); + } + this.databaseName = databaseName; + this.query = query; + this.ns = ns; + this.numberToSkip = options.numberToSkip || 0; + this.numberToReturn = options.numberToReturn || 0; + this.returnFieldSelector = options.returnFieldSelector || void 0; + this.requestId = options.requestId ?? _OpQueryRequest.getRequestId(); + this.pre32Limit = options.pre32Limit; + this.serializeFunctions = typeof options.serializeFunctions === "boolean" ? options.serializeFunctions : false; + this.ignoreUndefined = typeof options.ignoreUndefined === "boolean" ? options.ignoreUndefined : false; + this.maxBsonSize = options.maxBsonSize || 1024 * 1024 * 16; + this.checkKeys = typeof options.checkKeys === "boolean" ? options.checkKeys : false; + this.batchSize = this.numberToReturn; + this.tailable = false; + this.secondaryOk = typeof options.secondaryOk === "boolean" ? options.secondaryOk : false; + this.oplogReplay = false; + this.noCursorTimeout = false; + this.awaitData = false; + this.exhaust = false; + this.partial = false; + } + /** Assign next request Id. */ + incRequestId() { + this.requestId = _requestId++; + } + /** Peek next request Id. */ + nextRequestId() { + return _requestId + 1; + } + /** Increment then return next request Id. */ + static getRequestId() { + return ++_requestId; + } + // Uses a single allocated buffer for the process, avoiding multiple memory allocations + toBin() { + const buffers = []; + let projection = null; + let flags = 0; + if (this.tailable) { + flags |= OPTS_TAILABLE_CURSOR; + } + if (this.secondaryOk) { + flags |= OPTS_SECONDARY; + } + if (this.oplogReplay) { + flags |= OPTS_OPLOG_REPLAY; + } + if (this.noCursorTimeout) { + flags |= OPTS_NO_CURSOR_TIMEOUT; + } + if (this.awaitData) { + flags |= OPTS_AWAIT_DATA; + } + if (this.exhaust) { + flags |= OPTS_EXHAUST; + } + if (this.partial) { + flags |= OPTS_PARTIAL; + } + if (this.batchSize !== this.numberToReturn) + this.numberToReturn = this.batchSize; + const header = Buffer.alloc( + 4 * 4 + // Header + 4 + // Flags + Buffer.byteLength(this.ns) + 1 + // namespace + 4 + // numberToSkip + 4 + // numberToReturn + ); + buffers.push(header); + const query = BSON.serialize(this.query, { + checkKeys: this.checkKeys, + serializeFunctions: this.serializeFunctions, + ignoreUndefined: this.ignoreUndefined + }); + buffers.push(query); + if (this.returnFieldSelector && Object.keys(this.returnFieldSelector).length > 0) { + projection = BSON.serialize(this.returnFieldSelector, { + checkKeys: this.checkKeys, + serializeFunctions: this.serializeFunctions, + ignoreUndefined: this.ignoreUndefined + }); + buffers.push(projection); + } + const totalLength = header.length + query.length + (projection ? projection.length : 0); + let index = 4; + header[3] = totalLength >> 24 & 255; + header[2] = totalLength >> 16 & 255; + header[1] = totalLength >> 8 & 255; + header[0] = totalLength & 255; + header[index + 3] = this.requestId >> 24 & 255; + header[index + 2] = this.requestId >> 16 & 255; + header[index + 1] = this.requestId >> 8 & 255; + header[index] = this.requestId & 255; + index = index + 4; + header[index + 3] = 0 >> 24 & 255; + header[index + 2] = 0 >> 16 & 255; + header[index + 1] = 0 >> 8 & 255; + header[index] = 0 & 255; + index = index + 4; + header[index + 3] = constants_1.OP_QUERY >> 24 & 255; + header[index + 2] = constants_1.OP_QUERY >> 16 & 255; + header[index + 1] = constants_1.OP_QUERY >> 8 & 255; + header[index] = constants_1.OP_QUERY & 255; + index = index + 4; + header[index + 3] = flags >> 24 & 255; + header[index + 2] = flags >> 16 & 255; + header[index + 1] = flags >> 8 & 255; + header[index] = flags & 255; + index = index + 4; + index = index + header.write(this.ns, index, "utf8") + 1; + header[index - 1] = 0; + header[index + 3] = this.numberToSkip >> 24 & 255; + header[index + 2] = this.numberToSkip >> 16 & 255; + header[index + 1] = this.numberToSkip >> 8 & 255; + header[index] = this.numberToSkip & 255; + index = index + 4; + header[index + 3] = this.numberToReturn >> 24 & 255; + header[index + 2] = this.numberToReturn >> 16 & 255; + header[index + 1] = this.numberToReturn >> 8 & 255; + header[index] = this.numberToReturn & 255; + index = index + 4; + return buffers; + } + }; + exports2.OpQueryRequest = OpQueryRequest; + var OpReply = class { + constructor(message, msgHeader, msgBody, opts) { + this.index = 0; + this.sections = []; + this.moreToCome = false; + this.parsed = false; + this.raw = message; + this.data = msgBody; + this.opts = opts ?? { + useBigInt64: false, + promoteLongs: true, + promoteValues: true, + promoteBuffers: false, + bsonRegExp: false + }; + this.length = msgHeader.length; + this.requestId = msgHeader.requestId; + this.responseTo = msgHeader.responseTo; + this.opCode = msgHeader.opCode; + this.fromCompressed = msgHeader.fromCompressed; + this.useBigInt64 = typeof this.opts.useBigInt64 === "boolean" ? this.opts.useBigInt64 : false; + this.promoteLongs = typeof this.opts.promoteLongs === "boolean" ? this.opts.promoteLongs : true; + this.promoteValues = typeof this.opts.promoteValues === "boolean" ? this.opts.promoteValues : true; + this.promoteBuffers = typeof this.opts.promoteBuffers === "boolean" ? this.opts.promoteBuffers : false; + this.bsonRegExp = typeof this.opts.bsonRegExp === "boolean" ? this.opts.bsonRegExp : false; + } + isParsed() { + return this.parsed; + } + parse() { + if (this.parsed) + return this.sections[0]; + this.index = 20; + this.responseFlags = this.data.readInt32LE(0); + this.cursorId = new BSON.Long(this.data.readInt32LE(4), this.data.readInt32LE(8)); + this.startingFrom = this.data.readInt32LE(12); + this.numberReturned = this.data.readInt32LE(16); + if (this.numberReturned < 0 || this.numberReturned > 2 ** 32 - 1) { + throw new RangeError(`OP_REPLY numberReturned is an invalid array length ${this.numberReturned}`); + } + this.cursorNotFound = (this.responseFlags & CURSOR_NOT_FOUND) !== 0; + this.queryFailure = (this.responseFlags & QUERY_FAILURE) !== 0; + this.shardConfigStale = (this.responseFlags & SHARD_CONFIG_STALE) !== 0; + this.awaitCapable = (this.responseFlags & AWAIT_CAPABLE) !== 0; + for (let i = 0; i < this.numberReturned; i++) { + const bsonSize = this.data[this.index] | this.data[this.index + 1] << 8 | this.data[this.index + 2] << 16 | this.data[this.index + 3] << 24; + const section = this.data.subarray(this.index, this.index + bsonSize); + this.sections.push(section); + this.index = this.index + bsonSize; + } + this.parsed = true; + return this.sections[0]; + } + }; + exports2.OpReply = OpReply; + var OPTS_CHECKSUM_PRESENT = 1; + var OPTS_MORE_TO_COME = 2; + var OPTS_EXHAUST_ALLOWED = 1 << 16; + var DocumentSequence = class { + /** + * Create a new document sequence for the provided field. + * @param field - The field it will replace. + */ + constructor(field, documents) { + this.field = field; + this.documents = []; + this.chunks = []; + this.serializedDocumentsLength = 0; + const buffer = Buffer.allocUnsafe(1 + 4 + this.field.length + 1); + buffer[0] = 1; + encodeUTF8Into(buffer, `${this.field}\0`, 5); + this.chunks.push(buffer); + this.header = buffer; + if (documents) { + for (const doc of documents) { + this.push(doc, BSON.serialize(doc)); + } + } + } + /** + * Push a document to the document sequence. Will serialize the document + * as well and return the current serialized length of all documents. + * @param document - The document to add. + * @param buffer - The serialized document in raw BSON. + * @returns The new total document sequence length. + */ + push(document, buffer) { + this.serializedDocumentsLength += buffer.length; + this.documents.push(document); + this.chunks.push(buffer); + this.header?.writeInt32LE(4 + this.field.length + 1 + this.serializedDocumentsLength, 1); + return this.serializedDocumentsLength + this.header.length; + } + /** + * Get the fully serialized bytes for the document sequence section. + * @returns The section bytes. + */ + toBin() { + return Buffer.concat(this.chunks); + } + }; + exports2.DocumentSequence = DocumentSequence; + var OpMsgRequest = class _OpMsgRequest { + constructor(databaseName, command, options) { + if (command == null) + throw new error_1.MongoInvalidArgumentError("Query document must be specified for query"); + this.databaseName = databaseName; + this.command = command; + this.command.$db = databaseName; + this.options = options ?? {}; + this.requestId = options.requestId ? options.requestId : _OpMsgRequest.getRequestId(); + this.serializeFunctions = typeof options.serializeFunctions === "boolean" ? options.serializeFunctions : false; + this.ignoreUndefined = typeof options.ignoreUndefined === "boolean" ? options.ignoreUndefined : false; + this.checkKeys = typeof options.checkKeys === "boolean" ? options.checkKeys : false; + this.maxBsonSize = options.maxBsonSize || 1024 * 1024 * 16; + this.checksumPresent = false; + this.moreToCome = options.moreToCome ?? command.writeConcern?.w === 0; + this.exhaustAllowed = typeof options.exhaustAllowed === "boolean" ? options.exhaustAllowed : false; + } + toBin() { + const buffers = []; + let flags = 0; + if (this.checksumPresent) { + flags |= OPTS_CHECKSUM_PRESENT; + } + if (this.moreToCome) { + flags |= OPTS_MORE_TO_COME; + } + if (this.exhaustAllowed) { + flags |= OPTS_EXHAUST_ALLOWED; + } + const header = Buffer.alloc( + 4 * 4 + // Header + 4 + // Flags + ); + buffers.push(header); + let totalLength = header.length; + const command = this.command; + totalLength += this.makeSections(buffers, command); + header.writeInt32LE(totalLength, 0); + header.writeInt32LE(this.requestId, 4); + header.writeInt32LE(0, 8); + header.writeInt32LE(constants_1.OP_MSG, 12); + header.writeUInt32LE(flags, 16); + return buffers; + } + /** + * Add the sections to the OP_MSG request's buffers and returns the length. + */ + makeSections(buffers, document) { + const sequencesBuffer = this.extractDocumentSequences(document); + const payloadTypeBuffer = Buffer.allocUnsafe(1); + payloadTypeBuffer[0] = 0; + const documentBuffer = this.serializeBson(document); + buffers.push(payloadTypeBuffer); + buffers.push(documentBuffer); + buffers.push(sequencesBuffer); + return payloadTypeBuffer.length + documentBuffer.length + sequencesBuffer.length; + } + /** + * Extracts the document sequences from the command document and returns + * a buffer to be added as multiple sections after the initial type 0 + * section in the message. + */ + extractDocumentSequences(document) { + const chunks = []; + for (const [key, value] of Object.entries(document)) { + if (value instanceof DocumentSequence) { + chunks.push(value.toBin()); + delete document[key]; + } + } + if (chunks.length > 0) { + return Buffer.concat(chunks); + } + return Buffer.alloc(0); + } + serializeBson(document) { + return BSON.serialize(document, { + checkKeys: this.checkKeys, + serializeFunctions: this.serializeFunctions, + ignoreUndefined: this.ignoreUndefined + }); + } + static getRequestId() { + _requestId = _requestId + 1 & 2147483647; + return _requestId; + } + }; + exports2.OpMsgRequest = OpMsgRequest; + var OpMsgResponse = class { + constructor(message, msgHeader, msgBody, opts) { + this.index = 0; + this.sections = []; + this.parsed = false; + this.raw = message; + this.data = msgBody; + this.opts = opts ?? { + useBigInt64: false, + promoteLongs: true, + promoteValues: true, + promoteBuffers: false, + bsonRegExp: false + }; + this.length = msgHeader.length; + this.requestId = msgHeader.requestId; + this.responseTo = msgHeader.responseTo; + this.opCode = msgHeader.opCode; + this.fromCompressed = msgHeader.fromCompressed; + this.responseFlags = msgBody.readInt32LE(0); + this.checksumPresent = (this.responseFlags & OPTS_CHECKSUM_PRESENT) !== 0; + this.moreToCome = (this.responseFlags & OPTS_MORE_TO_COME) !== 0; + this.exhaustAllowed = (this.responseFlags & OPTS_EXHAUST_ALLOWED) !== 0; + this.useBigInt64 = typeof this.opts.useBigInt64 === "boolean" ? this.opts.useBigInt64 : false; + this.promoteLongs = typeof this.opts.promoteLongs === "boolean" ? this.opts.promoteLongs : true; + this.promoteValues = typeof this.opts.promoteValues === "boolean" ? this.opts.promoteValues : true; + this.promoteBuffers = typeof this.opts.promoteBuffers === "boolean" ? this.opts.promoteBuffers : false; + this.bsonRegExp = typeof this.opts.bsonRegExp === "boolean" ? this.opts.bsonRegExp : false; + } + isParsed() { + return this.parsed; + } + parse() { + if (this.parsed) + return this.sections[0]; + this.index = 4; + while (this.index < this.data.length) { + const payloadType = this.data.readUInt8(this.index++); + if (payloadType === 0) { + const bsonSize = this.data.readUInt32LE(this.index); + const bin = this.data.subarray(this.index, this.index + bsonSize); + this.sections.push(bin); + this.index += bsonSize; + } else if (payloadType === 1) { + throw new error_1.MongoRuntimeError("OP_MSG Payload Type 1 detected unsupported protocol"); + } + } + this.parsed = true; + return this.sections[0]; + } + }; + exports2.OpMsgResponse = OpMsgResponse; + var MESSAGE_HEADER_SIZE = 16; + var COMPRESSION_DETAILS_SIZE = 9; + var OpCompressedRequest = class { + constructor(command, options) { + this.command = command; + this.options = { + zlibCompressionLevel: options.zlibCompressionLevel, + agreedCompressor: options.agreedCompressor + }; + } + // Return whether a command contains an uncompressible command term + // Will return true if command contains no uncompressible command terms + static canCompress(command) { + const commandDoc = command instanceof OpMsgRequest ? command.command : command.query; + const commandName = Object.keys(commandDoc)[0]; + return !compression_1.uncompressibleCommands.has(commandName); + } + async toBin() { + const concatenatedOriginalCommandBuffer = Buffer.concat(this.command.toBin()); + const messageToBeCompressed = concatenatedOriginalCommandBuffer.slice(MESSAGE_HEADER_SIZE); + const originalCommandOpCode = concatenatedOriginalCommandBuffer.readInt32LE(12); + const compressedMessage = await (0, compression_1.compress)(this.options, messageToBeCompressed); + const msgHeader = Buffer.alloc(MESSAGE_HEADER_SIZE); + msgHeader.writeInt32LE(MESSAGE_HEADER_SIZE + COMPRESSION_DETAILS_SIZE + compressedMessage.length, 0); + msgHeader.writeInt32LE(this.command.requestId, 4); + msgHeader.writeInt32LE(0, 8); + msgHeader.writeInt32LE(constants_1.OP_COMPRESSED, 12); + const compressionDetails = Buffer.alloc(COMPRESSION_DETAILS_SIZE); + compressionDetails.writeInt32LE(originalCommandOpCode, 0); + compressionDetails.writeInt32LE(messageToBeCompressed.length, 4); + compressionDetails.writeUInt8(compression_1.Compressor[this.options.agreedCompressor], 8); + return [msgHeader, compressionDetails, compressedMessage]; + } + }; + exports2.OpCompressedRequest = OpCompressedRequest; + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/compression.js +var require_compression = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/compression.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.uncompressibleCommands = exports2.Compressor = void 0; + exports2.compress = compress; + exports2.decompress = decompress; + exports2.compressCommand = compressCommand; + exports2.decompressResponse = decompressResponse; + var util_1 = require("util"); + var zlib = require("zlib"); + var constants_1 = require_constants2(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var commands_1 = require_commands3(); + var constants_2 = require_constants(); + exports2.Compressor = Object.freeze({ + none: 0, + snappy: 1, + zlib: 2, + zstd: 3 + }); + exports2.uncompressibleCommands = /* @__PURE__ */ new Set([ + constants_1.LEGACY_HELLO_COMMAND, + "saslStart", + "saslContinue", + "getnonce", + "authenticate", + "createUser", + "updateUser", + "copydbSaslStart", + "copydbgetnonce", + "copydb" + ]); + var ZSTD_COMPRESSION_LEVEL = 3; + var zlibInflate = (0, util_1.promisify)(zlib.inflate.bind(zlib)); + var zlibDeflate = (0, util_1.promisify)(zlib.deflate.bind(zlib)); + var zstd; + var Snappy = null; + function loadSnappy() { + if (Snappy == null) { + const snappyImport = (0, deps_1.getSnappy)(); + if ("kModuleError" in snappyImport) { + throw snappyImport.kModuleError; + } + Snappy = snappyImport; + } + return Snappy; + } + async function compress(options, dataToBeCompressed) { + const zlibOptions = {}; + switch (options.agreedCompressor) { + case "snappy": { + Snappy ??= loadSnappy(); + return await Snappy.compress(dataToBeCompressed); + } + case "zstd": { + loadZstd(); + if ("kModuleError" in zstd) { + throw zstd["kModuleError"]; + } + return await zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL); + } + case "zlib": { + if (options.zlibCompressionLevel) { + zlibOptions.level = options.zlibCompressionLevel; + } + return await zlibDeflate(dataToBeCompressed, zlibOptions); + } + default: { + throw new error_1.MongoInvalidArgumentError(`Unknown compressor ${options.agreedCompressor} failed to compress`); + } + } + } + async function decompress(compressorID, compressedData) { + if (compressorID !== exports2.Compressor.snappy && compressorID !== exports2.Compressor.zstd && compressorID !== exports2.Compressor.zlib && compressorID !== exports2.Compressor.none) { + throw new error_1.MongoDecompressionError(`Server sent message compressed using an unsupported compressor. (Received compressor ID ${compressorID})`); + } + switch (compressorID) { + case exports2.Compressor.snappy: { + Snappy ??= loadSnappy(); + return await Snappy.uncompress(compressedData, { asBuffer: true }); + } + case exports2.Compressor.zstd: { + loadZstd(); + if ("kModuleError" in zstd) { + throw zstd["kModuleError"]; + } + return await zstd.decompress(compressedData); + } + case exports2.Compressor.zlib: { + return await zlibInflate(compressedData); + } + default: { + return compressedData; + } + } + } + function loadZstd() { + if (!zstd) { + zstd = (0, deps_1.getZstdLibrary)(); + } + } + var MESSAGE_HEADER_SIZE = 16; + async function compressCommand(command, description) { + const finalCommand = description.agreedCompressor === "none" || !commands_1.OpCompressedRequest.canCompress(command) ? command : new commands_1.OpCompressedRequest(command, { + agreedCompressor: description.agreedCompressor ?? "none", + zlibCompressionLevel: description.zlibCompressionLevel ?? 0 + }); + const data = await finalCommand.toBin(); + return Buffer.concat(data); + } + async function decompressResponse(message) { + const messageHeader = { + length: message.readInt32LE(0), + requestId: message.readInt32LE(4), + responseTo: message.readInt32LE(8), + opCode: message.readInt32LE(12) + }; + if (messageHeader.opCode !== constants_2.OP_COMPRESSED) { + const ResponseType2 = messageHeader.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply; + const messageBody2 = message.subarray(MESSAGE_HEADER_SIZE); + return new ResponseType2(message, messageHeader, messageBody2); + } + const header = { + ...messageHeader, + fromCompressed: true, + opCode: message.readInt32LE(MESSAGE_HEADER_SIZE), + length: message.readInt32LE(MESSAGE_HEADER_SIZE + 4) + }; + const compressorID = message[MESSAGE_HEADER_SIZE + 8]; + const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9); + const ResponseType = header.opCode === constants_2.OP_MSG ? commands_1.OpMsgResponse : commands_1.OpReply; + const messageBody = await decompress(compressorID, compressedBuffer); + if (messageBody.length !== header.length) { + throw new error_1.MongoDecompressionError("Message body and message header must be the same length"); + } + return new ResponseType(message, header, messageBody); + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/crypto_callbacks.js +var require_crypto_callbacks = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/crypto_callbacks.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.hmacSha256Hook = exports2.hmacSha512Hook = exports2.aes256CtrDecryptHook = exports2.aes256CtrEncryptHook = exports2.aes256CbcDecryptHook = exports2.aes256CbcEncryptHook = void 0; + exports2.makeAES256Hook = makeAES256Hook; + exports2.randomHook = randomHook; + exports2.sha256Hook = sha256Hook; + exports2.makeHmacHook = makeHmacHook; + exports2.signRsaSha256Hook = signRsaSha256Hook; + var crypto = require("crypto"); + function makeAES256Hook(method, mode) { + return function(key, iv, input, output) { + let result; + try { + const cipher = crypto[method](mode, key, iv); + cipher.setAutoPadding(false); + result = cipher.update(input); + const final = cipher.final(); + if (final.length > 0) { + result = Buffer.concat([result, final]); + } + } catch (e) { + return e; + } + result.copy(output); + return result.length; + }; + } + function randomHook(buffer, count) { + try { + crypto.randomFillSync(buffer, 0, count); + } catch (e) { + return e; + } + return count; + } + function sha256Hook(input, output) { + let result; + try { + result = crypto.createHash("sha256").update(input).digest(); + } catch (e) { + return e; + } + result.copy(output); + return result.length; + } + function makeHmacHook(algorithm) { + return (key, input, output) => { + let result; + try { + result = crypto.createHmac(algorithm, key).update(input).digest(); + } catch (e) { + return e; + } + result.copy(output); + return result.length; + }; + } + function signRsaSha256Hook(key, input, output) { + let result; + try { + const signer = crypto.createSign("sha256WithRSAEncryption"); + const privateKey = Buffer.from(`-----BEGIN PRIVATE KEY----- +${key.toString("base64")} +-----END PRIVATE KEY----- +`); + result = signer.update(input).end().sign(privateKey); + } catch (e) { + return e; + } + result.copy(output); + return result.length; + } + exports2.aes256CbcEncryptHook = makeAES256Hook("createCipheriv", "aes-256-cbc"); + exports2.aes256CbcDecryptHook = makeAES256Hook("createDecipheriv", "aes-256-cbc"); + exports2.aes256CtrEncryptHook = makeAES256Hook("createCipheriv", "aes-256-ctr"); + exports2.aes256CtrDecryptHook = makeAES256Hook("createDecipheriv", "aes-256-ctr"); + exports2.hmacSha512Hook = makeHmacHook("sha512"); + exports2.hmacSha256Hook = makeHmacHook("sha256"); + } +}); + +// node_modules/mongodb/lib/client-side-encryption/errors.js +var require_errors2 = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/errors.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoCryptKMSRequestNetworkTimeoutError = exports2.MongoCryptAzureKMSRequestError = exports2.MongoCryptCreateEncryptedCollectionError = exports2.MongoCryptCreateDataKeyError = exports2.MongoCryptInvalidArgumentError = exports2.MongoCryptError = void 0; + var error_1 = require_error(); + var MongoCryptError = class extends error_1.MongoError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, options = {}) { + super(message, options); + } + get name() { + return "MongoCryptError"; + } + }; + exports2.MongoCryptError = MongoCryptError; + var MongoCryptInvalidArgumentError = class extends MongoCryptError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message) { + super(message); + } + get name() { + return "MongoCryptInvalidArgumentError"; + } + }; + exports2.MongoCryptInvalidArgumentError = MongoCryptInvalidArgumentError; + var MongoCryptCreateDataKeyError = class extends MongoCryptError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(encryptedFields, { cause }) { + super(`Unable to complete creating data keys: ${cause.message}`, { cause }); + this.encryptedFields = encryptedFields; + } + get name() { + return "MongoCryptCreateDataKeyError"; + } + }; + exports2.MongoCryptCreateDataKeyError = MongoCryptCreateDataKeyError; + var MongoCryptCreateEncryptedCollectionError = class extends MongoCryptError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(encryptedFields, { cause }) { + super(`Unable to create collection: ${cause.message}`, { cause }); + this.encryptedFields = encryptedFields; + } + get name() { + return "MongoCryptCreateEncryptedCollectionError"; + } + }; + exports2.MongoCryptCreateEncryptedCollectionError = MongoCryptCreateEncryptedCollectionError; + var MongoCryptAzureKMSRequestError = class extends MongoCryptError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, body) { + super(message); + this.body = body; + } + get name() { + return "MongoCryptAzureKMSRequestError"; + } + }; + exports2.MongoCryptAzureKMSRequestError = MongoCryptAzureKMSRequestError; + var MongoCryptKMSRequestNetworkTimeoutError = class extends MongoCryptError { + get name() { + return "MongoCryptKMSRequestNetworkTimeoutError"; + } + }; + exports2.MongoCryptKMSRequestNetworkTimeoutError = MongoCryptKMSRequestNetworkTimeoutError; + } +}); + +// node_modules/mongodb/lib/cmap/auth/aws_temporary_credentials.js +var require_aws_temporary_credentials = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/aws_temporary_credentials.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.LegacyAWSTemporaryCredentialProvider = exports2.AWSSDKCredentialProvider = exports2.AWSTemporaryCredentialProvider = void 0; + var deps_1 = require_deps(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var AWS_RELATIVE_URI = "http://169.254.170.2"; + var AWS_EC2_URI = "http://169.254.169.254"; + var AWS_EC2_PATH = "/latest/meta-data/iam/security-credentials"; + var AWSTemporaryCredentialProvider = class _AWSTemporaryCredentialProvider { + static get awsSDK() { + _AWSTemporaryCredentialProvider._awsSDK ??= (0, deps_1.getAwsCredentialProvider)(); + return _AWSTemporaryCredentialProvider._awsSDK; + } + static get isAWSSDKInstalled() { + return !("kModuleError" in _AWSTemporaryCredentialProvider.awsSDK); + } + }; + exports2.AWSTemporaryCredentialProvider = AWSTemporaryCredentialProvider; + var AWSSDKCredentialProvider = class extends AWSTemporaryCredentialProvider { + /** + * Create the SDK credentials provider. + * @param credentialsProvider - The credentials provider. + */ + constructor(credentialsProvider) { + super(); + if (credentialsProvider) { + this._provider = credentialsProvider; + } + } + /** + * The AWS SDK caches credentials automatically and handles refresh when the credentials have expired. + * To ensure this occurs, we need to cache the `provider` returned by the AWS sdk and re-use it when fetching credentials. + */ + get provider() { + if ("kModuleError" in AWSTemporaryCredentialProvider.awsSDK) { + throw AWSTemporaryCredentialProvider.awsSDK.kModuleError; + } + if (this._provider) { + return this._provider; + } + let { AWS_STS_REGIONAL_ENDPOINTS = "", AWS_REGION = "" } = process.env; + AWS_STS_REGIONAL_ENDPOINTS = AWS_STS_REGIONAL_ENDPOINTS.toLowerCase(); + AWS_REGION = AWS_REGION.toLowerCase(); + const awsRegionSettingsExist = AWS_REGION.length !== 0 && AWS_STS_REGIONAL_ENDPOINTS.length !== 0; + const LEGACY_REGIONS = /* @__PURE__ */ new Set([ + "ap-northeast-1", + "ap-south-1", + "ap-southeast-1", + "ap-southeast-2", + "aws-global", + "ca-central-1", + "eu-central-1", + "eu-north-1", + "eu-west-1", + "eu-west-2", + "eu-west-3", + "sa-east-1", + "us-east-1", + "us-east-2", + "us-west-1", + "us-west-2" + ]); + const useRegionalSts = AWS_STS_REGIONAL_ENDPOINTS === "regional" || AWS_STS_REGIONAL_ENDPOINTS === "legacy" && !LEGACY_REGIONS.has(AWS_REGION); + this._provider = awsRegionSettingsExist && useRegionalSts ? AWSTemporaryCredentialProvider.awsSDK.fromNodeProviderChain({ + clientConfig: { region: AWS_REGION } + }) : AWSTemporaryCredentialProvider.awsSDK.fromNodeProviderChain(); + return this._provider; + } + async getCredentials() { + try { + const creds = await this.provider(); + return { + AccessKeyId: creds.accessKeyId, + SecretAccessKey: creds.secretAccessKey, + Token: creds.sessionToken, + Expiration: creds.expiration + }; + } catch (error) { + throw new error_1.MongoAWSError(error.message, { cause: error }); + } + } + }; + exports2.AWSSDKCredentialProvider = AWSSDKCredentialProvider; + var LegacyAWSTemporaryCredentialProvider = class extends AWSTemporaryCredentialProvider { + async getCredentials() { + if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) { + return await (0, utils_1.request)(`${AWS_RELATIVE_URI}${process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}`); + } + const token = await (0, utils_1.request)(`${AWS_EC2_URI}/latest/api/token`, { + method: "PUT", + json: false, + headers: { "X-aws-ec2-metadata-token-ttl-seconds": 30 } + }); + const roleName = await (0, utils_1.request)(`${AWS_EC2_URI}/${AWS_EC2_PATH}`, { + json: false, + headers: { "X-aws-ec2-metadata-token": token } + }); + const creds = await (0, utils_1.request)(`${AWS_EC2_URI}/${AWS_EC2_PATH}/${roleName}`, { + headers: { "X-aws-ec2-metadata-token": token } + }); + return creds; + } + }; + exports2.LegacyAWSTemporaryCredentialProvider = LegacyAWSTemporaryCredentialProvider; + } +}); + +// node_modules/mongodb/lib/client-side-encryption/providers/aws.js +var require_aws = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/providers/aws.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.loadAWSCredentials = loadAWSCredentials; + var aws_temporary_credentials_1 = require_aws_temporary_credentials(); + async function loadAWSCredentials(kmsProviders, provider) { + const credentialProvider = new aws_temporary_credentials_1.AWSSDKCredentialProvider(provider); + const { SecretAccessKey = "", AccessKeyId = "", Token } = await credentialProvider.getCredentials(); + const aws = { + secretAccessKey: SecretAccessKey, + accessKeyId: AccessKeyId + }; + Token != null && (aws.sessionToken = Token); + return { ...kmsProviders, aws }; + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/providers/azure.js +var require_azure = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/providers/azure.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.tokenCache = exports2.AzureCredentialCache = exports2.AZURE_BASE_URL = void 0; + exports2.addAzureParams = addAzureParams; + exports2.prepareRequest = prepareRequest; + exports2.fetchAzureKMSToken = fetchAzureKMSToken; + exports2.loadAzureCredentials = loadAzureCredentials; + var error_1 = require_error(); + var utils_1 = require_utils3(); + var errors_1 = require_errors2(); + var MINIMUM_TOKEN_REFRESH_IN_MILLISECONDS = 6e3; + exports2.AZURE_BASE_URL = "http://169.254.169.254/metadata/identity/oauth2/token?"; + var AzureCredentialCache = class { + constructor() { + this.cachedToken = null; + } + async getToken() { + if (this.cachedToken == null || this.needsRefresh(this.cachedToken)) { + this.cachedToken = await this._getToken(); + } + return { accessToken: this.cachedToken.accessToken }; + } + needsRefresh(token) { + const timeUntilExpirationMS = token.expiresOnTimestamp - Date.now(); + return timeUntilExpirationMS <= MINIMUM_TOKEN_REFRESH_IN_MILLISECONDS; + } + /** + * exposed for testing + */ + resetCache() { + this.cachedToken = null; + } + /** + * exposed for testing + */ + _getToken() { + return fetchAzureKMSToken(); + } + }; + exports2.AzureCredentialCache = AzureCredentialCache; + exports2.tokenCache = new AzureCredentialCache(); + async function parseResponse(response) { + const { status, body: rawBody } = response; + const body = (() => { + try { + return JSON.parse(rawBody); + } catch { + throw new errors_1.MongoCryptAzureKMSRequestError("Malformed JSON body in GET request."); + } + })(); + if (status !== 200) { + throw new errors_1.MongoCryptAzureKMSRequestError("Unable to complete request.", body); + } + if (!body.access_token) { + throw new errors_1.MongoCryptAzureKMSRequestError("Malformed response body - missing field `access_token`."); + } + if (!body.expires_in) { + throw new errors_1.MongoCryptAzureKMSRequestError("Malformed response body - missing field `expires_in`."); + } + const expiresInMS = Number(body.expires_in) * 1e3; + if (Number.isNaN(expiresInMS)) { + throw new errors_1.MongoCryptAzureKMSRequestError("Malformed response body - unable to parse int from `expires_in` field."); + } + return { + accessToken: body.access_token, + expiresOnTimestamp: Date.now() + expiresInMS + }; + } + function addAzureParams(url, resource, username) { + url.searchParams.append("api-version", "2018-02-01"); + url.searchParams.append("resource", resource); + if (username) { + url.searchParams.append("client_id", username); + } + return url; + } + function prepareRequest(options) { + const url = new URL(options.url?.toString() ?? exports2.AZURE_BASE_URL); + addAzureParams(url, "https://vault.azure.net"); + const headers = { ...options.headers, "Content-Type": "application/json", Metadata: true }; + return { headers, url }; + } + async function fetchAzureKMSToken(options = {}) { + const { headers, url } = prepareRequest(options); + try { + const response = await (0, utils_1.get)(url, { headers }); + return await parseResponse(response); + } catch (error) { + if (error instanceof error_1.MongoNetworkTimeoutError) { + throw new errors_1.MongoCryptAzureKMSRequestError(`[Azure KMS] ${error.message}`); + } + throw error; + } + } + async function loadAzureCredentials(kmsProviders) { + const azure = await exports2.tokenCache.getToken(); + return { ...kmsProviders, azure }; + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/providers/gcp.js +var require_gcp = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/providers/gcp.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.loadGCPCredentials = loadGCPCredentials; + var deps_1 = require_deps(); + async function loadGCPCredentials(kmsProviders) { + const gcpMetadata = (0, deps_1.getGcpMetadata)(); + if ("kModuleError" in gcpMetadata) { + return kmsProviders; + } + const { access_token: accessToken } = await gcpMetadata.instance({ + property: "service-accounts/default/token" + }); + return { ...kmsProviders, gcp: { accessToken } }; + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/providers/index.js +var require_providers2 = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/providers/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.isEmptyCredentials = isEmptyCredentials; + exports2.refreshKMSCredentials = refreshKMSCredentials; + var aws_1 = require_aws(); + var azure_1 = require_azure(); + var gcp_1 = require_gcp(); + function isEmptyCredentials(providerName, kmsProviders) { + const provider = kmsProviders[providerName]; + if (provider == null) { + return false; + } + return typeof provider === "object" && Object.keys(provider).length === 0; + } + async function refreshKMSCredentials(kmsProviders, credentialProviders) { + let finalKMSProviders = kmsProviders; + if (isEmptyCredentials("aws", kmsProviders)) { + finalKMSProviders = await (0, aws_1.loadAWSCredentials)(finalKMSProviders, credentialProviders?.aws); + } + if (isEmptyCredentials("gcp", kmsProviders)) { + finalKMSProviders = await (0, gcp_1.loadGCPCredentials)(finalKMSProviders); + } + if (isEmptyCredentials("azure", kmsProviders)) { + finalKMSProviders = await (0, azure_1.loadAzureCredentials)(finalKMSProviders); + } + return finalKMSProviders; + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/state_machine.js +var require_state_machine = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/state_machine.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.StateMachine = void 0; + var fs = require("fs/promises"); + var net = require("net"); + var tls = require("tls"); + var bson_1 = require_bson2(); + var abstract_cursor_1 = require_abstract_cursor(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var client_encryption_1 = require_client_encryption(); + var errors_1 = require_errors2(); + var socks = null; + function loadSocks() { + if (socks == null) { + const socksImport = (0, deps_1.getSocks)(); + if ("kModuleError" in socksImport) { + throw socksImport.kModuleError; + } + socks = socksImport; + } + return socks; + } + var MONGOCRYPT_CTX_ERROR = 0; + var MONGOCRYPT_CTX_NEED_MONGO_COLLINFO = 1; + var MONGOCRYPT_CTX_NEED_MONGO_MARKINGS = 2; + var MONGOCRYPT_CTX_NEED_MONGO_KEYS = 3; + var MONGOCRYPT_CTX_NEED_KMS_CREDENTIALS = 7; + var MONGOCRYPT_CTX_NEED_KMS = 4; + var MONGOCRYPT_CTX_READY = 5; + var MONGOCRYPT_CTX_DONE = 6; + var HTTPS_PORT = 443; + var stateToString = /* @__PURE__ */ new Map([ + [MONGOCRYPT_CTX_ERROR, "MONGOCRYPT_CTX_ERROR"], + [MONGOCRYPT_CTX_NEED_MONGO_COLLINFO, "MONGOCRYPT_CTX_NEED_MONGO_COLLINFO"], + [MONGOCRYPT_CTX_NEED_MONGO_MARKINGS, "MONGOCRYPT_CTX_NEED_MONGO_MARKINGS"], + [MONGOCRYPT_CTX_NEED_MONGO_KEYS, "MONGOCRYPT_CTX_NEED_MONGO_KEYS"], + [MONGOCRYPT_CTX_NEED_KMS_CREDENTIALS, "MONGOCRYPT_CTX_NEED_KMS_CREDENTIALS"], + [MONGOCRYPT_CTX_NEED_KMS, "MONGOCRYPT_CTX_NEED_KMS"], + [MONGOCRYPT_CTX_READY, "MONGOCRYPT_CTX_READY"], + [MONGOCRYPT_CTX_DONE, "MONGOCRYPT_CTX_DONE"] + ]); + var INSECURE_TLS_OPTIONS = [ + "tlsInsecure", + "tlsAllowInvalidCertificates", + "tlsAllowInvalidHostnames" + ]; + function debug(msg) { + if (process.env.MONGODB_CRYPT_DEBUG) { + console.error(msg); + } + } + var EMPTY_V; + var StateMachine = class { + constructor(options, bsonOptions = (0, bson_1.pluckBSONSerializeOptions)(options)) { + this.options = options; + this.bsonOptions = bsonOptions; + } + /** + * Executes the state machine according to the specification + */ + async execute(executor, context, options) { + const keyVaultNamespace = executor._keyVaultNamespace; + const keyVaultClient = executor._keyVaultClient; + const metaDataClient = executor._metaDataClient; + const mongocryptdClient = executor._mongocryptdClient; + const mongocryptdManager = executor._mongocryptdManager; + let result = null; + const getStatus = () => context.status; + const getState = () => context.state; + while (getState() !== MONGOCRYPT_CTX_DONE && getState() !== MONGOCRYPT_CTX_ERROR) { + options.signal?.throwIfAborted(); + debug(`[context#${context.id}] ${stateToString.get(getState()) || getState()}`); + switch (getState()) { + case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO: { + const filter = (0, bson_1.deserialize)(context.nextMongoOperation()); + if (!metaDataClient) { + throw new errors_1.MongoCryptError("unreachable state machine state: entered MONGOCRYPT_CTX_NEED_MONGO_COLLINFO but metadata client is undefined"); + } + const collInfoCursor = this.fetchCollectionInfo(metaDataClient, context.ns, filter, options); + for await (const collInfo of collInfoCursor) { + context.addMongoOperationResponse((0, bson_1.serialize)(collInfo)); + if (getState() === MONGOCRYPT_CTX_ERROR) + break; + } + if (getState() === MONGOCRYPT_CTX_ERROR) + break; + context.finishMongoOperation(); + break; + } + case MONGOCRYPT_CTX_NEED_MONGO_MARKINGS: { + const command = context.nextMongoOperation(); + if (getState() === MONGOCRYPT_CTX_ERROR) + break; + if (!mongocryptdClient) { + throw new errors_1.MongoCryptError("unreachable state machine state: entered MONGOCRYPT_CTX_NEED_MONGO_MARKINGS but mongocryptdClient is undefined"); + } + const markedCommand = mongocryptdManager ? await mongocryptdManager.withRespawn(this.markCommand.bind(this, mongocryptdClient, context.ns, command, options)) : await this.markCommand(mongocryptdClient, context.ns, command, options); + context.addMongoOperationResponse(markedCommand); + context.finishMongoOperation(); + break; + } + case MONGOCRYPT_CTX_NEED_MONGO_KEYS: { + const filter = context.nextMongoOperation(); + const keys = await this.fetchKeys(keyVaultClient, keyVaultNamespace, filter, options); + if (keys.length === 0) { + result = EMPTY_V ??= (0, bson_1.serialize)({ v: [] }); + } + for (const key of keys) { + context.addMongoOperationResponse((0, bson_1.serialize)(key)); + } + context.finishMongoOperation(); + break; + } + case MONGOCRYPT_CTX_NEED_KMS_CREDENTIALS: { + const kmsProviders = await executor.askForKMSCredentials(); + context.provideKMSProviders((0, bson_1.serialize)(kmsProviders)); + break; + } + case MONGOCRYPT_CTX_NEED_KMS: { + await Promise.all(this.requests(context, options)); + context.finishKMSRequests(); + break; + } + case MONGOCRYPT_CTX_READY: { + const finalizedContext = context.finalize(); + if (getState() === MONGOCRYPT_CTX_ERROR) { + const message = getStatus().message || "Finalization error"; + throw new errors_1.MongoCryptError(message); + } + result = finalizedContext; + break; + } + default: + throw new errors_1.MongoCryptError(`Unknown state: ${getState()}`); + } + } + if (getState() === MONGOCRYPT_CTX_ERROR || result == null) { + const message = getStatus().message; + if (!message) { + debug(`unidentifiable error in MongoCrypt - received an error status from \`libmongocrypt\` but received no error message.`); + } + throw new errors_1.MongoCryptError(message ?? "unidentifiable error in MongoCrypt - received an error status from `libmongocrypt` but received no error message."); + } + return result; + } + /** + * Handles the request to the KMS service. Exposed for testing purposes. Do not directly invoke. + * @param kmsContext - A C++ KMS context returned from the bindings + * @returns A promise that resolves when the KMS reply has be fully parsed + */ + async kmsRequest(request, options) { + const parsedUrl = request.endpoint.split(":"); + const port = parsedUrl[1] != null ? Number.parseInt(parsedUrl[1], 10) : HTTPS_PORT; + const socketOptions = { + host: parsedUrl[0], + servername: parsedUrl[0], + port, + ...(0, client_encryption_1.autoSelectSocketOptions)(this.options.socketOptions || {}) + }; + const message = request.message; + const buffer = new utils_1.BufferPool(); + let netSocket; + let socket; + function destroySockets() { + for (const sock of [socket, netSocket]) { + if (sock) { + sock.destroy(); + } + } + } + function onerror(cause) { + return new errors_1.MongoCryptError("KMS request failed", { cause }); + } + function onclose() { + return new errors_1.MongoCryptError("KMS request closed"); + } + const tlsOptions = this.options.tlsOptions; + if (tlsOptions) { + const kmsProvider = request.kmsProvider; + const providerTlsOptions = tlsOptions[kmsProvider]; + if (providerTlsOptions) { + const error = this.validateTlsOptions(kmsProvider, providerTlsOptions); + if (error) { + throw error; + } + try { + await this.setTlsOptions(providerTlsOptions, socketOptions); + } catch (err) { + throw onerror(err); + } + } + } + let abortListener; + try { + if (this.options.proxyOptions && this.options.proxyOptions.proxyHost) { + netSocket = new net.Socket(); + const { promise: willConnect, reject: rejectOnNetSocketError, resolve: resolveOnNetSocketConnect } = (0, utils_1.promiseWithResolvers)(); + netSocket.once("error", (err) => rejectOnNetSocketError(onerror(err))).once("close", () => rejectOnNetSocketError(onclose())).once("connect", () => resolveOnNetSocketConnect()); + const netSocketOptions = { + ...socketOptions, + host: this.options.proxyOptions.proxyHost, + port: this.options.proxyOptions.proxyPort || 1080 + }; + netSocket.connect(netSocketOptions); + await willConnect; + try { + socks ??= loadSocks(); + socketOptions.socket = (await socks.SocksClient.createConnection({ + existing_socket: netSocket, + command: "connect", + destination: { host: socketOptions.host, port: socketOptions.port }, + proxy: { + // host and port are ignored because we pass existing_socket + host: "iLoveJavaScript", + port: 0, + type: 5, + userId: this.options.proxyOptions.proxyUsername, + password: this.options.proxyOptions.proxyPassword + } + })).socket; + } catch (err) { + throw onerror(err); + } + } + socket = tls.connect(socketOptions, () => { + socket.write(message); + }); + const { promise: willResolveKmsRequest, reject: rejectOnTlsSocketError, resolve } = (0, utils_1.promiseWithResolvers)(); + abortListener = (0, utils_1.addAbortListener)(options?.signal, function() { + destroySockets(); + rejectOnTlsSocketError(this.reason); + }); + socket.once("error", (err) => rejectOnTlsSocketError(onerror(err))).once("close", () => rejectOnTlsSocketError(onclose())).on("data", (data) => { + buffer.append(data); + while (request.bytesNeeded > 0 && buffer.length) { + const bytesNeeded = Math.min(request.bytesNeeded, buffer.length); + request.addResponse(buffer.read(bytesNeeded)); + } + if (request.bytesNeeded <= 0) { + resolve(); + } + }); + await (options?.timeoutContext?.csotEnabled() ? Promise.all([ + willResolveKmsRequest, + timeout_1.Timeout.expires(options.timeoutContext?.remainingTimeMS) + ]) : willResolveKmsRequest); + } catch (error) { + if (error instanceof timeout_1.TimeoutError) + throw new error_1.MongoOperationTimeoutError("KMS request timed out"); + throw error; + } finally { + destroySockets(); + abortListener?.[utils_1.kDispose](); + } + } + *requests(context, options) { + for (let request = context.nextKMSRequest(); request != null; request = context.nextKMSRequest()) { + yield this.kmsRequest(request, options); + } + } + /** + * Validates the provided TLS options are secure. + * + * @param kmsProvider - The KMS provider name. + * @param tlsOptions - The client TLS options for the provider. + * + * @returns An error if any option is invalid. + */ + validateTlsOptions(kmsProvider, tlsOptions) { + const tlsOptionNames = Object.keys(tlsOptions); + for (const option of INSECURE_TLS_OPTIONS) { + if (tlsOptionNames.includes(option)) { + return new errors_1.MongoCryptError(`Insecure TLS options prohibited for ${kmsProvider}: ${option}`); + } + } + } + /** + * Sets only the valid secure TLS options. + * + * @param tlsOptions - The client TLS options for the provider. + * @param options - The existing connection options. + */ + async setTlsOptions(tlsOptions, options) { + if (tlsOptions.secureContext) { + options.secureContext = tlsOptions.secureContext; + } + if (tlsOptions.tlsCertificateKeyFile) { + const cert = await fs.readFile(tlsOptions.tlsCertificateKeyFile); + options.cert = options.key = cert; + } + if (tlsOptions.tlsCAFile) { + options.ca = await fs.readFile(tlsOptions.tlsCAFile); + } + if (tlsOptions.tlsCertificateKeyFilePassword) { + options.passphrase = tlsOptions.tlsCertificateKeyFilePassword; + } + } + /** + * Fetches collection info for a provided namespace, when libmongocrypt + * enters the `MONGOCRYPT_CTX_NEED_MONGO_COLLINFO` state. The result is + * used to inform libmongocrypt of the schema associated with this + * namespace. Exposed for testing purposes. Do not directly invoke. + * + * @param client - A MongoClient connected to the topology + * @param ns - The namespace to list collections from + * @param filter - A filter for the listCollections command + * @param callback - Invoked with the info of the requested collection, or with an error + */ + fetchCollectionInfo(client, ns, filter, options) { + const { db } = utils_1.MongoDBCollectionNamespace.fromString(ns); + const cursor = client.db(db).listCollections(filter, { + promoteLongs: false, + promoteValues: false, + timeoutContext: options?.timeoutContext && new abstract_cursor_1.CursorTimeoutContext(options?.timeoutContext, /* @__PURE__ */ Symbol()), + signal: options?.signal, + nameOnly: false + }); + return cursor; + } + /** + * Calls to the mongocryptd to provide markings for a command. + * Exposed for testing purposes. Do not directly invoke. + * @param client - A MongoClient connected to a mongocryptd + * @param ns - The namespace (database.collection) the command is being executed on + * @param command - The command to execute. + * @param callback - Invoked with the serialized and marked bson command, or with an error + */ + async markCommand(client, ns, command, options) { + const { db } = utils_1.MongoDBCollectionNamespace.fromString(ns); + const bsonOptions = { promoteLongs: false, promoteValues: false }; + const rawCommand = (0, bson_1.deserialize)(command, bsonOptions); + const commandOptions = { + timeoutMS: void 0, + signal: void 0 + }; + if (options?.timeoutContext?.csotEnabled()) { + commandOptions.timeoutMS = options.timeoutContext.remainingTimeMS; + } + if (options?.signal) { + commandOptions.signal = options.signal; + } + const response = await client.db(db).command(rawCommand, { + ...bsonOptions, + ...commandOptions + }); + return (0, bson_1.serialize)(response, this.bsonOptions); + } + /** + * Requests keys from the keyVault collection on the topology. + * Exposed for testing purposes. Do not directly invoke. + * @param client - A MongoClient connected to the topology + * @param keyVaultNamespace - The namespace (database.collection) of the keyVault Collection + * @param filter - The filter for the find query against the keyVault Collection + * @param callback - Invoked with the found keys, or with an error + */ + fetchKeys(client, keyVaultNamespace, filter, options) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(keyVaultNamespace); + const commandOptions = { + timeoutContext: void 0, + signal: void 0 + }; + if (options?.timeoutContext != null) { + commandOptions.timeoutContext = new abstract_cursor_1.CursorTimeoutContext(options.timeoutContext, /* @__PURE__ */ Symbol()); + } + if (options?.signal != null) { + commandOptions.signal = options.signal; + } + return client.db(dbName).collection(collectionName, { readConcern: { level: "majority" } }).find((0, bson_1.deserialize)(filter), commandOptions).toArray(); + } + }; + exports2.StateMachine = StateMachine; + } +}); + +// node_modules/mongodb/lib/client-side-encryption/client_encryption.js +var require_client_encryption = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/client_encryption.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientEncryption = void 0; + exports2.autoSelectSocketOptions = autoSelectSocketOptions; + var bson_1 = require_bson2(); + var deps_1 = require_deps(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var cryptoCallbacks = require_crypto_callbacks(); + var errors_1 = require_errors2(); + var index_1 = require_providers2(); + var state_machine_1 = require_state_machine(); + var ClientEncryption = class _ClientEncryption { + /** @internal */ + static getMongoCrypt() { + const encryption = (0, deps_1.getMongoDBClientEncryption)(); + if ("kModuleError" in encryption) { + throw encryption.kModuleError; + } + return encryption.MongoCrypt; + } + /** + * Create a new encryption instance + * + * @example + * ```ts + * new ClientEncryption(mongoClient, { + * keyVaultNamespace: 'client.encryption', + * kmsProviders: { + * local: { + * key: masterKey // The master key used for encryption/decryption. A 96-byte long Buffer + * } + * } + * }); + * ``` + * + * @example + * ```ts + * new ClientEncryption(mongoClient, { + * keyVaultNamespace: 'client.encryption', + * kmsProviders: { + * aws: { + * accessKeyId: AWS_ACCESS_KEY, + * secretAccessKey: AWS_SECRET_KEY + * } + * } + * }); + * ``` + */ + constructor(client, options) { + this._client = client; + this._proxyOptions = options.proxyOptions ?? {}; + this._tlsOptions = options.tlsOptions ?? {}; + this._kmsProviders = options.kmsProviders || {}; + const { timeoutMS } = (0, utils_1.resolveTimeoutOptions)(client, options); + this._timeoutMS = timeoutMS; + this._credentialProviders = options.credentialProviders; + if (options.credentialProviders?.aws && !(0, index_1.isEmptyCredentials)("aws", this._kmsProviders)) { + throw new errors_1.MongoCryptInvalidArgumentError("Can only provide a custom AWS credential provider when the state machine is configured for automatic AWS credential fetching"); + } + if (options.keyVaultNamespace == null) { + throw new errors_1.MongoCryptInvalidArgumentError("Missing required option `keyVaultNamespace`"); + } + const mongoCryptOptions = { + ...options, + cryptoCallbacks, + kmsProviders: !Buffer.isBuffer(this._kmsProviders) ? (0, bson_1.serialize)(this._kmsProviders) : this._kmsProviders + }; + this._keyVaultNamespace = options.keyVaultNamespace; + this._keyVaultClient = options.keyVaultClient || client; + const MongoCrypt = _ClientEncryption.getMongoCrypt(); + this._mongoCrypt = new MongoCrypt(mongoCryptOptions); + } + /** + * Creates a data key used for explicit encryption and inserts it into the key vault namespace + * + * @example + * ```ts + * // Using async/await to create a local key + * const dataKeyId = await clientEncryption.createDataKey('local'); + * ``` + * + * @example + * ```ts + * // Using async/await to create an aws key + * const dataKeyId = await clientEncryption.createDataKey('aws', { + * masterKey: { + * region: 'us-east-1', + * key: 'xxxxxxxxxxxxxx' // CMK ARN here + * } + * }); + * ``` + * + * @example + * ```ts + * // Using async/await to create an aws key with a keyAltName + * const dataKeyId = await clientEncryption.createDataKey('aws', { + * masterKey: { + * region: 'us-east-1', + * key: 'xxxxxxxxxxxxxx' // CMK ARN here + * }, + * keyAltNames: [ 'mySpecialKey' ] + * }); + * ``` + */ + async createDataKey(provider, options = {}) { + if (options.keyAltNames && !Array.isArray(options.keyAltNames)) { + throw new errors_1.MongoCryptInvalidArgumentError(`Option "keyAltNames" must be an array of strings, but was of type ${typeof options.keyAltNames}.`); + } + let keyAltNames = void 0; + if (options.keyAltNames && options.keyAltNames.length > 0) { + keyAltNames = options.keyAltNames.map((keyAltName, i) => { + if (typeof keyAltName !== "string") { + throw new errors_1.MongoCryptInvalidArgumentError(`Option "keyAltNames" must be an array of strings, but item at index ${i} was of type ${typeof keyAltName}`); + } + return (0, bson_1.serialize)({ keyAltName }); + }); + } + let keyMaterial = void 0; + if (options.keyMaterial) { + keyMaterial = (0, bson_1.serialize)({ keyMaterial: options.keyMaterial }); + } + const dataKeyBson = (0, bson_1.serialize)({ + provider, + ...options.masterKey + }); + const context = this._mongoCrypt.makeDataKeyContext(dataKeyBson, { + keyAltNames, + keyMaterial + }); + const stateMachine = new state_machine_1.StateMachine({ + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: autoSelectSocketOptions(this._client.s.options) + }); + const timeoutContext = options?.timeoutContext ?? timeout_1.TimeoutContext.create((0, utils_1.resolveTimeoutOptions)(this._client, { timeoutMS: this._timeoutMS })); + const dataKey = (0, bson_1.deserialize)(await stateMachine.execute(this, context, { timeoutContext })); + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + const { insertedId } = await this._keyVaultClient.db(dbName).collection(collectionName).insertOne(dataKey, { + writeConcern: { w: "majority" }, + timeoutMS: timeoutContext?.csotEnabled() ? timeoutContext?.getRemainingTimeMSOrThrow() : void 0 + }); + return insertedId; + } + /** + * Searches the keyvault for any data keys matching the provided filter. If there are matches, rewrapManyDataKey then attempts to re-wrap the data keys using the provided options. + * + * If no matches are found, then no bulk write is performed. + * + * @example + * ```ts + * // rewrapping all data data keys (using a filter that matches all documents) + * const filter = {}; + * + * const result = await clientEncryption.rewrapManyDataKey(filter); + * if (result.bulkWriteResult != null) { + * // keys were re-wrapped, results will be available in the bulkWrite object. + * } + * ``` + * + * @example + * ```ts + * // attempting to rewrap all data keys with no matches + * const filter = { _id: new Binary() } // assume _id matches no documents in the database + * const result = await clientEncryption.rewrapManyDataKey(filter); + * + * if (result.bulkWriteResult == null) { + * // no keys matched, `bulkWriteResult` does not exist on the result object + * } + * ``` + */ + async rewrapManyDataKey(filter, options) { + let keyEncryptionKeyBson = void 0; + if (options) { + const keyEncryptionKey = Object.assign({ provider: options.provider }, options.masterKey); + keyEncryptionKeyBson = (0, bson_1.serialize)(keyEncryptionKey); + } + const filterBson = (0, bson_1.serialize)(filter); + const context = this._mongoCrypt.makeRewrapManyDataKeyContext(filterBson, keyEncryptionKeyBson); + const stateMachine = new state_machine_1.StateMachine({ + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: autoSelectSocketOptions(this._client.s.options) + }); + const timeoutContext = timeout_1.TimeoutContext.create((0, utils_1.resolveTimeoutOptions)(this._client, { timeoutMS: this._timeoutMS })); + const { v: dataKeys } = (0, bson_1.deserialize)(await stateMachine.execute(this, context, { timeoutContext })); + if (dataKeys.length === 0) { + return {}; + } + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + const replacements = dataKeys.map((key) => ({ + updateOne: { + filter: { _id: key._id }, + update: { + $set: { + masterKey: key.masterKey, + keyMaterial: key.keyMaterial + }, + $currentDate: { + updateDate: true + } + } + } + })); + const result = await this._keyVaultClient.db(dbName).collection(collectionName).bulkWrite(replacements, { + writeConcern: { w: "majority" }, + timeoutMS: timeoutContext.csotEnabled() ? timeoutContext?.remainingTimeMS : void 0 + }); + return { bulkWriteResult: result }; + } + /** + * Deletes the key with the provided id from the keyvault, if it exists. + * + * @example + * ```ts + * // delete a key by _id + * const id = new Binary(); // id is a bson binary subtype 4 object + * const { deletedCount } = await clientEncryption.deleteKey(id); + * + * if (deletedCount != null && deletedCount > 0) { + * // successful deletion + * } + * ``` + * + */ + async deleteKey(_id) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + return await this._keyVaultClient.db(dbName).collection(collectionName).deleteOne({ _id }, { writeConcern: { w: "majority" }, timeoutMS: this._timeoutMS }); + } + /** + * Finds all the keys currently stored in the keyvault. + * + * This method will not throw. + * + * @returns a FindCursor over all keys in the keyvault. + * @example + * ```ts + * // fetching all keys + * const keys = await clientEncryption.getKeys().toArray(); + * ``` + */ + getKeys() { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + return this._keyVaultClient.db(dbName).collection(collectionName).find({}, { readConcern: { level: "majority" }, timeoutMS: this._timeoutMS }); + } + /** + * Finds a key in the keyvault with the specified _id. + * + * Returns a promise that either resolves to a {@link DataKey} if a document matches the key or null if no documents + * match the id. The promise rejects with an error if an error is thrown. + * @example + * ```ts + * // getting a key by id + * const id = new Binary(); // id is a bson binary subtype 4 object + * const key = await clientEncryption.getKey(id); + * if (!key) { + * // key is null if there was no matching key + * } + * ``` + */ + async getKey(_id) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + return await this._keyVaultClient.db(dbName).collection(collectionName).findOne({ _id }, { readConcern: { level: "majority" }, timeoutMS: this._timeoutMS }); + } + /** + * Finds a key in the keyvault which has the specified keyAltName. + * + * @param keyAltName - a keyAltName to search for a key + * @returns Returns a promise that either resolves to a {@link DataKey} if a document matches the key or null if no documents + * match the keyAltName. The promise rejects with an error if an error is thrown. + * @example + * ```ts + * // get a key by alt name + * const keyAltName = 'keyAltName'; + * const key = await clientEncryption.getKeyByAltName(keyAltName); + * if (!key) { + * // key is null if there is no matching key + * } + * ``` + */ + async getKeyByAltName(keyAltName) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + return await this._keyVaultClient.db(dbName).collection(collectionName).findOne({ keyAltNames: keyAltName }, { readConcern: { level: "majority" }, timeoutMS: this._timeoutMS }); + } + /** + * Adds a keyAltName to a key identified by the provided _id. + * + * This method resolves to/returns the *old* key value (prior to adding the new altKeyName). + * + * @param _id - The id of the document to update. + * @param keyAltName - a keyAltName to search for a key + * @returns Returns a promise that either resolves to a {@link DataKey} if a document matches the key or null if no documents + * match the id. The promise rejects with an error if an error is thrown. + * @example + * ```ts + * // adding an keyAltName to a data key + * const id = new Binary(); // id is a bson binary subtype 4 object + * const keyAltName = 'keyAltName'; + * const oldKey = await clientEncryption.addKeyAltName(id, keyAltName); + * if (!oldKey) { + * // null is returned if there is no matching document with an id matching the supplied id + * } + * ``` + */ + async addKeyAltName(_id, keyAltName) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + const value = await this._keyVaultClient.db(dbName).collection(collectionName).findOneAndUpdate({ _id }, { $addToSet: { keyAltNames: keyAltName } }, { writeConcern: { w: "majority" }, returnDocument: "before", timeoutMS: this._timeoutMS }); + return value; + } + /** + * Adds a keyAltName to a key identified by the provided _id. + * + * This method resolves to/returns the *old* key value (prior to removing the new altKeyName). + * + * If the removed keyAltName is the last keyAltName for that key, the `altKeyNames` property is unset from the document. + * + * @param _id - The id of the document to update. + * @param keyAltName - a keyAltName to search for a key + * @returns Returns a promise that either resolves to a {@link DataKey} if a document matches the key or null if no documents + * match the id. The promise rejects with an error if an error is thrown. + * @example + * ```ts + * // removing a key alt name from a data key + * const id = new Binary(); // id is a bson binary subtype 4 object + * const keyAltName = 'keyAltName'; + * const oldKey = await clientEncryption.removeKeyAltName(id, keyAltName); + * + * if (!oldKey) { + * // null is returned if there is no matching document with an id matching the supplied id + * } + * ``` + */ + async removeKeyAltName(_id, keyAltName) { + const { db: dbName, collection: collectionName } = utils_1.MongoDBCollectionNamespace.fromString(this._keyVaultNamespace); + const pipeline = [ + { + $set: { + keyAltNames: { + $cond: [ + { + $eq: ["$keyAltNames", [keyAltName]] + }, + "$$REMOVE", + { + $filter: { + input: "$keyAltNames", + cond: { + $ne: ["$$this", keyAltName] + } + } + } + ] + } + } + } + ]; + const value = await this._keyVaultClient.db(dbName).collection(collectionName).findOneAndUpdate({ _id }, pipeline, { + writeConcern: { w: "majority" }, + returnDocument: "before", + timeoutMS: this._timeoutMS + }); + return value; + } + /** + * A convenience method for creating an encrypted collection. + * This method will create data keys for any encryptedFields that do not have a `keyId` defined + * and then create a new collection with the full set of encryptedFields. + * + * @param db - A Node.js driver Db object with which to create the collection + * @param name - The name of the collection to be created + * @param options - Options for createDataKey and for createCollection + * @returns created collection and generated encryptedFields + * @throws MongoCryptCreateDataKeyError - If part way through the process a createDataKey invocation fails, an error will be rejected that has the partial `encryptedFields` that were created. + * @throws MongoCryptCreateEncryptedCollectionError - If creating the collection fails, an error will be rejected that has the entire `encryptedFields` that were created. + */ + async createEncryptedCollection(db, name, options) { + const { provider, masterKey, createCollectionOptions: { encryptedFields: { ...encryptedFields }, ...createCollectionOptions } } = options; + const timeoutContext = this._timeoutMS != null ? timeout_1.TimeoutContext.create((0, utils_1.resolveTimeoutOptions)(this._client, { timeoutMS: this._timeoutMS })) : void 0; + if (Array.isArray(encryptedFields.fields)) { + const createDataKeyPromises = encryptedFields.fields.map(async (field) => field == null || typeof field !== "object" || field.keyId != null ? field : { + ...field, + keyId: await this.createDataKey(provider, { + masterKey, + // clone the timeoutContext + // in order to avoid sharing the same timeout for server selection and connection checkout across different concurrent operations + timeoutContext: timeoutContext?.csotEnabled() ? timeoutContext?.clone() : void 0 + }) + }); + const createDataKeyResolutions = await Promise.allSettled(createDataKeyPromises); + encryptedFields.fields = createDataKeyResolutions.map((resolution, index) => resolution.status === "fulfilled" ? resolution.value : encryptedFields.fields[index]); + const rejection = createDataKeyResolutions.find((result) => result.status === "rejected"); + if (rejection != null) { + throw new errors_1.MongoCryptCreateDataKeyError(encryptedFields, { cause: rejection.reason }); + } + } + try { + const collection = await db.createCollection(name, { + ...createCollectionOptions, + encryptedFields, + timeoutMS: timeoutContext?.csotEnabled() ? timeoutContext?.getRemainingTimeMSOrThrow() : void 0 + }); + return { collection, encryptedFields }; + } catch (cause) { + throw new errors_1.MongoCryptCreateEncryptedCollectionError(encryptedFields, { cause }); + } + } + /** + * Explicitly encrypt a provided value. Note that either `options.keyId` or `options.keyAltName` must + * be specified. Specifying both `options.keyId` and `options.keyAltName` is considered an error. + * + * @param value - The value that you wish to serialize. Must be of a type that can be serialized into BSON + * @param options - + * @returns a Promise that either resolves with the encrypted value, or rejects with an error. + * + * @example + * ```ts + * // Encryption with async/await api + * async function encryptMyData(value) { + * const keyId = await clientEncryption.createDataKey('local'); + * return clientEncryption.encrypt(value, { keyId, algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }); + * } + * ``` + * + * @example + * ```ts + * // Encryption using a keyAltName + * async function encryptMyData(value) { + * await clientEncryption.createDataKey('local', { keyAltNames: 'mySpecialKey' }); + * return clientEncryption.encrypt(value, { keyAltName: 'mySpecialKey', algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }); + * } + * ``` + */ + async encrypt(value, options) { + return await this._encrypt(value, false, options); + } + /** + * Encrypts a Match Expression or Aggregate Expression to query a range index. + * + * Only supported when queryType is "range" and algorithm is "Range". + * + * @param expression - a BSON document of one of the following forms: + * 1. A Match Expression of this form: + * `{$and: [{: {$gt: }}, {: {$lt: }}]}` + * 2. An Aggregate Expression of this form: + * `{$and: [{$gt: [, ]}, {$lt: [, ]}]}` + * + * `$gt` may also be `$gte`. `$lt` may also be `$lte`. + * + * @param options - + * @returns Returns a Promise that either resolves with the encrypted value or rejects with an error. + */ + async encryptExpression(expression, options) { + return await this._encrypt(expression, true, options); + } + /** + * Explicitly decrypt a provided encrypted value + * + * @param value - An encrypted value + * @returns a Promise that either resolves with the decrypted value, or rejects with an error + * + * @example + * ```ts + * // Decrypting value with async/await API + * async function decryptMyValue(value) { + * return clientEncryption.decrypt(value); + * } + * ``` + */ + async decrypt(value) { + const valueBuffer = (0, bson_1.serialize)({ v: value }); + const context = this._mongoCrypt.makeExplicitDecryptionContext(valueBuffer); + const stateMachine = new state_machine_1.StateMachine({ + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: autoSelectSocketOptions(this._client.s.options) + }); + const timeoutContext = this._timeoutMS != null ? timeout_1.TimeoutContext.create((0, utils_1.resolveTimeoutOptions)(this._client, { timeoutMS: this._timeoutMS })) : void 0; + const { v } = (0, bson_1.deserialize)(await stateMachine.execute(this, context, { timeoutContext })); + return v; + } + /** + * @internal + * Ask the user for KMS credentials. + * + * This returns anything that looks like the kmsProviders original input + * option. It can be empty, and any provider specified here will override + * the original ones. + */ + async askForKMSCredentials() { + return await (0, index_1.refreshKMSCredentials)(this._kmsProviders, this._credentialProviders); + } + static get libmongocryptVersion() { + return _ClientEncryption.getMongoCrypt().libmongocryptVersion; + } + /** + * @internal + * A helper that perform explicit encryption of values and expressions. + * Explicitly encrypt a provided value. Note that either `options.keyId` or `options.keyAltName` must + * be specified. Specifying both `options.keyId` and `options.keyAltName` is considered an error. + * + * @param value - The value that you wish to encrypt. Must be of a type that can be serialized into BSON + * @param expressionMode - a boolean that indicates whether or not to encrypt the value as an expression + * @param options - options to pass to encrypt + * @returns the raw result of the call to stateMachine.execute(). When expressionMode is set to true, the return + * value will be a bson document. When false, the value will be a BSON Binary. + * + */ + async _encrypt(value, expressionMode, options) { + const { algorithm, keyId, keyAltName, contentionFactor, queryType, rangeOptions, textOptions } = options; + const contextOptions = { + expressionMode, + algorithm + }; + if (keyId) { + contextOptions.keyId = keyId.buffer; + } + if (keyAltName) { + if (keyId) { + throw new errors_1.MongoCryptInvalidArgumentError(`"options" cannot contain both "keyId" and "keyAltName"`); + } + if (typeof keyAltName !== "string") { + throw new errors_1.MongoCryptInvalidArgumentError(`"options.keyAltName" must be of type string, but was of type ${typeof keyAltName}`); + } + contextOptions.keyAltName = (0, bson_1.serialize)({ keyAltName }); + } + if (typeof contentionFactor === "number" || typeof contentionFactor === "bigint") { + contextOptions.contentionFactor = contentionFactor; + } + if (typeof queryType === "string") { + contextOptions.queryType = queryType; + } + if (typeof rangeOptions === "object") { + contextOptions.rangeOptions = (0, bson_1.serialize)(rangeOptions); + } + if (typeof textOptions === "object") { + contextOptions.textOptions = (0, bson_1.serialize)(textOptions); + } + const valueBuffer = (0, bson_1.serialize)({ v: value }); + const stateMachine = new state_machine_1.StateMachine({ + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: autoSelectSocketOptions(this._client.s.options) + }); + const context = this._mongoCrypt.makeExplicitEncryptionContext(valueBuffer, contextOptions); + const timeoutContext = this._timeoutMS != null ? timeout_1.TimeoutContext.create((0, utils_1.resolveTimeoutOptions)(this._client, { timeoutMS: this._timeoutMS })) : void 0; + const { v } = (0, bson_1.deserialize)(await stateMachine.execute(this, context, { timeoutContext })); + return v; + } + }; + exports2.ClientEncryption = ClientEncryption; + function autoSelectSocketOptions(baseOptions) { + const options = { autoSelectFamily: true }; + if ("autoSelectFamily" in baseOptions) { + options.autoSelectFamily = baseOptions.autoSelectFamily; + } + if ("autoSelectFamilyAttemptTimeout" in baseOptions) { + options.autoSelectFamilyAttemptTimeout = baseOptions.autoSelectFamilyAttemptTimeout; + } + return options; + } + } +}); + +// node_modules/mongodb/lib/client-side-encryption/mongocryptd_manager.js +var require_mongocryptd_manager = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/mongocryptd_manager.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongocryptdManager = void 0; + var error_1 = require_error(); + var MongocryptdManager = class _MongocryptdManager { + constructor(extraOptions = {}) { + this.spawnPath = ""; + this.spawnArgs = []; + this.uri = typeof extraOptions.mongocryptdURI === "string" && extraOptions.mongocryptdURI.length > 0 ? extraOptions.mongocryptdURI : _MongocryptdManager.DEFAULT_MONGOCRYPTD_URI; + this.bypassSpawn = !!extraOptions.mongocryptdBypassSpawn; + if (Object.hasOwn(extraOptions, "mongocryptdSpawnPath") && extraOptions.mongocryptdSpawnPath) { + this.spawnPath = extraOptions.mongocryptdSpawnPath; + } + if (Object.hasOwn(extraOptions, "mongocryptdSpawnArgs") && Array.isArray(extraOptions.mongocryptdSpawnArgs)) { + this.spawnArgs = this.spawnArgs.concat(extraOptions.mongocryptdSpawnArgs); + } + if (this.spawnArgs.filter((arg) => typeof arg === "string").every((arg) => arg.indexOf("--idleShutdownTimeoutSecs") < 0)) { + this.spawnArgs.push("--idleShutdownTimeoutSecs", "60"); + } + } + /** + * Will check to see if a mongocryptd is up. If it is not up, it will attempt + * to spawn a mongocryptd in a detached process, and then wait for it to be up. + */ + async spawn() { + const cmdName = this.spawnPath || "mongocryptd"; + const { spawn } = require("child_process"); + this._child = spawn(cmdName, this.spawnArgs, { + stdio: "ignore", + detached: true + }); + this._child.on("error", () => { + }); + this._child.unref(); + } + /** + * @returns the result of `fn` or rejects with an error. + */ + async withRespawn(fn) { + try { + const result2 = await fn(); + return result2; + } catch (err) { + const shouldSpawn = err instanceof error_1.MongoNetworkTimeoutError && !this.bypassSpawn; + if (!shouldSpawn) { + throw err; + } + } + await this.spawn(); + const result = await fn(); + return result; + } + }; + exports2.MongocryptdManager = MongocryptdManager; + MongocryptdManager.DEFAULT_MONGOCRYPTD_URI = "mongodb://localhost:27020"; + } +}); + +// node_modules/mongodb/lib/client-side-encryption/auto_encrypter.js +var require_auto_encrypter = __commonJS({ + "node_modules/mongodb/lib/client-side-encryption/auto_encrypter.js"(exports2) { + "use strict"; + var _a; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AutoEncrypter = exports2.AutoEncryptionLoggerLevel = void 0; + var net = require("net"); + var bson_1 = require_bson2(); + var constants_1 = require_constants2(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var mongo_client_1 = require_mongo_client(); + var utils_1 = require_utils3(); + var client_encryption_1 = require_client_encryption(); + var cryptoCallbacks = require_crypto_callbacks(); + var errors_1 = require_errors2(); + var mongocryptd_manager_1 = require_mongocryptd_manager(); + var providers_1 = require_providers2(); + var state_machine_1 = require_state_machine(); + exports2.AutoEncryptionLoggerLevel = Object.freeze({ + FatalError: 0, + Error: 1, + Warning: 2, + Info: 3, + Trace: 4 + }); + var AutoEncrypter = class _AutoEncrypter { + /** @internal */ + static getMongoCrypt() { + const encryption = (0, deps_1.getMongoDBClientEncryption)(); + if ("kModuleError" in encryption) { + throw encryption.kModuleError; + } + return encryption.MongoCrypt; + } + /** + * Create an AutoEncrypter + * + * **Note**: Do not instantiate this class directly. Rather, supply the relevant options to a MongoClient + * + * **Note**: Supplying `options.schemaMap` provides more security than relying on JSON Schemas obtained from the server. + * It protects against a malicious server advertising a false JSON Schema, which could trick the client into sending unencrypted data that should be encrypted. + * Schemas supplied in the schemaMap only apply to configuring automatic encryption for Client-Side Field Level Encryption. + * Other validation rules in the JSON schema will not be enforced by the driver and will result in an error. + * + * @example Create an AutoEncrypter that makes use of mongocryptd + * ```ts + * // Enabling autoEncryption via a MongoClient using mongocryptd + * const { MongoClient } = require('mongodb'); + * const client = new MongoClient(URL, { + * autoEncryption: { + * kmsProviders: { + * aws: { + * accessKeyId: AWS_ACCESS_KEY, + * secretAccessKey: AWS_SECRET_KEY + * } + * } + * } + * }); + * ``` + * + * await client.connect(); + * // From here on, the client will be encrypting / decrypting automatically + * @example Create an AutoEncrypter that makes use of libmongocrypt's CSFLE shared library + * ```ts + * // Enabling autoEncryption via a MongoClient using CSFLE shared library + * const { MongoClient } = require('mongodb'); + * const client = new MongoClient(URL, { + * autoEncryption: { + * kmsProviders: { + * aws: {} + * }, + * extraOptions: { + * cryptSharedLibPath: '/path/to/local/crypt/shared/lib', + * cryptSharedLibRequired: true + * } + * } + * }); + * ``` + * + * await client.connect(); + * // From here on, the client will be encrypting / decrypting automatically + */ + constructor(client, options) { + this[_a] = false; + this._client = client; + this._bypassEncryption = options.bypassAutoEncryption === true; + this._keyVaultNamespace = options.keyVaultNamespace || "admin.datakeys"; + this._keyVaultClient = options.keyVaultClient || client; + this._metaDataClient = options.metadataClient || client; + this._proxyOptions = options.proxyOptions || {}; + this._tlsOptions = options.tlsOptions || {}; + this._kmsProviders = options.kmsProviders || {}; + this._credentialProviders = options.credentialProviders; + if (options.credentialProviders?.aws && !(0, providers_1.isEmptyCredentials)("aws", this._kmsProviders)) { + throw new errors_1.MongoCryptInvalidArgumentError("Can only provide a custom AWS credential provider when the state machine is configured for automatic AWS credential fetching"); + } + const mongoCryptOptions = { + enableMultipleCollinfo: true, + cryptoCallbacks + }; + if (options.schemaMap) { + mongoCryptOptions.schemaMap = Buffer.isBuffer(options.schemaMap) ? options.schemaMap : (0, bson_1.serialize)(options.schemaMap); + } + if (options.encryptedFieldsMap) { + mongoCryptOptions.encryptedFieldsMap = Buffer.isBuffer(options.encryptedFieldsMap) ? options.encryptedFieldsMap : (0, bson_1.serialize)(options.encryptedFieldsMap); + } + mongoCryptOptions.kmsProviders = !Buffer.isBuffer(this._kmsProviders) ? (0, bson_1.serialize)(this._kmsProviders) : this._kmsProviders; + if (options.options?.logger) { + mongoCryptOptions.logger = options.options.logger; + } + if (options.extraOptions && options.extraOptions.cryptSharedLibPath) { + mongoCryptOptions.cryptSharedLibPath = options.extraOptions.cryptSharedLibPath; + } + if (options.bypassQueryAnalysis) { + mongoCryptOptions.bypassQueryAnalysis = options.bypassQueryAnalysis; + } + if (options.keyExpirationMS != null) { + mongoCryptOptions.keyExpirationMS = options.keyExpirationMS; + } + this._bypassMongocryptdAndCryptShared = this._bypassEncryption || !!options.bypassQueryAnalysis; + if (options.extraOptions && options.extraOptions.cryptSharedLibSearchPaths) { + mongoCryptOptions.cryptSharedLibSearchPaths = options.extraOptions.cryptSharedLibSearchPaths; + } else if (!this._bypassMongocryptdAndCryptShared) { + mongoCryptOptions.cryptSharedLibSearchPaths = ["$SYSTEM"]; + } + const MongoCrypt = _AutoEncrypter.getMongoCrypt(); + this._mongocrypt = new MongoCrypt(mongoCryptOptions); + this._contextCounter = 0; + if (options.extraOptions && options.extraOptions.cryptSharedLibRequired && !this.cryptSharedLibVersionInfo) { + throw new errors_1.MongoCryptInvalidArgumentError("`cryptSharedLibRequired` set but no crypt_shared library loaded"); + } + if (!this._bypassMongocryptdAndCryptShared && !this.cryptSharedLibVersionInfo) { + this._mongocryptdManager = new mongocryptd_manager_1.MongocryptdManager(options.extraOptions); + const clientOptions = { + serverSelectionTimeoutMS: 1e4 + }; + if ((options.extraOptions == null || typeof options.extraOptions.mongocryptdURI !== "string") && !net.getDefaultAutoSelectFamily) { + clientOptions.family = 4; + } + if (net.getDefaultAutoSelectFamily) { + Object.assign(clientOptions, (0, client_encryption_1.autoSelectSocketOptions)(this._client.s?.options ?? {})); + } + this._mongocryptdClient = new mongo_client_1.MongoClient(this._mongocryptdManager.uri, clientOptions); + } + } + /** + * Initializes the auto encrypter by spawning a mongocryptd and connecting to it. + * + * This function is a no-op when bypassSpawn is set or the crypt shared library is used. + */ + async init() { + if (this._bypassMongocryptdAndCryptShared || this.cryptSharedLibVersionInfo) { + return; + } + if (!this._mongocryptdManager) { + throw new error_1.MongoRuntimeError("Reached impossible state: mongocryptdManager is undefined when neither bypassSpawn nor the shared lib are specified."); + } + if (!this._mongocryptdClient) { + throw new error_1.MongoRuntimeError("Reached impossible state: mongocryptdClient is undefined when neither bypassSpawn nor the shared lib are specified."); + } + if (!this._mongocryptdManager.bypassSpawn) { + await this._mongocryptdManager.spawn(); + } + try { + const client = await this._mongocryptdClient.connect(); + return client; + } catch (error) { + throw new error_1.MongoRuntimeError("Unable to connect to `mongocryptd`, please make sure it is running or in your PATH for auto-spawn", { cause: error }); + } + } + /** + * Cleans up the `_mongocryptdClient`, if present. + */ + async close() { + await this._mongocryptdClient?.close(); + } + /** + * Encrypt a command for a given namespace. + */ + async encrypt(ns, cmd, options = {}) { + options.signal?.throwIfAborted(); + if (this._bypassEncryption) { + return cmd; + } + const commandBuffer = Buffer.isBuffer(cmd) ? cmd : (0, bson_1.serialize)(cmd, options); + const context = this._mongocrypt.makeEncryptionContext(utils_1.MongoDBCollectionNamespace.fromString(ns).db, commandBuffer); + context.id = this._contextCounter++; + context.ns = ns; + context.document = cmd; + const stateMachine = new state_machine_1.StateMachine({ + promoteValues: false, + promoteLongs: false, + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: (0, client_encryption_1.autoSelectSocketOptions)(this._client.s.options) + }); + return (0, bson_1.deserialize)(await stateMachine.execute(this, context, options), { + promoteValues: false, + promoteLongs: false + }); + } + /** + * Decrypt a command response + */ + async decrypt(response, options = {}) { + options.signal?.throwIfAborted(); + const context = this._mongocrypt.makeDecryptionContext(response); + context.id = this._contextCounter++; + const stateMachine = new state_machine_1.StateMachine({ + ...options, + proxyOptions: this._proxyOptions, + tlsOptions: this._tlsOptions, + socketOptions: (0, client_encryption_1.autoSelectSocketOptions)(this._client.s.options) + }); + return await stateMachine.execute(this, context, options); + } + /** + * Ask the user for KMS credentials. + * + * This returns anything that looks like the kmsProviders original input + * option. It can be empty, and any provider specified here will override + * the original ones. + */ + async askForKMSCredentials() { + return await (0, providers_1.refreshKMSCredentials)(this._kmsProviders, this._credentialProviders); + } + /** + * Return the current libmongocrypt's CSFLE shared library version + * as `{ version: bigint, versionStr: string }`, or `null` if no CSFLE + * shared library was loaded. + */ + get cryptSharedLibVersionInfo() { + return this._mongocrypt.cryptSharedLibVersionInfo; + } + static get libmongocryptVersion() { + return _AutoEncrypter.getMongoCrypt().libmongocryptVersion; + } + }; + exports2.AutoEncrypter = AutoEncrypter; + _a = constants_1.kDecorateResult; + } +}); + +// node_modules/mongodb/lib/encrypter.js +var require_encrypter = __commonJS({ + "node_modules/mongodb/lib/encrypter.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Encrypter = void 0; + var auto_encrypter_1 = require_auto_encrypter(); + var constants_1 = require_constants2(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var mongo_client_1 = require_mongo_client(); + var Encrypter = class { + constructor(client, uri, options) { + if (typeof options.autoEncryption !== "object") { + throw new error_1.MongoInvalidArgumentError('Option "autoEncryption" must be specified'); + } + this.internalClient = null; + this.bypassAutoEncryption = !!options.autoEncryption.bypassAutoEncryption; + this.needsConnecting = false; + if (options.maxPoolSize === 0 && options.autoEncryption.keyVaultClient == null) { + options.autoEncryption.keyVaultClient = client; + } else if (options.autoEncryption.keyVaultClient == null) { + options.autoEncryption.keyVaultClient = this.getInternalClient(client, uri, options); + } + if (this.bypassAutoEncryption) { + options.autoEncryption.metadataClient = void 0; + } else if (options.maxPoolSize === 0) { + options.autoEncryption.metadataClient = client; + } else { + options.autoEncryption.metadataClient = this.getInternalClient(client, uri, options); + } + if (options.proxyHost) { + options.autoEncryption.proxyOptions = { + proxyHost: options.proxyHost, + proxyPort: options.proxyPort, + proxyUsername: options.proxyUsername, + proxyPassword: options.proxyPassword + }; + } + this.autoEncrypter = new auto_encrypter_1.AutoEncrypter(client, options.autoEncryption); + } + getInternalClient(client, uri, options) { + let internalClient = this.internalClient; + if (internalClient == null) { + const clonedOptions = {}; + for (const key of [ + ...Object.getOwnPropertyNames(options), + ...Object.getOwnPropertySymbols(options) + ]) { + if (["autoEncryption", "minPoolSize", "servers", "caseTranslate", "dbName"].includes(key)) + continue; + Reflect.set(clonedOptions, key, Reflect.get(options, key)); + } + clonedOptions.minPoolSize = 0; + internalClient = new mongo_client_1.MongoClient(uri, clonedOptions); + this.internalClient = internalClient; + for (const eventName of constants_1.MONGO_CLIENT_EVENTS) { + for (const listener of client.listeners(eventName)) { + internalClient.on(eventName, listener); + } + } + client.on("newListener", (eventName, listener) => { + internalClient?.on(eventName, listener); + }); + this.needsConnecting = true; + } + return internalClient; + } + async connectInternalClient() { + const internalClient = this.internalClient; + if (this.needsConnecting && internalClient != null) { + this.needsConnecting = false; + await internalClient.connect(); + } + } + async close(client) { + let error; + try { + await this.autoEncrypter.close(); + } catch (autoEncrypterError) { + error = autoEncrypterError; + } + const internalClient = this.internalClient; + if (internalClient != null && client !== internalClient) { + return await internalClient.close(); + } + if (error != null) { + throw error; + } + } + static checkForMongoCrypt() { + const mongodbClientEncryption = (0, deps_1.getMongoDBClientEncryption)(); + if ("kModuleError" in mongodbClientEncryption) { + throw new error_1.MongoMissingDependencyError("Auto-encryption requested, but the module is not installed. Please add `mongodb-client-encryption` as a dependency of your project", { + cause: mongodbClientEncryption["kModuleError"], + dependencyName: "mongodb-client-encryption" + }); + } + } + }; + exports2.Encrypter = Encrypter; + } +}); + +// node_modules/mongodb/lib/cmap/metrics.js +var require_metrics = __commonJS({ + "node_modules/mongodb/lib/cmap/metrics.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ConnectionPoolMetrics = void 0; + var ConnectionPoolMetrics = class _ConnectionPoolMetrics { + constructor() { + this.txnConnections = 0; + this.cursorConnections = 0; + this.otherConnections = 0; + } + /** + * Mark a connection as pinned for a specific operation. + */ + markPinned(pinType) { + if (pinType === _ConnectionPoolMetrics.TXN) { + this.txnConnections += 1; + } else if (pinType === _ConnectionPoolMetrics.CURSOR) { + this.cursorConnections += 1; + } else { + this.otherConnections += 1; + } + } + /** + * Unmark a connection as pinned for an operation. + */ + markUnpinned(pinType) { + if (pinType === _ConnectionPoolMetrics.TXN) { + this.txnConnections -= 1; + } else if (pinType === _ConnectionPoolMetrics.CURSOR) { + this.cursorConnections -= 1; + } else { + this.otherConnections -= 1; + } + } + /** + * Return information about the cmap metrics as a string. + */ + info(maxPoolSize) { + return `Timed out while checking out a connection from connection pool: maxPoolSize: ${maxPoolSize}, connections in use by cursors: ${this.cursorConnections}, connections in use by transactions: ${this.txnConnections}, connections in use by other operations: ${this.otherConnections}`; + } + /** + * Reset the metrics to the initial values. + */ + reset() { + this.txnConnections = 0; + this.cursorConnections = 0; + this.otherConnections = 0; + } + }; + exports2.ConnectionPoolMetrics = ConnectionPoolMetrics; + ConnectionPoolMetrics.TXN = "txn"; + ConnectionPoolMetrics.CURSOR = "cursor"; + ConnectionPoolMetrics.OTHER = "other"; + } +}); + +// node_modules/mongodb/lib/transactions.js +var require_transactions = __commonJS({ + "node_modules/mongodb/lib/transactions.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Transaction = exports2.TxnState = void 0; + exports2.isTransactionCommand = isTransactionCommand; + var error_1 = require_error(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var write_concern_1 = require_write_concern(); + exports2.TxnState = Object.freeze({ + NO_TRANSACTION: "NO_TRANSACTION", + STARTING_TRANSACTION: "STARTING_TRANSACTION", + TRANSACTION_IN_PROGRESS: "TRANSACTION_IN_PROGRESS", + TRANSACTION_COMMITTED: "TRANSACTION_COMMITTED", + TRANSACTION_COMMITTED_EMPTY: "TRANSACTION_COMMITTED_EMPTY", + TRANSACTION_ABORTED: "TRANSACTION_ABORTED" + }); + var stateMachine = { + [exports2.TxnState.NO_TRANSACTION]: [exports2.TxnState.NO_TRANSACTION, exports2.TxnState.STARTING_TRANSACTION], + [exports2.TxnState.STARTING_TRANSACTION]: [ + exports2.TxnState.TRANSACTION_IN_PROGRESS, + exports2.TxnState.TRANSACTION_COMMITTED, + exports2.TxnState.TRANSACTION_COMMITTED_EMPTY, + exports2.TxnState.TRANSACTION_ABORTED + ], + [exports2.TxnState.TRANSACTION_IN_PROGRESS]: [ + exports2.TxnState.TRANSACTION_IN_PROGRESS, + exports2.TxnState.TRANSACTION_COMMITTED, + exports2.TxnState.TRANSACTION_ABORTED + ], + [exports2.TxnState.TRANSACTION_COMMITTED]: [ + exports2.TxnState.TRANSACTION_COMMITTED, + exports2.TxnState.TRANSACTION_COMMITTED_EMPTY, + exports2.TxnState.STARTING_TRANSACTION, + exports2.TxnState.NO_TRANSACTION + ], + [exports2.TxnState.TRANSACTION_ABORTED]: [exports2.TxnState.STARTING_TRANSACTION, exports2.TxnState.NO_TRANSACTION], + [exports2.TxnState.TRANSACTION_COMMITTED_EMPTY]: [ + exports2.TxnState.TRANSACTION_COMMITTED_EMPTY, + exports2.TxnState.NO_TRANSACTION + ] + }; + var ACTIVE_STATES = /* @__PURE__ */ new Set([ + exports2.TxnState.STARTING_TRANSACTION, + exports2.TxnState.TRANSACTION_IN_PROGRESS + ]); + var COMMITTED_STATES = /* @__PURE__ */ new Set([ + exports2.TxnState.TRANSACTION_COMMITTED, + exports2.TxnState.TRANSACTION_COMMITTED_EMPTY, + exports2.TxnState.TRANSACTION_ABORTED + ]); + var Transaction = class { + /** Create a transaction @internal */ + constructor(options) { + options = options ?? {}; + this.state = exports2.TxnState.NO_TRANSACTION; + this.options = {}; + const writeConcern = write_concern_1.WriteConcern.fromOptions(options); + if (writeConcern) { + if (writeConcern.w === 0) { + throw new error_1.MongoTransactionError("Transactions do not support unacknowledged write concern"); + } + this.options.writeConcern = writeConcern; + } + if (options.readConcern) { + this.options.readConcern = read_concern_1.ReadConcern.fromOptions(options); + } + if (options.readPreference) { + this.options.readPreference = read_preference_1.ReadPreference.fromOptions(options); + } + if (options.maxCommitTimeMS) { + this.options.maxTimeMS = options.maxCommitTimeMS; + } + this._pinnedServer = void 0; + this._recoveryToken = void 0; + } + /** @internal */ + get server() { + return this._pinnedServer; + } + /** @deprecated - Will be made internal in a future major release. */ + get recoveryToken() { + return this._recoveryToken; + } + /** @deprecated - Will be made internal in a future major release. */ + get isPinned() { + return !!this.server; + } + /** + * @deprecated - Will be made internal in a future major release. + * @returns Whether the transaction has started + */ + get isStarting() { + return this.state === exports2.TxnState.STARTING_TRANSACTION; + } + /** + * @deprecated - Will be made internal in a future major release. + * @returns Whether this session is presently in a transaction + */ + get isActive() { + return ACTIVE_STATES.has(this.state); + } + /** @deprecated - Will be made internal in a future major release. */ + get isCommitted() { + return COMMITTED_STATES.has(this.state); + } + /** + * Transition the transaction in the state machine + * @internal + * @param nextState - The new state to transition to + */ + transition(nextState) { + const nextStates = stateMachine[this.state]; + if (nextStates && nextStates.includes(nextState)) { + this.state = nextState; + if (this.state === exports2.TxnState.NO_TRANSACTION || this.state === exports2.TxnState.STARTING_TRANSACTION || this.state === exports2.TxnState.TRANSACTION_ABORTED) { + this.unpinServer(); + } + return; + } + throw new error_1.MongoRuntimeError(`Attempted illegal state transition from [${this.state}] to [${nextState}]`); + } + /** @internal */ + pinServer(server) { + if (this.isActive) { + this._pinnedServer = server; + } + } + /** @internal */ + unpinServer() { + this._pinnedServer = void 0; + } + }; + exports2.Transaction = Transaction; + function isTransactionCommand(command) { + return !!(command.commitTransaction || command.abortTransaction); + } + } +}); + +// node_modules/mongodb/lib/sessions.js +var require_sessions = __commonJS({ + "node_modules/mongodb/lib/sessions.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ServerSessionPool = exports2.ServerSession = exports2.ClientSession = void 0; + exports2.maybeClearPinnedConnection = maybeClearPinnedConnection; + exports2.applySession = applySession; + exports2.updateSessionFromResponse = updateSessionFromResponse; + var bson_1 = require_bson2(); + var metrics_1 = require_metrics(); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var execute_operation_1 = require_execute_operation(); + var run_command_1 = require_run_command(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var resource_management_1 = require_resource_management(); + var common_1 = require_common(); + var transactions_1 = require_transactions(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var ClientSession = class _ClientSession extends mongo_types_1.TypedEventEmitter { + /** + * Create a client session. + * @internal + * @param client - The current client + * @param sessionPool - The server session pool (Internal Class) + * @param options - Optional settings + * @param clientOptions - Optional settings provided when creating a MongoClient + */ + constructor(client, sessionPool, options, clientOptions) { + super(); + this.timeoutContext = null; + this.on("error", utils_1.noop); + if (client == null) { + throw new error_1.MongoRuntimeError("ClientSession requires a MongoClient"); + } + if (sessionPool == null || !(sessionPool instanceof ServerSessionPool)) { + throw new error_1.MongoRuntimeError("ClientSession requires a ServerSessionPool"); + } + options = options ?? {}; + this.snapshotEnabled = options.snapshot === true; + if (options.causalConsistency === true && this.snapshotEnabled) { + throw new error_1.MongoInvalidArgumentError('Properties "causalConsistency" and "snapshot" are mutually exclusive'); + } + this.client = client; + this.sessionPool = sessionPool; + this.hasEnded = false; + this.clientOptions = clientOptions; + this.explicit = !!options.explicit; + this._serverSession = this.explicit ? this.sessionPool.acquire() : null; + this.txnNumberIncrement = 0; + const defaultCausalConsistencyValue = this.explicit && options.snapshot !== true; + this.supports = { + // if we can enable causal consistency, do so by default + causalConsistency: options.causalConsistency ?? defaultCausalConsistencyValue + }; + this.clusterTime = options.initialClusterTime; + this.operationTime = void 0; + this.owner = options.owner; + this.defaultTransactionOptions = { ...options.defaultTransactionOptions }; + this.transaction = new transactions_1.Transaction(); + } + /** The server id associated with this session */ + get id() { + return this.serverSession?.id; + } + get serverSession() { + let serverSession = this._serverSession; + if (serverSession == null) { + if (this.explicit) { + throw new error_1.MongoRuntimeError("Unexpected null serverSession for an explicit session"); + } + if (this.hasEnded) { + throw new error_1.MongoRuntimeError("Unexpected null serverSession for an ended implicit session"); + } + serverSession = this.sessionPool.acquire(); + this._serverSession = serverSession; + } + return serverSession; + } + get loadBalanced() { + return this.client.topology?.description.type === common_1.TopologyType.LoadBalanced; + } + /** @internal */ + pin(conn) { + if (this.pinnedConnection) { + throw TypeError("Cannot pin multiple connections to the same session"); + } + this.pinnedConnection = conn; + conn.emit(constants_1.PINNED, this.inTransaction() ? metrics_1.ConnectionPoolMetrics.TXN : metrics_1.ConnectionPoolMetrics.CURSOR); + } + /** @internal */ + unpin(options) { + if (this.loadBalanced) { + return maybeClearPinnedConnection(this, options); + } + this.transaction.unpinServer(); + } + get isPinned() { + return this.loadBalanced ? !!this.pinnedConnection : this.transaction.isPinned; + } + /** + * Frees any client-side resources held by the current session. If a session is in a transaction, + * the transaction is aborted. + * + * Does not end the session on the server. + * + * @param options - Optional settings. Currently reserved for future use + */ + async endSession(options) { + try { + if (this.inTransaction()) { + await this.abortTransaction({ ...options, throwTimeout: true }); + } + } catch (error) { + if (error.name === "MongoOperationTimeoutError") + throw error; + (0, utils_1.squashError)(error); + } finally { + if (!this.hasEnded) { + const serverSession = this.serverSession; + if (serverSession != null) { + this.sessionPool.release(serverSession); + this._serverSession = new ServerSession(serverSession); + } + this.hasEnded = true; + this.emit("ended", this); + } + maybeClearPinnedConnection(this, { force: true, ...options }); + } + } + /** @internal */ + async asyncDispose() { + await this.endSession({ force: true }); + } + /** + * Advances the operationTime for a ClientSession. + * + * @param operationTime - the `BSON.Timestamp` of the operation type it is desired to advance to + */ + advanceOperationTime(operationTime) { + if (this.operationTime == null) { + this.operationTime = operationTime; + return; + } + if (operationTime.greaterThan(this.operationTime)) { + this.operationTime = operationTime; + } + } + /** + * Advances the clusterTime for a ClientSession to the provided clusterTime of another ClientSession + * + * @param clusterTime - the $clusterTime returned by the server from another session in the form of a document containing the `BSON.Timestamp` clusterTime and signature + */ + advanceClusterTime(clusterTime) { + if (!clusterTime || typeof clusterTime !== "object") { + throw new error_1.MongoInvalidArgumentError("input cluster time must be an object"); + } + if (!clusterTime.clusterTime || clusterTime.clusterTime._bsontype !== "Timestamp") { + throw new error_1.MongoInvalidArgumentError('input cluster time "clusterTime" property must be a valid BSON Timestamp'); + } + if (!clusterTime.signature || clusterTime.signature.hash?._bsontype !== "Binary" || typeof clusterTime.signature.keyId !== "bigint" && typeof clusterTime.signature.keyId !== "number" && clusterTime.signature.keyId?._bsontype !== "Long") { + throw new error_1.MongoInvalidArgumentError('input cluster time must have a valid "signature" property with BSON Binary hash and BSON Long keyId'); + } + (0, common_1._advanceClusterTime)(this, clusterTime); + } + /** + * Used to determine if this session equals another + * + * @param session - The session to compare to + */ + equals(session) { + if (!(session instanceof _ClientSession)) { + return false; + } + if (this.id == null || session.id == null) { + return false; + } + return utils_1.ByteUtils.equals(this.id.id.buffer, session.id.id.buffer); + } + /** + * Increment the transaction number on the internal ServerSession + * + * @privateRemarks + * This helper increments a value stored on the client session that will be + * added to the serverSession's txnNumber upon applying it to a command. + * This is because the serverSession is lazily acquired after a connection is obtained + */ + incrementTransactionNumber() { + this.txnNumberIncrement += 1; + } + /** @returns whether this session is currently in a transaction or not */ + inTransaction() { + return this.transaction.isActive; + } + /** + * Starts a new transaction with the given options. + * + * @remarks + * **IMPORTANT**: Running operations in parallel is not supported during a transaction. The use of `Promise.all`, + * `Promise.allSettled`, `Promise.race`, etc to parallelize operations inside a transaction is + * undefined behaviour. + * + * @param options - Options for the transaction + */ + startTransaction(options) { + if (this.snapshotEnabled) { + throw new error_1.MongoCompatibilityError("Transactions are not supported in snapshot sessions"); + } + if (this.inTransaction()) { + throw new error_1.MongoTransactionError("Transaction already in progress"); + } + if (this.isPinned && this.transaction.isCommitted) { + this.unpin(); + } + this.commitAttempted = false; + this.incrementTransactionNumber(); + this.transaction = new transactions_1.Transaction({ + readConcern: options?.readConcern ?? this.defaultTransactionOptions.readConcern ?? this.clientOptions?.readConcern, + writeConcern: options?.writeConcern ?? this.defaultTransactionOptions.writeConcern ?? this.clientOptions?.writeConcern, + readPreference: options?.readPreference ?? this.defaultTransactionOptions.readPreference ?? this.clientOptions?.readPreference, + maxCommitTimeMS: options?.maxCommitTimeMS ?? this.defaultTransactionOptions.maxCommitTimeMS + }); + this.transaction.transition(transactions_1.TxnState.STARTING_TRANSACTION); + } + /** + * Commits the currently active transaction in this session. + * + * @param _options - `timeoutMS` is deprecated and has no effect. + */ + async commitTransaction(_options) { + if (this.transaction.state === transactions_1.TxnState.NO_TRANSACTION) { + throw new error_1.MongoTransactionError("No transaction started"); + } + if (this.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION || this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED_EMPTY) { + this.transaction.transition(transactions_1.TxnState.TRANSACTION_COMMITTED_EMPTY); + return; + } + if (this.transaction.state === transactions_1.TxnState.TRANSACTION_ABORTED) { + throw new error_1.MongoTransactionError("Cannot call commitTransaction after calling abortTransaction"); + } + const command = { commitTransaction: 1 }; + const wc = this.transaction.options.writeConcern ?? this.clientOptions?.writeConcern; + if (wc != null) { + if (this.timeoutContext == null) { + write_concern_1.WriteConcern.apply(command, { wtimeoutMS: 1e4, w: "majority", ...wc }); + } else { + const wcKeys = Object.keys(wc); + if (wcKeys.length > 2 || !wcKeys.includes("wtimeoutMS") && !wcKeys.includes("wTimeoutMS")) + write_concern_1.WriteConcern.apply(command, { ...wc, wtimeoutMS: void 0 }); + } + } + if (this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED || this.commitAttempted) { + if (this.timeoutContext == null) { + write_concern_1.WriteConcern.apply(command, { wtimeoutMS: 1e4, ...wc, w: "majority" }); + } else { + write_concern_1.WriteConcern.apply(command, { w: "majority", ...wc, wtimeoutMS: void 0 }); + } + } + if (typeof this.transaction.options.maxTimeMS === "number") { + command.maxTimeMS = this.transaction.options.maxTimeMS; + } + if (this.transaction.recoveryToken) { + command.recoveryToken = this.transaction.recoveryToken; + } + const operation = new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace("admin"), command, { + session: this, + readPreference: read_preference_1.ReadPreference.primary, + bypassPinningCheck: true + }); + try { + await (0, execute_operation_1.executeOperation)(this.client, operation); + this.commitAttempted = void 0; + return; + } catch (firstCommitError) { + this.commitAttempted = true; + if (firstCommitError instanceof error_1.MongoError && (0, error_1.isRetryableWriteError)(firstCommitError)) { + write_concern_1.WriteConcern.apply(command, { wtimeoutMS: 1e4, ...wc, w: "majority" }); + this.unpin({ force: true }); + try { + await (0, execute_operation_1.executeOperation)(this.client, new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace("admin"), command, { + session: this, + readPreference: read_preference_1.ReadPreference.primary, + bypassPinningCheck: true + })); + return; + } catch (retryCommitError) { + if (shouldAddUnknownTransactionCommitResultLabel(retryCommitError)) { + retryCommitError.addErrorLabel(error_1.MongoErrorLabel.UnknownTransactionCommitResult); + } + if (shouldUnpinAfterCommitError(retryCommitError)) { + this.unpin({ error: retryCommitError }); + } + throw retryCommitError; + } + } + if (shouldAddUnknownTransactionCommitResultLabel(firstCommitError)) { + firstCommitError.addErrorLabel(error_1.MongoErrorLabel.UnknownTransactionCommitResult); + } + if (shouldUnpinAfterCommitError(firstCommitError)) { + this.unpin({ error: firstCommitError }); + } + throw firstCommitError; + } finally { + this.transaction.transition(transactions_1.TxnState.TRANSACTION_COMMITTED); + } + } + async abortTransaction(options) { + if (this.transaction.state === transactions_1.TxnState.NO_TRANSACTION) { + throw new error_1.MongoTransactionError("No transaction started"); + } + if (this.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION) { + this.transaction.transition(transactions_1.TxnState.TRANSACTION_ABORTED); + return; + } + if (this.transaction.state === transactions_1.TxnState.TRANSACTION_ABORTED) { + throw new error_1.MongoTransactionError("Cannot call abortTransaction twice"); + } + if (this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED || this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED_EMPTY) { + throw new error_1.MongoTransactionError("Cannot call abortTransaction after calling commitTransaction"); + } + const command = { abortTransaction: 1 }; + const wc = this.transaction.options.writeConcern ?? this.clientOptions?.writeConcern; + if (wc != null) { + write_concern_1.WriteConcern.apply(command, { wtimeoutMS: 1e4, w: "majority", ...wc }); + } + if (this.transaction.recoveryToken) { + command.recoveryToken = this.transaction.recoveryToken; + } + const operation = new run_command_1.RunCommandOperation(new utils_1.MongoDBNamespace("admin"), command, { + session: this, + readPreference: read_preference_1.ReadPreference.primary, + bypassPinningCheck: true + }); + try { + await (0, execute_operation_1.executeOperation)(this.client, operation); + this.unpin(); + return; + } catch (firstAbortError) { + this.unpin(); + if (firstAbortError.name === "MongoRuntimeError") + throw firstAbortError; + if (options?.throwTimeout && firstAbortError.name === "MongoOperationTimeoutError") { + throw firstAbortError; + } + if (firstAbortError instanceof error_1.MongoError && (0, error_1.isRetryableWriteError)(firstAbortError)) { + try { + await (0, execute_operation_1.executeOperation)(this.client, operation); + return; + } catch (secondAbortError) { + if (secondAbortError.name === "MongoRuntimeError") + throw secondAbortError; + if (options?.throwTimeout && secondAbortError.name === "MongoOperationTimeoutError") { + throw secondAbortError; + } + } + } + } finally { + this.transaction.transition(transactions_1.TxnState.TRANSACTION_ABORTED); + if (this.loadBalanced) { + maybeClearPinnedConnection(this, { force: false }); + } + } + } + /** + * This is here to ensure that ClientSession is never serialized to BSON. + */ + toBSON() { + throw new error_1.MongoRuntimeError("ClientSession cannot be serialized to BSON."); + } + /** + * Starts a transaction and runs a provided function, ensuring the commitTransaction is always attempted when all operations run in the function have completed. + * + * **IMPORTANT:** This method requires the function passed in to return a Promise. That promise must be made by `await`-ing all operations in such a way that rejections are propagated to the returned promise. + * + * **IMPORTANT:** Running operations in parallel is not supported during a transaction. The use of `Promise.all`, + * `Promise.allSettled`, `Promise.race`, etc to parallelize operations inside a transaction is + * undefined behaviour. + * + * **IMPORTANT:** When running an operation inside a `withTransaction` callback, if it is not + * provided the explicit session in its options, it will not be part of the transaction and it will not respect timeoutMS. + * + * + * @remarks + * - If all operations successfully complete and the `commitTransaction` operation is successful, then the provided function will return the result of the provided function. + * - If the transaction is unable to complete or an error is thrown from within the provided function, then the provided function will throw an error. + * - If the transaction is manually aborted within the provided function it will not throw. + * - If the driver needs to attempt to retry the operations, the provided function may be called multiple times. + * + * Checkout a descriptive example here: + * @see https://www.mongodb.com/blog/post/quick-start-nodejs--mongodb--how-to-implement-transactions + * + * If a command inside withTransaction fails: + * - It may cause the transaction on the server to be aborted. + * - This situation is normally handled transparently by the driver. + * - However, if the application catches such an error and does not rethrow it, the driver will not be able to determine whether the transaction was aborted or not. + * - The driver will then retry the transaction indefinitely. + * + * To avoid this situation, the application must not silently handle errors within the provided function. + * If the application needs to handle errors within, it must await all operations such that if an operation is rejected it becomes the rejection of the callback function passed into withTransaction. + * + * @param fn - callback to run within a transaction + * @param options - optional settings for the transaction + * @returns A raw command response or undefined + */ + async withTransaction(fn, options) { + const MAX_TIMEOUT = 12e4; + const startTime = this.timeoutContext?.csotEnabled() ? this.timeoutContext.start : (0, utils_1.now)(); + let committed = false; + let result; + try { + while (!committed) { + this.startTransaction(options); + try { + const promise = fn(this); + if (!(0, utils_1.isPromiseLike)(promise)) { + throw new error_1.MongoInvalidArgumentError("Function provided to `withTransaction` must return a Promise"); + } + result = await promise; + if (this.transaction.state === transactions_1.TxnState.NO_TRANSACTION || this.transaction.state === transactions_1.TxnState.TRANSACTION_COMMITTED || this.transaction.state === transactions_1.TxnState.TRANSACTION_ABORTED) { + return result; + } + } catch (fnError) { + if (!(fnError instanceof error_1.MongoError) || fnError instanceof error_1.MongoInvalidArgumentError) { + await this.abortTransaction(); + throw fnError; + } + if (this.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION || this.transaction.state === transactions_1.TxnState.TRANSACTION_IN_PROGRESS) { + await this.abortTransaction(); + } + if (fnError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError) && (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) { + continue; + } + throw fnError; + } + while (!committed) { + try { + await this.commitTransaction(); + committed = true; + } catch (commitError) { + if (!isMaxTimeMSExpiredError(commitError) && commitError.hasErrorLabel(error_1.MongoErrorLabel.UnknownTransactionCommitResult) && (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) { + continue; + } + if (commitError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError) && (this.timeoutContext != null || (0, utils_1.now)() - startTime < MAX_TIMEOUT)) { + break; + } + throw commitError; + } + } + } + return result; + } finally { + this.timeoutContext = null; + } + } + }; + exports2.ClientSession = ClientSession; + (0, resource_management_1.configureResourceManagement)(ClientSession.prototype); + var NON_DETERMINISTIC_WRITE_CONCERN_ERRORS = /* @__PURE__ */ new Set([ + "CannotSatisfyWriteConcern", + "UnknownReplWriteConcern", + "UnsatisfiableWriteConcern" + ]); + function shouldUnpinAfterCommitError(commitError) { + if (commitError instanceof error_1.MongoError) { + if ((0, error_1.isRetryableWriteError)(commitError) || commitError instanceof error_1.MongoWriteConcernError || isMaxTimeMSExpiredError(commitError)) { + if (isUnknownTransactionCommitResult(commitError)) { + return true; + } + } else if (commitError.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) { + return true; + } + } + return false; + } + function shouldAddUnknownTransactionCommitResultLabel(commitError) { + let ok = (0, error_1.isRetryableWriteError)(commitError); + ok ||= commitError instanceof error_1.MongoWriteConcernError; + ok ||= isMaxTimeMSExpiredError(commitError); + ok &&= isUnknownTransactionCommitResult(commitError); + return ok; + } + function isUnknownTransactionCommitResult(err) { + const isNonDeterministicWriteConcernError = err instanceof error_1.MongoServerError && err.codeName && NON_DETERMINISTIC_WRITE_CONCERN_ERRORS.has(err.codeName); + return isMaxTimeMSExpiredError(err) || !isNonDeterministicWriteConcernError && err.code !== error_1.MONGODB_ERROR_CODES.UnsatisfiableWriteConcern && err.code !== error_1.MONGODB_ERROR_CODES.UnknownReplWriteConcern; + } + function maybeClearPinnedConnection(session, options) { + const conn = session.pinnedConnection; + const error = options?.error; + if (session.inTransaction() && error && error instanceof error_1.MongoError && error.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) { + return; + } + const topology = session.client.topology; + if (conn && topology != null) { + const servers = Array.from(topology.s.servers.values()); + const loadBalancer = servers[0]; + if (options?.error == null || options?.force) { + loadBalancer.pool.checkIn(conn); + session.pinnedConnection = void 0; + conn.emit(constants_1.UNPINNED, session.transaction.state !== transactions_1.TxnState.NO_TRANSACTION ? metrics_1.ConnectionPoolMetrics.TXN : metrics_1.ConnectionPoolMetrics.CURSOR); + if (options?.forceClear) { + loadBalancer.pool.clear({ serviceId: conn.serviceId }); + } + } + } + } + function isMaxTimeMSExpiredError(err) { + if (err == null || !(err instanceof error_1.MongoServerError)) { + return false; + } + return err.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired || err.writeConcernError?.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired; + } + var ServerSession = class { + /** @internal */ + constructor(cloned) { + if (cloned != null) { + const idBytes = Buffer.allocUnsafe(16); + idBytes.set(cloned.id.id.buffer); + this.id = { id: new bson_1.Binary(idBytes, cloned.id.id.sub_type) }; + this.lastUse = cloned.lastUse; + this.txnNumber = cloned.txnNumber; + this.isDirty = cloned.isDirty; + return; + } + this.id = { id: new bson_1.Binary((0, utils_1.uuidV4)(), bson_1.Binary.SUBTYPE_UUID) }; + this.lastUse = (0, utils_1.now)(); + this.txnNumber = 0; + this.isDirty = false; + } + /** + * Determines if the server session has timed out. + * + * @param sessionTimeoutMinutes - The server's "logicalSessionTimeoutMinutes" + */ + hasTimedOut(sessionTimeoutMinutes) { + const idleTimeMinutes = Math.round((0, utils_1.calculateDurationInMs)(this.lastUse) % 864e5 % 36e5 / 6e4); + return idleTimeMinutes > sessionTimeoutMinutes - 1; + } + }; + exports2.ServerSession = ServerSession; + var ServerSessionPool = class { + constructor(client) { + if (client == null) { + throw new error_1.MongoRuntimeError("ServerSessionPool requires a MongoClient"); + } + this.client = client; + this.sessions = new utils_1.List(); + } + /** + * Acquire a Server Session from the pool. + * Iterates through each session in the pool, removing any stale sessions + * along the way. The first non-stale session found is removed from the + * pool and returned. If no non-stale session is found, a new ServerSession is created. + */ + acquire() { + const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10; + let session = null; + while (this.sessions.length > 0) { + const potentialSession = this.sessions.shift(); + if (potentialSession != null && (!!this.client.topology?.loadBalanced || !potentialSession.hasTimedOut(sessionTimeoutMinutes))) { + session = potentialSession; + break; + } + } + if (session == null) { + session = new ServerSession(); + } + return session; + } + /** + * Release a session to the session pool + * Adds the session back to the session pool if the session has not timed out yet. + * This method also removes any stale sessions from the pool. + * + * @param session - The session to release to the pool + */ + release(session) { + const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10; + if (this.client.topology?.loadBalanced && !sessionTimeoutMinutes) { + this.sessions.unshift(session); + } + if (!sessionTimeoutMinutes) { + return; + } + this.sessions.prune((session2) => session2.hasTimedOut(sessionTimeoutMinutes)); + if (!session.hasTimedOut(sessionTimeoutMinutes)) { + if (session.isDirty) { + return; + } + this.sessions.unshift(session); + } + } + }; + exports2.ServerSessionPool = ServerSessionPool; + function applySession(session, command, options) { + if (session.hasEnded) { + return new error_1.MongoExpiredSessionError(); + } + const serverSession = session.serverSession; + if (serverSession == null) { + return new error_1.MongoRuntimeError("Unable to acquire server session"); + } + if (options.writeConcern?.w === 0) { + if (session && session.explicit) { + return new error_1.MongoAPIError("Cannot have explicit session with unacknowledged writes"); + } + return; + } + serverSession.lastUse = (0, utils_1.now)(); + command.lsid = serverSession.id; + const inTxnOrTxnCommand = session.inTransaction() || (0, transactions_1.isTransactionCommand)(command); + const isRetryableWrite = !!options.willRetryWrite; + if (isRetryableWrite || inTxnOrTxnCommand) { + serverSession.txnNumber += session.txnNumberIncrement; + session.txnNumberIncrement = 0; + command.txnNumber = bson_1.Long.fromNumber(serverSession.txnNumber); + } + if (!inTxnOrTxnCommand) { + if (session.transaction.state !== transactions_1.TxnState.NO_TRANSACTION) { + session.transaction.transition(transactions_1.TxnState.NO_TRANSACTION); + } + if (session.supports.causalConsistency && session.operationTime && (0, utils_1.commandSupportsReadConcern)(command)) { + command.readConcern = command.readConcern || {}; + Object.assign(command.readConcern, { afterClusterTime: session.operationTime }); + } else if (session.snapshotEnabled) { + command.readConcern = command.readConcern || { level: read_concern_1.ReadConcernLevel.snapshot }; + if (session.snapshotTime != null) { + Object.assign(command.readConcern, { atClusterTime: session.snapshotTime }); + } + } + return; + } + command.autocommit = false; + if (session.transaction.state === transactions_1.TxnState.STARTING_TRANSACTION) { + session.transaction.transition(transactions_1.TxnState.TRANSACTION_IN_PROGRESS); + command.startTransaction = true; + const readConcern = session.transaction.options.readConcern || session?.clientOptions?.readConcern; + if (readConcern) { + command.readConcern = readConcern; + } + if (session.supports.causalConsistency && session.operationTime) { + command.readConcern = command.readConcern || {}; + Object.assign(command.readConcern, { afterClusterTime: session.operationTime }); + } + } + return; + } + function updateSessionFromResponse(session, document) { + if (document.$clusterTime) { + (0, common_1._advanceClusterTime)(session, document.$clusterTime); + } + if (document.operationTime && session && session.supports.causalConsistency) { + session.advanceOperationTime(document.operationTime); + } + if (document.recoveryToken && session && session.inTransaction()) { + session.transaction._recoveryToken = document.recoveryToken; + } + if (session?.snapshotEnabled && session.snapshotTime == null) { + const atClusterTime = document.atClusterTime; + if (atClusterTime) { + session.snapshotTime = atClusterTime; + } + } + } + } +}); + +// node_modules/mongodb/lib/cmap/command_monitoring_events.js +var require_command_monitoring_events = __commonJS({ + "node_modules/mongodb/lib/cmap/command_monitoring_events.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SENSITIVE_COMMANDS = exports2.CommandFailedEvent = exports2.CommandSucceededEvent = exports2.CommandStartedEvent = void 0; + var constants_1 = require_constants2(); + var utils_1 = require_utils3(); + var commands_1 = require_commands3(); + var CommandStartedEvent = class { + /** + * Create a started event + * + * @internal + * @param pool - the pool that originated the command + * @param command - the command + */ + constructor(connection, command, serverConnectionId) { + this.name = constants_1.COMMAND_STARTED; + const cmd = extractCommand(command); + const commandName = extractCommandName(cmd); + const { address, connectionId, serviceId } = extractConnectionDetails(connection); + if (exports2.SENSITIVE_COMMANDS.has(commandName)) { + this.commandObj = {}; + this.commandObj[commandName] = true; + } + this.address = address; + this.connectionId = connectionId; + this.serviceId = serviceId; + this.requestId = command.requestId; + this.databaseName = command.databaseName; + this.commandName = commandName; + this.command = maybeRedact(commandName, cmd, cmd); + this.serverConnectionId = serverConnectionId; + } + /* @internal */ + get hasServiceId() { + return !!this.serviceId; + } + }; + exports2.CommandStartedEvent = CommandStartedEvent; + var CommandSucceededEvent = class { + /** + * Create a succeeded event + * + * @internal + * @param pool - the pool that originated the command + * @param command - the command + * @param reply - the reply for this command from the server + * @param started - a high resolution tuple timestamp of when the command was first sent, to calculate duration + */ + constructor(connection, command, reply2, started, serverConnectionId) { + this.name = constants_1.COMMAND_SUCCEEDED; + const cmd = extractCommand(command); + const commandName = extractCommandName(cmd); + const { address, connectionId, serviceId } = extractConnectionDetails(connection); + this.address = address; + this.connectionId = connectionId; + this.serviceId = serviceId; + this.requestId = command.requestId; + this.commandName = commandName; + this.duration = (0, utils_1.calculateDurationInMs)(started); + this.reply = maybeRedact(commandName, cmd, extractReply(reply2)); + this.serverConnectionId = serverConnectionId; + this.databaseName = command.databaseName; + } + /* @internal */ + get hasServiceId() { + return !!this.serviceId; + } + }; + exports2.CommandSucceededEvent = CommandSucceededEvent; + var CommandFailedEvent = class { + /** + * Create a failure event + * + * @internal + * @param pool - the pool that originated the command + * @param command - the command + * @param error - the generated error or a server error response + * @param started - a high resolution tuple timestamp of when the command was first sent, to calculate duration + */ + constructor(connection, command, error, started, serverConnectionId) { + this.name = constants_1.COMMAND_FAILED; + const cmd = extractCommand(command); + const commandName = extractCommandName(cmd); + const { address, connectionId, serviceId } = extractConnectionDetails(connection); + this.address = address; + this.connectionId = connectionId; + this.serviceId = serviceId; + this.requestId = command.requestId; + this.commandName = commandName; + this.duration = (0, utils_1.calculateDurationInMs)(started); + this.failure = maybeRedact(commandName, cmd, error); + this.serverConnectionId = serverConnectionId; + this.databaseName = command.databaseName; + } + /* @internal */ + get hasServiceId() { + return !!this.serviceId; + } + }; + exports2.CommandFailedEvent = CommandFailedEvent; + exports2.SENSITIVE_COMMANDS = /* @__PURE__ */ new Set([ + "authenticate", + "saslStart", + "saslContinue", + "getnonce", + "createUser", + "updateUser", + "copydbgetnonce", + "copydbsaslstart", + "copydb" + ]); + var HELLO_COMMANDS = /* @__PURE__ */ new Set(["hello", constants_1.LEGACY_HELLO_COMMAND, constants_1.LEGACY_HELLO_COMMAND_CAMEL_CASE]); + var extractCommandName = (commandDoc) => Object.keys(commandDoc)[0]; + var collectionName = (command) => command.ns.split(".")[1]; + var maybeRedact = (commandName, commandDoc, result) => exports2.SENSITIVE_COMMANDS.has(commandName) || HELLO_COMMANDS.has(commandName) && commandDoc.speculativeAuthenticate ? {} : result; + var LEGACY_FIND_QUERY_MAP = { + $query: "filter", + $orderby: "sort", + $hint: "hint", + $comment: "comment", + $maxScan: "maxScan", + $max: "max", + $min: "min", + $returnKey: "returnKey", + $showDiskLoc: "showRecordId", + $maxTimeMS: "maxTimeMS", + $snapshot: "snapshot" + }; + var LEGACY_FIND_OPTIONS_MAP = { + numberToSkip: "skip", + numberToReturn: "batchSize", + returnFieldSelector: "projection" + }; + function extractCommand(command) { + if (command instanceof commands_1.OpMsgRequest) { + const cmd = { ...command.command }; + if (cmd.ops instanceof commands_1.DocumentSequence) { + cmd.ops = cmd.ops.documents; + } + if (cmd.nsInfo instanceof commands_1.DocumentSequence) { + cmd.nsInfo = cmd.nsInfo.documents; + } + return cmd; + } + if (command.query?.$query) { + let result; + if (command.ns === "admin.$cmd") { + result = Object.assign({}, command.query.$query); + } else { + result = { find: collectionName(command) }; + Object.keys(LEGACY_FIND_QUERY_MAP).forEach((key) => { + if (command.query[key] != null) { + result[LEGACY_FIND_QUERY_MAP[key]] = { ...command.query[key] }; + } + }); + } + Object.keys(LEGACY_FIND_OPTIONS_MAP).forEach((key) => { + const legacyKey = key; + if (command[legacyKey] != null) { + result[LEGACY_FIND_OPTIONS_MAP[legacyKey]] = command[legacyKey]; + } + }); + return result; + } + let clonedQuery = {}; + const clonedCommand = { ...command }; + if (command.query) { + clonedQuery = { ...command.query }; + clonedCommand.query = clonedQuery; + } + return command.query ? clonedQuery : clonedCommand; + } + function extractReply(reply2) { + if (!reply2) { + return reply2; + } + return reply2.result ? reply2.result : reply2; + } + function extractConnectionDetails(connection) { + let connectionId; + if ("id" in connection) { + connectionId = connection.id; + } + return { + address: connection.address, + serviceId: connection.serviceId, + connectionId + }; + } + } +}); + +// node_modules/mongodb/lib/sdam/server_description.js +var require_server_description = __commonJS({ + "node_modules/mongodb/lib/sdam/server_description.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ServerDescription = void 0; + exports2.parseServerType = parseServerType; + exports2.compareTopologyVersion = compareTopologyVersion; + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var common_1 = require_common(); + var WRITABLE_SERVER_TYPES = /* @__PURE__ */ new Set([ + common_1.ServerType.RSPrimary, + common_1.ServerType.Standalone, + common_1.ServerType.Mongos, + common_1.ServerType.LoadBalancer + ]); + var DATA_BEARING_SERVER_TYPES = /* @__PURE__ */ new Set([ + common_1.ServerType.RSPrimary, + common_1.ServerType.RSSecondary, + common_1.ServerType.Mongos, + common_1.ServerType.Standalone, + common_1.ServerType.LoadBalancer + ]); + var ServerDescription = class { + /** + * Create a ServerDescription + * @internal + * + * @param address - The address of the server + * @param hello - An optional hello response for this server + */ + constructor(address, hello, options = {}) { + if (address == null || address === "") { + throw new error_1.MongoRuntimeError("ServerDescription must be provided with a non-empty address"); + } + this.address = typeof address === "string" ? utils_1.HostAddress.fromString(address).toString() : address.toString(); + this.type = parseServerType(hello, options); + this.hosts = hello?.hosts?.map((host) => host.toLowerCase()) ?? []; + this.passives = hello?.passives?.map((host) => host.toLowerCase()) ?? []; + this.arbiters = hello?.arbiters?.map((host) => host.toLowerCase()) ?? []; + this.tags = hello?.tags ?? {}; + this.minWireVersion = hello?.minWireVersion ?? 0; + this.maxWireVersion = hello?.maxWireVersion ?? 0; + this.roundTripTime = options?.roundTripTime ?? -1; + this.minRoundTripTime = options?.minRoundTripTime ?? 0; + this.lastUpdateTime = (0, utils_1.now)(); + this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0; + this.error = options.error ?? null; + this.error?.stack; + this.topologyVersion = this.error?.topologyVersion ?? hello?.topologyVersion ?? null; + this.setName = hello?.setName ?? null; + this.setVersion = hello?.setVersion ?? null; + this.electionId = hello?.electionId ?? null; + this.logicalSessionTimeoutMinutes = hello?.logicalSessionTimeoutMinutes ?? null; + this.maxMessageSizeBytes = hello?.maxMessageSizeBytes ?? null; + this.maxWriteBatchSize = hello?.maxWriteBatchSize ?? null; + this.maxBsonObjectSize = hello?.maxBsonObjectSize ?? null; + this.primary = hello?.primary ?? null; + this.me = hello?.me?.toLowerCase() ?? null; + this.$clusterTime = hello?.$clusterTime ?? null; + this.iscryptd = Boolean(hello?.iscryptd); + } + get hostAddress() { + return utils_1.HostAddress.fromString(this.address); + } + get allHosts() { + return this.hosts.concat(this.arbiters).concat(this.passives); + } + /** Is this server available for reads*/ + get isReadable() { + return this.type === common_1.ServerType.RSSecondary || this.isWritable; + } + /** Is this server data bearing */ + get isDataBearing() { + return DATA_BEARING_SERVER_TYPES.has(this.type); + } + /** Is this server available for writes */ + get isWritable() { + return WRITABLE_SERVER_TYPES.has(this.type); + } + get host() { + const chopLength = `:${this.port}`.length; + return this.address.slice(0, -chopLength); + } + get port() { + const port = this.address.split(":").pop(); + return port ? Number.parseInt(port, 10) : 27017; + } + /** + * Determines if another `ServerDescription` is equal to this one per the rules defined in the SDAM specification. + * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md + */ + equals(other) { + const topologyVersionsEqual = this.topologyVersion === other?.topologyVersion || compareTopologyVersion(this.topologyVersion, other?.topologyVersion) === 0; + const electionIdsEqual = this.electionId != null && other?.electionId != null ? (0, utils_1.compareObjectId)(this.electionId, other.electionId) === 0 : this.electionId === other?.electionId; + return other != null && other.iscryptd === this.iscryptd && (0, utils_1.errorStrictEqual)(this.error, other.error) && this.type === other.type && this.minWireVersion === other.minWireVersion && (0, utils_1.arrayStrictEqual)(this.hosts, other.hosts) && tagsStrictEqual(this.tags, other.tags) && this.setName === other.setName && this.setVersion === other.setVersion && electionIdsEqual && this.primary === other.primary && this.logicalSessionTimeoutMinutes === other.logicalSessionTimeoutMinutes && topologyVersionsEqual; + } + }; + exports2.ServerDescription = ServerDescription; + function parseServerType(hello, options) { + if (options?.loadBalanced) { + return common_1.ServerType.LoadBalancer; + } + if (!hello || !hello.ok) { + return common_1.ServerType.Unknown; + } + if (hello.isreplicaset) { + return common_1.ServerType.RSGhost; + } + if (hello.msg && hello.msg === "isdbgrid") { + return common_1.ServerType.Mongos; + } + if (hello.setName) { + if (hello.hidden) { + return common_1.ServerType.RSOther; + } else if (hello.isWritablePrimary) { + return common_1.ServerType.RSPrimary; + } else if (hello.secondary) { + return common_1.ServerType.RSSecondary; + } else if (hello.arbiterOnly) { + return common_1.ServerType.RSArbiter; + } else { + return common_1.ServerType.RSOther; + } + } + return common_1.ServerType.Standalone; + } + function tagsStrictEqual(tags, tags2) { + const tagsKeys = Object.keys(tags); + const tags2Keys = Object.keys(tags2); + return tagsKeys.length === tags2Keys.length && tagsKeys.every((key) => tags2[key] === tags[key]); + } + function compareTopologyVersion(currentTv, newTv) { + if (currentTv == null || newTv == null) { + return -1; + } + if (!currentTv.processId.equals(newTv.processId)) { + return -1; + } + const currentCounter = typeof currentTv.counter === "bigint" ? bson_1.Long.fromBigInt(currentTv.counter) : bson_1.Long.isLong(currentTv.counter) ? currentTv.counter : bson_1.Long.fromNumber(currentTv.counter); + const newCounter = typeof newTv.counter === "bigint" ? bson_1.Long.fromBigInt(newTv.counter) : bson_1.Long.isLong(newTv.counter) ? newTv.counter : bson_1.Long.fromNumber(newTv.counter); + return currentCounter.compare(newCounter); + } + } +}); + +// node_modules/mongodb/lib/cmap/stream_description.js +var require_stream_description = __commonJS({ + "node_modules/mongodb/lib/cmap/stream_description.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.StreamDescription = void 0; + var bson_1 = require_bson2(); + var common_1 = require_common(); + var server_description_1 = require_server_description(); + var RESPONSE_FIELDS = [ + "minWireVersion", + "maxWireVersion", + "maxBsonObjectSize", + "maxMessageSizeBytes", + "maxWriteBatchSize", + "logicalSessionTimeoutMinutes" + ]; + var StreamDescription = class { + constructor(address, options) { + this.hello = null; + this.address = address; + this.type = common_1.ServerType.Unknown; + this.minWireVersion = void 0; + this.maxWireVersion = void 0; + this.maxBsonObjectSize = 16777216; + this.maxMessageSizeBytes = 48e6; + this.maxWriteBatchSize = 1e5; + this.logicalSessionTimeoutMinutes = options?.logicalSessionTimeoutMinutes; + this.loadBalanced = !!options?.loadBalanced; + this.compressors = options && options.compressors && Array.isArray(options.compressors) ? options.compressors : []; + this.serverConnectionId = null; + } + receiveResponse(response) { + if (response == null) { + return; + } + this.hello = response; + this.type = (0, server_description_1.parseServerType)(response); + if ("connectionId" in response) { + this.serverConnectionId = this.parseServerConnectionID(response.connectionId); + } else { + this.serverConnectionId = null; + } + for (const field of RESPONSE_FIELDS) { + if (response[field] != null) { + this[field] = response[field]; + } + if ("__nodejs_mock_server__" in response) { + this.__nodejs_mock_server__ = response["__nodejs_mock_server__"]; + } + } + if (response.compression) { + this.compressor = this.compressors.filter((c) => response.compression?.includes(c))[0]; + } + } + /* @internal */ + parseServerConnectionID(serverConnectionId) { + return bson_1.Long.isLong(serverConnectionId) ? serverConnectionId.toBigInt() : ( + // @ts-expect-error: Doubles are coercible to number + BigInt(serverConnectionId) + ); + } + }; + exports2.StreamDescription = StreamDescription; + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/on_data.js +var require_on_data = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/on_data.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.onData = onData; + var utils_1 = require_utils3(); + function onData(emitter, { timeoutContext, signal }) { + signal?.throwIfAborted(); + const unconsumedEvents = new utils_1.List(); + const unconsumedPromises = new utils_1.List(); + let error = null; + let finished = false; + const iterator = { + next() { + const value = unconsumedEvents.shift(); + if (value != null) { + return Promise.resolve({ value, done: false }); + } + if (error != null) { + const p = Promise.reject(error); + error = null; + return p; + } + if (finished) + return closeHandler(); + const { promise, resolve, reject } = (0, utils_1.promiseWithResolvers)(); + unconsumedPromises.push({ resolve, reject }); + return promise; + }, + return() { + return closeHandler(); + }, + throw(err) { + errorHandler(err); + return Promise.resolve({ value: void 0, done: true }); + }, + [Symbol.asyncIterator]() { + return this; + }, + // Note this should currently not be used, but is required by the AsyncGenerator interface. + async [Symbol.asyncDispose]() { + await closeHandler(); + } + }; + emitter.on("data", eventHandler); + emitter.on("error", errorHandler); + const abortListener = (0, utils_1.addAbortListener)(signal, function() { + errorHandler(this.reason); + }); + const timeoutForSocketRead = timeoutContext?.timeoutForSocketRead; + timeoutForSocketRead?.throwIfExpired(); + timeoutForSocketRead?.then(void 0, errorHandler); + return iterator; + function eventHandler(value) { + const promise = unconsumedPromises.shift(); + if (promise != null) + promise.resolve({ value, done: false }); + else + unconsumedEvents.push(value); + } + function errorHandler(err) { + const promise = unconsumedPromises.shift(); + if (promise != null) + promise.reject(err); + else + error = err; + void closeHandler(); + } + function closeHandler() { + emitter.off("data", eventHandler); + emitter.off("error", errorHandler); + abortListener?.[utils_1.kDispose](); + finished = true; + timeoutForSocketRead?.clear(); + const doneResult = { value: void 0, done: finished }; + for (const promise of unconsumedPromises) { + promise.resolve(doneResult); + } + return Promise.resolve(doneResult); + } + } + } +}); + +// node_modules/mongodb/lib/sdam/topology_description.js +var require_topology_description = __commonJS({ + "node_modules/mongodb/lib/sdam/topology_description.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.TopologyDescription = void 0; + var bson_1 = require_bson2(); + var WIRE_CONSTANTS = require_constants(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var common_1 = require_common(); + var server_description_1 = require_server_description(); + var MIN_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_SERVER_VERSION; + var MAX_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MAX_SUPPORTED_SERVER_VERSION; + var MIN_SUPPORTED_WIRE_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_WIRE_VERSION; + var MAX_SUPPORTED_WIRE_VERSION = WIRE_CONSTANTS.MAX_SUPPORTED_WIRE_VERSION; + var MONGOS_OR_UNKNOWN = /* @__PURE__ */ new Set([common_1.ServerType.Mongos, common_1.ServerType.Unknown]); + var MONGOS_OR_STANDALONE = /* @__PURE__ */ new Set([common_1.ServerType.Mongos, common_1.ServerType.Standalone]); + var NON_PRIMARY_RS_MEMBERS = /* @__PURE__ */ new Set([ + common_1.ServerType.RSSecondary, + common_1.ServerType.RSArbiter, + common_1.ServerType.RSOther + ]); + var TopologyDescription = class _TopologyDescription { + /** + * Create a TopologyDescription + */ + constructor(topologyType, serverDescriptions = null, setName = null, maxSetVersion = null, maxElectionId = null, commonWireVersion = null, options = null) { + options = options ?? {}; + this.type = topologyType ?? common_1.TopologyType.Unknown; + this.servers = serverDescriptions ?? /* @__PURE__ */ new Map(); + this.stale = false; + this.compatible = true; + this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 0; + this.localThresholdMS = options.localThresholdMS ?? 15; + this.setName = setName ?? null; + this.maxElectionId = maxElectionId ?? null; + this.maxSetVersion = maxSetVersion ?? null; + this.commonWireVersion = commonWireVersion ?? 0; + for (const serverDescription of this.servers.values()) { + if (serverDescription.type === common_1.ServerType.Unknown || serverDescription.type === common_1.ServerType.LoadBalancer) { + continue; + } + if (serverDescription.minWireVersion > MAX_SUPPORTED_WIRE_VERSION) { + this.compatible = false; + this.compatibilityError = `Server at ${serverDescription.address} requires wire version ${serverDescription.minWireVersion}, but this version of the driver only supports up to ${MAX_SUPPORTED_WIRE_VERSION} (MongoDB ${MAX_SUPPORTED_SERVER_VERSION})`; + } + if (serverDescription.maxWireVersion < MIN_SUPPORTED_WIRE_VERSION) { + this.compatible = false; + this.compatibilityError = `Server at ${serverDescription.address} reports wire version ${serverDescription.maxWireVersion}, but this version of the driver requires at least ${MIN_SUPPORTED_WIRE_VERSION} (MongoDB ${MIN_SUPPORTED_SERVER_VERSION}).`; + break; + } + } + this.logicalSessionTimeoutMinutes = null; + for (const [, server] of this.servers) { + if (server.isReadable) { + if (server.logicalSessionTimeoutMinutes == null) { + this.logicalSessionTimeoutMinutes = null; + break; + } + if (this.logicalSessionTimeoutMinutes == null) { + this.logicalSessionTimeoutMinutes = server.logicalSessionTimeoutMinutes; + continue; + } + this.logicalSessionTimeoutMinutes = Math.min(this.logicalSessionTimeoutMinutes, server.logicalSessionTimeoutMinutes); + } + } + } + /** + * Returns a new TopologyDescription based on the SrvPollingEvent + * @internal + */ + updateFromSrvPollingEvent(ev, srvMaxHosts = 0) { + const incomingHostnames = ev.hostnames(); + const currentHostnames = new Set(this.servers.keys()); + const hostnamesToAdd = new Set(incomingHostnames); + const hostnamesToRemove = /* @__PURE__ */ new Set(); + for (const hostname of currentHostnames) { + hostnamesToAdd.delete(hostname); + if (!incomingHostnames.has(hostname)) { + hostnamesToRemove.add(hostname); + } + } + if (hostnamesToAdd.size === 0 && hostnamesToRemove.size === 0) { + return this; + } + const serverDescriptions = new Map(this.servers); + for (const removedHost of hostnamesToRemove) { + serverDescriptions.delete(removedHost); + } + if (hostnamesToAdd.size > 0) { + if (srvMaxHosts === 0) { + for (const hostToAdd of hostnamesToAdd) { + serverDescriptions.set(hostToAdd, new server_description_1.ServerDescription(hostToAdd)); + } + } else if (serverDescriptions.size < srvMaxHosts) { + const selectedHosts = (0, utils_1.shuffle)(hostnamesToAdd, srvMaxHosts - serverDescriptions.size); + for (const selectedHostToAdd of selectedHosts) { + serverDescriptions.set(selectedHostToAdd, new server_description_1.ServerDescription(selectedHostToAdd)); + } + } + } + return new _TopologyDescription(this.type, serverDescriptions, this.setName, this.maxSetVersion, this.maxElectionId, this.commonWireVersion, { heartbeatFrequencyMS: this.heartbeatFrequencyMS, localThresholdMS: this.localThresholdMS }); + } + /** + * Returns a copy of this description updated with a given ServerDescription + * @internal + */ + update(serverDescription) { + const address = serverDescription.address; + let { type: topologyType, setName, maxSetVersion, maxElectionId, commonWireVersion } = this; + const serverType = serverDescription.type; + const serverDescriptions = new Map(this.servers); + if (serverDescription.maxWireVersion !== 0) { + if (commonWireVersion == null) { + commonWireVersion = serverDescription.maxWireVersion; + } else { + commonWireVersion = Math.min(commonWireVersion, serverDescription.maxWireVersion); + } + } + if (typeof serverDescription.setName === "string" && typeof setName === "string" && serverDescription.setName !== setName) { + if (topologyType === common_1.TopologyType.Single) { + serverDescription = new server_description_1.ServerDescription(address); + } else { + serverDescriptions.delete(address); + } + } + serverDescriptions.set(address, serverDescription); + if (topologyType === common_1.TopologyType.Single) { + return new _TopologyDescription(common_1.TopologyType.Single, serverDescriptions, setName, maxSetVersion, maxElectionId, commonWireVersion, { heartbeatFrequencyMS: this.heartbeatFrequencyMS, localThresholdMS: this.localThresholdMS }); + } + if (topologyType === common_1.TopologyType.Unknown) { + if (serverType === common_1.ServerType.Standalone && this.servers.size !== 1) { + serverDescriptions.delete(address); + } else { + topologyType = topologyTypeForServerType(serverType); + } + } + if (topologyType === common_1.TopologyType.Sharded) { + if (!MONGOS_OR_UNKNOWN.has(serverType)) { + serverDescriptions.delete(address); + } + } + if (topologyType === common_1.TopologyType.ReplicaSetNoPrimary) { + if (MONGOS_OR_STANDALONE.has(serverType)) { + serverDescriptions.delete(address); + } + if (serverType === common_1.ServerType.RSPrimary) { + const result = updateRsFromPrimary(serverDescriptions, serverDescription, setName, maxSetVersion, maxElectionId); + topologyType = result[0]; + setName = result[1]; + maxSetVersion = result[2]; + maxElectionId = result[3]; + } else if (NON_PRIMARY_RS_MEMBERS.has(serverType)) { + const result = updateRsNoPrimaryFromMember(serverDescriptions, serverDescription, setName); + topologyType = result[0]; + setName = result[1]; + } + } + if (topologyType === common_1.TopologyType.ReplicaSetWithPrimary) { + if (MONGOS_OR_STANDALONE.has(serverType)) { + serverDescriptions.delete(address); + topologyType = checkHasPrimary(serverDescriptions); + } else if (serverType === common_1.ServerType.RSPrimary) { + const result = updateRsFromPrimary(serverDescriptions, serverDescription, setName, maxSetVersion, maxElectionId); + topologyType = result[0]; + setName = result[1]; + maxSetVersion = result[2]; + maxElectionId = result[3]; + } else if (NON_PRIMARY_RS_MEMBERS.has(serverType)) { + topologyType = updateRsWithPrimaryFromMember(serverDescriptions, serverDescription, setName); + } else { + topologyType = checkHasPrimary(serverDescriptions); + } + } + return new _TopologyDescription(topologyType, serverDescriptions, setName, maxSetVersion, maxElectionId, commonWireVersion, { heartbeatFrequencyMS: this.heartbeatFrequencyMS, localThresholdMS: this.localThresholdMS }); + } + get error() { + const descriptionsWithError = Array.from(this.servers.values()).filter((sd) => sd.error); + if (descriptionsWithError.length > 0) { + return descriptionsWithError[0].error; + } + return null; + } + /** + * Determines if the topology description has any known servers + */ + get hasKnownServers() { + return Array.from(this.servers.values()).some((sd) => sd.type !== common_1.ServerType.Unknown); + } + /** + * Determines if this topology description has a data-bearing server available. + */ + get hasDataBearingServers() { + return Array.from(this.servers.values()).some((sd) => sd.isDataBearing); + } + /** + * Determines if the topology has a definition for the provided address + * @internal + */ + hasServer(address) { + return this.servers.has(address); + } + /** + * Returns a JSON-serializable representation of the TopologyDescription. This is primarily + * intended for use with JSON.stringify(). + * + * This method will not throw. + */ + toJSON() { + return bson_1.EJSON.serialize(this); + } + }; + exports2.TopologyDescription = TopologyDescription; + function topologyTypeForServerType(serverType) { + switch (serverType) { + case common_1.ServerType.Standalone: + return common_1.TopologyType.Single; + case common_1.ServerType.Mongos: + return common_1.TopologyType.Sharded; + case common_1.ServerType.RSPrimary: + return common_1.TopologyType.ReplicaSetWithPrimary; + case common_1.ServerType.RSOther: + case common_1.ServerType.RSSecondary: + return common_1.TopologyType.ReplicaSetNoPrimary; + default: + return common_1.TopologyType.Unknown; + } + } + function updateRsFromPrimary(serverDescriptions, serverDescription, setName = null, maxSetVersion = null, maxElectionId = null) { + const setVersionElectionIdMismatch = (serverDescription2, maxSetVersion2, maxElectionId2) => { + return `primary marked stale due to electionId/setVersion mismatch: server setVersion: ${serverDescription2.setVersion}, server electionId: ${serverDescription2.electionId}, topology setVersion: ${maxSetVersion2}, topology electionId: ${maxElectionId2}`; + }; + setName = setName || serverDescription.setName; + if (setName !== serverDescription.setName) { + serverDescriptions.delete(serverDescription.address); + return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId]; + } + if (serverDescription.maxWireVersion >= 17) { + const electionIdComparison = (0, utils_1.compareObjectId)(maxElectionId, serverDescription.electionId); + const maxElectionIdIsEqual = electionIdComparison === 0; + const maxElectionIdIsLess = electionIdComparison === -1; + const maxSetVersionIsLessOrEqual = (maxSetVersion ?? -1) <= (serverDescription.setVersion ?? -1); + if (maxElectionIdIsLess || maxElectionIdIsEqual && maxSetVersionIsLessOrEqual) { + maxElectionId = serverDescription.electionId; + maxSetVersion = serverDescription.setVersion; + } else { + serverDescriptions.set(serverDescription.address, new server_description_1.ServerDescription(serverDescription.address, void 0, { + error: new error_1.MongoStalePrimaryError(setVersionElectionIdMismatch(serverDescription, maxSetVersion, maxElectionId)) + })); + return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId]; + } + } else { + const electionId = serverDescription.electionId ? serverDescription.electionId : null; + if (serverDescription.setVersion && electionId) { + if (maxSetVersion && maxElectionId) { + if (maxSetVersion > serverDescription.setVersion || (0, utils_1.compareObjectId)(maxElectionId, electionId) > 0) { + serverDescriptions.set(serverDescription.address, new server_description_1.ServerDescription(serverDescription.address, void 0, { + error: new error_1.MongoStalePrimaryError(setVersionElectionIdMismatch(serverDescription, maxSetVersion, maxElectionId)) + })); + return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId]; + } + } + maxElectionId = serverDescription.electionId; + } + if (serverDescription.setVersion != null && (maxSetVersion == null || serverDescription.setVersion > maxSetVersion)) { + maxSetVersion = serverDescription.setVersion; + } + } + for (const [address, server] of serverDescriptions) { + if (server.type === common_1.ServerType.RSPrimary && server.address !== serverDescription.address) { + serverDescriptions.set(address, new server_description_1.ServerDescription(server.address, void 0, { + error: new error_1.MongoStalePrimaryError("primary marked stale due to discovery of newer primary") + })); + break; + } + } + serverDescription.allHosts.forEach((address) => { + if (!serverDescriptions.has(address)) { + serverDescriptions.set(address, new server_description_1.ServerDescription(address)); + } + }); + const currentAddresses = Array.from(serverDescriptions.keys()); + const responseAddresses = serverDescription.allHosts; + currentAddresses.filter((addr) => responseAddresses.indexOf(addr) === -1).forEach((address) => { + serverDescriptions.delete(address); + }); + return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId]; + } + function updateRsWithPrimaryFromMember(serverDescriptions, serverDescription, setName = null) { + if (setName == null) { + throw new error_1.MongoRuntimeError('Argument "setName" is required if connected to a replica set'); + } + if (setName !== serverDescription.setName || serverDescription.me && serverDescription.address !== serverDescription.me) { + serverDescriptions.delete(serverDescription.address); + } + return checkHasPrimary(serverDescriptions); + } + function updateRsNoPrimaryFromMember(serverDescriptions, serverDescription, setName = null) { + const topologyType = common_1.TopologyType.ReplicaSetNoPrimary; + setName = setName ?? serverDescription.setName; + if (setName !== serverDescription.setName) { + serverDescriptions.delete(serverDescription.address); + return [topologyType, setName]; + } + serverDescription.allHosts.forEach((address) => { + if (!serverDescriptions.has(address)) { + serverDescriptions.set(address, new server_description_1.ServerDescription(address)); + } + }); + if (serverDescription.me && serverDescription.address !== serverDescription.me) { + serverDescriptions.delete(serverDescription.address); + } + return [topologyType, setName]; + } + function checkHasPrimary(serverDescriptions) { + for (const serverDescription of serverDescriptions.values()) { + if (serverDescription.type === common_1.ServerType.RSPrimary) { + return common_1.TopologyType.ReplicaSetWithPrimary; + } + } + return common_1.TopologyType.ReplicaSetNoPrimary; + } + } +}); + +// node_modules/mongodb/lib/cmap/wire_protocol/shared.js +var require_shared = __commonJS({ + "node_modules/mongodb/lib/cmap/wire_protocol/shared.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.getReadPreference = getReadPreference; + exports2.isSharded = isSharded; + var error_1 = require_error(); + var read_preference_1 = require_read_preference(); + var common_1 = require_common(); + var topology_description_1 = require_topology_description(); + function getReadPreference(options) { + let readPreference = options?.readPreference ?? read_preference_1.ReadPreference.primary; + if (typeof readPreference === "string") { + readPreference = read_preference_1.ReadPreference.fromString(readPreference); + } + if (!(readPreference instanceof read_preference_1.ReadPreference)) { + throw new error_1.MongoInvalidArgumentError('Option "readPreference" must be a ReadPreference instance'); + } + return readPreference; + } + function isSharded(topologyOrServer) { + if (topologyOrServer == null) { + return false; + } + if (topologyOrServer.description && topologyOrServer.description.type === common_1.ServerType.Mongos) { + return true; + } + if (topologyOrServer.description && topologyOrServer.description instanceof topology_description_1.TopologyDescription) { + const servers = Array.from(topologyOrServer.description.servers.values()); + return servers.some((server) => server.type === common_1.ServerType.Mongos); + } + return false; + } + } +}); + +// node_modules/mongodb/lib/cmap/connection.js +var require_connection5 = __commonJS({ + "node_modules/mongodb/lib/cmap/connection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CryptoConnection = exports2.SizedMessageTransform = exports2.Connection = void 0; + exports2.hasSessionSupport = hasSessionSupport; + var stream_1 = require("stream"); + var timers_1 = require("timers"); + var bson_1 = require_bson2(); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_logger_1 = require_mongo_logger(); + var mongo_types_1 = require_mongo_types(); + var read_preference_1 = require_read_preference(); + var common_1 = require_common(); + var sessions_1 = require_sessions(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var command_monitoring_events_1 = require_command_monitoring_events(); + var commands_1 = require_commands3(); + var stream_description_1 = require_stream_description(); + var compression_1 = require_compression(); + var on_data_1 = require_on_data(); + var responses_1 = require_responses(); + var shared_1 = require_shared(); + function hasSessionSupport(conn) { + const description = conn.description; + return description.logicalSessionTimeoutMinutes != null; + } + function streamIdentifier(stream, options) { + if (options.proxyHost) { + return options.hostAddress.toString(); + } + const { remoteAddress, remotePort } = stream; + if (typeof remoteAddress === "string" && typeof remotePort === "number") { + return utils_1.HostAddress.fromHostPort(remoteAddress, remotePort).toString(); + } + return (0, utils_1.uuidV4)().toString("hex"); + } + var Connection = class _Connection extends mongo_types_1.TypedEventEmitter { + constructor(stream, options) { + super(); + this.lastHelloMS = -1; + this.helloOk = false; + this.delayedTimeoutId = null; + this.closed = false; + this.clusterTime = null; + this.error = null; + this.dataEvents = null; + this.on("error", utils_1.noop); + this.socket = stream; + this.id = options.id; + this.address = streamIdentifier(stream, options); + this.socketTimeoutMS = options.socketTimeoutMS ?? 0; + this.monitorCommands = options.monitorCommands; + this.serverApi = options.serverApi; + this.mongoLogger = options.mongoLogger; + this.established = false; + this.description = new stream_description_1.StreamDescription(this.address, options); + this.generation = options.generation; + this.lastUseTime = (0, utils_1.now)(); + this.messageStream = this.socket.on("error", this.onSocketError.bind(this)).pipe(new SizedMessageTransform({ connection: this })).on("error", this.onTransformError.bind(this)); + this.socket.on("close", this.onClose.bind(this)); + this.socket.on("timeout", this.onTimeout.bind(this)); + this.messageStream.pause(); + } + get hello() { + return this.description.hello; + } + // the `connect` method stores the result of the handshake hello on the connection + set hello(response) { + this.description.receiveResponse(response); + Object.freeze(this.description); + } + get serviceId() { + return this.hello?.serviceId; + } + get loadBalanced() { + return this.description.loadBalanced; + } + get idleTime() { + return (0, utils_1.calculateDurationInMs)(this.lastUseTime); + } + get hasSessionSupport() { + return this.description.logicalSessionTimeoutMinutes != null; + } + get supportsOpMsg() { + return this.description != null && // TODO(NODE-6672,NODE-6287): This guard is primarily for maxWireVersion = 0 + (0, utils_1.maxWireVersion)(this) >= 6 && !this.description.__nodejs_mock_server__; + } + get shouldEmitAndLogCommand() { + return (this.monitorCommands || this.established && !this.authContext?.reauthenticating && this.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.COMMAND, mongo_logger_1.SeverityLevel.DEBUG)) ?? false; + } + markAvailable() { + this.lastUseTime = (0, utils_1.now)(); + } + onSocketError(cause) { + this.onError(new error_1.MongoNetworkError(cause.message, { cause })); + } + onTransformError(error) { + this.onError(error); + } + onError(error) { + this.cleanup(error); + } + onClose() { + const message = `connection ${this.id} to ${this.address} closed`; + this.cleanup(new error_1.MongoNetworkError(message)); + } + onTimeout() { + this.delayedTimeoutId = (0, timers_1.setTimeout)(() => { + const message = `connection ${this.id} to ${this.address} timed out`; + const beforeHandshake = this.hello == null; + this.cleanup(new error_1.MongoNetworkTimeoutError(message, { beforeHandshake })); + }, 1).unref(); + } + destroy() { + if (this.closed) { + return; + } + this.removeAllListeners(_Connection.PINNED); + this.removeAllListeners(_Connection.UNPINNED); + const message = `connection ${this.id} to ${this.address} closed`; + this.cleanup(new error_1.MongoNetworkError(message)); + } + /** + * A method that cleans up the connection. When `force` is true, this method + * forcibly destroys the socket. + * + * If an error is provided, any in-flight operations will be closed with the error. + * + * This method does nothing if the connection is already closed. + */ + cleanup(error) { + if (this.closed) { + return; + } + this.socket.destroy(); + this.error = error; + this.dataEvents?.throw(error).then(void 0, utils_1.squashError); + this.closed = true; + this.emit(_Connection.CLOSE); + } + prepareCommand(db, command, options) { + let cmd = { ...command }; + const readPreference = (0, shared_1.getReadPreference)(options); + const session = options?.session; + let clusterTime = this.clusterTime; + if (this.serverApi) { + const { version, strict, deprecationErrors } = this.serverApi; + cmd.apiVersion = version; + if (strict != null) + cmd.apiStrict = strict; + if (deprecationErrors != null) + cmd.apiDeprecationErrors = deprecationErrors; + } + if (this.hasSessionSupport && session) { + if (session.clusterTime && clusterTime && session.clusterTime.clusterTime.greaterThan(clusterTime.clusterTime)) { + clusterTime = session.clusterTime; + } + const sessionError = (0, sessions_1.applySession)(session, cmd, options); + if (sessionError) + throw sessionError; + } else if (session?.explicit) { + throw new error_1.MongoCompatibilityError("Current topology does not support sessions"); + } + if (clusterTime) { + cmd.$clusterTime = clusterTime; + } + if (this.description.type !== common_1.ServerType.Standalone) { + if (!(0, shared_1.isSharded)(this) && !this.description.loadBalanced && this.supportsOpMsg && options.directConnection === true && readPreference?.mode === "primary") { + cmd.$readPreference = read_preference_1.ReadPreference.primaryPreferred.toJSON(); + } else if ((0, shared_1.isSharded)(this) && !this.supportsOpMsg && readPreference?.mode !== "primary") { + cmd = { + $query: cmd, + $readPreference: readPreference.toJSON() + }; + } else if (readPreference?.mode !== "primary") { + cmd.$readPreference = readPreference.toJSON(); + } + } + const commandOptions = { + numberToSkip: 0, + numberToReturn: -1, + checkKeys: false, + // This value is not overridable + secondaryOk: readPreference.secondaryOk(), + ...options + }; + options.timeoutContext?.addMaxTimeMSToCommand(cmd, options); + const message = this.supportsOpMsg ? new commands_1.OpMsgRequest(db, cmd, commandOptions) : new commands_1.OpQueryRequest(db, cmd, commandOptions); + return message; + } + async *sendWire(message, options, responseType) { + this.throwIfAborted(); + const timeout = options.socketTimeoutMS ?? options?.timeoutContext?.getSocketTimeoutMS() ?? this.socketTimeoutMS; + this.socket.setTimeout(timeout); + try { + await this.writeCommand(message, { + agreedCompressor: this.description.compressor ?? "none", + zlibCompressionLevel: this.description.zlibCompressionLevel, + timeoutContext: options.timeoutContext, + signal: options.signal + }); + if (options.noResponse || message.moreToCome) { + yield responses_1.MongoDBResponse.empty; + return; + } + this.throwIfAborted(); + if (options.timeoutContext?.csotEnabled() && options.timeoutContext.minRoundTripTime != null && options.timeoutContext.remainingTimeMS < options.timeoutContext.minRoundTripTime) { + throw new error_1.MongoOperationTimeoutError("Server roundtrip time is greater than the time remaining"); + } + for await (const response of this.readMany(options)) { + this.socket.setTimeout(0); + const bson = response.parse(); + const document = (responseType ?? responses_1.MongoDBResponse).make(bson); + yield document; + this.throwIfAborted(); + this.socket.setTimeout(timeout); + } + } finally { + this.socket.setTimeout(0); + } + } + async *sendCommand(ns, command, options, responseType) { + options?.signal?.throwIfAborted(); + const message = this.prepareCommand(ns.db, command, options); + let started = 0; + if (this.shouldEmitAndLogCommand) { + started = (0, utils_1.now)(); + this.emitAndLogCommand(this.monitorCommands, _Connection.COMMAND_STARTED, message.databaseName, this.established, new command_monitoring_events_1.CommandStartedEvent(this, message, this.description.serverConnectionId)); + } + const bsonOptions = options.documentsReturnedIn == null || !options.raw ? options : { + ...options, + raw: false, + fieldsAsRaw: { [options.documentsReturnedIn]: true } + }; + let document = void 0; + let object = void 0; + try { + this.throwIfAborted(); + for await (document of this.sendWire(message, options, responseType)) { + object = void 0; + if (options.session != null) { + (0, sessions_1.updateSessionFromResponse)(options.session, document); + } + if (document.$clusterTime) { + this.clusterTime = document.$clusterTime; + this.emit(_Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime); + } + if (document.ok === 0) { + if (options.timeoutContext?.csotEnabled() && document.isMaxTimeExpiredError) { + throw new error_1.MongoOperationTimeoutError("Server reported a timeout error", { + cause: new error_1.MongoServerError(object ??= document.toObject(bsonOptions)) + }); + } + throw new error_1.MongoServerError(object ??= document.toObject(bsonOptions)); + } + if (this.shouldEmitAndLogCommand) { + this.emitAndLogCommand(this.monitorCommands, _Connection.COMMAND_SUCCEEDED, message.databaseName, this.established, new command_monitoring_events_1.CommandSucceededEvent(this, message, options.noResponse ? void 0 : message.moreToCome ? { ok: 1 } : object ??= document.toObject(bsonOptions), started, this.description.serverConnectionId)); + } + if (responseType == null) { + yield object ??= document.toObject(bsonOptions); + } else { + yield document; + } + this.throwIfAborted(); + } + } catch (error) { + if (this.shouldEmitAndLogCommand) { + this.emitAndLogCommand(this.monitorCommands, _Connection.COMMAND_FAILED, message.databaseName, this.established, new command_monitoring_events_1.CommandFailedEvent(this, message, error, started, this.description.serverConnectionId)); + } + throw error; + } + } + async command(ns, command, options = {}, responseType) { + this.throwIfAborted(); + options.signal?.throwIfAborted(); + for await (const document of this.sendCommand(ns, command, options, responseType)) { + if (options.timeoutContext?.csotEnabled()) { + if (responses_1.MongoDBResponse.is(document)) { + if (document.isMaxTimeExpiredError) { + throw new error_1.MongoOperationTimeoutError("Server reported a timeout error", { + cause: new error_1.MongoServerError(document.toObject()) + }); + } + } else { + if (Array.isArray(document?.writeErrors) && document.writeErrors.some((error) => error?.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired) || document?.writeConcernError?.code === error_1.MONGODB_ERROR_CODES.MaxTimeMSExpired) { + throw new error_1.MongoOperationTimeoutError("Server reported a timeout error", { + cause: new error_1.MongoServerError(document) + }); + } + } + } + return document; + } + throw new error_1.MongoUnexpectedServerResponseError("Unable to get response from server"); + } + exhaustCommand(ns, command, options, replyListener) { + const exhaustLoop = async () => { + this.throwIfAborted(); + for await (const reply2 of this.sendCommand(ns, command, options)) { + replyListener(void 0, reply2); + this.throwIfAborted(); + } + throw new error_1.MongoUnexpectedServerResponseError("Server ended moreToCome unexpectedly"); + }; + exhaustLoop().then(void 0, replyListener); + } + throwIfAborted() { + if (this.error) + throw this.error; + } + /** + * @internal + * + * Writes an OP_MSG or OP_QUERY request to the socket, optionally compressing the command. This method + * waits until the socket's buffer has emptied (the Nodejs socket `drain` event has fired). + */ + async writeCommand(command, options) { + const finalCommand = options.agreedCompressor === "none" || !commands_1.OpCompressedRequest.canCompress(command) ? command : new commands_1.OpCompressedRequest(command, { + agreedCompressor: options.agreedCompressor ?? "none", + zlibCompressionLevel: options.zlibCompressionLevel ?? 0 + }); + const buffer = Buffer.concat(await finalCommand.toBin()); + if (options.timeoutContext?.csotEnabled()) { + if (options.timeoutContext.minRoundTripTime != null && options.timeoutContext.remainingTimeMS < options.timeoutContext.minRoundTripTime) { + throw new error_1.MongoOperationTimeoutError("Server roundtrip time is greater than the time remaining"); + } + } + if (this.socket.write(buffer)) + return; + const drainEvent = (0, utils_1.once)(this.socket, "drain", options); + const timeout = options?.timeoutContext?.timeoutForSocketWrite; + const drained = timeout ? Promise.race([drainEvent, timeout]) : drainEvent; + try { + return await drained; + } catch (writeError) { + if (timeout_1.TimeoutError.is(writeError)) { + const timeoutError = new error_1.MongoOperationTimeoutError("Timed out at socket write"); + this.onError(timeoutError); + throw timeoutError; + } else if (writeError === options.signal?.reason) { + this.onError(writeError); + } + throw writeError; + } finally { + timeout?.clear(); + } + } + /** + * @internal + * + * Returns an async generator that yields full wire protocol messages from the underlying socket. This function + * yields messages until `moreToCome` is false or not present in a response, or the caller cancels the request + * by calling `return` on the generator. + * + * Note that `for-await` loops call `return` automatically when the loop is exited. + */ + async *readMany(options) { + try { + this.dataEvents = (0, on_data_1.onData)(this.messageStream, options); + this.messageStream.resume(); + for await (const message of this.dataEvents) { + const response = await (0, compression_1.decompressResponse)(message); + yield response; + if (!response.moreToCome) { + return; + } + } + } catch (readError) { + if (timeout_1.TimeoutError.is(readError)) { + const timeoutError = new error_1.MongoOperationTimeoutError(`Timed out during socket read (${readError.duration}ms)`); + this.dataEvents = null; + this.onError(timeoutError); + throw timeoutError; + } else if (readError === options.signal?.reason) { + this.onError(readError); + } + throw readError; + } finally { + this.dataEvents = null; + this.messageStream.pause(); + } + } + }; + exports2.Connection = Connection; + Connection.COMMAND_STARTED = constants_1.COMMAND_STARTED; + Connection.COMMAND_SUCCEEDED = constants_1.COMMAND_SUCCEEDED; + Connection.COMMAND_FAILED = constants_1.COMMAND_FAILED; + Connection.CLUSTER_TIME_RECEIVED = constants_1.CLUSTER_TIME_RECEIVED; + Connection.CLOSE = constants_1.CLOSE; + Connection.PINNED = constants_1.PINNED; + Connection.UNPINNED = constants_1.UNPINNED; + var SizedMessageTransform = class extends stream_1.Transform { + constructor({ connection }) { + super({ writableObjectMode: false, readableObjectMode: true }); + this.bufferPool = new utils_1.BufferPool(); + this.connection = connection; + } + _transform(chunk, encoding, callback) { + if (this.connection.delayedTimeoutId != null) { + (0, timers_1.clearTimeout)(this.connection.delayedTimeoutId); + this.connection.delayedTimeoutId = null; + } + this.bufferPool.append(chunk); + while (this.bufferPool.length) { + const sizeOfMessage = this.bufferPool.getInt32(); + if (sizeOfMessage == null) { + break; + } + if (sizeOfMessage < 0) { + return callback(new error_1.MongoParseError(`Message size cannot be negative: ${sizeOfMessage}`)); + } + if (sizeOfMessage > this.bufferPool.length) { + break; + } + const message = this.bufferPool.read(sizeOfMessage); + if (!this.push(message)) { + return callback(new error_1.MongoRuntimeError(`SizedMessageTransform does not support backpressure`)); + } + } + callback(); + } + }; + exports2.SizedMessageTransform = SizedMessageTransform; + var CryptoConnection = class extends Connection { + constructor(stream, options) { + super(stream, options); + this.autoEncrypter = options.autoEncrypter; + } + async command(ns, cmd, options, responseType) { + const { autoEncrypter } = this; + if (!autoEncrypter) { + throw new error_1.MongoMissingDependencyError("No AutoEncrypter available for encryption", { + dependencyName: "n/a" + }); + } + const serverWireVersion = (0, utils_1.maxWireVersion)(this); + if (serverWireVersion === 0) { + return await super.command(ns, cmd, options, responseType); + } + const sort = cmd.find || cmd.findAndModify ? cmd.sort : null; + const indexKeys = cmd.createIndexes ? cmd.indexes.map((index) => index.key) : null; + const encrypted = await autoEncrypter.encrypt(ns.toString(), cmd, options); + if (sort != null && (cmd.find || cmd.findAndModify)) { + encrypted.sort = sort; + } + if (indexKeys != null && cmd.createIndexes) { + for (const [offset, index] of indexKeys.entries()) { + encrypted.indexes[offset].key = index; + } + } + const encryptedResponse = await super.command( + ns, + encrypted, + options, + // Eventually we want to require `responseType` which means we would satisfy `T` as the return type. + // In the meantime, we want encryptedResponse to always be _at least_ a MongoDBResponse if not a more specific subclass + // So that we can ensure we have access to the on-demand APIs for decorate response + responseType ?? responses_1.MongoDBResponse + ); + const result = await autoEncrypter.decrypt(encryptedResponse.toBytes(), options); + const decryptedResponse = responseType?.make(result) ?? (0, bson_1.deserialize)(result, options); + if (autoEncrypter[constants_1.kDecorateResult]) { + if (responseType == null) { + (0, utils_1.decorateDecryptionResult)(decryptedResponse, encryptedResponse.toObject(), true); + } else if (decryptedResponse instanceof responses_1.CursorResponse) { + decryptedResponse.encryptedResponse = encryptedResponse; + } + } + return decryptedResponse; + } + }; + exports2.CryptoConnection = CryptoConnection; + } +}); + +// node_modules/mongodb/lib/cmap/connect.js +var require_connect = __commonJS({ + "node_modules/mongodb/lib/cmap/connect.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.LEGAL_TCP_SOCKET_OPTIONS = exports2.LEGAL_TLS_SOCKET_OPTIONS = void 0; + exports2.connect = connect; + exports2.makeConnection = makeConnection; + exports2.performInitialHandshake = performInitialHandshake; + exports2.prepareHandshakeDocument = prepareHandshakeDocument; + exports2.makeSocket = makeSocket; + var net = require("net"); + var tls = require("tls"); + var constants_1 = require_constants2(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + var providers_1 = require_providers(); + var connection_1 = require_connection5(); + var constants_2 = require_constants(); + async function connect(options) { + let connection = null; + try { + const socket = await makeSocket(options); + connection = makeConnection(options, socket); + await performInitialHandshake(connection, options); + return connection; + } catch (error) { + connection?.destroy(); + throw error; + } + } + function makeConnection(options, socket) { + let ConnectionType = options.connectionType ?? connection_1.Connection; + if (options.autoEncrypter) { + ConnectionType = connection_1.CryptoConnection; + } + return new ConnectionType(socket, options); + } + function checkSupportedServer(hello, options) { + const maxWireVersion = Number(hello.maxWireVersion); + const minWireVersion = Number(hello.minWireVersion); + const serverVersionHighEnough = !Number.isNaN(maxWireVersion) && maxWireVersion >= constants_2.MIN_SUPPORTED_WIRE_VERSION; + const serverVersionLowEnough = !Number.isNaN(minWireVersion) && minWireVersion <= constants_2.MAX_SUPPORTED_WIRE_VERSION; + if (serverVersionHighEnough) { + if (serverVersionLowEnough) { + return null; + } + const message2 = `Server at ${options.hostAddress} reports minimum wire version ${JSON.stringify(hello.minWireVersion)}, but this version of the Node.js Driver requires at most ${constants_2.MAX_SUPPORTED_WIRE_VERSION} (MongoDB ${constants_2.MAX_SUPPORTED_SERVER_VERSION})`; + return new error_1.MongoCompatibilityError(message2); + } + const message = `Server at ${options.hostAddress} reports maximum wire version ${JSON.stringify(hello.maxWireVersion) ?? 0}, but this version of the Node.js Driver requires at least ${constants_2.MIN_SUPPORTED_WIRE_VERSION} (MongoDB ${constants_2.MIN_SUPPORTED_SERVER_VERSION})`; + return new error_1.MongoCompatibilityError(message); + } + async function performInitialHandshake(conn, options) { + const credentials = options.credentials; + if (credentials) { + if (!(credentials.mechanism === providers_1.AuthMechanism.MONGODB_DEFAULT) && !options.authProviders.getOrCreateProvider(credentials.mechanism, credentials.mechanismProperties)) { + throw new error_1.MongoInvalidArgumentError(`AuthMechanism '${credentials.mechanism}' not supported`); + } + } + const authContext = new auth_provider_1.AuthContext(conn, credentials, options); + conn.authContext = authContext; + const handshakeDoc = await prepareHandshakeDocument(authContext); + const handshakeOptions = { ...options, raw: false }; + if (typeof options.connectTimeoutMS === "number") { + handshakeOptions.socketTimeoutMS = options.connectTimeoutMS; + } + const start = (/* @__PURE__ */ new Date()).getTime(); + const response = await executeHandshake(handshakeDoc, handshakeOptions); + if (!("isWritablePrimary" in response)) { + response.isWritablePrimary = response[constants_1.LEGACY_HELLO_COMMAND]; + } + if (response.helloOk) { + conn.helloOk = true; + } + const supportedServerErr = checkSupportedServer(response, options); + if (supportedServerErr) { + throw supportedServerErr; + } + if (options.loadBalanced) { + if (!response.serviceId) { + throw new error_1.MongoCompatibilityError("Driver attempted to initialize in load balancing mode, but the server does not support this mode."); + } + } + conn.hello = response; + conn.lastHelloMS = (/* @__PURE__ */ new Date()).getTime() - start; + if (!response.arbiterOnly && credentials) { + authContext.response = response; + const resolvedCredentials = credentials.resolveAuthMechanism(response); + const provider = options.authProviders.getOrCreateProvider(resolvedCredentials.mechanism, resolvedCredentials.mechanismProperties); + if (!provider) { + throw new error_1.MongoInvalidArgumentError(`No AuthProvider for ${resolvedCredentials.mechanism} defined.`); + } + try { + await provider.auth(authContext); + } catch (error) { + if (error instanceof error_1.MongoError) { + error.addErrorLabel(error_1.MongoErrorLabel.HandshakeError); + if ((0, error_1.needsRetryableWriteLabel)(error, response.maxWireVersion, conn.description.type)) { + error.addErrorLabel(error_1.MongoErrorLabel.RetryableWriteError); + } + } + throw error; + } + } + conn.established = true; + async function executeHandshake(handshakeDoc2, handshakeOptions2) { + try { + const handshakeResponse = await conn.command((0, utils_1.ns)("admin.$cmd"), handshakeDoc2, handshakeOptions2); + return handshakeResponse; + } catch (error) { + if (error instanceof error_1.MongoError) { + error.addErrorLabel(error_1.MongoErrorLabel.HandshakeError); + } + throw error; + } + } + } + async function prepareHandshakeDocument(authContext) { + const options = authContext.options; + const compressors = options.compressors ? options.compressors : []; + const { serverApi } = authContext.connection; + const clientMetadata = await options.extendedMetadata; + const handshakeDoc = { + [serverApi?.version || options.loadBalanced === true ? "hello" : constants_1.LEGACY_HELLO_COMMAND]: 1, + helloOk: true, + client: clientMetadata, + compression: compressors + }; + if (options.loadBalanced === true) { + handshakeDoc.loadBalanced = true; + } + const credentials = authContext.credentials; + if (credentials) { + if (credentials.mechanism === providers_1.AuthMechanism.MONGODB_DEFAULT && credentials.username) { + handshakeDoc.saslSupportedMechs = `${credentials.source}.${credentials.username}`; + const provider2 = authContext.options.authProviders.getOrCreateProvider(providers_1.AuthMechanism.MONGODB_SCRAM_SHA256, credentials.mechanismProperties); + if (!provider2) { + throw new error_1.MongoInvalidArgumentError(`No AuthProvider for ${providers_1.AuthMechanism.MONGODB_SCRAM_SHA256} defined.`); + } + return await provider2.prepare(handshakeDoc, authContext); + } + const provider = authContext.options.authProviders.getOrCreateProvider(credentials.mechanism, credentials.mechanismProperties); + if (!provider) { + throw new error_1.MongoInvalidArgumentError(`No AuthProvider for ${credentials.mechanism} defined.`); + } + return await provider.prepare(handshakeDoc, authContext); + } + return handshakeDoc; + } + exports2.LEGAL_TLS_SOCKET_OPTIONS = [ + "allowPartialTrustChain", + "ALPNProtocols", + "ca", + "cert", + "checkServerIdentity", + "ciphers", + "crl", + "ecdhCurve", + "key", + "minDHSize", + "passphrase", + "pfx", + "rejectUnauthorized", + "secureContext", + "secureProtocol", + "servername", + "session" + ]; + exports2.LEGAL_TCP_SOCKET_OPTIONS = [ + "autoSelectFamily", + "autoSelectFamilyAttemptTimeout", + "keepAliveInitialDelay", + "family", + "hints", + "localAddress", + "localPort", + "lookup" + ]; + function parseConnectOptions(options) { + const hostAddress = options.hostAddress; + if (!hostAddress) + throw new error_1.MongoInvalidArgumentError('Option "hostAddress" is required'); + const result = {}; + for (const name of exports2.LEGAL_TCP_SOCKET_OPTIONS) { + if (options[name] != null) { + result[name] = options[name]; + } + } + result.keepAliveInitialDelay ??= 12e4; + result.keepAlive = true; + result.noDelay = options.noDelay ?? true; + if (typeof hostAddress.socketPath === "string") { + result.path = hostAddress.socketPath; + return result; + } else if (typeof hostAddress.host === "string") { + result.host = hostAddress.host; + result.port = hostAddress.port; + return result; + } else { + throw new error_1.MongoRuntimeError(`Unexpected HostAddress ${JSON.stringify(hostAddress)}`); + } + } + function parseSslOptions(options) { + const result = parseConnectOptions(options); + for (const name of exports2.LEGAL_TLS_SOCKET_OPTIONS) { + if (options[name] != null) { + result[name] = options[name]; + } + } + if (options.existingSocket) { + result.socket = options.existingSocket; + } + if (result.servername == null && result.host && !net.isIP(result.host)) { + result.servername = result.host; + } + return result; + } + async function makeSocket(options) { + const useTLS = options.tls ?? false; + const connectTimeoutMS = options.connectTimeoutMS ?? 3e4; + const existingSocket = options.existingSocket; + let socket; + if (options.proxyHost != null) { + return await makeSocks5Connection({ + ...options, + connectTimeoutMS + // Should always be present for Socks5 + }); + } + if (useTLS) { + const tlsSocket = tls.connect(parseSslOptions(options)); + if (typeof tlsSocket.disableRenegotiation === "function") { + tlsSocket.disableRenegotiation(); + } + socket = tlsSocket; + } else if (existingSocket) { + socket = existingSocket; + } else { + socket = net.createConnection(parseConnectOptions(options)); + } + socket.setTimeout(connectTimeoutMS); + let cancellationHandler = null; + const { promise: connectedSocket, resolve, reject } = (0, utils_1.promiseWithResolvers)(); + if (existingSocket) { + resolve(socket); + } else { + const start = performance.now(); + const connectEvent = useTLS ? "secureConnect" : "connect"; + socket.once(connectEvent, () => resolve(socket)).once("error", (cause) => reject(new error_1.MongoNetworkError(error_1.MongoError.buildErrorMessage(cause), { cause }))).once("timeout", () => { + reject(new error_1.MongoNetworkTimeoutError(`Socket '${connectEvent}' timed out after ${performance.now() - start | 0}ms (connectTimeoutMS: ${connectTimeoutMS})`)); + }).once("close", () => reject(new error_1.MongoNetworkError(`Socket closed after ${performance.now() - start | 0} during connection establishment`))); + if (options.cancellationToken != null) { + cancellationHandler = () => reject(new error_1.MongoNetworkError(`Socket connection establishment was cancelled after ${performance.now() - start | 0}`)); + options.cancellationToken.once("cancel", cancellationHandler); + } + } + try { + socket = await connectedSocket; + return socket; + } catch (error) { + socket.destroy(); + throw error; + } finally { + socket.setTimeout(0); + if (cancellationHandler != null) { + options.cancellationToken?.removeListener("cancel", cancellationHandler); + } + } + } + var socks = null; + function loadSocks() { + if (socks == null) { + const socksImport = (0, deps_1.getSocks)(); + if ("kModuleError" in socksImport) { + throw socksImport.kModuleError; + } + socks = socksImport; + } + return socks; + } + async function makeSocks5Connection(options) { + const hostAddress = utils_1.HostAddress.fromHostPort( + options.proxyHost ?? "", + // proxyHost is guaranteed to set here + options.proxyPort ?? 1080 + ); + const rawSocket = await makeSocket({ + ...options, + hostAddress, + tls: false, + proxyHost: void 0 + }); + const destination = parseConnectOptions(options); + if (typeof destination.host !== "string" || typeof destination.port !== "number") { + throw new error_1.MongoInvalidArgumentError("Can only make Socks5 connections to TCP hosts"); + } + socks ??= loadSocks(); + let existingSocket; + try { + const connection = await socks.SocksClient.createConnection({ + existing_socket: rawSocket, + timeout: options.connectTimeoutMS, + command: "connect", + destination: { + host: destination.host, + port: destination.port + }, + proxy: { + // host and port are ignored because we pass existing_socket + host: "iLoveJavaScript", + port: 0, + type: 5, + userId: options.proxyUsername || void 0, + password: options.proxyPassword || void 0 + } + }); + existingSocket = connection.socket; + } catch (cause) { + throw new error_1.MongoNetworkError(error_1.MongoError.buildErrorMessage(cause), { cause }); + } + return await makeSocket({ ...options, existingSocket, proxyHost: void 0 }); + } + } +}); + +// node_modules/mongodb/lib/sdam/events.js +var require_events = __commonJS({ + "node_modules/mongodb/lib/sdam/events.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ServerHeartbeatFailedEvent = exports2.ServerHeartbeatSucceededEvent = exports2.ServerHeartbeatStartedEvent = exports2.TopologyClosedEvent = exports2.TopologyOpeningEvent = exports2.TopologyDescriptionChangedEvent = exports2.ServerClosedEvent = exports2.ServerOpeningEvent = exports2.ServerDescriptionChangedEvent = void 0; + var constants_1 = require_constants2(); + var ServerDescriptionChangedEvent = class { + /** @internal */ + constructor(topologyId, address, previousDescription, newDescription) { + this.name = constants_1.SERVER_DESCRIPTION_CHANGED; + this.topologyId = topologyId; + this.address = address; + this.previousDescription = previousDescription; + this.newDescription = newDescription; + } + }; + exports2.ServerDescriptionChangedEvent = ServerDescriptionChangedEvent; + var ServerOpeningEvent = class { + /** @internal */ + constructor(topologyId, address) { + this.name = constants_1.SERVER_OPENING; + this.topologyId = topologyId; + this.address = address; + } + }; + exports2.ServerOpeningEvent = ServerOpeningEvent; + var ServerClosedEvent = class { + /** @internal */ + constructor(topologyId, address) { + this.name = constants_1.SERVER_CLOSED; + this.topologyId = topologyId; + this.address = address; + } + }; + exports2.ServerClosedEvent = ServerClosedEvent; + var TopologyDescriptionChangedEvent = class { + /** @internal */ + constructor(topologyId, previousDescription, newDescription) { + this.name = constants_1.TOPOLOGY_DESCRIPTION_CHANGED; + this.topologyId = topologyId; + this.previousDescription = previousDescription; + this.newDescription = newDescription; + } + }; + exports2.TopologyDescriptionChangedEvent = TopologyDescriptionChangedEvent; + var TopologyOpeningEvent = class { + /** @internal */ + constructor(topologyId) { + this.name = constants_1.TOPOLOGY_OPENING; + this.topologyId = topologyId; + } + }; + exports2.TopologyOpeningEvent = TopologyOpeningEvent; + var TopologyClosedEvent = class { + /** @internal */ + constructor(topologyId) { + this.name = constants_1.TOPOLOGY_CLOSED; + this.topologyId = topologyId; + } + }; + exports2.TopologyClosedEvent = TopologyClosedEvent; + var ServerHeartbeatStartedEvent = class { + /** @internal */ + constructor(connectionId, awaited) { + this.name = constants_1.SERVER_HEARTBEAT_STARTED; + this.connectionId = connectionId; + this.awaited = awaited; + } + }; + exports2.ServerHeartbeatStartedEvent = ServerHeartbeatStartedEvent; + var ServerHeartbeatSucceededEvent = class { + /** @internal */ + constructor(connectionId, duration, reply2, awaited) { + this.name = constants_1.SERVER_HEARTBEAT_SUCCEEDED; + this.connectionId = connectionId; + this.duration = duration; + this.reply = reply2 ?? {}; + this.awaited = awaited; + } + }; + exports2.ServerHeartbeatSucceededEvent = ServerHeartbeatSucceededEvent; + var ServerHeartbeatFailedEvent = class { + /** @internal */ + constructor(connectionId, duration, failure, awaited) { + this.name = constants_1.SERVER_HEARTBEAT_FAILED; + this.connectionId = connectionId; + this.duration = duration; + this.failure = failure; + this.awaited = awaited; + } + }; + exports2.ServerHeartbeatFailedEvent = ServerHeartbeatFailedEvent; + } +}); + +// node_modules/mongodb/lib/cmap/connection_pool_events.js +var require_connection_pool_events = __commonJS({ + "node_modules/mongodb/lib/cmap/connection_pool_events.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ConnectionPoolClearedEvent = exports2.ConnectionCheckedInEvent = exports2.ConnectionCheckedOutEvent = exports2.ConnectionCheckOutFailedEvent = exports2.ConnectionCheckOutStartedEvent = exports2.ConnectionClosedEvent = exports2.ConnectionReadyEvent = exports2.ConnectionCreatedEvent = exports2.ConnectionPoolClosedEvent = exports2.ConnectionPoolReadyEvent = exports2.ConnectionPoolCreatedEvent = exports2.ConnectionPoolMonitoringEvent = void 0; + var constants_1 = require_constants2(); + var utils_1 = require_utils3(); + var ConnectionPoolMonitoringEvent = class { + /** @internal */ + constructor(pool) { + this.time = /* @__PURE__ */ new Date(); + this.address = pool.address; + } + }; + exports2.ConnectionPoolMonitoringEvent = ConnectionPoolMonitoringEvent; + var ConnectionPoolCreatedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool) { + super(pool); + this.name = constants_1.CONNECTION_POOL_CREATED; + const { maxConnecting, maxPoolSize, minPoolSize, maxIdleTimeMS, waitQueueTimeoutMS } = pool.options; + this.options = { maxConnecting, maxPoolSize, minPoolSize, maxIdleTimeMS, waitQueueTimeoutMS }; + } + }; + exports2.ConnectionPoolCreatedEvent = ConnectionPoolCreatedEvent; + var ConnectionPoolReadyEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool) { + super(pool); + this.name = constants_1.CONNECTION_POOL_READY; + } + }; + exports2.ConnectionPoolReadyEvent = ConnectionPoolReadyEvent; + var ConnectionPoolClosedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool) { + super(pool); + this.name = constants_1.CONNECTION_POOL_CLOSED; + } + }; + exports2.ConnectionPoolClosedEvent = ConnectionPoolClosedEvent; + var ConnectionCreatedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, connection) { + super(pool); + this.name = constants_1.CONNECTION_CREATED; + this.connectionId = connection.id; + } + }; + exports2.ConnectionCreatedEvent = ConnectionCreatedEvent; + var ConnectionReadyEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, connection, connectionCreatedEventTime) { + super(pool); + this.name = constants_1.CONNECTION_READY; + this.durationMS = (0, utils_1.now)() - connectionCreatedEventTime; + this.connectionId = connection.id; + } + }; + exports2.ConnectionReadyEvent = ConnectionReadyEvent; + var ConnectionClosedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, connection, reason, error) { + super(pool); + this.name = constants_1.CONNECTION_CLOSED; + this.connectionId = connection.id; + this.reason = reason; + this.serviceId = connection.serviceId; + this.error = error ?? null; + } + }; + exports2.ConnectionClosedEvent = ConnectionClosedEvent; + var ConnectionCheckOutStartedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool) { + super(pool); + this.name = constants_1.CONNECTION_CHECK_OUT_STARTED; + } + }; + exports2.ConnectionCheckOutStartedEvent = ConnectionCheckOutStartedEvent; + var ConnectionCheckOutFailedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, reason, checkoutTime, error) { + super(pool); + this.name = constants_1.CONNECTION_CHECK_OUT_FAILED; + this.durationMS = (0, utils_1.now)() - checkoutTime; + this.reason = reason; + this.error = error; + } + }; + exports2.ConnectionCheckOutFailedEvent = ConnectionCheckOutFailedEvent; + var ConnectionCheckedOutEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, connection, checkoutTime) { + super(pool); + this.name = constants_1.CONNECTION_CHECKED_OUT; + this.durationMS = (0, utils_1.now)() - checkoutTime; + this.connectionId = connection.id; + } + }; + exports2.ConnectionCheckedOutEvent = ConnectionCheckedOutEvent; + var ConnectionCheckedInEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, connection) { + super(pool); + this.name = constants_1.CONNECTION_CHECKED_IN; + this.connectionId = connection.id; + } + }; + exports2.ConnectionCheckedInEvent = ConnectionCheckedInEvent; + var ConnectionPoolClearedEvent = class extends ConnectionPoolMonitoringEvent { + /** @internal */ + constructor(pool, options = {}) { + super(pool); + this.name = constants_1.CONNECTION_POOL_CLEARED; + this.serviceId = options.serviceId; + this.interruptInUseConnections = options.interruptInUseConnections; + } + }; + exports2.ConnectionPoolClearedEvent = ConnectionPoolClearedEvent; + } +}); + +// node_modules/mongodb/lib/cmap/errors.js +var require_errors3 = __commonJS({ + "node_modules/mongodb/lib/cmap/errors.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.WaitQueueTimeoutError = exports2.PoolClearedOnNetworkError = exports2.PoolClearedError = exports2.PoolClosedError = void 0; + var error_1 = require_error(); + var PoolClosedError = class extends error_1.MongoDriverError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(pool) { + super("Attempted to check out a connection from closed connection pool"); + this.address = pool.address; + } + get name() { + return "MongoPoolClosedError"; + } + }; + exports2.PoolClosedError = PoolClosedError; + var PoolClearedError = class extends error_1.MongoNetworkError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(pool, message) { + const errorMessage = message ? message : `Connection pool for ${pool.address} was cleared because another operation failed with: "${pool.serverError?.message}"`; + super(errorMessage, pool.serverError ? { cause: pool.serverError } : void 0); + this.address = pool.address; + this.addErrorLabel(error_1.MongoErrorLabel.PoolRequstedRetry); + } + get name() { + return "MongoPoolClearedError"; + } + }; + exports2.PoolClearedError = PoolClearedError; + var PoolClearedOnNetworkError = class extends PoolClearedError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(pool) { + super(pool, `Connection to ${pool.address} interrupted due to server monitor timeout`); + } + get name() { + return "PoolClearedOnNetworkError"; + } + }; + exports2.PoolClearedOnNetworkError = PoolClearedOnNetworkError; + var WaitQueueTimeoutError = class extends error_1.MongoDriverError { + /** + * **Do not use this constructor!** + * + * Meant for internal use only. + * + * @remarks + * This class is only meant to be constructed within the driver. This constructor is + * not subject to semantic versioning compatibility guarantees and may change at any time. + * + * @public + **/ + constructor(message, address) { + super(message); + this.address = address; + } + get name() { + return "MongoWaitQueueTimeoutError"; + } + }; + exports2.WaitQueueTimeoutError = WaitQueueTimeoutError; + } +}); + +// node_modules/mongodb/lib/cmap/connection_pool.js +var require_connection_pool = __commonJS({ + "node_modules/mongodb/lib/cmap/connection_pool.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ConnectionPool = exports2.PoolState = void 0; + var timers_1 = require("timers"); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var connect_1 = require_connect(); + var connection_1 = require_connection5(); + var connection_pool_events_1 = require_connection_pool_events(); + var errors_1 = require_errors3(); + var metrics_1 = require_metrics(); + exports2.PoolState = Object.freeze({ + paused: "paused", + ready: "ready", + closed: "closed" + }); + var ConnectionPool = class _ConnectionPool extends mongo_types_1.TypedEventEmitter { + constructor(server, options) { + super(); + this.on("error", utils_1.noop); + this.options = Object.freeze({ + connectionType: connection_1.Connection, + ...options, + maxPoolSize: options.maxPoolSize ?? 100, + minPoolSize: options.minPoolSize ?? 0, + maxConnecting: options.maxConnecting ?? 2, + maxIdleTimeMS: options.maxIdleTimeMS ?? 0, + waitQueueTimeoutMS: options.waitQueueTimeoutMS ?? 0, + minPoolSizeCheckFrequencyMS: options.minPoolSizeCheckFrequencyMS ?? 100, + autoEncrypter: options.autoEncrypter + }); + if (this.options.minPoolSize > this.options.maxPoolSize) { + throw new error_1.MongoInvalidArgumentError("Connection pool minimum size must not be greater than maximum pool size"); + } + this.poolState = exports2.PoolState.paused; + this.server = server; + this.connections = new utils_1.List(); + this.pending = 0; + this.checkedOut = /* @__PURE__ */ new Set(); + this.minPoolSizeTimer = void 0; + this.generation = 0; + this.serviceGenerations = /* @__PURE__ */ new Map(); + this.connectionCounter = (0, utils_1.makeCounter)(1); + this.cancellationToken = new mongo_types_1.CancellationToken(); + this.cancellationToken.setMaxListeners(Infinity); + this.waitQueue = new utils_1.List(); + this.metrics = new metrics_1.ConnectionPoolMetrics(); + this.processingWaitQueue = false; + this.mongoLogger = this.server.topology.client?.mongoLogger; + this.component = "connection"; + process.nextTick(() => { + this.emitAndLog(_ConnectionPool.CONNECTION_POOL_CREATED, new connection_pool_events_1.ConnectionPoolCreatedEvent(this)); + }); + } + /** The address of the endpoint the pool is connected to */ + get address() { + return this.options.hostAddress.toString(); + } + /** + * Check if the pool has been closed + * + * TODO(NODE-3263): We can remove this property once shell no longer needs it + */ + get closed() { + return this.poolState === exports2.PoolState.closed; + } + /** An integer expressing how many total connections (available + pending + in use) the pool currently has */ + get totalConnectionCount() { + return this.availableConnectionCount + this.pendingConnectionCount + this.currentCheckedOutCount; + } + /** An integer expressing how many connections are currently available in the pool. */ + get availableConnectionCount() { + return this.connections.length; + } + get pendingConnectionCount() { + return this.pending; + } + get currentCheckedOutCount() { + return this.checkedOut.size; + } + get waitQueueSize() { + return this.waitQueue.length; + } + get loadBalanced() { + return this.options.loadBalanced; + } + get serverError() { + return this.server.description.error; + } + /** + * This is exposed ONLY for use in mongosh, to enable + * killing all connections if a user quits the shell with + * operations in progress. + * + * This property may be removed as a part of NODE-3263. + */ + get checkedOutConnections() { + return this.checkedOut; + } + /** + * Get the metrics information for the pool when a wait queue timeout occurs. + */ + waitQueueErrorMetrics() { + return this.metrics.info(this.options.maxPoolSize); + } + /** + * Set the pool state to "ready" + */ + ready() { + if (this.poolState !== exports2.PoolState.paused) { + return; + } + this.poolState = exports2.PoolState.ready; + this.emitAndLog(_ConnectionPool.CONNECTION_POOL_READY, new connection_pool_events_1.ConnectionPoolReadyEvent(this)); + (0, timers_1.clearTimeout)(this.minPoolSizeTimer); + this.ensureMinPoolSize(); + } + /** + * Check a connection out of this pool. The connection will continue to be tracked, but no reference to it + * will be held by the pool. This means that if a connection is checked out it MUST be checked back in or + * explicitly destroyed by the new owner. + */ + async checkOut(options) { + const checkoutTime = (0, utils_1.now)(); + this.emitAndLog(_ConnectionPool.CONNECTION_CHECK_OUT_STARTED, new connection_pool_events_1.ConnectionCheckOutStartedEvent(this)); + const { promise, resolve, reject } = (0, utils_1.promiseWithResolvers)(); + const timeout = options.timeoutContext.connectionCheckoutTimeout; + const waitQueueMember = { + resolve, + reject, + cancelled: false, + checkoutTime + }; + const abortListener = (0, utils_1.addAbortListener)(options.signal, function() { + waitQueueMember.cancelled = true; + reject(this.reason); + }); + this.waitQueue.push(waitQueueMember); + process.nextTick(() => this.processWaitQueue()); + try { + timeout?.throwIfExpired(); + return await (timeout ? Promise.race([promise, timeout]) : promise); + } catch (error) { + if (timeout_1.TimeoutError.is(error)) { + timeout?.clear(); + waitQueueMember.cancelled = true; + this.emitAndLog(_ConnectionPool.CONNECTION_CHECK_OUT_FAILED, new connection_pool_events_1.ConnectionCheckOutFailedEvent(this, "timeout", waitQueueMember.checkoutTime)); + const timeoutError = new errors_1.WaitQueueTimeoutError(this.loadBalanced ? this.waitQueueErrorMetrics() : "Timed out while checking out a connection from connection pool", this.address); + if (options.timeoutContext.csotEnabled()) { + throw new error_1.MongoOperationTimeoutError("Timed out during connection checkout", { + cause: timeoutError + }); + } + throw timeoutError; + } + throw error; + } finally { + abortListener?.[utils_1.kDispose](); + timeout?.clear(); + } + } + /** + * Check a connection into the pool. + * + * @param connection - The connection to check in + */ + checkIn(connection) { + if (!this.checkedOut.has(connection)) { + return; + } + const poolClosed = this.closed; + const stale = this.connectionIsStale(connection); + const willDestroy = !!(poolClosed || stale || connection.closed); + if (!willDestroy) { + connection.markAvailable(); + this.connections.unshift(connection); + } + this.checkedOut.delete(connection); + this.emitAndLog(_ConnectionPool.CONNECTION_CHECKED_IN, new connection_pool_events_1.ConnectionCheckedInEvent(this, connection)); + if (willDestroy) { + const reason = connection.closed ? "error" : poolClosed ? "poolClosed" : "stale"; + this.destroyConnection(connection, reason); + } + process.nextTick(() => this.processWaitQueue()); + } + /** + * Clear the pool + * + * Pool reset is handled by incrementing the pool's generation count. Any existing connection of a + * previous generation will eventually be pruned during subsequent checkouts. + */ + clear(options = {}) { + if (this.closed) { + return; + } + if (this.loadBalanced) { + const { serviceId } = options; + if (!serviceId) { + throw new error_1.MongoRuntimeError("ConnectionPool.clear() called in load balanced mode with no serviceId."); + } + const sid = serviceId.toHexString(); + const generation = this.serviceGenerations.get(sid); + if (generation == null) { + throw new error_1.MongoRuntimeError("Service generations are required in load balancer mode."); + } else { + this.serviceGenerations.set(sid, generation + 1); + } + this.emitAndLog(_ConnectionPool.CONNECTION_POOL_CLEARED, new connection_pool_events_1.ConnectionPoolClearedEvent(this, { serviceId })); + return; + } + const interruptInUseConnections = options.interruptInUseConnections ?? false; + const oldGeneration = this.generation; + this.generation += 1; + const alreadyPaused = this.poolState === exports2.PoolState.paused; + this.poolState = exports2.PoolState.paused; + this.clearMinPoolSizeTimer(); + if (!alreadyPaused) { + this.emitAndLog(_ConnectionPool.CONNECTION_POOL_CLEARED, new connection_pool_events_1.ConnectionPoolClearedEvent(this, { + interruptInUseConnections + })); + } + if (interruptInUseConnections) { + process.nextTick(() => this.interruptInUseConnections(oldGeneration)); + } + this.processWaitQueue(); + } + /** + * Closes all stale in-use connections in the pool with a resumable PoolClearedOnNetworkError. + * + * Only connections where `connection.generation <= minGeneration` are killed. + */ + interruptInUseConnections(minGeneration) { + for (const connection of this.checkedOut) { + if (connection.generation <= minGeneration) { + connection.onError(new errors_1.PoolClearedOnNetworkError(this)); + } + } + } + /** For MongoClient.close() procedures */ + closeCheckedOutConnections() { + for (const conn of this.checkedOut) { + conn.onError(new error_1.MongoClientClosedError()); + } + } + /** Close the pool */ + close() { + if (this.closed) { + return; + } + this.cancellationToken.emit("cancel"); + if (typeof this.connectionCounter.return === "function") { + this.connectionCounter.return(void 0); + } + this.poolState = exports2.PoolState.closed; + this.clearMinPoolSizeTimer(); + this.processWaitQueue(); + for (const conn of this.connections) { + this.emitAndLog(_ConnectionPool.CONNECTION_CLOSED, new connection_pool_events_1.ConnectionClosedEvent(this, conn, "poolClosed")); + conn.destroy(); + } + this.connections.clear(); + this.emitAndLog(_ConnectionPool.CONNECTION_POOL_CLOSED, new connection_pool_events_1.ConnectionPoolClosedEvent(this)); + } + /** + * @internal + * Reauthenticate a connection + */ + async reauthenticate(connection) { + const authContext = connection.authContext; + if (!authContext) { + throw new error_1.MongoRuntimeError("No auth context found on connection."); + } + const credentials = authContext.credentials; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("Connection is missing credentials when asked to reauthenticate"); + } + const resolvedCredentials = credentials.resolveAuthMechanism(connection.hello); + const provider = this.server.topology.client.s.authProviders.getOrCreateProvider(resolvedCredentials.mechanism, resolvedCredentials.mechanismProperties); + if (!provider) { + throw new error_1.MongoMissingCredentialsError(`Reauthenticate failed due to no auth provider for ${credentials.mechanism}`); + } + await provider.reauth(authContext); + return; + } + /** Clear the min pool size timer */ + clearMinPoolSizeTimer() { + const minPoolSizeTimer = this.minPoolSizeTimer; + if (minPoolSizeTimer) { + (0, timers_1.clearTimeout)(minPoolSizeTimer); + } + } + destroyConnection(connection, reason) { + this.emitAndLog(_ConnectionPool.CONNECTION_CLOSED, new connection_pool_events_1.ConnectionClosedEvent(this, connection, reason)); + connection.destroy(); + } + connectionIsStale(connection) { + const serviceId = connection.serviceId; + if (this.loadBalanced && serviceId) { + const sid = serviceId.toHexString(); + const generation = this.serviceGenerations.get(sid); + return connection.generation !== generation; + } + return connection.generation !== this.generation; + } + connectionIsIdle(connection) { + return !!(this.options.maxIdleTimeMS && connection.idleTime > this.options.maxIdleTimeMS); + } + /** + * Destroys a connection if the connection is perished. + * + * @returns `true` if the connection was destroyed, `false` otherwise. + */ + destroyConnectionIfPerished(connection) { + const isStale = this.connectionIsStale(connection); + const isIdle = this.connectionIsIdle(connection); + if (!isStale && !isIdle && !connection.closed) { + return false; + } + const reason = connection.closed ? "error" : isStale ? "stale" : "idle"; + this.destroyConnection(connection, reason); + return true; + } + createConnection(callback) { + const connectOptions = { + ...this.options, + id: this.connectionCounter.next().value, + generation: this.generation, + cancellationToken: this.cancellationToken, + mongoLogger: this.mongoLogger, + authProviders: this.server.topology.client.s.authProviders, + extendedMetadata: this.server.topology.client.options.extendedMetadata + }; + this.pending++; + const connectionCreatedTime = (0, utils_1.now)(); + this.emitAndLog(_ConnectionPool.CONNECTION_CREATED, new connection_pool_events_1.ConnectionCreatedEvent(this, { id: connectOptions.id })); + (0, connect_1.connect)(connectOptions).then((connection) => { + if (this.poolState !== exports2.PoolState.ready) { + this.pending--; + connection.destroy(); + callback(this.closed ? new errors_1.PoolClosedError(this) : new errors_1.PoolClearedError(this)); + return; + } + for (const event of [...constants_1.APM_EVENTS, connection_1.Connection.CLUSTER_TIME_RECEIVED]) { + connection.on(event, (e) => this.emit(event, e)); + } + if (this.loadBalanced) { + connection.on(connection_1.Connection.PINNED, (pinType) => this.metrics.markPinned(pinType)); + connection.on(connection_1.Connection.UNPINNED, (pinType) => this.metrics.markUnpinned(pinType)); + const serviceId = connection.serviceId; + if (serviceId) { + let generation; + const sid = serviceId.toHexString(); + if (generation = this.serviceGenerations.get(sid)) { + connection.generation = generation; + } else { + this.serviceGenerations.set(sid, 0); + connection.generation = 0; + } + } + } + connection.markAvailable(); + this.emitAndLog(_ConnectionPool.CONNECTION_READY, new connection_pool_events_1.ConnectionReadyEvent(this, connection, connectionCreatedTime)); + this.pending--; + callback(void 0, connection); + }, (error) => { + this.pending--; + this.server.handleError(error); + this.emitAndLog(_ConnectionPool.CONNECTION_CLOSED, new connection_pool_events_1.ConnectionClosedEvent( + this, + { id: connectOptions.id, serviceId: void 0 }, + "error", + // TODO(NODE-5192): Remove this cast + error + )); + if (error instanceof error_1.MongoNetworkError || error instanceof error_1.MongoServerError) { + error.connectionGeneration = connectOptions.generation; + } + callback(error ?? new error_1.MongoRuntimeError("Connection creation failed without error")); + }); + } + ensureMinPoolSize() { + const minPoolSize = this.options.minPoolSize; + if (this.poolState !== exports2.PoolState.ready) { + return; + } + this.connections.prune((connection) => this.destroyConnectionIfPerished(connection)); + if (this.totalConnectionCount < minPoolSize && this.pendingConnectionCount < this.options.maxConnecting) { + this.createConnection((err, connection) => { + if (!err && connection) { + this.connections.push(connection); + process.nextTick(() => this.processWaitQueue()); + } + if (this.poolState === exports2.PoolState.ready) { + (0, timers_1.clearTimeout)(this.minPoolSizeTimer); + this.minPoolSizeTimer = (0, timers_1.setTimeout)(() => this.ensureMinPoolSize(), this.options.minPoolSizeCheckFrequencyMS); + } + }); + } else { + (0, timers_1.clearTimeout)(this.minPoolSizeTimer); + this.minPoolSizeTimer = (0, timers_1.setTimeout)(() => this.ensureMinPoolSize(), this.options.minPoolSizeCheckFrequencyMS); + } + } + processWaitQueue() { + if (this.processingWaitQueue) { + return; + } + this.processingWaitQueue = true; + while (this.waitQueueSize) { + const waitQueueMember = this.waitQueue.first(); + if (!waitQueueMember) { + this.waitQueue.shift(); + continue; + } + if (waitQueueMember.cancelled) { + this.waitQueue.shift(); + continue; + } + if (this.poolState !== exports2.PoolState.ready) { + const reason = this.closed ? "poolClosed" : "connectionError"; + const error = this.closed ? new errors_1.PoolClosedError(this) : new errors_1.PoolClearedError(this); + this.emitAndLog(_ConnectionPool.CONNECTION_CHECK_OUT_FAILED, new connection_pool_events_1.ConnectionCheckOutFailedEvent(this, reason, waitQueueMember.checkoutTime, error)); + this.waitQueue.shift(); + waitQueueMember.reject(error); + continue; + } + if (!this.availableConnectionCount) { + break; + } + const connection = this.connections.shift(); + if (!connection) { + break; + } + if (!this.destroyConnectionIfPerished(connection)) { + this.checkedOut.add(connection); + this.emitAndLog(_ConnectionPool.CONNECTION_CHECKED_OUT, new connection_pool_events_1.ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)); + this.waitQueue.shift(); + waitQueueMember.resolve(connection); + } + } + const { maxPoolSize, maxConnecting } = this.options; + while (this.waitQueueSize > 0 && this.pendingConnectionCount < maxConnecting && (maxPoolSize === 0 || this.totalConnectionCount < maxPoolSize)) { + const waitQueueMember = this.waitQueue.shift(); + if (!waitQueueMember || waitQueueMember.cancelled) { + continue; + } + this.createConnection((err, connection) => { + if (waitQueueMember.cancelled) { + if (!err && connection) { + this.connections.push(connection); + } + } else { + if (err) { + this.emitAndLog( + _ConnectionPool.CONNECTION_CHECK_OUT_FAILED, + // TODO(NODE-5192): Remove this cast + new connection_pool_events_1.ConnectionCheckOutFailedEvent(this, "connectionError", waitQueueMember.checkoutTime, err) + ); + waitQueueMember.reject(err); + } else if (connection) { + this.checkedOut.add(connection); + this.emitAndLog(_ConnectionPool.CONNECTION_CHECKED_OUT, new connection_pool_events_1.ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)); + waitQueueMember.resolve(connection); + } + } + process.nextTick(() => this.processWaitQueue()); + }); + } + this.processingWaitQueue = false; + } + }; + exports2.ConnectionPool = ConnectionPool; + ConnectionPool.CONNECTION_POOL_CREATED = constants_1.CONNECTION_POOL_CREATED; + ConnectionPool.CONNECTION_POOL_CLOSED = constants_1.CONNECTION_POOL_CLOSED; + ConnectionPool.CONNECTION_POOL_CLEARED = constants_1.CONNECTION_POOL_CLEARED; + ConnectionPool.CONNECTION_POOL_READY = constants_1.CONNECTION_POOL_READY; + ConnectionPool.CONNECTION_CREATED = constants_1.CONNECTION_CREATED; + ConnectionPool.CONNECTION_READY = constants_1.CONNECTION_READY; + ConnectionPool.CONNECTION_CLOSED = constants_1.CONNECTION_CLOSED; + ConnectionPool.CONNECTION_CHECK_OUT_STARTED = constants_1.CONNECTION_CHECK_OUT_STARTED; + ConnectionPool.CONNECTION_CHECK_OUT_FAILED = constants_1.CONNECTION_CHECK_OUT_FAILED; + ConnectionPool.CONNECTION_CHECKED_OUT = constants_1.CONNECTION_CHECKED_OUT; + ConnectionPool.CONNECTION_CHECKED_IN = constants_1.CONNECTION_CHECKED_IN; + } +}); + +// node_modules/mongodb/lib/sdam/server.js +var require_server = __commonJS({ + "node_modules/mongodb/lib/sdam/server.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Server = void 0; + var connection_1 = require_connection5(); + var connection_pool_1 = require_connection_pool(); + var errors_1 = require_errors3(); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var aggregate_1 = require_aggregate(); + var transactions_1 = require_transactions(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var common_1 = require_common(); + var monitor_1 = require_monitor(); + var server_description_1 = require_server_description(); + var server_selection_1 = require_server_selection(); + var stateTransition = (0, utils_1.makeStateMachine)({ + [common_1.STATE_CLOSED]: [common_1.STATE_CLOSED, common_1.STATE_CONNECTING], + [common_1.STATE_CONNECTING]: [common_1.STATE_CONNECTING, common_1.STATE_CLOSING, common_1.STATE_CONNECTED, common_1.STATE_CLOSED], + [common_1.STATE_CONNECTED]: [common_1.STATE_CONNECTED, common_1.STATE_CLOSING, common_1.STATE_CLOSED], + [common_1.STATE_CLOSING]: [common_1.STATE_CLOSING, common_1.STATE_CLOSED] + }); + var Server = class _Server extends mongo_types_1.TypedEventEmitter { + /** + * Create a server + */ + constructor(topology, description, options) { + super(); + this.on("error", utils_1.noop); + this.serverApi = options.serverApi; + const poolOptions = { hostAddress: description.hostAddress, ...options }; + this.topology = topology; + this.pool = new connection_pool_1.ConnectionPool(this, poolOptions); + this.s = { + description, + options, + state: common_1.STATE_CLOSED, + operationCount: 0 + }; + for (const event of [...constants_1.CMAP_EVENTS, ...constants_1.APM_EVENTS]) { + this.pool.on(event, (e) => this.emit(event, e)); + } + this.pool.on(connection_1.Connection.CLUSTER_TIME_RECEIVED, (clusterTime) => { + this.clusterTime = clusterTime; + }); + if (this.loadBalanced) { + this.monitor = null; + return; + } + this.monitor = new monitor_1.Monitor(this, this.s.options); + for (const event of constants_1.HEARTBEAT_EVENTS) { + this.monitor.on(event, (e) => this.emit(event, e)); + } + this.monitor.on("resetServer", (error) => markServerUnknown(this, error)); + this.monitor.on(_Server.SERVER_HEARTBEAT_SUCCEEDED, (event) => { + this.emit(_Server.DESCRIPTION_RECEIVED, new server_description_1.ServerDescription(this.description.hostAddress, event.reply, { + roundTripTime: this.monitor?.roundTripTime, + minRoundTripTime: this.monitor?.minRoundTripTime + })); + if (this.s.state === common_1.STATE_CONNECTING) { + stateTransition(this, common_1.STATE_CONNECTED); + this.emit(_Server.CONNECT, this); + } + }); + } + get clusterTime() { + return this.topology.clusterTime; + } + set clusterTime(clusterTime) { + this.topology.clusterTime = clusterTime; + } + get description() { + return this.s.description; + } + get name() { + return this.s.description.address; + } + get autoEncrypter() { + if (this.s.options && this.s.options.autoEncrypter) { + return this.s.options.autoEncrypter; + } + return; + } + get loadBalanced() { + return this.topology.description.type === common_1.TopologyType.LoadBalanced; + } + /** + * Initiate server connect + */ + connect() { + if (this.s.state !== common_1.STATE_CLOSED) { + return; + } + stateTransition(this, common_1.STATE_CONNECTING); + if (!this.loadBalanced) { + this.monitor?.connect(); + } else { + stateTransition(this, common_1.STATE_CONNECTED); + this.emit(_Server.CONNECT, this); + } + } + closeCheckedOutConnections() { + return this.pool.closeCheckedOutConnections(); + } + /** Destroy the server connection */ + close() { + if (this.s.state === common_1.STATE_CLOSED) { + return; + } + stateTransition(this, common_1.STATE_CLOSING); + if (!this.loadBalanced) { + this.monitor?.close(); + } + this.pool.close(); + stateTransition(this, common_1.STATE_CLOSED); + this.emit("closed"); + } + /** + * Immediately schedule monitoring of this server. If there already an attempt being made + * this will be a no-op. + */ + requestCheck() { + if (!this.loadBalanced) { + this.monitor?.requestCheck(); + } + } + async command(operation, timeoutContext) { + if (this.s.state === common_1.STATE_CLOSING || this.s.state === common_1.STATE_CLOSED) { + throw new error_1.MongoServerClosedError(); + } + const session = operation.session; + let conn = session?.pinnedConnection; + this.incrementOperationCount(); + if (conn == null) { + try { + conn = await this.pool.checkOut({ timeoutContext, signal: operation.options.signal }); + } catch (checkoutError) { + this.decrementOperationCount(); + if (!(checkoutError instanceof errors_1.PoolClearedError)) + this.handleError(checkoutError); + throw checkoutError; + } + } + let reauthPromise = null; + const cleanup = () => { + this.decrementOperationCount(); + if (session?.pinnedConnection !== conn) { + if (reauthPromise != null) { + const checkBackIn = () => { + this.pool.checkIn(conn); + }; + void reauthPromise.then(checkBackIn, checkBackIn); + } else { + this.pool.checkIn(conn); + } + } + }; + let cmd; + try { + cmd = operation.buildCommand(conn, session); + } catch (e) { + cleanup(); + throw e; + } + const options = operation.buildOptions(timeoutContext); + const ns = operation.ns; + if (this.loadBalanced && isPinnableCommand(cmd, session) && !session?.pinnedConnection) { + session?.pin(conn); + } + options.directConnection = this.topology.s.options.directConnection; + const omitReadPreference = operation instanceof aggregate_1.AggregateOperation && operation.hasWriteStage && (0, utils_1.maxWireVersion)(conn) < server_selection_1.MIN_SECONDARY_WRITE_WIRE_VERSION; + if (omitReadPreference) { + delete options.readPreference; + } + if (this.description.iscryptd) { + options.omitMaxTimeMS = true; + } + try { + try { + const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE); + (0, write_concern_1.throwIfWriteConcernError)(res); + return res; + } catch (commandError) { + throw this.decorateCommandError(conn, cmd, options, commandError); + } + } catch (operationError) { + if (operationError instanceof error_1.MongoError && operationError.code === error_1.MONGODB_ERROR_CODES.Reauthenticate) { + reauthPromise = this.pool.reauthenticate(conn); + reauthPromise.then(void 0, (error) => { + reauthPromise = null; + (0, utils_1.squashError)(error); + }); + await (0, utils_1.abortable)(reauthPromise, options); + reauthPromise = null; + try { + const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE); + (0, write_concern_1.throwIfWriteConcernError)(res); + return res; + } catch (commandError) { + throw this.decorateCommandError(conn, cmd, options, commandError); + } + } else { + throw operationError; + } + } finally { + cleanup(); + } + } + /** + * Handle SDAM error + * @internal + */ + handleError(error, connection) { + if (!(error instanceof error_1.MongoError)) { + return; + } + const isStaleError = error.connectionGeneration && error.connectionGeneration < this.pool.generation; + if (isStaleError) { + return; + } + const isNetworkNonTimeoutError = error instanceof error_1.MongoNetworkError && !(error instanceof error_1.MongoNetworkTimeoutError); + const isNetworkTimeoutBeforeHandshakeError = error instanceof error_1.MongoNetworkError && error.beforeHandshake; + const isAuthHandshakeError = error.hasErrorLabel(error_1.MongoErrorLabel.HandshakeError); + if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) { + if (!this.loadBalanced) { + error.addErrorLabel(error_1.MongoErrorLabel.ResetPool); + markServerUnknown(this, error); + } else if (connection) { + this.pool.clear({ serviceId: connection.serviceId }); + } + } else { + if ((0, error_1.isSDAMUnrecoverableError)(error)) { + if (shouldHandleStateChangeError(this, error)) { + const shouldClearPool = (0, error_1.isNodeShuttingDownError)(error); + if (this.loadBalanced && connection && shouldClearPool) { + this.pool.clear({ serviceId: connection.serviceId }); + } + if (!this.loadBalanced) { + if (shouldClearPool) { + error.addErrorLabel(error_1.MongoErrorLabel.ResetPool); + } + markServerUnknown(this, error); + process.nextTick(() => this.requestCheck()); + } + } + } + } + } + /** + * Ensure that error is properly decorated and internal state is updated before throwing + * @internal + */ + decorateCommandError(connection, cmd, options, error) { + if (typeof error !== "object" || error == null || !("name" in error)) { + throw new error_1.MongoRuntimeError("An unexpected error type: " + typeof error); + } + if (error.name === "AbortError" && "cause" in error && error.cause instanceof error_1.MongoError) { + error = error.cause; + } + if (!(error instanceof error_1.MongoError)) { + return error; + } + if (connectionIsStale(this.pool, connection)) { + return error; + } + const session = options?.session; + if (error instanceof error_1.MongoNetworkError) { + if (session && !session.hasEnded && session.serverSession) { + session.serverSession.isDirty = true; + } + if (inActiveTransaction(session, cmd) && !error.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) { + error.addErrorLabel(error_1.MongoErrorLabel.TransientTransactionError); + } + if ((isRetryableWritesEnabled(this.topology) || (0, transactions_1.isTransactionCommand)(cmd)) && (0, utils_1.supportsRetryableWrites)(this) && !inActiveTransaction(session, cmd)) { + error.addErrorLabel(error_1.MongoErrorLabel.RetryableWriteError); + } + } else { + if ((isRetryableWritesEnabled(this.topology) || (0, transactions_1.isTransactionCommand)(cmd)) && (0, error_1.needsRetryableWriteLabel)(error, (0, utils_1.maxWireVersion)(this), this.description.type) && !inActiveTransaction(session, cmd)) { + error.addErrorLabel(error_1.MongoErrorLabel.RetryableWriteError); + } + } + if (session && session.isPinned && error.hasErrorLabel(error_1.MongoErrorLabel.TransientTransactionError)) { + session.unpin({ force: true }); + } + this.handleError(error, connection); + return error; + } + /** + * Decrement the operation count, returning the new count. + */ + decrementOperationCount() { + return this.s.operationCount -= 1; + } + /** + * Increment the operation count, returning the new count. + */ + incrementOperationCount() { + return this.s.operationCount += 1; + } + }; + exports2.Server = Server; + Server.SERVER_HEARTBEAT_STARTED = constants_1.SERVER_HEARTBEAT_STARTED; + Server.SERVER_HEARTBEAT_SUCCEEDED = constants_1.SERVER_HEARTBEAT_SUCCEEDED; + Server.SERVER_HEARTBEAT_FAILED = constants_1.SERVER_HEARTBEAT_FAILED; + Server.CONNECT = constants_1.CONNECT; + Server.DESCRIPTION_RECEIVED = constants_1.DESCRIPTION_RECEIVED; + Server.CLOSED = constants_1.CLOSED; + Server.ENDED = constants_1.ENDED; + function markServerUnknown(server, error) { + if (server.loadBalanced) { + return; + } + if (error instanceof error_1.MongoNetworkError && !(error instanceof error_1.MongoNetworkTimeoutError)) { + server.monitor?.reset(); + } + server.emit(Server.DESCRIPTION_RECEIVED, new server_description_1.ServerDescription(server.description.hostAddress, void 0, { error })); + } + function isPinnableCommand(cmd, session) { + if (session) { + return session.inTransaction() || session.transaction.isCommitted && "commitTransaction" in cmd || "aggregate" in cmd || "find" in cmd || "getMore" in cmd || "listCollections" in cmd || "listIndexes" in cmd || "bulkWrite" in cmd; + } + return false; + } + function connectionIsStale(pool, connection) { + if (connection.serviceId) { + return connection.generation !== pool.serviceGenerations.get(connection.serviceId.toHexString()); + } + return connection.generation !== pool.generation; + } + function shouldHandleStateChangeError(server, err) { + const etv = err.topologyVersion; + const stv = server.description.topologyVersion; + return (0, server_description_1.compareTopologyVersion)(stv, etv) < 0; + } + function inActiveTransaction(session, cmd) { + return session && session.inTransaction() && !(0, transactions_1.isTransactionCommand)(cmd); + } + function isRetryableWritesEnabled(topology) { + return topology.s.options.retryWrites !== false; + } + } +}); + +// node_modules/mongodb/lib/sdam/monitor.js +var require_monitor = __commonJS({ + "node_modules/mongodb/lib/sdam/monitor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.RTTSampler = exports2.MonitorInterval = exports2.RTTPinger = exports2.Monitor = exports2.ServerMonitoringMode = void 0; + var timers_1 = require("timers"); + var bson_1 = require_bson2(); + var connect_1 = require_connect(); + var client_metadata_1 = require_client_metadata(); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_logger_1 = require_mongo_logger(); + var mongo_types_1 = require_mongo_types(); + var utils_1 = require_utils3(); + var common_1 = require_common(); + var events_1 = require_events(); + var server_1 = require_server(); + var STATE_IDLE = "idle"; + var STATE_MONITORING = "monitoring"; + var stateTransition = (0, utils_1.makeStateMachine)({ + [common_1.STATE_CLOSING]: [common_1.STATE_CLOSING, STATE_IDLE, common_1.STATE_CLOSED], + [common_1.STATE_CLOSED]: [common_1.STATE_CLOSED, STATE_MONITORING], + [STATE_IDLE]: [STATE_IDLE, STATE_MONITORING, common_1.STATE_CLOSING], + [STATE_MONITORING]: [STATE_MONITORING, STATE_IDLE, common_1.STATE_CLOSING] + }); + var INVALID_REQUEST_CHECK_STATES = /* @__PURE__ */ new Set([common_1.STATE_CLOSING, common_1.STATE_CLOSED, STATE_MONITORING]); + function isInCloseState(monitor) { + return monitor.s.state === common_1.STATE_CLOSED || monitor.s.state === common_1.STATE_CLOSING; + } + exports2.ServerMonitoringMode = Object.freeze({ + auto: "auto", + poll: "poll", + stream: "stream" + }); + var Monitor = class extends mongo_types_1.TypedEventEmitter { + constructor(server, options) { + super(); + this.component = mongo_logger_1.MongoLoggableComponent.TOPOLOGY; + this.on("error", utils_1.noop); + this.server = server; + this.connection = null; + this.cancellationToken = new mongo_types_1.CancellationToken(); + this.cancellationToken.setMaxListeners(Infinity); + this.monitorId = void 0; + this.s = { + state: common_1.STATE_CLOSED + }; + this.address = server.description.address; + this.options = Object.freeze({ + connectTimeoutMS: options.connectTimeoutMS ?? 1e4, + heartbeatFrequencyMS: options.heartbeatFrequencyMS ?? 1e4, + minHeartbeatFrequencyMS: options.minHeartbeatFrequencyMS ?? 500, + serverMonitoringMode: options.serverMonitoringMode + }); + this.isRunningInFaasEnv = (0, client_metadata_1.getFAASEnv)() != null; + this.mongoLogger = this.server.topology.client?.mongoLogger; + this.rttSampler = new RTTSampler(10); + const cancellationToken = this.cancellationToken; + const connectOptions = { + id: "", + generation: server.pool.generation, + cancellationToken, + hostAddress: server.description.hostAddress, + ...options, + // force BSON serialization options + raw: false, + useBigInt64: false, + promoteLongs: true, + promoteValues: true, + promoteBuffers: true + }; + delete connectOptions.credentials; + if (connectOptions.autoEncrypter) { + delete connectOptions.autoEncrypter; + } + this.connectOptions = Object.freeze(connectOptions); + } + connect() { + if (this.s.state !== common_1.STATE_CLOSED) { + return; + } + const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS; + const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS; + this.monitorId = new MonitorInterval(monitorServer(this), { + heartbeatFrequencyMS, + minHeartbeatFrequencyMS, + immediate: true + }); + } + requestCheck() { + if (INVALID_REQUEST_CHECK_STATES.has(this.s.state)) { + return; + } + this.monitorId?.wake(); + } + reset() { + const topologyVersion = this.server.description.topologyVersion; + if (isInCloseState(this) || topologyVersion == null) { + return; + } + stateTransition(this, common_1.STATE_CLOSING); + resetMonitorState(this); + stateTransition(this, STATE_IDLE); + const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS; + const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS; + this.monitorId = new MonitorInterval(monitorServer(this), { + heartbeatFrequencyMS, + minHeartbeatFrequencyMS + }); + } + close() { + if (isInCloseState(this)) { + return; + } + stateTransition(this, common_1.STATE_CLOSING); + resetMonitorState(this); + this.emit("close"); + stateTransition(this, common_1.STATE_CLOSED); + } + get roundTripTime() { + return this.rttSampler.average(); + } + get minRoundTripTime() { + return this.rttSampler.min(); + } + get latestRtt() { + return this.rttSampler.last; + } + addRttSample(rtt) { + this.rttSampler.addSample(rtt); + } + clearRttSamples() { + this.rttSampler.clear(); + } + }; + exports2.Monitor = Monitor; + function resetMonitorState(monitor) { + monitor.monitorId?.stop(); + monitor.monitorId = void 0; + monitor.rttPinger?.close(); + monitor.rttPinger = void 0; + monitor.cancellationToken.emit("cancel"); + monitor.connection?.destroy(); + monitor.connection = null; + monitor.clearRttSamples(); + } + function useStreamingProtocol(monitor, topologyVersion) { + if (topologyVersion == null) + return false; + const serverMonitoringMode = monitor.options.serverMonitoringMode; + if (serverMonitoringMode === exports2.ServerMonitoringMode.poll) + return false; + if (serverMonitoringMode === exports2.ServerMonitoringMode.stream) + return true; + if (monitor.isRunningInFaasEnv) + return false; + return true; + } + function checkServer(monitor, callback) { + let start; + let awaited; + const topologyVersion = monitor.server.description.topologyVersion; + const isAwaitable = useStreamingProtocol(monitor, topologyVersion); + monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_STARTED, monitor.server.topology.s.id, void 0, new events_1.ServerHeartbeatStartedEvent(monitor.address, isAwaitable)); + function onHeartbeatFailed(err) { + monitor.connection?.destroy(); + monitor.connection = null; + monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_FAILED, monitor.server.topology.s.id, void 0, new events_1.ServerHeartbeatFailedEvent(monitor.address, (0, utils_1.calculateDurationInMs)(start), err, awaited)); + const error = !(err instanceof error_1.MongoError) ? new error_1.MongoError(error_1.MongoError.buildErrorMessage(err), { cause: err }) : err; + error.addErrorLabel(error_1.MongoErrorLabel.ResetPool); + if (error instanceof error_1.MongoNetworkTimeoutError) { + error.addErrorLabel(error_1.MongoErrorLabel.InterruptInUseConnections); + } + monitor.emit("resetServer", error); + callback(err); + } + function onHeartbeatSucceeded(hello) { + if (!("isWritablePrimary" in hello)) { + hello.isWritablePrimary = hello[constants_1.LEGACY_HELLO_COMMAND]; + } + const duration = isAwaitable && monitor.rttPinger ? monitor.rttPinger.latestRtt ?? (0, utils_1.calculateDurationInMs)(start) : (0, utils_1.calculateDurationInMs)(start); + monitor.addRttSample(duration); + monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_SUCCEEDED, monitor.server.topology.s.id, hello.connectionId, new events_1.ServerHeartbeatSucceededEvent(monitor.address, duration, hello, isAwaitable)); + if (isAwaitable) { + monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_STARTED, monitor.server.topology.s.id, void 0, new events_1.ServerHeartbeatStartedEvent(monitor.address, true)); + start = (0, utils_1.now)(); + } else { + monitor.rttPinger?.close(); + monitor.rttPinger = void 0; + callback(void 0, hello); + } + } + const { connection } = monitor; + if (connection && !connection.closed) { + const { serverApi, helloOk } = connection; + const connectTimeoutMS = monitor.options.connectTimeoutMS; + const maxAwaitTimeMS = monitor.options.heartbeatFrequencyMS; + const cmd = { + [serverApi?.version || helloOk ? "hello" : constants_1.LEGACY_HELLO_COMMAND]: 1, + ...isAwaitable && topologyVersion ? { maxAwaitTimeMS, topologyVersion: makeTopologyVersion(topologyVersion) } : {} + }; + const options = isAwaitable ? { + socketTimeoutMS: connectTimeoutMS ? connectTimeoutMS + maxAwaitTimeMS : 0, + exhaustAllowed: true + } : { socketTimeoutMS: connectTimeoutMS }; + if (isAwaitable && monitor.rttPinger == null) { + monitor.rttPinger = new RTTPinger(monitor); + } + start = (0, utils_1.now)(); + if (isAwaitable) { + awaited = true; + return connection.exhaustCommand((0, utils_1.ns)("admin.$cmd"), cmd, options, (error, hello) => { + if (error) + return onHeartbeatFailed(error); + return onHeartbeatSucceeded(hello); + }); + } + awaited = false; + connection.command((0, utils_1.ns)("admin.$cmd"), cmd, options).then(onHeartbeatSucceeded, onHeartbeatFailed); + return; + } + (async () => { + const socket = await (0, connect_1.makeSocket)(monitor.connectOptions); + const connection2 = (0, connect_1.makeConnection)(monitor.connectOptions, socket); + start = (0, utils_1.now)(); + try { + await (0, connect_1.performInitialHandshake)(connection2, monitor.connectOptions); + return connection2; + } catch (error) { + connection2.destroy(); + throw error; + } + })().then((connection2) => { + if (isInCloseState(monitor)) { + connection2.destroy(); + return; + } + const duration = (0, utils_1.calculateDurationInMs)(start); + monitor.addRttSample(duration); + monitor.connection = connection2; + monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_SUCCEEDED, monitor.server.topology.s.id, connection2.hello?.connectionId, new events_1.ServerHeartbeatSucceededEvent(monitor.address, duration, connection2.hello, useStreamingProtocol(monitor, connection2.hello?.topologyVersion))); + callback(void 0, connection2.hello); + }, (error) => { + monitor.connection = null; + awaited = false; + onHeartbeatFailed(error); + }); + } + function monitorServer(monitor) { + return (callback) => { + if (monitor.s.state === STATE_MONITORING) { + process.nextTick(callback); + return; + } + stateTransition(monitor, STATE_MONITORING); + function done() { + if (!isInCloseState(monitor)) { + stateTransition(monitor, STATE_IDLE); + } + callback(); + } + checkServer(monitor, (err, hello) => { + if (err) { + if (monitor.server.description.type === common_1.ServerType.Unknown) { + return done(); + } + } + if (useStreamingProtocol(monitor, hello?.topologyVersion)) { + (0, timers_1.setTimeout)(() => { + if (!isInCloseState(monitor)) { + monitor.monitorId?.wake(); + } + }, 0); + } + done(); + }); + }; + } + function makeTopologyVersion(tv) { + return { + processId: tv.processId, + // tests mock counter as just number, but in a real situation counter should always be a Long + // TODO(NODE-2674): Preserve int64 sent from MongoDB + counter: bson_1.Long.isLong(tv.counter) ? tv.counter : bson_1.Long.fromNumber(tv.counter) + }; + } + var RTTPinger = class { + constructor(monitor) { + this.connection = void 0; + this.cancellationToken = monitor.cancellationToken; + this.closed = false; + this.monitor = monitor; + this.latestRtt = monitor.latestRtt ?? void 0; + const heartbeatFrequencyMS = monitor.options.heartbeatFrequencyMS; + this.monitorId = (0, timers_1.setTimeout)(() => this.measureRoundTripTime(), heartbeatFrequencyMS); + } + get roundTripTime() { + return this.monitor.roundTripTime; + } + get minRoundTripTime() { + return this.monitor.minRoundTripTime; + } + close() { + this.closed = true; + (0, timers_1.clearTimeout)(this.monitorId); + this.connection?.destroy(); + this.connection = void 0; + } + measureAndReschedule(start, conn) { + if (this.closed) { + conn?.destroy(); + return; + } + if (this.connection == null) { + this.connection = conn; + } + this.latestRtt = (0, utils_1.calculateDurationInMs)(start); + this.monitorId = (0, timers_1.setTimeout)(() => this.measureRoundTripTime(), this.monitor.options.heartbeatFrequencyMS); + } + measureRoundTripTime() { + const start = (0, utils_1.now)(); + if (this.closed) { + return; + } + const connection = this.connection; + if (connection == null) { + (0, connect_1.connect)(this.monitor.connectOptions).then((connection2) => { + this.measureAndReschedule(start, connection2); + }, () => { + this.connection = void 0; + }); + return; + } + const commandName = connection.serverApi?.version || connection.helloOk ? "hello" : constants_1.LEGACY_HELLO_COMMAND; + connection.command((0, utils_1.ns)("admin.$cmd"), { [commandName]: 1 }, void 0).then(() => this.measureAndReschedule(start), () => { + this.connection?.destroy(); + this.connection = void 0; + return; + }); + } + }; + exports2.RTTPinger = RTTPinger; + var MonitorInterval = class { + constructor(fn, options = {}) { + this.isExpeditedCallToFnScheduled = false; + this.stopped = false; + this.isExecutionInProgress = false; + this.hasExecutedOnce = false; + this._executeAndReschedule = () => { + if (this.stopped) + return; + if (this.timerId) { + (0, timers_1.clearTimeout)(this.timerId); + } + this.isExpeditedCallToFnScheduled = false; + this.isExecutionInProgress = true; + this.fn(() => { + this.lastExecutionEnded = (0, utils_1.now)(); + this.isExecutionInProgress = false; + this._reschedule(this.heartbeatFrequencyMS); + }); + }; + this.fn = fn; + this.lastExecutionEnded = -Infinity; + this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 1e3; + this.minHeartbeatFrequencyMS = options.minHeartbeatFrequencyMS ?? 500; + if (options.immediate) { + this._executeAndReschedule(); + } else { + this._reschedule(void 0); + } + } + wake() { + const currentTime = (0, utils_1.now)(); + const timeSinceLastCall = currentTime - this.lastExecutionEnded; + if (timeSinceLastCall < 0) { + return this._executeAndReschedule(); + } + if (this.isExecutionInProgress) { + return; + } + if (this.isExpeditedCallToFnScheduled) { + return; + } + if (timeSinceLastCall < this.minHeartbeatFrequencyMS) { + this.isExpeditedCallToFnScheduled = true; + this._reschedule(this.minHeartbeatFrequencyMS - timeSinceLastCall); + return; + } + this._executeAndReschedule(); + } + stop() { + this.stopped = true; + if (this.timerId) { + (0, timers_1.clearTimeout)(this.timerId); + this.timerId = void 0; + } + this.lastExecutionEnded = -Infinity; + this.isExpeditedCallToFnScheduled = false; + } + toString() { + return JSON.stringify(this); + } + toJSON() { + const currentTime = (0, utils_1.now)(); + const timeSinceLastCall = currentTime - this.lastExecutionEnded; + return { + timerId: this.timerId != null ? "set" : "cleared", + lastCallTime: this.lastExecutionEnded, + isExpeditedCheckScheduled: this.isExpeditedCallToFnScheduled, + stopped: this.stopped, + heartbeatFrequencyMS: this.heartbeatFrequencyMS, + minHeartbeatFrequencyMS: this.minHeartbeatFrequencyMS, + currentTime, + timeSinceLastCall + }; + } + _reschedule(ms) { + if (this.stopped) + return; + if (this.timerId) { + (0, timers_1.clearTimeout)(this.timerId); + } + this.timerId = (0, timers_1.setTimeout)(this._executeAndReschedule, ms || this.heartbeatFrequencyMS); + } + }; + exports2.MonitorInterval = MonitorInterval; + var RTTSampler = class { + constructor(windowSize = 10) { + this.rttSamples = new Float64Array(windowSize); + this.length = 0; + this.writeIndex = 0; + } + /** + * Adds an rtt sample to the end of the circular buffer + * When `windowSize` samples have been collected, `addSample` overwrites the least recently added + * sample + */ + addSample(sample) { + this.rttSamples[this.writeIndex++] = sample; + if (this.length < this.rttSamples.length) { + this.length++; + } + this.writeIndex %= this.rttSamples.length; + } + /** + * When \< 2 samples have been collected, returns 0 + * Otherwise computes the minimum value samples contained in the buffer + */ + min() { + if (this.length < 2) + return 0; + let min = this.rttSamples[0]; + for (let i = 1; i < this.length; i++) { + if (this.rttSamples[i] < min) + min = this.rttSamples[i]; + } + return min; + } + /** + * Returns mean of samples contained in the buffer + */ + average() { + if (this.length === 0) + return 0; + let sum = 0; + for (let i = 0; i < this.length; i++) { + sum += this.rttSamples[i]; + } + return sum / this.length; + } + /** + * Returns most recently inserted element in the buffer + * Returns null if the buffer is empty + * */ + get last() { + if (this.length === 0) + return null; + return this.rttSamples[this.writeIndex === 0 ? this.length - 1 : this.writeIndex - 1]; + } + /** + * Clear the buffer + * NOTE: this does not overwrite the data held in the internal array, just the pointers into + * this array + */ + clear() { + this.length = 0; + this.writeIndex = 0; + } + }; + exports2.RTTSampler = RTTSampler; + } +}); + +// node_modules/mongodb/lib/connection_string.js +var require_connection_string = __commonJS({ + "node_modules/mongodb/lib/connection_string.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DEFAULT_OPTIONS = exports2.OPTIONS = void 0; + exports2.resolveSRVRecord = resolveSRVRecord; + exports2.parseOptions = parseOptions; + var dns = require("dns"); + var mongodb_connection_string_url_1 = require_lib8(); + var url_1 = require("url"); + var mongo_credentials_1 = require_mongo_credentials(); + var providers_1 = require_providers(); + var compression_1 = require_compression(); + var encrypter_1 = require_encrypter(); + var error_1 = require_error(); + var mongo_client_1 = require_mongo_client(); + var mongo_logger_1 = require_mongo_logger(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var monitor_1 = require_monitor(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var VALID_TXT_RECORDS = ["authSource", "replicaSet", "loadBalanced"]; + var LB_SINGLE_HOST_ERROR = "loadBalanced option only supported with a single host in the URI"; + var LB_REPLICA_SET_ERROR = "loadBalanced option not supported with a replicaSet option"; + var LB_DIRECT_CONNECTION_ERROR = "loadBalanced option not supported when directConnection is provided"; + function retryDNSTimeoutFor(api) { + return async function dnsReqRetryTimeout(lookupAddress) { + try { + return await dns.promises[api](lookupAddress); + } catch (firstDNSError) { + if (firstDNSError.code === dns.TIMEOUT) { + return await dns.promises[api](lookupAddress); + } else { + throw firstDNSError; + } + } + }; + } + var resolveSrv = retryDNSTimeoutFor("resolveSrv"); + var resolveTxt = retryDNSTimeoutFor("resolveTxt"); + async function resolveSRVRecord(options) { + if (typeof options.srvHost !== "string") { + throw new error_1.MongoAPIError('Option "srvHost" must not be empty'); + } + const lookupAddress = options.srvHost; + const txtResolutionPromise = resolveTxt(lookupAddress); + txtResolutionPromise.then(void 0, utils_1.squashError); + const hostname = `_${options.srvServiceName}._tcp.${lookupAddress}`; + const addresses = await resolveSrv(hostname); + if (addresses.length === 0) { + throw new error_1.MongoAPIError("No addresses found at host"); + } + for (const { name } of addresses) { + (0, utils_1.checkParentDomainMatch)(name, lookupAddress); + } + const hostAddresses = addresses.map((r) => utils_1.HostAddress.fromString(`${r.name}:${r.port ?? 27017}`)); + validateLoadBalancedOptions(hostAddresses, options, true); + let record; + try { + record = await txtResolutionPromise; + } catch (error) { + if (error.code !== "ENODATA" && error.code !== "ENOTFOUND") { + throw error; + } + return hostAddresses; + } + if (record.length > 1) { + throw new error_1.MongoParseError("Multiple text records not allowed"); + } + const txtRecordOptions = new url_1.URLSearchParams(record[0].join("")); + const txtRecordOptionKeys = [...txtRecordOptions.keys()]; + if (txtRecordOptionKeys.some((key) => !VALID_TXT_RECORDS.includes(key))) { + throw new error_1.MongoParseError(`Text record may only set any of: ${VALID_TXT_RECORDS.join(", ")}`); + } + if (VALID_TXT_RECORDS.some((option) => txtRecordOptions.get(option) === "")) { + throw new error_1.MongoParseError("Cannot have empty URI params in DNS TXT Record"); + } + const source = txtRecordOptions.get("authSource") ?? void 0; + const replicaSet = txtRecordOptions.get("replicaSet") ?? void 0; + const loadBalanced = txtRecordOptions.get("loadBalanced") ?? void 0; + if (!options.userSpecifiedAuthSource && source && options.credentials && !providers_1.AUTH_MECHS_AUTH_SRC_EXTERNAL.has(options.credentials.mechanism)) { + options.credentials = mongo_credentials_1.MongoCredentials.merge(options.credentials, { source }); + } + if (!options.userSpecifiedReplicaSet && replicaSet) { + options.replicaSet = replicaSet; + } + if (loadBalanced === "true") { + options.loadBalanced = true; + } + if (options.replicaSet && options.srvMaxHosts > 0) { + throw new error_1.MongoParseError("Cannot combine replicaSet option with srvMaxHosts"); + } + validateLoadBalancedOptions(hostAddresses, options, true); + return hostAddresses; + } + function checkTLSOptions(allOptions) { + if (!allOptions) + return; + const check = (a, b) => { + if (allOptions.has(a) && allOptions.has(b)) { + throw new error_1.MongoAPIError(`The '${a}' option cannot be used with the '${b}' option`); + } + }; + check("tlsInsecure", "tlsAllowInvalidCertificates"); + check("tlsInsecure", "tlsAllowInvalidHostnames"); + } + function getBoolean(name, value) { + if (typeof value === "boolean") + return value; + switch (value) { + case "true": + return true; + case "false": + return false; + default: + throw new error_1.MongoParseError(`${name} must be either "true" or "false"`); + } + } + function getIntFromOptions(name, value) { + const parsedInt = (0, utils_1.parseInteger)(value); + if (parsedInt != null) { + return parsedInt; + } + throw new error_1.MongoParseError(`Expected ${name} to be stringified int value, got: ${value}`); + } + function getUIntFromOptions(name, value) { + const parsedValue = getIntFromOptions(name, value); + if (parsedValue < 0) { + throw new error_1.MongoParseError(`${name} can only be a positive int value, got: ${value}`); + } + return parsedValue; + } + function* entriesFromString(value) { + if (value === "") { + return; + } + const keyValuePairs = value.split(","); + for (const keyValue of keyValuePairs) { + const [key, value2] = keyValue.split(/:(.*)/); + if (value2 == null) { + throw new error_1.MongoParseError("Cannot have undefined values in key value pairs"); + } + yield [key, value2]; + } + } + var CaseInsensitiveMap = class extends Map { + constructor(entries = []) { + super(entries.map(([k, v]) => [k.toLowerCase(), v])); + } + has(k) { + return super.has(k.toLowerCase()); + } + get(k) { + return super.get(k.toLowerCase()); + } + set(k, v) { + return super.set(k.toLowerCase(), v); + } + delete(k) { + return super.delete(k.toLowerCase()); + } + }; + function parseOptions(uri, mongoClient = void 0, options = {}) { + if (mongoClient != null && !(mongoClient instanceof mongo_client_1.MongoClient)) { + options = mongoClient; + mongoClient = void 0; + } + if (options.useBigInt64 && typeof options.promoteLongs === "boolean" && !options.promoteLongs) { + throw new error_1.MongoAPIError("Must request either bigint or Long for int64 deserialization"); + } + if (options.useBigInt64 && typeof options.promoteValues === "boolean" && !options.promoteValues) { + throw new error_1.MongoAPIError("Must request either bigint or Long for int64 deserialization"); + } + const url = new mongodb_connection_string_url_1.default(uri); + const { hosts, isSRV } = url; + const mongoOptions = /* @__PURE__ */ Object.create(null); + mongoOptions.hosts = isSRV ? [] : hosts.map(utils_1.HostAddress.fromString); + const urlOptions = new CaseInsensitiveMap(); + if (url.pathname !== "/" && url.pathname !== "") { + const dbName = decodeURIComponent(url.pathname[0] === "/" ? url.pathname.slice(1) : url.pathname); + if (dbName) { + urlOptions.set("dbName", [dbName]); + } + } + if (url.username !== "") { + const auth = { + username: decodeURIComponent(url.username) + }; + if (typeof url.password === "string") { + auth.password = decodeURIComponent(url.password); + } + urlOptions.set("auth", [auth]); + } + for (const key of url.searchParams.keys()) { + const values = url.searchParams.getAll(key); + const isReadPreferenceTags = /readPreferenceTags/i.test(key); + if (!isReadPreferenceTags && values.length > 1) { + throw new error_1.MongoInvalidArgumentError(`URI option "${key}" cannot appear more than once in the connection string`); + } + if (!isReadPreferenceTags && values.includes("") && !isIgnoredOption(key)) { + throw new error_1.MongoAPIError(`URI option "${key}" cannot be specified with no value`); + } + if (!urlOptions.has(key)) { + urlOptions.set(key, values); + } + } + const objectOptions = new CaseInsensitiveMap(Object.entries(options).filter(([, v]) => v != null)); + if (urlOptions.has("serverApi")) { + throw new error_1.MongoParseError("URI cannot contain `serverApi`, it can only be passed to the client"); + } + const uriMechanismProperties = urlOptions.get("authMechanismProperties"); + if (uriMechanismProperties) { + for (const property of uriMechanismProperties) { + if (/(^|,)ALLOWED_HOSTS:/.test(property)) { + throw new error_1.MongoParseError("Auth mechanism property ALLOWED_HOSTS is not allowed in the connection string."); + } + } + } + if (objectOptions.has("loadBalanced")) { + throw new error_1.MongoParseError("loadBalanced is only a valid option in the URI"); + } + const allProvidedOptions = new CaseInsensitiveMap(); + const allProvidedKeys = /* @__PURE__ */ new Set([...urlOptions.keys(), ...objectOptions.keys()]); + for (const key of allProvidedKeys) { + const values = []; + const objectOptionValue = objectOptions.get(key); + if (objectOptionValue != null) { + values.push(objectOptionValue); + } + const urlValues = urlOptions.get(key) ?? []; + values.push(...urlValues); + allProvidedOptions.set(key, values); + } + if (allProvidedOptions.has("tls") || allProvidedOptions.has("ssl")) { + const tlsAndSslOpts = (allProvidedOptions.get("tls") || []).concat(allProvidedOptions.get("ssl") || []).map(getBoolean.bind(null, "tls/ssl")); + if (new Set(tlsAndSslOpts).size !== 1) { + throw new error_1.MongoParseError("All values of tls/ssl must be the same."); + } + } + checkTLSOptions(allProvidedOptions); + const unsupportedOptions = (0, utils_1.setDifference)(allProvidedKeys, Array.from(Object.keys(exports2.OPTIONS)).map((s) => s.toLowerCase())); + if (unsupportedOptions.size !== 0) { + const optionWord = unsupportedOptions.size > 1 ? "options" : "option"; + const isOrAre = unsupportedOptions.size > 1 ? "are" : "is"; + throw new error_1.MongoParseError(`${optionWord} ${Array.from(unsupportedOptions).join(", ")} ${isOrAre} not supported`); + } + for (const [key, descriptor] of Object.entries(exports2.OPTIONS)) { + const values = allProvidedOptions.get(key); + if (!values || values.length === 0) { + if (exports2.DEFAULT_OPTIONS.has(key)) { + setOption(mongoOptions, key, descriptor, [exports2.DEFAULT_OPTIONS.get(key)]); + } + } else { + const { deprecated, ignored } = descriptor; + if (deprecated) { + const deprecatedMsg = typeof deprecated === "string" ? `: ${deprecated}` : ""; + (0, utils_1.emitWarning)(`${key} is a deprecated option${deprecatedMsg}`); + } + if (ignored) + continue; + setOption(mongoOptions, key, descriptor, values); + } + } + if (mongoOptions.credentials) { + const isGssapi = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_GSSAPI; + const isX509 = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_X509; + const isAws = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_AWS; + const isOidc = mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_OIDC; + if ((isGssapi || isX509) && allProvidedOptions.has("authSource") && mongoOptions.credentials.source !== "$external") { + throw new error_1.MongoParseError(`authMechanism ${mongoOptions.credentials.mechanism} requires an authSource of '$external'`); + } + if (!(isGssapi || isX509 || isAws || isOidc) && mongoOptions.dbName && !allProvidedOptions.has("authSource")) { + mongoOptions.credentials = mongo_credentials_1.MongoCredentials.merge(mongoOptions.credentials, { + source: mongoOptions.dbName + }); + } + if (isAws && mongoOptions.credentials.username && !mongoOptions.credentials.password) { + throw new error_1.MongoMissingCredentialsError(`When using ${mongoOptions.credentials.mechanism} password must be set when a username is specified`); + } + mongoOptions.credentials.validate(); + if (mongoOptions.credentials.password === "" && mongoOptions.credentials.username === "" && mongoOptions.credentials.mechanism === providers_1.AuthMechanism.MONGODB_DEFAULT && Object.keys(mongoOptions.credentials.mechanismProperties).length === 0) { + delete mongoOptions.credentials; + } + } + if (!mongoOptions.dbName) { + mongoOptions.dbName = "test"; + } + validateLoadBalancedOptions(hosts, mongoOptions, isSRV); + if (mongoClient && mongoOptions.autoEncryption) { + encrypter_1.Encrypter.checkForMongoCrypt(); + mongoOptions.encrypter = new encrypter_1.Encrypter(mongoClient, uri, options); + mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter; + } + mongoOptions.userSpecifiedAuthSource = objectOptions.has("authSource") || urlOptions.has("authSource"); + mongoOptions.userSpecifiedReplicaSet = objectOptions.has("replicaSet") || urlOptions.has("replicaSet"); + if (isSRV) { + mongoOptions.srvHost = hosts[0]; + if (mongoOptions.directConnection) { + throw new error_1.MongoAPIError("SRV URI does not support directConnection"); + } + if (mongoOptions.srvMaxHosts > 0 && typeof mongoOptions.replicaSet === "string") { + throw new error_1.MongoParseError("Cannot use srvMaxHosts option with replicaSet"); + } + const noUserSpecifiedTLS = !objectOptions.has("tls") && !urlOptions.has("tls"); + const noUserSpecifiedSSL = !objectOptions.has("ssl") && !urlOptions.has("ssl"); + if (noUserSpecifiedTLS && noUserSpecifiedSSL) { + mongoOptions.tls = true; + } + } else { + const userSpecifiedSrvOptions = urlOptions.has("srvMaxHosts") || objectOptions.has("srvMaxHosts") || urlOptions.has("srvServiceName") || objectOptions.has("srvServiceName"); + if (userSpecifiedSrvOptions) { + throw new error_1.MongoParseError("Cannot use srvMaxHosts or srvServiceName with a non-srv connection string"); + } + } + if (mongoOptions.directConnection && mongoOptions.hosts.length !== 1) { + throw new error_1.MongoParseError("directConnection option requires exactly one host"); + } + if (!mongoOptions.proxyHost && (mongoOptions.proxyPort || mongoOptions.proxyUsername || mongoOptions.proxyPassword)) { + throw new error_1.MongoParseError("Must specify proxyHost if other proxy options are passed"); + } + if (mongoOptions.proxyUsername && !mongoOptions.proxyPassword || !mongoOptions.proxyUsername && mongoOptions.proxyPassword) { + throw new error_1.MongoParseError("Can only specify both of proxy username/password or neither"); + } + const proxyOptions = ["proxyHost", "proxyPort", "proxyUsername", "proxyPassword"].map((key) => urlOptions.get(key) ?? []); + if (proxyOptions.some((options2) => options2.length > 1)) { + throw new error_1.MongoParseError("Proxy options cannot be specified multiple times in the connection string"); + } + mongoOptions.mongoLoggerOptions = mongo_logger_1.MongoLogger.resolveOptions({ + MONGODB_LOG_COMMAND: process.env.MONGODB_LOG_COMMAND, + MONGODB_LOG_TOPOLOGY: process.env.MONGODB_LOG_TOPOLOGY, + MONGODB_LOG_SERVER_SELECTION: process.env.MONGODB_LOG_SERVER_SELECTION, + MONGODB_LOG_CONNECTION: process.env.MONGODB_LOG_CONNECTION, + MONGODB_LOG_CLIENT: process.env.MONGODB_LOG_CLIENT, + MONGODB_LOG_ALL: process.env.MONGODB_LOG_ALL, + MONGODB_LOG_MAX_DOCUMENT_LENGTH: process.env.MONGODB_LOG_MAX_DOCUMENT_LENGTH, + MONGODB_LOG_PATH: process.env.MONGODB_LOG_PATH + }, { + mongodbLogPath: mongoOptions.mongodbLogPath, + mongodbLogComponentSeverities: mongoOptions.mongodbLogComponentSeverities, + mongodbLogMaxDocumentLength: mongoOptions.mongodbLogMaxDocumentLength + }); + return mongoOptions; + } + function validateLoadBalancedOptions(hosts, mongoOptions, isSrv) { + if (mongoOptions.loadBalanced) { + if (hosts.length > 1) { + throw new error_1.MongoParseError(LB_SINGLE_HOST_ERROR); + } + if (mongoOptions.replicaSet) { + throw new error_1.MongoParseError(LB_REPLICA_SET_ERROR); + } + if (mongoOptions.directConnection) { + throw new error_1.MongoParseError(LB_DIRECT_CONNECTION_ERROR); + } + if (isSrv && mongoOptions.srvMaxHosts > 0) { + throw new error_1.MongoParseError("Cannot limit srv hosts with loadBalanced enabled"); + } + } + return; + } + function isIgnoredOption(key) { + return Object.entries(exports2.OPTIONS).some(([name, descriptor]) => descriptor.ignored && name.toLowerCase() === key.toLowerCase()); + } + function setOption(mongoOptions, key, descriptor, values) { + const { target, type, transform } = descriptor; + const name = target ?? key; + switch (type) { + case "boolean": + mongoOptions[name] = getBoolean(name, values[0]); + break; + case "int": + mongoOptions[name] = getIntFromOptions(name, values[0]); + break; + case "uint": + mongoOptions[name] = getUIntFromOptions(name, values[0]); + break; + case "string": + if (values[0] == null) { + break; + } + mongoOptions[name] = String(values[0]); + break; + case "record": + if (!(0, utils_1.isRecord)(values[0])) { + throw new error_1.MongoParseError(`${name} must be an object`); + } + mongoOptions[name] = values[0]; + break; + case "any": + mongoOptions[name] = values[0]; + break; + default: { + if (!transform) { + throw new error_1.MongoParseError("Descriptors missing a type must define a transform"); + } + const transformValue = transform({ name, options: mongoOptions, values }); + mongoOptions[name] = transformValue; + break; + } + } + } + exports2.OPTIONS = { + appName: { + type: "string" + }, + auth: { + target: "credentials", + transform({ name, options, values: [value] }) { + if (!(0, utils_1.isRecord)(value, ["username", "password"])) { + throw new error_1.MongoParseError(`${name} must be an object with 'username' and 'password' properties`); + } + return mongo_credentials_1.MongoCredentials.merge(options.credentials, { + username: value.username, + password: value.password + }); + } + }, + authMechanism: { + target: "credentials", + transform({ options, values: [value] }) { + const mechanisms = Object.values(providers_1.AuthMechanism); + const [mechanism] = mechanisms.filter((m) => m.match(RegExp(String.raw`\b${value}\b`, "i"))); + if (!mechanism) { + throw new error_1.MongoParseError(`authMechanism one of ${mechanisms}, got ${value}`); + } + let source = options.credentials?.source; + if (mechanism === providers_1.AuthMechanism.MONGODB_PLAIN || providers_1.AUTH_MECHS_AUTH_SRC_EXTERNAL.has(mechanism)) { + source = "$external"; + } + let password = options.credentials?.password; + if (mechanism === providers_1.AuthMechanism.MONGODB_X509 && password === "") { + password = void 0; + } + return mongo_credentials_1.MongoCredentials.merge(options.credentials, { + mechanism, + source, + password + }); + } + }, + // Note that if the authMechanismProperties contain a TOKEN_RESOURCE that has a + // comma in it, it MUST be supplied as a MongoClient option instead of in the + // connection string. + authMechanismProperties: { + target: "credentials", + transform({ options, values }) { + let mechanismProperties = /* @__PURE__ */ Object.create(null); + for (const optionValue of values) { + if (typeof optionValue === "string") { + for (const [key, value] of entriesFromString(optionValue)) { + try { + mechanismProperties[key] = getBoolean(key, value); + } catch { + mechanismProperties[key] = value; + } + } + } else { + if (!(0, utils_1.isRecord)(optionValue)) { + throw new error_1.MongoParseError("AuthMechanismProperties must be an object"); + } + mechanismProperties = { ...optionValue }; + } + } + return mongo_credentials_1.MongoCredentials.merge(options.credentials, { + mechanismProperties + }); + } + }, + authSource: { + target: "credentials", + transform({ options, values: [value] }) { + const source = String(value); + return mongo_credentials_1.MongoCredentials.merge(options.credentials, { source }); + } + }, + autoEncryption: { + type: "record" + }, + autoSelectFamily: { + type: "boolean", + default: true + }, + autoSelectFamilyAttemptTimeout: { + type: "uint" + }, + bsonRegExp: { + type: "boolean" + }, + serverApi: { + target: "serverApi", + transform({ values: [version] }) { + const serverApiToValidate = typeof version === "string" ? { version } : version; + const versionToValidate = serverApiToValidate && serverApiToValidate.version; + if (!versionToValidate) { + throw new error_1.MongoParseError(`Invalid \`serverApi\` property; must specify a version from the following enum: ["${Object.values(mongo_client_1.ServerApiVersion).join('", "')}"]`); + } + if (!Object.values(mongo_client_1.ServerApiVersion).some((v) => v === versionToValidate)) { + throw new error_1.MongoParseError(`Invalid server API version=${versionToValidate}; must be in the following enum: ["${Object.values(mongo_client_1.ServerApiVersion).join('", "')}"]`); + } + return serverApiToValidate; + } + }, + checkKeys: { + type: "boolean" + }, + compressors: { + default: "none", + target: "compressors", + transform({ values }) { + const compressionList = /* @__PURE__ */ new Set(); + for (const compVal of values) { + const compValArray = typeof compVal === "string" ? compVal.split(",") : compVal; + if (!Array.isArray(compValArray)) { + throw new error_1.MongoInvalidArgumentError("compressors must be an array or a comma-delimited list of strings"); + } + for (const c of compValArray) { + if (Object.keys(compression_1.Compressor).includes(String(c))) { + compressionList.add(String(c)); + } else { + throw new error_1.MongoInvalidArgumentError(`${c} is not a valid compression mechanism. Must be one of: ${Object.keys(compression_1.Compressor)}.`); + } + } + } + return [...compressionList]; + } + }, + connectTimeoutMS: { + default: 3e4, + type: "uint" + }, + dbName: { + type: "string" + }, + directConnection: { + default: false, + type: "boolean" + }, + driverInfo: { + default: {}, + type: "record" + }, + enableUtf8Validation: { type: "boolean", default: true }, + family: { + transform({ name, values: [value] }) { + const transformValue = getIntFromOptions(name, value); + if (transformValue === 4 || transformValue === 6) { + return transformValue; + } + throw new error_1.MongoParseError(`Option 'family' must be 4 or 6 got ${transformValue}.`); + } + }, + fieldsAsRaw: { + type: "record" + }, + forceServerObjectId: { + default: false, + type: "boolean" + }, + fsync: { + deprecated: "Please use journal instead", + target: "writeConcern", + transform({ name, options, values: [value] }) { + const wc = write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + fsync: getBoolean(name, value) + } + }); + if (!wc) + throw new error_1.MongoParseError(`Unable to make a writeConcern from fsync=${value}`); + return wc; + } + }, + heartbeatFrequencyMS: { + default: 1e4, + type: "uint" + }, + ignoreUndefined: { + type: "boolean" + }, + j: { + deprecated: "Please use journal instead", + target: "writeConcern", + transform({ name, options, values: [value] }) { + const wc = write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + journal: getBoolean(name, value) + } + }); + if (!wc) + throw new error_1.MongoParseError(`Unable to make a writeConcern from journal=${value}`); + return wc; + } + }, + journal: { + target: "writeConcern", + transform({ name, options, values: [value] }) { + const wc = write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + journal: getBoolean(name, value) + } + }); + if (!wc) + throw new error_1.MongoParseError(`Unable to make a writeConcern from journal=${value}`); + return wc; + } + }, + loadBalanced: { + default: false, + type: "boolean" + }, + localThresholdMS: { + default: 15, + type: "uint" + }, + maxConnecting: { + default: 2, + transform({ name, values: [value] }) { + const maxConnecting = getUIntFromOptions(name, value); + if (maxConnecting === 0) { + throw new error_1.MongoInvalidArgumentError("maxConnecting must be > 0 if specified"); + } + return maxConnecting; + } + }, + maxIdleTimeMS: { + default: 0, + type: "uint" + }, + maxPoolSize: { + default: 100, + type: "uint" + }, + maxStalenessSeconds: { + target: "readPreference", + transform({ name, options, values: [value] }) { + const maxStalenessSeconds = getUIntFromOptions(name, value); + if (options.readPreference) { + return read_preference_1.ReadPreference.fromOptions({ + readPreference: { ...options.readPreference, maxStalenessSeconds } + }); + } else { + return new read_preference_1.ReadPreference("secondary", void 0, { maxStalenessSeconds }); + } + } + }, + minInternalBufferSize: { + type: "uint" + }, + minPoolSize: { + default: 0, + type: "uint" + }, + minHeartbeatFrequencyMS: { + default: 500, + type: "uint" + }, + monitorCommands: { + default: false, + type: "boolean" + }, + name: { + target: "driverInfo", + transform({ values: [value], options }) { + return { ...options.driverInfo, name: String(value) }; + } + }, + noDelay: { + default: true, + type: "boolean" + }, + pkFactory: { + default: utils_1.DEFAULT_PK_FACTORY, + transform({ values: [value] }) { + if ((0, utils_1.isRecord)(value, ["createPk"]) && typeof value.createPk === "function") { + return value; + } + throw new error_1.MongoParseError(`Option pkFactory must be an object with a createPk function, got ${value}`); + } + }, + promoteBuffers: { + type: "boolean" + }, + promoteLongs: { + type: "boolean" + }, + promoteValues: { + type: "boolean" + }, + useBigInt64: { + type: "boolean" + }, + proxyHost: { + type: "string" + }, + proxyPassword: { + type: "string" + }, + proxyPort: { + type: "uint" + }, + proxyUsername: { + type: "string" + }, + raw: { + default: false, + type: "boolean" + }, + readConcern: { + transform({ values: [value], options }) { + if (value instanceof read_concern_1.ReadConcern || (0, utils_1.isRecord)(value, ["level"])) { + return read_concern_1.ReadConcern.fromOptions({ ...options.readConcern, ...value }); + } + throw new error_1.MongoParseError(`ReadConcern must be an object, got ${JSON.stringify(value)}`); + } + }, + readConcernLevel: { + target: "readConcern", + transform({ values: [level], options }) { + return read_concern_1.ReadConcern.fromOptions({ + ...options.readConcern, + level + }); + } + }, + readPreference: { + default: read_preference_1.ReadPreference.primary, + transform({ values: [value], options }) { + if (value instanceof read_preference_1.ReadPreference) { + return read_preference_1.ReadPreference.fromOptions({ + readPreference: { ...options.readPreference, ...value }, + ...value + }); + } + if ((0, utils_1.isRecord)(value, ["mode"])) { + const rp = read_preference_1.ReadPreference.fromOptions({ + readPreference: { ...options.readPreference, ...value }, + ...value + }); + if (rp) + return rp; + else + throw new error_1.MongoParseError(`Cannot make read preference from ${JSON.stringify(value)}`); + } + if (typeof value === "string") { + const rpOpts = { + hedge: options.readPreference?.hedge, + maxStalenessSeconds: options.readPreference?.maxStalenessSeconds + }; + return new read_preference_1.ReadPreference(value, options.readPreference?.tags, rpOpts); + } + throw new error_1.MongoParseError(`Unknown ReadPreference value: ${value}`); + } + }, + readPreferenceTags: { + target: "readPreference", + transform({ values, options }) { + const tags = Array.isArray(values[0]) ? values[0] : values; + const readPreferenceTags = []; + for (const tag of tags) { + const readPreferenceTag = /* @__PURE__ */ Object.create(null); + if (typeof tag === "string") { + for (const [k, v] of entriesFromString(tag)) { + readPreferenceTag[k] = v; + } + } + if ((0, utils_1.isRecord)(tag)) { + for (const [k, v] of Object.entries(tag)) { + readPreferenceTag[k] = v; + } + } + readPreferenceTags.push(readPreferenceTag); + } + return read_preference_1.ReadPreference.fromOptions({ + readPreference: options.readPreference, + readPreferenceTags + }); + } + }, + replicaSet: { + type: "string" + }, + retryReads: { + default: true, + type: "boolean" + }, + retryWrites: { + default: true, + type: "boolean" + }, + serializeFunctions: { + type: "boolean" + }, + serverMonitoringMode: { + default: "auto", + transform({ values: [value] }) { + if (!Object.values(monitor_1.ServerMonitoringMode).includes(value)) { + throw new error_1.MongoParseError("serverMonitoringMode must be one of `auto`, `poll`, or `stream`"); + } + return value; + } + }, + serverSelectionTimeoutMS: { + default: 3e4, + type: "uint" + }, + servername: { + type: "string" + }, + socketTimeoutMS: { + default: 0, + type: "uint" + }, + srvMaxHosts: { + type: "uint", + default: 0 + }, + srvServiceName: { + type: "string", + default: "mongodb" + }, + ssl: { + target: "tls", + type: "boolean" + }, + timeoutMS: { + deprecated: "timeoutMS has no effect and will be removed in a future release", + ignored: true + }, + tls: { + type: "boolean" + }, + tlsAllowInvalidCertificates: { + target: "rejectUnauthorized", + transform({ name, values: [value] }) { + return !getBoolean(name, value); + } + }, + tlsAllowInvalidHostnames: { + target: "checkServerIdentity", + transform({ name, values: [value] }) { + return getBoolean(name, value) ? () => void 0 : void 0; + } + }, + tlsCAFile: { + type: "string" + }, + tlsCRLFile: { + type: "string" + }, + tlsCertificateKeyFile: { + type: "string" + }, + tlsCertificateKeyFilePassword: { + target: "passphrase", + type: "any" + }, + tlsInsecure: { + transform({ name, options, values: [value] }) { + const tlsInsecure = getBoolean(name, value); + if (tlsInsecure) { + options.checkServerIdentity = () => void 0; + options.rejectUnauthorized = false; + } else { + options.checkServerIdentity = options.tlsAllowInvalidHostnames ? () => void 0 : void 0; + options.rejectUnauthorized = options.tlsAllowInvalidCertificates ? false : true; + } + return tlsInsecure; + } + }, + w: { + target: "writeConcern", + transform({ values: [value], options }) { + return write_concern_1.WriteConcern.fromOptions({ writeConcern: { ...options.writeConcern, w: value } }); + } + }, + waitQueueTimeoutMS: { + default: 0, + type: "uint" + }, + writeConcern: { + target: "writeConcern", + transform({ values: [value], options }) { + if ((0, utils_1.isRecord)(value) || value instanceof write_concern_1.WriteConcern) { + return write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + ...value + } + }); + } else if (value === "majority" || typeof value === "number") { + return write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + w: value + } + }); + } + throw new error_1.MongoParseError(`Invalid WriteConcern cannot parse: ${JSON.stringify(value)}`); + } + }, + wtimeout: { + deprecated: "Please use wtimeoutMS instead", + target: "writeConcern", + transform({ values: [value], options }) { + const wc = write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + wtimeout: getUIntFromOptions("wtimeout", value) + } + }); + if (wc) + return wc; + throw new error_1.MongoParseError(`Cannot make WriteConcern from wtimeout`); + } + }, + wtimeoutMS: { + target: "writeConcern", + transform({ values: [value], options }) { + const wc = write_concern_1.WriteConcern.fromOptions({ + writeConcern: { + ...options.writeConcern, + wtimeoutMS: getUIntFromOptions("wtimeoutMS", value) + } + }); + if (wc) + return wc; + throw new error_1.MongoParseError(`Cannot make WriteConcern from wtimeout`); + } + }, + zlibCompressionLevel: { + default: 0, + type: "int" + }, + mongodbLogPath: { + transform({ values: [value] }) { + if (!(typeof value === "string" && ["stderr", "stdout"].includes(value) || value && typeof value === "object" && "write" in value && typeof value.write === "function")) { + throw new error_1.MongoAPIError(`Option 'mongodbLogPath' must be of type 'stderr' | 'stdout' | MongoDBLogWritable`); + } + return value; + } + }, + mongodbLogComponentSeverities: { + transform({ values: [value] }) { + if (typeof value !== "object" || !value) { + throw new error_1.MongoAPIError(`Option 'mongodbLogComponentSeverities' must be a non-null object`); + } + for (const [k, v] of Object.entries(value)) { + if (typeof v !== "string" || typeof k !== "string") { + throw new error_1.MongoAPIError(`User input for option 'mongodbLogComponentSeverities' object cannot include a non-string key or value`); + } + if (!Object.values(mongo_logger_1.MongoLoggableComponent).some((val) => val === k) && k !== "default") { + throw new error_1.MongoAPIError(`User input for option 'mongodbLogComponentSeverities' contains invalid key: ${k}`); + } + if (!Object.values(mongo_logger_1.SeverityLevel).some((val) => val === v)) { + throw new error_1.MongoAPIError(`Option 'mongodbLogComponentSeverities' does not support ${v} as a value for ${k}`); + } + } + return value; + } + }, + mongodbLogMaxDocumentLength: { type: "uint" }, + // Custom types for modifying core behavior + connectionType: { type: "any" }, + srvPoller: { type: "any" }, + // Accepted Node.js Options + allowPartialTrustChain: { type: "any" }, + minDHSize: { type: "any" }, + pskCallback: { type: "any" }, + secureContext: { type: "any" }, + enableTrace: { type: "any" }, + requestCert: { type: "any" }, + rejectUnauthorized: { type: "any" }, + checkServerIdentity: { type: "any" }, + keepAliveInitialDelay: { type: "any" }, + ALPNProtocols: { type: "any" }, + SNICallback: { type: "any" }, + session: { type: "any" }, + requestOCSP: { type: "any" }, + localAddress: { type: "any" }, + localPort: { type: "any" }, + hints: { type: "any" }, + lookup: { type: "any" }, + ca: { type: "any" }, + cert: { type: "any" }, + ciphers: { type: "any" }, + crl: { type: "any" }, + ecdhCurve: { type: "any" }, + key: { type: "any" }, + passphrase: { type: "any" }, + pfx: { type: "any" }, + secureProtocol: { type: "any" }, + index: { type: "any" }, + // Legacy options from v3 era + useNewUrlParser: { + type: "boolean", + deprecated: "useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version" + }, + useUnifiedTopology: { + type: "boolean", + deprecated: "useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version" + }, + __skipPingOnConnect: { type: "boolean" } + }; + exports2.DEFAULT_OPTIONS = new CaseInsensitiveMap(Object.entries(exports2.OPTIONS).filter(([, descriptor]) => descriptor.default != null).map(([k, d]) => [k, d.default])); + } +}); + +// node_modules/mongodb/lib/operations/list_collections.js +var require_list_collections = __commonJS({ + "node_modules/mongodb/lib/operations/list_collections.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListCollectionsOperation = void 0; + var responses_1 = require_responses(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var ListCollectionsOperation = class extends command_1.CommandOperation { + constructor(db, filter, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + this.options = { ...options }; + delete this.options.writeConcern; + this.db = db; + this.filter = filter; + this.nameOnly = !!this.options.nameOnly; + this.authorizedCollections = !!this.options.authorizedCollections; + if (typeof this.options.batchSize === "number") { + this.batchSize = this.options.batchSize; + } + this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse; + } + get commandName() { + return "listCollections"; + } + buildCommandDocument(connection) { + const command = { + listCollections: 1, + filter: this.filter, + cursor: this.batchSize ? { batchSize: this.batchSize } : {}, + nameOnly: this.nameOnly, + authorizedCollections: this.authorizedCollections + }; + if ((0, utils_1.maxWireVersion)(connection) >= 9 && this.options.comment !== void 0) { + command.comment = this.options.comment; + } + return command; + } + handleOk(response) { + return response; + } + }; + exports2.ListCollectionsOperation = ListCollectionsOperation; + (0, operation_1.defineAspects)(ListCollectionsOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/cursor/list_collections_cursor.js +var require_list_collections_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/list_collections_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListCollectionsCursor = void 0; + var execute_operation_1 = require_execute_operation(); + var list_collections_1 = require_list_collections(); + var abstract_cursor_1 = require_abstract_cursor(); + var ListCollectionsCursor = class _ListCollectionsCursor extends abstract_cursor_1.AbstractCursor { + constructor(db, filter, options) { + super(db.client, db.s.namespace, { ...options }); + this.parent = db; + this.filter = filter; + this.options = options; + } + clone() { + return new _ListCollectionsCursor(this.parent, this.filter, { + ...this.options, + ...this.cursorOptions + }); + } + /** @internal */ + async _initialize(session) { + const operation = new list_collections_1.ListCollectionsOperation(this.parent, this.filter, { + ...this.cursorOptions, + ...this.options, + session, + signal: this.signal + }); + const response = await (0, execute_operation_1.executeOperation)(this.parent.client, operation, this.timeoutContext); + return { server: operation.server, session, response }; + } + }; + exports2.ListCollectionsCursor = ListCollectionsCursor; + } +}); + +// node_modules/mongodb/lib/cursor/run_command_cursor.js +var require_run_command_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/run_command_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.RunCommandCursor = void 0; + var error_1 = require_error(); + var execute_operation_1 = require_execute_operation(); + var get_more_1 = require_get_more(); + var run_command_1 = require_run_command(); + var utils_1 = require_utils3(); + var abstract_cursor_1 = require_abstract_cursor(); + var RunCommandCursor = class extends abstract_cursor_1.AbstractCursor { + /** + * Controls the `getMore.comment` field + * @param comment - any BSON value + */ + setComment(comment) { + this.getMoreOptions.comment = comment; + return this; + } + /** + * Controls the `getMore.maxTimeMS` field. Only valid when cursor is tailable await + * @param maxTimeMS - the number of milliseconds to wait for new data + */ + setMaxTimeMS(maxTimeMS) { + this.getMoreOptions.maxAwaitTimeMS = maxTimeMS; + return this; + } + /** + * Controls the `getMore.batchSize` field + * @param batchSize - the number documents to return in the `nextBatch` + */ + setBatchSize(batchSize) { + this.getMoreOptions.batchSize = batchSize; + return this; + } + /** Unsupported for RunCommandCursor */ + clone() { + throw new error_1.MongoAPIError("Clone not supported, create a new cursor with db.runCursorCommand"); + } + /** Unsupported for RunCommandCursor: readConcern must be configured directly on command document */ + withReadConcern(_) { + throw new error_1.MongoAPIError("RunCommandCursor does not support readConcern it must be attached to the command being run"); + } + /** Unsupported for RunCommandCursor: various cursor flags must be configured directly on command document */ + addCursorFlag(_, __) { + throw new error_1.MongoAPIError("RunCommandCursor does not support cursor flags, they must be attached to the command being run"); + } + /** + * Unsupported for RunCommandCursor: maxTimeMS must be configured directly on command document + */ + maxTimeMS(_) { + throw new error_1.MongoAPIError("maxTimeMS must be configured on the command document directly, to configure getMore.maxTimeMS use cursor.setMaxTimeMS()"); + } + /** Unsupported for RunCommandCursor: batchSize must be configured directly on command document */ + batchSize(_) { + throw new error_1.MongoAPIError("batchSize must be configured on the command document directly, to configure getMore.batchSize use cursor.setBatchSize()"); + } + /** @internal */ + constructor(db, command, options = {}) { + super(db.client, (0, utils_1.ns)(db.namespace), options); + this.getMoreOptions = {}; + this.db = db; + this.command = Object.freeze({ ...command }); + } + /** @internal */ + async _initialize(session) { + const operation = new run_command_1.RunCursorCommandOperation(this.db.s.namespace, this.command, { + ...this.cursorOptions, + session, + readPreference: this.cursorOptions.readPreference + }); + const response = await (0, execute_operation_1.executeOperation)(this.client, operation, this.timeoutContext); + return { + server: operation.server, + session, + response + }; + } + /** @internal */ + async getMore(_batchSize) { + if (!this.session) { + throw new error_1.MongoRuntimeError("Unexpected null session. A cursor creating command should have set this"); + } + const getMoreOperation = new get_more_1.GetMoreOperation(this.namespace, this.id, this.server, { + ...this.cursorOptions, + session: this.session, + ...this.getMoreOptions + }); + return await (0, execute_operation_1.executeOperation)(this.client, getMoreOperation, this.timeoutContext); + } + }; + exports2.RunCommandCursor = RunCommandCursor; + } +}); + +// node_modules/mongodb/lib/operations/indexes.js +var require_indexes = __commonJS({ + "node_modules/mongodb/lib/operations/indexes.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListIndexesOperation = exports2.DropIndexOperation = exports2.CreateIndexesOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var VALID_INDEX_OPTIONS = /* @__PURE__ */ new Set([ + "background", + "unique", + "name", + "partialFilterExpression", + "sparse", + "hidden", + "expireAfterSeconds", + "storageEngine", + "collation", + "version", + // text indexes + "weights", + "default_language", + "language_override", + "textIndexVersion", + // 2d-sphere indexes + "2dsphereIndexVersion", + // 2d indexes + "bits", + "min", + "max", + // geoHaystack Indexes + "bucketSize", + // wildcard indexes + "wildcardProjection" + ]); + function isIndexDirection(x) { + return typeof x === "number" || x === "2d" || x === "2dsphere" || x === "text" || x === "geoHaystack"; + } + function isSingleIndexTuple(t) { + return Array.isArray(t) && t.length === 2 && isIndexDirection(t[1]); + } + function constructIndexDescriptionMap(indexSpec) { + const key = /* @__PURE__ */ new Map(); + const indexSpecs = !Array.isArray(indexSpec) || isSingleIndexTuple(indexSpec) ? [indexSpec] : indexSpec; + for (const spec of indexSpecs) { + if (typeof spec === "string") { + key.set(spec, 1); + } else if (Array.isArray(spec)) { + key.set(spec[0], spec[1] ?? 1); + } else if (spec instanceof Map) { + for (const [property, value] of spec) { + key.set(property, value); + } + } else if ((0, utils_1.isObject)(spec)) { + for (const [property, value] of Object.entries(spec)) { + key.set(property, value); + } + } + } + return key; + } + function resolveIndexDescription(description) { + const validProvidedOptions = Object.entries(description).filter(([optionName]) => VALID_INDEX_OPTIONS.has(optionName)); + return Object.fromEntries( + // we support the `version` option, but the `createIndexes` command expects it to be the `v` + validProvidedOptions.map(([name, value]) => name === "version" ? ["v", value] : [name, value]) + ); + } + var CreateIndexesOperation = class _CreateIndexesOperation extends command_1.CommandOperation { + constructor(parent, collectionName, indexes, options) { + super(parent, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options ?? {}; + this.options.collation = void 0; + this.collectionName = collectionName; + this.indexes = indexes.map((userIndex) => { + const key = userIndex.key instanceof Map ? userIndex.key : new Map(Object.entries(userIndex.key)); + const name = userIndex.name ?? Array.from(key).flat().join("_"); + const validIndexOptions = resolveIndexDescription(userIndex); + return { + ...validIndexOptions, + name, + key + }; + }); + this.ns = parent.s.namespace; + } + static fromIndexDescriptionArray(parent, collectionName, indexes, options) { + return new _CreateIndexesOperation(parent, collectionName, indexes, options); + } + static fromIndexSpecification(parent, collectionName, indexSpec, options = {}) { + const key = constructIndexDescriptionMap(indexSpec); + const description = { ...options, key }; + return new _CreateIndexesOperation(parent, collectionName, [description], options); + } + get commandName() { + return "createIndexes"; + } + buildCommandDocument(connection) { + const options = this.options; + const indexes = this.indexes; + const serverWireVersion = (0, utils_1.maxWireVersion)(connection); + const cmd = { createIndexes: this.collectionName, indexes }; + if (options.commitQuorum != null) { + if (serverWireVersion < 9) { + throw new error_1.MongoCompatibilityError("Option `commitQuorum` for `createIndexes` not supported on servers < 4.4"); + } + cmd.commitQuorum = options.commitQuorum; + } + return cmd; + } + handleOk(_response) { + const indexNames = this.indexes.map((index) => index.name || ""); + return indexNames; + } + }; + exports2.CreateIndexesOperation = CreateIndexesOperation; + var DropIndexOperation = class extends command_1.CommandOperation { + constructor(collection, indexName, options) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options ?? {}; + this.collection = collection; + this.indexName = indexName; + this.ns = collection.fullNamespace; + } + get commandName() { + return "dropIndexes"; + } + buildCommandDocument(_connection) { + return { dropIndexes: this.collection.collectionName, index: this.indexName }; + } + }; + exports2.DropIndexOperation = DropIndexOperation; + var ListIndexesOperation = class extends command_1.CommandOperation { + constructor(collection, options) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + this.options = { ...options }; + delete this.options.writeConcern; + this.collectionNamespace = collection.s.namespace; + } + get commandName() { + return "listIndexes"; + } + buildCommandDocument(connection) { + const serverWireVersion = (0, utils_1.maxWireVersion)(connection); + const cursor = this.options.batchSize ? { batchSize: this.options.batchSize } : {}; + const command = { listIndexes: this.collectionNamespace.collection, cursor }; + if (serverWireVersion >= 9 && this.options.comment !== void 0) { + command.comment = this.options.comment; + } + return command; + } + handleOk(response) { + return response; + } + }; + exports2.ListIndexesOperation = ListIndexesOperation; + (0, operation_1.defineAspects)(ListIndexesOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + (0, operation_1.defineAspects)(CreateIndexesOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.SUPPORTS_RAW_DATA]); + (0, operation_1.defineAspects)(DropIndexOperation, [operation_1.Aspect.WRITE_OPERATION, operation_1.Aspect.SUPPORTS_RAW_DATA]); + } +}); + +// node_modules/mongodb/lib/operations/create_collection.js +var require_create_collection = __commonJS({ + "node_modules/mongodb/lib/operations/create_collection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CreateCollectionOperation = void 0; + exports2.createCollections = createCollections; + var constants_1 = require_constants(); + var responses_1 = require_responses(); + var collection_1 = require_collection(); + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var execute_operation_1 = require_execute_operation(); + var indexes_1 = require_indexes(); + var operation_1 = require_operation(); + var ILLEGAL_COMMAND_FIELDS = /* @__PURE__ */ new Set([ + "w", + "wtimeout", + "timeoutMS", + "j", + "fsync", + "autoIndexId", + "pkFactory", + "raw", + "readPreference", + "session", + "readConcern", + "writeConcern", + "raw", + "fieldsAsRaw", + "useBigInt64", + "promoteLongs", + "promoteValues", + "promoteBuffers", + "bsonRegExp", + "serializeFunctions", + "ignoreUndefined", + "enableUtf8Validation" + ]); + var INVALID_QE_VERSION = "Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption."; + var CreateCollectionOperation = class extends command_1.CommandOperation { + constructor(db, name, options = {}) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.db = db; + this.name = name; + } + get commandName() { + return "create"; + } + buildCommandDocument(_connection, _session) { + const isOptionValid = ([k, v]) => v != null && typeof v !== "function" && !ILLEGAL_COMMAND_FIELDS.has(k); + return { + create: this.name, + ...Object.fromEntries(Object.entries(this.options).filter(isOptionValid)) + }; + } + handleOk(_response) { + return new collection_1.Collection(this.db, this.name, this.options); + } + }; + exports2.CreateCollectionOperation = CreateCollectionOperation; + async function createCollections(db, name, options) { + const timeoutContext = timeout_1.TimeoutContext.create({ + session: options.session, + serverSelectionTimeoutMS: db.client.s.options.serverSelectionTimeoutMS, + waitQueueTimeoutMS: db.client.s.options.waitQueueTimeoutMS, + timeoutMS: options.timeoutMS + }); + const encryptedFields = options.encryptedFields ?? db.client.s.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`]; + if (encryptedFields) { + class CreateSupportingFLEv2CollectionOperation extends CreateCollectionOperation { + buildCommandDocument(connection, session) { + if (!connection.description.loadBalanced && (0, utils_1.maxWireVersion)(connection) < constants_1.MIN_SUPPORTED_QE_WIRE_VERSION) { + throw new error_1.MongoCompatibilityError(`${INVALID_QE_VERSION} The minimum server version required is ${constants_1.MIN_SUPPORTED_QE_SERVER_VERSION}`); + } + return super.buildCommandDocument(connection, session); + } + } + const escCollection = encryptedFields.escCollection ?? `enxcol_.${name}.esc`; + const ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`; + for (const collectionName of [escCollection, ecocCollection]) { + const createOp = new CreateSupportingFLEv2CollectionOperation(db, collectionName, { + clusteredIndex: { + key: { _id: 1 }, + unique: true + }, + session: options.session + }); + await (0, execute_operation_1.executeOperation)(db.client, createOp, timeoutContext); + } + if (!options.encryptedFields) { + options = { ...options, encryptedFields }; + } + } + const coll = await (0, execute_operation_1.executeOperation)(db.client, new CreateCollectionOperation(db, name, options), timeoutContext); + if (encryptedFields) { + const createIndexOp = indexes_1.CreateIndexesOperation.fromIndexSpecification(db, name, { __safeContent__: 1 }, { session: options.session }); + await (0, execute_operation_1.executeOperation)(db.client, createIndexOp, timeoutContext); + } + return coll; + } + (0, operation_1.defineAspects)(CreateCollectionOperation, [operation_1.Aspect.WRITE_OPERATION]); + } +}); + +// node_modules/mongodb/lib/operations/drop.js +var require_drop = __commonJS({ + "node_modules/mongodb/lib/operations/drop.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DropDatabaseOperation = exports2.DropCollectionOperation = void 0; + exports2.dropCollections = dropCollections; + var __1 = require_lib9(); + var responses_1 = require_responses(); + var abstract_cursor_1 = require_abstract_cursor(); + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var command_1 = require_command2(); + var execute_operation_1 = require_execute_operation(); + var operation_1 = require_operation(); + var DropCollectionOperation = class extends command_1.CommandOperation { + constructor(db, name, options = {}) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.name = name; + } + get commandName() { + return "drop"; + } + buildCommandDocument(_connection, _session) { + return { drop: this.name }; + } + handleOk(_response) { + return true; + } + }; + exports2.DropCollectionOperation = DropCollectionOperation; + async function dropCollections(db, name, options) { + const timeoutContext = timeout_1.TimeoutContext.create({ + session: options.session, + serverSelectionTimeoutMS: db.client.s.options.serverSelectionTimeoutMS, + waitQueueTimeoutMS: db.client.s.options.waitQueueTimeoutMS, + timeoutMS: options.timeoutMS + }); + const encryptedFieldsMap = db.client.s.options.autoEncryption?.encryptedFieldsMap; + let encryptedFields = options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`]; + if (!encryptedFields && encryptedFieldsMap) { + const listCollectionsResult = await db.listCollections({ name }, { + nameOnly: false, + session: options.session, + timeoutContext: new abstract_cursor_1.CursorTimeoutContext(timeoutContext, /* @__PURE__ */ Symbol()) + }).toArray(); + encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields; + } + if (encryptedFields) { + const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`; + const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`; + for (const collectionName of [escCollection, ecocCollection]) { + const dropOp = new DropCollectionOperation(db, collectionName, options); + try { + await (0, execute_operation_1.executeOperation)(db.client, dropOp, timeoutContext); + } catch (err) { + if (!(err instanceof __1.MongoServerError) || err.code !== error_1.MONGODB_ERROR_CODES.NamespaceNotFound) { + throw err; + } + } + } + } + return await (0, execute_operation_1.executeOperation)(db.client, new DropCollectionOperation(db, name, options), timeoutContext); + } + var DropDatabaseOperation = class extends command_1.CommandOperation { + constructor(db, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + } + get commandName() { + return "dropDatabase"; + } + buildCommandDocument(_connection, _session) { + return { dropDatabase: 1 }; + } + handleOk(_response) { + return true; + } + }; + exports2.DropDatabaseOperation = DropDatabaseOperation; + (0, operation_1.defineAspects)(DropCollectionOperation, [operation_1.Aspect.WRITE_OPERATION]); + (0, operation_1.defineAspects)(DropDatabaseOperation, [operation_1.Aspect.WRITE_OPERATION]); + } +}); + +// node_modules/mongodb/lib/operations/profiling_level.js +var require_profiling_level = __commonJS({ + "node_modules/mongodb/lib/operations/profiling_level.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ProfilingLevelOperation = void 0; + var bson_1 = require_bson2(); + var responses_1 = require_responses(); + var error_1 = require_error(); + var command_1 = require_command2(); + var ProfilingLevelResponse = class extends responses_1.MongoDBResponse { + get was() { + return this.get("was", bson_1.BSONType.int, true); + } + }; + var ProfilingLevelOperation = class extends command_1.CommandOperation { + constructor(db, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = ProfilingLevelResponse; + this.options = options; + } + get commandName() { + return "profile"; + } + buildCommandDocument(_connection) { + return { profile: -1 }; + } + handleOk(response) { + if (response.ok === 1) { + const was = response.was; + if (was === 0) + return "off"; + if (was === 1) + return "slow_only"; + if (was === 2) + return "all"; + throw new error_1.MongoUnexpectedServerResponseError(`Illegal profiling level value ${was}`); + } else { + throw new error_1.MongoUnexpectedServerResponseError("Error with profile command"); + } + } + }; + exports2.ProfilingLevelOperation = ProfilingLevelOperation; + } +}); + +// node_modules/mongodb/lib/operations/rename.js +var require_rename = __commonJS({ + "node_modules/mongodb/lib/operations/rename.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.RenameOperation = void 0; + var responses_1 = require_responses(); + var collection_1 = require_collection(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var RenameOperation = class extends command_1.CommandOperation { + constructor(collection, newName, options) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.collection = collection; + this.newName = newName; + this.options = options; + this.ns = new utils_1.MongoDBNamespace("admin", "$cmd"); + } + get commandName() { + return "renameCollection"; + } + buildCommandDocument(_connection, _session) { + const renameCollection = this.collection.namespace; + const to = this.collection.s.namespace.withCollection(this.newName).toString(); + const dropTarget = typeof this.options.dropTarget === "boolean" ? this.options.dropTarget : false; + return { + renameCollection, + to, + dropTarget + }; + } + handleOk(_response) { + return new collection_1.Collection(this.collection.db, this.newName, this.collection.s.options); + } + }; + exports2.RenameOperation = RenameOperation; + (0, operation_1.defineAspects)(RenameOperation, [operation_1.Aspect.WRITE_OPERATION]); + } +}); + +// node_modules/mongodb/lib/operations/set_profiling_level.js +var require_set_profiling_level = __commonJS({ + "node_modules/mongodb/lib/operations/set_profiling_level.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SetProfilingLevelOperation = exports2.ProfilingLevel = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var levelValues = /* @__PURE__ */ new Set(["off", "slow_only", "all"]); + exports2.ProfilingLevel = Object.freeze({ + off: "off", + slowOnly: "slow_only", + all: "all" + }); + var SetProfilingLevelOperation = class extends command_1.CommandOperation { + constructor(db, level, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + switch (level) { + case exports2.ProfilingLevel.off: + this.profile = 0; + break; + case exports2.ProfilingLevel.slowOnly: + this.profile = 1; + break; + case exports2.ProfilingLevel.all: + this.profile = 2; + break; + default: + this.profile = 0; + break; + } + this.level = level; + } + get commandName() { + return "profile"; + } + buildCommandDocument(_connection) { + const level = this.level; + if (!levelValues.has(level)) { + throw new error_1.MongoInvalidArgumentError(`Profiling level must be one of "${(0, utils_1.enumToString)(exports2.ProfilingLevel)}"`); + } + return { profile: this.profile }; + } + handleOk(_response) { + return this.level; + } + }; + exports2.SetProfilingLevelOperation = SetProfilingLevelOperation; + } +}); + +// node_modules/mongodb/lib/operations/stats.js +var require_stats = __commonJS({ + "node_modules/mongodb/lib/operations/stats.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DbStatsOperation = void 0; + var responses_1 = require_responses(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var DbStatsOperation = class extends command_1.CommandOperation { + constructor(db, options) { + super(db, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + } + get commandName() { + return "dbStats"; + } + buildCommandDocument(_connection) { + const command = { dbStats: true }; + if (this.options.scale != null) { + command.scale = this.options.scale; + } + return command; + } + }; + exports2.DbStatsOperation = DbStatsOperation; + (0, operation_1.defineAspects)(DbStatsOperation, [operation_1.Aspect.READ_OPERATION]); + } +}); + +// node_modules/mongodb/lib/db.js +var require_db = __commonJS({ + "node_modules/mongodb/lib/db.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Db = void 0; + var admin_1 = require_admin(); + var bson_1 = require_bson2(); + var change_stream_1 = require_change_stream(); + var collection_1 = require_collection(); + var CONSTANTS = require_constants2(); + var aggregation_cursor_1 = require_aggregation_cursor(); + var list_collections_cursor_1 = require_list_collections_cursor(); + var run_command_cursor_1 = require_run_command_cursor(); + var error_1 = require_error(); + var create_collection_1 = require_create_collection(); + var drop_1 = require_drop(); + var execute_operation_1 = require_execute_operation(); + var indexes_1 = require_indexes(); + var profiling_level_1 = require_profiling_level(); + var remove_user_1 = require_remove_user(); + var rename_1 = require_rename(); + var run_command_1 = require_run_command(); + var set_profiling_level_1 = require_set_profiling_level(); + var stats_1 = require_stats(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var DB_OPTIONS_ALLOW_LIST = [ + "writeConcern", + "readPreference", + "readPreferenceTags", + "native_parser", + "forceServerObjectId", + "pkFactory", + "serializeFunctions", + "raw", + "authSource", + "ignoreUndefined", + "readConcern", + "retryMiliSeconds", + "numberOfRetries", + "useBigInt64", + "promoteBuffers", + "promoteLongs", + "bsonRegExp", + "enableUtf8Validation", + "promoteValues", + "compression", + "retryWrites" + ]; + var Db = class { + /** + * Creates a new Db instance. + * + * Db name cannot contain a dot, the server may apply more restrictions when an operation is run. + * + * @param client - The MongoClient for the database. + * @param databaseName - The name of the database this instance represents. + * @param options - Optional settings for Db construction. + */ + constructor(client, databaseName, options) { + options = options ?? {}; + options = (0, utils_1.filterOptions)(options, DB_OPTIONS_ALLOW_LIST); + if (typeof databaseName === "string" && databaseName.includes(".")) { + throw new error_1.MongoInvalidArgumentError(`Database names cannot contain the character '.'`); + } + this.s = { + // Options + options, + // Unpack read preference + readPreference: read_preference_1.ReadPreference.fromOptions(options), + // Merge bson options + bsonOptions: (0, bson_1.resolveBSONOptions)(options, client), + // Set up the primary key factory or fallback to ObjectId + pkFactory: options?.pkFactory ?? utils_1.DEFAULT_PK_FACTORY, + // ReadConcern + readConcern: read_concern_1.ReadConcern.fromOptions(options), + writeConcern: write_concern_1.WriteConcern.fromOptions(options), + // Namespace + namespace: new utils_1.MongoDBNamespace(databaseName) + }; + this.client = client; + } + get databaseName() { + return this.s.namespace.db; + } + // Options + get options() { + return this.s.options; + } + /** + * Check if a secondary can be used (because the read preference is *not* set to primary) + */ + get secondaryOk() { + return this.s.readPreference?.preference !== "primary" || false; + } + get readConcern() { + return this.s.readConcern; + } + /** + * The current readPreference of the Db. If not explicitly defined for + * this Db, will be inherited from the parent MongoClient + */ + get readPreference() { + if (this.s.readPreference == null) { + return this.client.readPreference; + } + return this.s.readPreference; + } + get bsonOptions() { + return this.s.bsonOptions; + } + // get the write Concern + get writeConcern() { + return this.s.writeConcern; + } + get namespace() { + return this.s.namespace.toString(); + } + /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */ + get timeoutMS() { + return void 0; + } + /** + * Create a new collection on a server with the specified options. Use this to create capped collections. + * More information about command options available at https://www.mongodb.com/docs/manual/reference/command/create/ + * + * Collection namespace validation is performed server-side. + * + * @param name - The name of the collection to create + * @param options - Optional settings for the command + */ + async createCollection(name, options) { + options = (0, utils_1.resolveOptions)(this, options); + return await (0, create_collection_1.createCollections)(this, name, options); + } + /** + * Execute a command + * + * @remarks + * This command does not inherit options from the MongoClient. + * + * The driver will ensure the following fields are attached to the command sent to the server: + * - `lsid` - sourced from an implicit session or options.session + * - `$readPreference` - defaults to primary or can be configured by options.readPreference + * - `$db` - sourced from the name of this database + * + * If the client has a serverApi setting: + * - `apiVersion` + * - `apiStrict` + * - `apiDeprecationErrors` + * + * When in a transaction: + * - `readConcern` - sourced from readConcern set on the TransactionOptions + * - `writeConcern` - sourced from writeConcern set on the TransactionOptions + * + * Attaching any of the above fields to the command will have no effect as the driver will overwrite the value. + * + * @param command - The command to run + * @param options - Optional settings for the command + */ + async command(command, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new run_command_1.RunCommandOperation(this.s.namespace, command, (0, utils_1.resolveOptions)(void 0, { + ...(0, bson_1.resolveBSONOptions)(options), + timeoutMS: options?.timeoutMS ?? this.timeoutMS, + session: options?.session, + readPreference: options?.readPreference, + signal: options?.signal + }))); + } + /** + * Execute an aggregation framework pipeline against the database. + * + * @param pipeline - An array of aggregation stages to be executed + * @param options - Optional settings for the command + */ + aggregate(pipeline = [], options) { + return new aggregation_cursor_1.AggregationCursor(this.client, this.s.namespace, pipeline, (0, utils_1.resolveOptions)(this, options)); + } + /** Return the Admin db instance */ + admin() { + return new admin_1.Admin(this); + } + /** + * Returns a reference to a MongoDB Collection. If it does not exist it will be created implicitly. + * + * Collection namespace validation is performed server-side. + * + * @param name - the collection name we wish to access. + * @returns return the new Collection instance + */ + collection(name, options = {}) { + if (typeof options === "function") { + throw new error_1.MongoInvalidArgumentError("The callback form of this helper has been removed."); + } + return new collection_1.Collection(this, name, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Get all the db statistics. + * + * @param options - Optional settings for the command + */ + async stats(options) { + return await (0, execute_operation_1.executeOperation)(this.client, new stats_1.DbStatsOperation(this, (0, utils_1.resolveOptions)(this, options))); + } + listCollections(filter = {}, options = {}) { + return new list_collections_cursor_1.ListCollectionsCursor(this, filter, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Rename a collection. + * + * @remarks + * This operation does not inherit options from the MongoClient. + * + * @param fromCollection - Name of current collection to rename + * @param toCollection - New name of of the collection + * @param options - Optional settings for the command + */ + async renameCollection(fromCollection, toCollection, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new rename_1.RenameOperation(this.collection(fromCollection), toCollection, (0, utils_1.resolveOptions)(void 0, { + ...options, + new_collection: true, + readPreference: read_preference_1.ReadPreference.primary + }))); + } + /** + * Drop a collection from the database, removing it permanently. New accesses will create a new collection. + * + * @param name - Name of collection to drop + * @param options - Optional settings for the command + */ + async dropCollection(name, options) { + options = (0, utils_1.resolveOptions)(this, options); + return await (0, drop_1.dropCollections)(this, name, options); + } + /** + * Drop a database, removing it permanently from the server. + * + * @param options - Optional settings for the command + */ + async dropDatabase(options) { + return await (0, execute_operation_1.executeOperation)(this.client, new drop_1.DropDatabaseOperation(this, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Fetch all collections for the current db. + * + * @param options - Optional settings for the command + */ + async collections(options) { + options = (0, utils_1.resolveOptions)(this, options); + const collections = await this.listCollections({}, { ...options, nameOnly: true }).toArray(); + return collections.filter( + // Filter collections removing any illegal ones + ({ name }) => !name.includes("$") + ).map(({ name }) => new collection_1.Collection(this, name, this.s.options)); + } + /** + * Creates an index on the db and collection. + * + * @param name - Name of the collection to create the index on. + * @param indexSpec - Specify the field to index, or an index specification + * @param options - Optional settings for the command + */ + async createIndex(name, indexSpec, options) { + const indexes = await (0, execute_operation_1.executeOperation)(this.client, indexes_1.CreateIndexesOperation.fromIndexSpecification(this, name, indexSpec, options)); + return indexes[0]; + } + /** + * Remove a user from a database + * + * @param username - The username to remove + * @param options - Optional settings for the command + */ + async removeUser(username, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new remove_user_1.RemoveUserOperation(this, username, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Set the current profiling level of MongoDB + * + * @param level - The new profiling level (off, slow_only, all). + * @param options - Optional settings for the command + */ + async setProfilingLevel(level, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new set_profiling_level_1.SetProfilingLevelOperation(this, level, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Retrieve the current profiling Level for MongoDB + * + * @param options - Optional settings for the command + */ + async profilingLevel(options) { + return await (0, execute_operation_1.executeOperation)(this.client, new profiling_level_1.ProfilingLevelOperation(this, (0, utils_1.resolveOptions)(this, options))); + } + async indexInformation(name, options) { + return await this.collection(name).indexInformation((0, utils_1.resolveOptions)(this, options)); + } + /** + * Create a new Change Stream, watching for new changes (insertions, updates, + * replacements, deletions, and invalidations) in this database. Will ignore all + * changes to system collections. + * + * @remarks + * watch() accepts two generic arguments for distinct use cases: + * - The first is to provide the schema that may be defined for all the collections within this database + * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument + * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents. + * @param options - Optional settings for the command + * @typeParam TSchema - Type of the data being detected by the change stream + * @typeParam TChange - Type of the whole change stream document emitted + */ + watch(pipeline = [], options = {}) { + if (!Array.isArray(pipeline)) { + options = pipeline; + pipeline = []; + } + return new change_stream_1.ChangeStream(this, pipeline, (0, utils_1.resolveOptions)(this, options)); + } + /** + * A low level cursor API providing basic driver functionality: + * - ClientSession management + * - ReadPreference for server selection + * - Running getMores automatically when a local batch is exhausted + * + * @param command - The command that will start a cursor on the server. + * @param options - Configurations for running the command, bson options will apply to getMores + */ + runCursorCommand(command, options) { + return new run_command_cursor_1.RunCommandCursor(this, command, { ...options }); + } + }; + exports2.Db = Db; + Db.SYSTEM_NAMESPACE_COLLECTION = CONSTANTS.SYSTEM_NAMESPACE_COLLECTION; + Db.SYSTEM_INDEX_COLLECTION = CONSTANTS.SYSTEM_INDEX_COLLECTION; + Db.SYSTEM_PROFILE_COLLECTION = CONSTANTS.SYSTEM_PROFILE_COLLECTION; + Db.SYSTEM_USER_COLLECTION = CONSTANTS.SYSTEM_USER_COLLECTION; + Db.SYSTEM_COMMAND_COLLECTION = CONSTANTS.SYSTEM_COMMAND_COLLECTION; + Db.SYSTEM_JS_COLLECTION = CONSTANTS.SYSTEM_JS_COLLECTION; + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_aws.js +var require_mongodb_aws = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_aws.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoDBAWS = void 0; + var BSON = require_bson2(); + var deps_1 = require_deps(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + var aws_temporary_credentials_1 = require_aws_temporary_credentials(); + var mongo_credentials_1 = require_mongo_credentials(); + var providers_1 = require_providers(); + var ASCII_N = 110; + var bsonOptions = { + useBigInt64: false, + promoteLongs: true, + promoteValues: true, + promoteBuffers: false, + bsonRegExp: false + }; + var MongoDBAWS = class extends auth_provider_1.AuthProvider { + constructor(credentialProvider) { + super(); + this.credentialProvider = credentialProvider; + this.credentialFetcher = aws_temporary_credentials_1.AWSTemporaryCredentialProvider.isAWSSDKInstalled ? new aws_temporary_credentials_1.AWSSDKCredentialProvider(credentialProvider) : new aws_temporary_credentials_1.LegacyAWSTemporaryCredentialProvider(); + } + async auth(authContext) { + const { connection } = authContext; + if (!authContext.credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + if ("kModuleError" in deps_1.aws4) { + throw deps_1.aws4["kModuleError"]; + } + const { sign } = deps_1.aws4; + if ((0, utils_1.maxWireVersion)(connection) < 9) { + throw new error_1.MongoCompatibilityError("MONGODB-AWS authentication requires MongoDB version 4.4 or later"); + } + if (!authContext.credentials.username) { + authContext.credentials = await makeTempCredentials(authContext.credentials, this.credentialFetcher); + } + const { credentials } = authContext; + const accessKeyId = credentials.username; + const secretAccessKey = credentials.password; + const sessionToken = credentials.mechanismProperties.AWS_SESSION_TOKEN; + const awsCredentials = accessKeyId && secretAccessKey && sessionToken ? { accessKeyId, secretAccessKey, sessionToken } : accessKeyId && secretAccessKey ? { accessKeyId, secretAccessKey } : void 0; + const db = credentials.source; + const nonce = await (0, utils_1.randomBytes)(32); + const saslStart = { + saslStart: 1, + mechanism: "MONGODB-AWS", + payload: BSON.serialize({ r: nonce, p: ASCII_N }, bsonOptions) + }; + const saslStartResponse = await connection.command((0, utils_1.ns)(`${db}.$cmd`), saslStart, void 0); + const serverResponse = BSON.deserialize(saslStartResponse.payload.buffer, bsonOptions); + const host = serverResponse.h; + const serverNonce = serverResponse.s.buffer; + if (serverNonce.length !== 64) { + throw new error_1.MongoRuntimeError(`Invalid server nonce length ${serverNonce.length}, expected 64`); + } + if (!utils_1.ByteUtils.equals(serverNonce.subarray(0, nonce.byteLength), nonce)) { + throw new error_1.MongoRuntimeError("Server nonce does not begin with client nonce"); + } + if (host.length < 1 || host.length > 255 || host.indexOf("..") !== -1) { + throw new error_1.MongoRuntimeError(`Server returned an invalid host: "${host}"`); + } + const body = "Action=GetCallerIdentity&Version=2011-06-15"; + const options = sign({ + method: "POST", + host, + region: deriveRegion(serverResponse.h), + service: "sts", + headers: { + "Content-Type": "application/x-www-form-urlencoded", + "Content-Length": body.length, + "X-MongoDB-Server-Nonce": utils_1.ByteUtils.toBase64(serverNonce), + "X-MongoDB-GS2-CB-Flag": "n" + }, + path: "/", + body + }, awsCredentials); + const payload = { + a: options.headers.Authorization, + d: options.headers["X-Amz-Date"] + }; + if (sessionToken) { + payload.t = sessionToken; + } + const saslContinue = { + saslContinue: 1, + conversationId: saslStartResponse.conversationId, + payload: BSON.serialize(payload, bsonOptions) + }; + await connection.command((0, utils_1.ns)(`${db}.$cmd`), saslContinue, void 0); + } + }; + exports2.MongoDBAWS = MongoDBAWS; + async function makeTempCredentials(credentials, awsCredentialFetcher) { + function makeMongoCredentialsFromAWSTemp(creds) { + if (!creds.AccessKeyId || !creds.SecretAccessKey) { + throw new error_1.MongoMissingCredentialsError("Could not obtain temporary MONGODB-AWS credentials"); + } + return new mongo_credentials_1.MongoCredentials({ + username: creds.AccessKeyId, + password: creds.SecretAccessKey, + source: credentials.source, + mechanism: providers_1.AuthMechanism.MONGODB_AWS, + mechanismProperties: { + AWS_SESSION_TOKEN: creds.Token + } + }); + } + const temporaryCredentials = await awsCredentialFetcher.getCredentials(); + return makeMongoCredentialsFromAWSTemp(temporaryCredentials); + } + function deriveRegion(host) { + const parts = host.split("."); + if (parts.length === 1 || parts[1] === "amazonaws") { + return "us-east-1"; + } + return parts[1]; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/command_builders.js +var require_command_builders = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/command_builders.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.finishCommandDocument = finishCommandDocument; + exports2.startCommandDocument = startCommandDocument; + var bson_1 = require_bson2(); + var providers_1 = require_providers(); + function finishCommandDocument(token, conversationId) { + if (conversationId != null) { + return { + saslContinue: 1, + conversationId, + payload: new bson_1.Binary(bson_1.BSON.serialize({ jwt: token })) + }; + } + return { + saslStart: 1, + mechanism: providers_1.AuthMechanism.MONGODB_OIDC, + payload: new bson_1.Binary(bson_1.BSON.serialize({ jwt: token })) + }; + } + function startCommandDocument(credentials) { + const payload = {}; + if (credentials.username) { + payload.n = credentials.username; + } + return { + saslStart: 1, + autoAuthorize: 1, + mechanism: providers_1.AuthMechanism.MONGODB_OIDC, + payload: new bson_1.Binary(bson_1.BSON.serialize(payload)) + }; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/callback_workflow.js +var require_callback_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/callback_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CallbackWorkflow = exports2.AUTOMATED_TIMEOUT_MS = exports2.HUMAN_TIMEOUT_MS = void 0; + var promises_1 = require("timers/promises"); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var command_builders_1 = require_command_builders(); + exports2.HUMAN_TIMEOUT_MS = 3e5; + exports2.AUTOMATED_TIMEOUT_MS = 6e4; + var RESULT_PROPERTIES = ["accessToken", "expiresInSeconds", "refreshToken"]; + var CALLBACK_RESULT_ERROR = "User provided OIDC callbacks must return a valid object with an accessToken."; + var THROTTLE_MS = 100; + var CallbackWorkflow = class { + /** + * Instantiate the callback workflow. + */ + constructor(cache, callback) { + this.cache = cache; + this.callback = this.withLock(callback); + this.lastExecutionTime = Date.now() - THROTTLE_MS; + } + /** + * Get the document to add for speculative authentication. This also needs + * to add a db field from the credentials source. + */ + async speculativeAuth(connection, credentials) { + if (this.cache.hasAccessToken) { + const accessToken = this.cache.getAccessToken(); + connection.accessToken = accessToken; + const document = (0, command_builders_1.finishCommandDocument)(accessToken); + document.db = credentials.source; + return { speculativeAuthenticate: document }; + } + return {}; + } + /** + * Reauthenticate the callback workflow. For this we invalidated the access token + * in the cache and run the authentication steps again. No initial handshake needs + * to be sent. + */ + async reauthenticate(connection, credentials) { + if (this.cache.hasAccessToken) { + if (connection.accessToken === this.cache.getAccessToken()) { + this.cache.removeAccessToken(); + delete connection.accessToken; + } else { + connection.accessToken = this.cache.getAccessToken(); + } + } + await this.execute(connection, credentials); + } + /** + * Starts the callback authentication process. If there is a speculative + * authentication document from the initial handshake, then we will use that + * value to get the issuer, otherwise we will send the saslStart command. + */ + async startAuthentication(connection, credentials, response) { + let result; + if (response?.speculativeAuthenticate) { + result = response.speculativeAuthenticate; + } else { + result = await connection.command((0, utils_1.ns)(credentials.source), (0, command_builders_1.startCommandDocument)(credentials), void 0); + } + return result; + } + /** + * Finishes the callback authentication process. + */ + async finishAuthentication(connection, credentials, token, conversationId) { + await connection.command((0, utils_1.ns)(credentials.source), (0, command_builders_1.finishCommandDocument)(token, conversationId), void 0); + } + /** + * Executes the callback and validates the output. + */ + async executeAndValidateCallback(params) { + const result = await this.callback(params); + if (isCallbackResultInvalid(result)) { + throw new error_1.MongoMissingCredentialsError(CALLBACK_RESULT_ERROR); + } + return result; + } + /** + * Ensure the callback is only executed one at a time and throttles the calls + * to every 100ms. + */ + withLock(callback) { + let lock = Promise.resolve(); + return async (params) => { + await lock; + lock = lock.catch(() => null).then(async () => { + const difference = Date.now() - this.lastExecutionTime; + if (difference <= THROTTLE_MS) { + await (0, promises_1.setTimeout)(THROTTLE_MS - difference, { signal: params.timeoutContext }); + } + this.lastExecutionTime = Date.now(); + return await callback(params); + }); + return await lock; + }; + } + }; + exports2.CallbackWorkflow = CallbackWorkflow; + function isCallbackResultInvalid(tokenResult) { + if (tokenResult == null || typeof tokenResult !== "object") + return true; + if (!("accessToken" in tokenResult)) + return true; + return !Object.getOwnPropertyNames(tokenResult).every((prop) => RESULT_PROPERTIES.includes(prop)); + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/automated_callback_workflow.js +var require_automated_callback_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/automated_callback_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AutomatedCallbackWorkflow = void 0; + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var mongodb_oidc_1 = require_mongodb_oidc(); + var callback_workflow_1 = require_callback_workflow(); + var AutomatedCallbackWorkflow = class extends callback_workflow_1.CallbackWorkflow { + /** + * Instantiate the human callback workflow. + */ + constructor(cache, callback) { + super(cache, callback); + } + /** + * Execute the OIDC callback workflow. + */ + async execute(connection, credentials) { + if (this.cache.hasAccessToken) { + const token = this.cache.getAccessToken(); + if (!connection.accessToken) { + connection.accessToken = token; + } + try { + return await this.finishAuthentication(connection, credentials, token); + } catch (error) { + if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.AuthenticationFailed) { + this.cache.removeAccessToken(); + return await this.execute(connection, credentials); + } else { + throw error; + } + } + } + const response = await this.fetchAccessToken(credentials); + this.cache.put(response); + connection.accessToken = response.accessToken; + await this.finishAuthentication(connection, credentials, response.accessToken); + } + /** + * Fetches the access token using the callback. + */ + async fetchAccessToken(credentials) { + const controller = new AbortController(); + const params = { + timeoutContext: controller.signal, + version: mongodb_oidc_1.OIDC_VERSION + }; + if (credentials.username) { + params.username = credentials.username; + } + if (credentials.mechanismProperties.TOKEN_RESOURCE) { + params.tokenAudience = credentials.mechanismProperties.TOKEN_RESOURCE; + } + const timeout = timeout_1.Timeout.expires(callback_workflow_1.AUTOMATED_TIMEOUT_MS); + try { + return await Promise.race([this.executeAndValidateCallback(params), timeout]); + } catch (error) { + if (timeout_1.TimeoutError.is(error)) { + controller.abort(); + throw new error_1.MongoOIDCError(`OIDC callback timed out after ${callback_workflow_1.AUTOMATED_TIMEOUT_MS}ms.`); + } + throw error; + } finally { + timeout.clear(); + } + } + }; + exports2.AutomatedCallbackWorkflow = AutomatedCallbackWorkflow; + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/azure_machine_workflow.js +var require_azure_machine_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/azure_machine_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.callback = void 0; + var azure_1 = require_azure(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var AZURE_HEADERS = Object.freeze({ Metadata: "true", Accept: "application/json" }); + var ENDPOINT_RESULT_ERROR = "Azure endpoint did not return a value with only access_token and expires_in properties"; + var TOKEN_RESOURCE_MISSING_ERROR = "TOKEN_RESOURCE must be set in the auth mechanism properties when ENVIRONMENT is azure."; + var callback = async (params) => { + const tokenAudience = params.tokenAudience; + const username = params.username; + if (!tokenAudience) { + throw new error_1.MongoAzureError(TOKEN_RESOURCE_MISSING_ERROR); + } + const response = await getAzureTokenData(tokenAudience, username); + if (!isEndpointResultValid(response)) { + throw new error_1.MongoAzureError(ENDPOINT_RESULT_ERROR); + } + return response; + }; + exports2.callback = callback; + async function getAzureTokenData(tokenAudience, username) { + const url = new URL(azure_1.AZURE_BASE_URL); + (0, azure_1.addAzureParams)(url, tokenAudience, username); + const response = await (0, utils_1.get)(url, { + headers: AZURE_HEADERS + }); + if (response.status !== 200) { + throw new error_1.MongoAzureError(`Status code ${response.status} returned from the Azure endpoint. Response body: ${response.body}`); + } + const result = JSON.parse(response.body); + return { + accessToken: result.access_token, + expiresInSeconds: Number(result.expires_in) + }; + } + function isEndpointResultValid(token) { + if (token == null || typeof token !== "object") + return false; + return "accessToken" in token && typeof token.accessToken === "string" && "expiresInSeconds" in token && typeof token.expiresInSeconds === "number"; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/gcp_machine_workflow.js +var require_gcp_machine_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/gcp_machine_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.callback = void 0; + var error_1 = require_error(); + var utils_1 = require_utils3(); + var GCP_BASE_URL = "http://metadata/computeMetadata/v1/instance/service-accounts/default/identity"; + var GCP_HEADERS = Object.freeze({ "Metadata-Flavor": "Google" }); + var TOKEN_RESOURCE_MISSING_ERROR = "TOKEN_RESOURCE must be set in the auth mechanism properties when ENVIRONMENT is gcp."; + var callback = async (params) => { + const tokenAudience = params.tokenAudience; + if (!tokenAudience) { + throw new error_1.MongoGCPError(TOKEN_RESOURCE_MISSING_ERROR); + } + return await getGcpTokenData(tokenAudience); + }; + exports2.callback = callback; + async function getGcpTokenData(tokenAudience) { + const url = new URL(GCP_BASE_URL); + url.searchParams.append("audience", tokenAudience); + const response = await (0, utils_1.get)(url, { + headers: GCP_HEADERS + }); + if (response.status !== 200) { + throw new error_1.MongoGCPError(`Status code ${response.status} returned from the GCP endpoint. Response body: ${response.body}`); + } + return { accessToken: response.body }; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/k8s_machine_workflow.js +var require_k8s_machine_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/k8s_machine_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.callback = void 0; + var promises_1 = require("fs/promises"); + var FALLBACK_FILENAME = "/var/run/secrets/kubernetes.io/serviceaccount/token"; + var AZURE_FILENAME = "AZURE_FEDERATED_TOKEN_FILE"; + var AWS_FILENAME = "AWS_WEB_IDENTITY_TOKEN_FILE"; + var callback = async () => { + let filename; + if (process.env[AZURE_FILENAME]) { + filename = process.env[AZURE_FILENAME]; + } else if (process.env[AWS_FILENAME]) { + filename = process.env[AWS_FILENAME]; + } else { + filename = FALLBACK_FILENAME; + } + const token = await (0, promises_1.readFile)(filename, "utf8"); + return { accessToken: token }; + }; + exports2.callback = callback; + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/token_cache.js +var require_token_cache = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/token_cache.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.TokenCache = void 0; + var error_1 = require_error(); + var MongoOIDCError = class extends error_1.MongoDriverError { + }; + var TokenCache = class { + get hasAccessToken() { + return !!this.accessToken; + } + get hasRefreshToken() { + return !!this.refreshToken; + } + get hasIdpInfo() { + return !!this.idpInfo; + } + getAccessToken() { + if (!this.accessToken) { + throw new MongoOIDCError("Attempted to get an access token when none exists."); + } + return this.accessToken; + } + getRefreshToken() { + if (!this.refreshToken) { + throw new MongoOIDCError("Attempted to get a refresh token when none exists."); + } + return this.refreshToken; + } + getIdpInfo() { + if (!this.idpInfo) { + throw new MongoOIDCError("Attempted to get IDP information when none exists."); + } + return this.idpInfo; + } + put(response, idpInfo) { + this.accessToken = response.accessToken; + this.refreshToken = response.refreshToken; + this.expiresInSeconds = response.expiresInSeconds; + if (idpInfo) { + this.idpInfo = idpInfo; + } + } + removeAccessToken() { + this.accessToken = void 0; + } + removeRefreshToken() { + this.refreshToken = void 0; + } + }; + exports2.TokenCache = TokenCache; + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/token_machine_workflow.js +var require_token_machine_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/token_machine_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.callback = void 0; + var fs = require("fs"); + var error_1 = require_error(); + var TOKEN_MISSING_ERROR = "OIDC_TOKEN_FILE must be set in the environment."; + var callback = async () => { + const tokenFile = process.env.OIDC_TOKEN_FILE; + if (!tokenFile) { + throw new error_1.MongoAWSError(TOKEN_MISSING_ERROR); + } + const token = await fs.promises.readFile(tokenFile, "utf8"); + return { accessToken: token }; + }; + exports2.callback = callback; + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc.js +var require_mongodb_oidc = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoDBOIDC = exports2.OIDC_WORKFLOWS = exports2.OIDC_VERSION = void 0; + var error_1 = require_error(); + var auth_provider_1 = require_auth_provider(); + var automated_callback_workflow_1 = require_automated_callback_workflow(); + var azure_machine_workflow_1 = require_azure_machine_workflow(); + var gcp_machine_workflow_1 = require_gcp_machine_workflow(); + var k8s_machine_workflow_1 = require_k8s_machine_workflow(); + var token_cache_1 = require_token_cache(); + var token_machine_workflow_1 = require_token_machine_workflow(); + var MISSING_CREDENTIALS_ERROR = "AuthContext must provide credentials."; + exports2.OIDC_VERSION = 1; + exports2.OIDC_WORKFLOWS = /* @__PURE__ */ new Map(); + exports2.OIDC_WORKFLOWS.set("test", () => new automated_callback_workflow_1.AutomatedCallbackWorkflow(new token_cache_1.TokenCache(), token_machine_workflow_1.callback)); + exports2.OIDC_WORKFLOWS.set("azure", () => new automated_callback_workflow_1.AutomatedCallbackWorkflow(new token_cache_1.TokenCache(), azure_machine_workflow_1.callback)); + exports2.OIDC_WORKFLOWS.set("gcp", () => new automated_callback_workflow_1.AutomatedCallbackWorkflow(new token_cache_1.TokenCache(), gcp_machine_workflow_1.callback)); + exports2.OIDC_WORKFLOWS.set("k8s", () => new automated_callback_workflow_1.AutomatedCallbackWorkflow(new token_cache_1.TokenCache(), k8s_machine_workflow_1.callback)); + var MongoDBOIDC = class extends auth_provider_1.AuthProvider { + /** + * Instantiate the auth provider. + */ + constructor(workflow) { + super(); + if (!workflow) { + throw new error_1.MongoInvalidArgumentError("No workflow provided to the OIDC auth provider."); + } + this.workflow = workflow; + } + /** + * Authenticate using OIDC + */ + async auth(authContext) { + const { connection, reauthenticating, response } = authContext; + if (response?.speculativeAuthenticate?.done && !reauthenticating) { + return; + } + const credentials = getCredentials(authContext); + if (reauthenticating) { + await this.workflow.reauthenticate(connection, credentials); + } else { + await this.workflow.execute(connection, credentials, response); + } + } + /** + * Add the speculative auth for the initial handshake. + */ + async prepare(handshakeDoc, authContext) { + const { connection } = authContext; + const credentials = getCredentials(authContext); + const result = await this.workflow.speculativeAuth(connection, credentials); + return { ...handshakeDoc, ...result }; + } + }; + exports2.MongoDBOIDC = MongoDBOIDC; + function getCredentials(authContext) { + const { credentials } = authContext; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError(MISSING_CREDENTIALS_ERROR); + } + return credentials; + } + } +}); + +// node_modules/mongodb/lib/cmap/auth/mongodb_oidc/human_callback_workflow.js +var require_human_callback_workflow = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/mongodb_oidc/human_callback_workflow.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.HumanCallbackWorkflow = void 0; + var bson_1 = require_bson2(); + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var mongodb_oidc_1 = require_mongodb_oidc(); + var callback_workflow_1 = require_callback_workflow(); + var HumanCallbackWorkflow = class extends callback_workflow_1.CallbackWorkflow { + /** + * Instantiate the human callback workflow. + */ + constructor(cache, callback) { + super(cache, callback); + } + /** + * Execute the OIDC human callback workflow. + */ + async execute(connection, credentials) { + if (this.cache.hasAccessToken) { + const token = this.cache.getAccessToken(); + connection.accessToken = token; + try { + return await this.finishAuthentication(connection, credentials, token); + } catch (error) { + if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.AuthenticationFailed) { + this.cache.removeAccessToken(); + delete connection.accessToken; + return await this.execute(connection, credentials); + } else { + throw error; + } + } + } + if (this.cache.hasRefreshToken) { + const refreshToken = this.cache.getRefreshToken(); + const result = await this.fetchAccessToken(this.cache.getIdpInfo(), credentials, refreshToken); + this.cache.put(result); + connection.accessToken = result.accessToken; + try { + return await this.finishAuthentication(connection, credentials, result.accessToken); + } catch (error) { + if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.AuthenticationFailed) { + this.cache.removeRefreshToken(); + delete connection.accessToken; + return await this.execute(connection, credentials); + } else { + throw error; + } + } + } + const startResponse = await this.startAuthentication(connection, credentials); + const conversationId = startResponse.conversationId; + const idpInfo = bson_1.BSON.deserialize(startResponse.payload.buffer); + const callbackResponse = await this.fetchAccessToken(idpInfo, credentials); + this.cache.put(callbackResponse, idpInfo); + connection.accessToken = callbackResponse.accessToken; + return await this.finishAuthentication(connection, credentials, callbackResponse.accessToken, conversationId); + } + /** + * Fetches an access token using the callback. + */ + async fetchAccessToken(idpInfo, credentials, refreshToken) { + const controller = new AbortController(); + const params = { + timeoutContext: controller.signal, + version: mongodb_oidc_1.OIDC_VERSION, + idpInfo + }; + if (credentials.username) { + params.username = credentials.username; + } + if (refreshToken) { + params.refreshToken = refreshToken; + } + const timeout = timeout_1.Timeout.expires(callback_workflow_1.HUMAN_TIMEOUT_MS); + try { + return await Promise.race([this.executeAndValidateCallback(params), timeout]); + } catch (error) { + if (timeout_1.TimeoutError.is(error)) { + controller.abort(); + throw new error_1.MongoOIDCError(`OIDC callback timed out after ${callback_workflow_1.HUMAN_TIMEOUT_MS}ms.`); + } + throw error; + } finally { + timeout.clear(); + } + } + }; + exports2.HumanCallbackWorkflow = HumanCallbackWorkflow; + } +}); + +// node_modules/mongodb/lib/cmap/auth/plain.js +var require_plain = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/plain.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Plain = void 0; + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + var Plain = class extends auth_provider_1.AuthProvider { + async auth(authContext) { + const { connection, credentials } = authContext; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + const { username, password } = credentials; + const payload = new bson_1.Binary(Buffer.from(`\0${username}\0${password}`)); + const command = { + saslStart: 1, + mechanism: "PLAIN", + payload, + autoAuthorize: 1 + }; + await connection.command((0, utils_1.ns)("$external.$cmd"), command, void 0); + } + }; + exports2.Plain = Plain; + } +}); + +// node_modules/@mongodb-js/saslprep/dist/index.js +var require_dist2 = __commonJS({ + "node_modules/@mongodb-js/saslprep/dist/index.js"(exports2, module2) { + "use strict"; + var getCodePoint = (character) => character.codePointAt(0); + var first = (x) => x[0]; + var last = (x) => x[x.length - 1]; + function toCodePoints(input) { + const codepoints = []; + const size = input.length; + for (let i = 0; i < size; i += 1) { + const before = input.charCodeAt(i); + if (before >= 55296 && before <= 56319 && size > i + 1) { + const next = input.charCodeAt(i + 1); + if (next >= 56320 && next <= 57343) { + codepoints.push((before - 55296) * 1024 + next - 56320 + 65536); + i += 1; + continue; + } + } + codepoints.push(before); + } + return codepoints; + } + function saslprep({ unassigned_code_points, commonly_mapped_to_nothing, non_ASCII_space_characters, prohibited_characters, bidirectional_r_al, bidirectional_l }, input, opts = {}) { + const mapping2space = non_ASCII_space_characters; + const mapping2nothing = commonly_mapped_to_nothing; + if (typeof input !== "string") { + throw new TypeError("Expected string."); + } + if (input.length === 0) { + return ""; + } + const mapped_input = toCodePoints(input).map((character) => mapping2space.get(character) ? 32 : character).filter((character) => !mapping2nothing.get(character)); + const normalized_input = String.fromCodePoint.apply(null, mapped_input).normalize("NFKC"); + const normalized_map = toCodePoints(normalized_input); + const hasProhibited = normalized_map.some((character) => prohibited_characters.get(character)); + if (hasProhibited) { + throw new Error("Prohibited character, see https://tools.ietf.org/html/rfc4013#section-2.3"); + } + if (opts.allowUnassigned !== true) { + const hasUnassigned = normalized_map.some((character) => unassigned_code_points.get(character)); + if (hasUnassigned) { + throw new Error("Unassigned code point, see https://tools.ietf.org/html/rfc4013#section-2.5"); + } + } + const hasBidiRAL = normalized_map.some((character) => bidirectional_r_al.get(character)); + const hasBidiL = normalized_map.some((character) => bidirectional_l.get(character)); + if (hasBidiRAL && hasBidiL) { + throw new Error("String must not contain RandALCat and LCat at the same time, see https://tools.ietf.org/html/rfc3454#section-6"); + } + const isFirstBidiRAL = bidirectional_r_al.get(getCodePoint(first(normalized_input))); + const isLastBidiRAL = bidirectional_r_al.get(getCodePoint(last(normalized_input))); + if (hasBidiRAL && !(isFirstBidiRAL && isLastBidiRAL)) { + throw new Error("Bidirectional RandALCat character must be the first and the last character of the string, see https://tools.ietf.org/html/rfc3454#section-6"); + } + return normalized_input; + } + saslprep.saslprep = saslprep; + saslprep.default = saslprep; + module2.exports = saslprep; + } +}); + +// node_modules/memory-pager/index.js +var require_memory_pager = __commonJS({ + "node_modules/memory-pager/index.js"(exports2, module2) { + module2.exports = Pager; + function Pager(pageSize, opts) { + if (!(this instanceof Pager)) return new Pager(pageSize, opts); + this.length = 0; + this.updates = []; + this.path = new Uint16Array(4); + this.pages = new Array(32768); + this.maxPages = this.pages.length; + this.level = 0; + this.pageSize = pageSize || 1024; + this.deduplicate = opts ? opts.deduplicate : null; + this.zeros = this.deduplicate ? alloc(this.deduplicate.length) : null; + } + Pager.prototype.updated = function(page) { + while (this.deduplicate && page.buffer[page.deduplicate] === this.deduplicate[page.deduplicate]) { + page.deduplicate++; + if (page.deduplicate === this.deduplicate.length) { + page.deduplicate = 0; + if (page.buffer.equals && page.buffer.equals(this.deduplicate)) page.buffer = this.deduplicate; + break; + } + } + if (page.updated || !this.updates) return; + page.updated = true; + this.updates.push(page); + }; + Pager.prototype.lastUpdate = function() { + if (!this.updates || !this.updates.length) return null; + var page = this.updates.pop(); + page.updated = false; + return page; + }; + Pager.prototype._array = function(i, noAllocate) { + if (i >= this.maxPages) { + if (noAllocate) return; + grow(this, i); + } + factor(i, this.path); + var arr = this.pages; + for (var j = this.level; j > 0; j--) { + var p = this.path[j]; + var next = arr[p]; + if (!next) { + if (noAllocate) return; + next = arr[p] = new Array(32768); + } + arr = next; + } + return arr; + }; + Pager.prototype.get = function(i, noAllocate) { + var arr = this._array(i, noAllocate); + var first = this.path[0]; + var page = arr && arr[first]; + if (!page && !noAllocate) { + page = arr[first] = new Page(i, alloc(this.pageSize)); + if (i >= this.length) this.length = i + 1; + } + if (page && page.buffer === this.deduplicate && this.deduplicate && !noAllocate) { + page.buffer = copy(page.buffer); + page.deduplicate = 0; + } + return page; + }; + Pager.prototype.set = function(i, buf) { + var arr = this._array(i, false); + var first = this.path[0]; + if (i >= this.length) this.length = i + 1; + if (!buf || this.zeros && buf.equals && buf.equals(this.zeros)) { + arr[first] = void 0; + return; + } + if (this.deduplicate && buf.equals && buf.equals(this.deduplicate)) { + buf = this.deduplicate; + } + var page = arr[first]; + var b = truncate(buf, this.pageSize); + if (page) page.buffer = b; + else arr[first] = new Page(i, b); + }; + Pager.prototype.toBuffer = function() { + var list = new Array(this.length); + var empty = alloc(this.pageSize); + var ptr = 0; + while (ptr < list.length) { + var arr = this._array(ptr, true); + for (var i = 0; i < 32768 && ptr < list.length; i++) { + list[ptr++] = arr && arr[i] ? arr[i].buffer : empty; + } + } + return Buffer.concat(list); + }; + function grow(pager, index) { + while (pager.maxPages < index) { + var old = pager.pages; + pager.pages = new Array(32768); + pager.pages[0] = old; + pager.level++; + pager.maxPages *= 32768; + } + } + function truncate(buf, len) { + if (buf.length === len) return buf; + if (buf.length > len) return buf.slice(0, len); + var cpy = alloc(len); + buf.copy(cpy); + return cpy; + } + function alloc(size) { + if (Buffer.alloc) return Buffer.alloc(size); + var buf = new Buffer(size); + buf.fill(0); + return buf; + } + function copy(buf) { + var cpy = Buffer.allocUnsafe ? Buffer.allocUnsafe(buf.length) : new Buffer(buf.length); + buf.copy(cpy); + return cpy; + } + function Page(i, buf) { + this.offset = i * buf.length; + this.buffer = buf; + this.updated = false; + this.deduplicate = 0; + } + function factor(n, out) { + n = (n - (out[0] = n & 32767)) / 32768; + n = (n - (out[1] = n & 32767)) / 32768; + out[3] = (n - (out[2] = n & 32767)) / 32768 & 32767; + } + } +}); + +// node_modules/sparse-bitfield/index.js +var require_sparse_bitfield = __commonJS({ + "node_modules/sparse-bitfield/index.js"(exports2, module2) { + var pager = require_memory_pager(); + module2.exports = Bitfield; + function Bitfield(opts) { + if (!(this instanceof Bitfield)) return new Bitfield(opts); + if (!opts) opts = {}; + if (Buffer.isBuffer(opts)) opts = { buffer: opts }; + this.pageOffset = opts.pageOffset || 0; + this.pageSize = opts.pageSize || 1024; + this.pages = opts.pages || pager(this.pageSize); + this.byteLength = this.pages.length * this.pageSize; + this.length = 8 * this.byteLength; + if (!powerOfTwo(this.pageSize)) throw new Error("The page size should be a power of two"); + this._trackUpdates = !!opts.trackUpdates; + this._pageMask = this.pageSize - 1; + if (opts.buffer) { + for (var i = 0; i < opts.buffer.length; i += this.pageSize) { + this.pages.set(i / this.pageSize, opts.buffer.slice(i, i + this.pageSize)); + } + this.byteLength = opts.buffer.length; + this.length = 8 * this.byteLength; + } + } + Bitfield.prototype.get = function(i) { + var o = i & 7; + var j = (i - o) / 8; + return !!(this.getByte(j) & 128 >> o); + }; + Bitfield.prototype.getByte = function(i) { + var o = i & this._pageMask; + var j = (i - o) / this.pageSize; + var page = this.pages.get(j, true); + return page ? page.buffer[o + this.pageOffset] : 0; + }; + Bitfield.prototype.set = function(i, v) { + var o = i & 7; + var j = (i - o) / 8; + var b = this.getByte(j); + return this.setByte(j, v ? b | 128 >> o : b & (255 ^ 128 >> o)); + }; + Bitfield.prototype.toBuffer = function() { + var all = alloc(this.pages.length * this.pageSize); + for (var i = 0; i < this.pages.length; i++) { + var next = this.pages.get(i, true); + var allOffset = i * this.pageSize; + if (next) next.buffer.copy(all, allOffset, this.pageOffset, this.pageOffset + this.pageSize); + } + return all; + }; + Bitfield.prototype.setByte = function(i, b) { + var o = i & this._pageMask; + var j = (i - o) / this.pageSize; + var page = this.pages.get(j, false); + o += this.pageOffset; + if (page.buffer[o] === b) return false; + page.buffer[o] = b; + if (i >= this.byteLength) { + this.byteLength = i + 1; + this.length = this.byteLength * 8; + } + if (this._trackUpdates) this.pages.updated(page); + return true; + }; + function alloc(n) { + if (Buffer.alloc) return Buffer.alloc(n); + var b = new Buffer(n); + b.fill(0); + return b; + } + function powerOfTwo(x) { + return !(x & x - 1); + } + } +}); + +// node_modules/@mongodb-js/saslprep/dist/memory-code-points.js +var require_memory_code_points = __commonJS({ + "node_modules/@mongodb-js/saslprep/dist/memory-code-points.js"(exports2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.createMemoryCodePoints = createMemoryCodePoints; + var sparse_bitfield_1 = __importDefault(require_sparse_bitfield()); + function createMemoryCodePoints(data) { + let offset = 0; + function read() { + const size = data.readUInt32BE(offset); + offset += 4; + const codepoints = data.slice(offset, offset + size); + offset += size; + return (0, sparse_bitfield_1.default)({ buffer: codepoints }); + } + const unassigned_code_points = read(); + const commonly_mapped_to_nothing = read(); + const non_ASCII_space_characters = read(); + const prohibited_characters = read(); + const bidirectional_r_al = read(); + const bidirectional_l = read(); + return { + unassigned_code_points, + commonly_mapped_to_nothing, + non_ASCII_space_characters, + prohibited_characters, + bidirectional_r_al, + bidirectional_l + }; + } + } +}); + +// node_modules/@mongodb-js/saslprep/dist/code-points-data.js +var require_code_points_data = __commonJS({ + "node_modules/@mongodb-js/saslprep/dist/code-points-data.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var zlib_1 = require("zlib"); + exports2.default = (0, zlib_1.gunzipSync)(Buffer.from("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", "base64")); + } +}); + +// node_modules/@mongodb-js/saslprep/dist/node.js +var require_node = __commonJS({ + "node_modules/@mongodb-js/saslprep/dist/node.js"(exports2, module2) { + "use strict"; + var __importDefault = exports2 && exports2.__importDefault || function(mod) { + return mod && mod.__esModule ? mod : { "default": mod }; + }; + var index_1 = __importDefault(require_dist2()); + var memory_code_points_1 = require_memory_code_points(); + var code_points_data_1 = __importDefault(require_code_points_data()); + var codePoints = (0, memory_code_points_1.createMemoryCodePoints)(code_points_data_1.default); + function saslprep(input, opts) { + return (0, index_1.default)(codePoints, input, opts); + } + saslprep.saslprep = saslprep; + saslprep.default = saslprep; + module2.exports = saslprep; + } +}); + +// node_modules/mongodb/lib/cmap/auth/scram.js +var require_scram = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/scram.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ScramSHA256 = exports2.ScramSHA1 = void 0; + var saslprep_1 = require_node(); + var crypto = require("crypto"); + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + var providers_1 = require_providers(); + var ScramSHA = class extends auth_provider_1.AuthProvider { + constructor(cryptoMethod) { + super(); + this.cryptoMethod = cryptoMethod || "sha1"; + } + async prepare(handshakeDoc, authContext) { + const cryptoMethod = this.cryptoMethod; + const credentials = authContext.credentials; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + const nonce = await (0, utils_1.randomBytes)(24); + authContext.nonce = nonce; + const request = { + ...handshakeDoc, + speculativeAuthenticate: { + ...makeFirstMessage(cryptoMethod, credentials, nonce), + db: credentials.source + } + }; + return request; + } + async auth(authContext) { + const { reauthenticating, response } = authContext; + if (response?.speculativeAuthenticate && !reauthenticating) { + return await continueScramConversation(this.cryptoMethod, response.speculativeAuthenticate, authContext); + } + return await executeScram(this.cryptoMethod, authContext); + } + }; + function cleanUsername(username) { + return username.replace("=", "=3D").replace(",", "=2C"); + } + function clientFirstMessageBare(username, nonce) { + return Buffer.concat([ + Buffer.from("n=", "utf8"), + Buffer.from(username, "utf8"), + Buffer.from(",r=", "utf8"), + Buffer.from(nonce.toString("base64"), "utf8") + ]); + } + function makeFirstMessage(cryptoMethod, credentials, nonce) { + const username = cleanUsername(credentials.username); + const mechanism = cryptoMethod === "sha1" ? providers_1.AuthMechanism.MONGODB_SCRAM_SHA1 : providers_1.AuthMechanism.MONGODB_SCRAM_SHA256; + return { + saslStart: 1, + mechanism, + payload: new bson_1.Binary(Buffer.concat([Buffer.from("n,,", "utf8"), clientFirstMessageBare(username, nonce)])), + autoAuthorize: 1, + options: { skipEmptyExchange: true } + }; + } + async function executeScram(cryptoMethod, authContext) { + const { connection, credentials } = authContext; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + if (!authContext.nonce) { + throw new error_1.MongoInvalidArgumentError("AuthContext must contain a valid nonce property"); + } + const nonce = authContext.nonce; + const db = credentials.source; + const saslStartCmd = makeFirstMessage(cryptoMethod, credentials, nonce); + const response = await connection.command((0, utils_1.ns)(`${db}.$cmd`), saslStartCmd, void 0); + await continueScramConversation(cryptoMethod, response, authContext); + } + async function continueScramConversation(cryptoMethod, response, authContext) { + const connection = authContext.connection; + const credentials = authContext.credentials; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + if (!authContext.nonce) { + throw new error_1.MongoInvalidArgumentError("Unable to continue SCRAM without valid nonce"); + } + const nonce = authContext.nonce; + const db = credentials.source; + const username = cleanUsername(credentials.username); + const password = credentials.password; + const processedPassword = cryptoMethod === "sha256" ? (0, saslprep_1.saslprep)(password) : passwordDigest(username, password); + const payload = Buffer.isBuffer(response.payload) ? new bson_1.Binary(response.payload) : response.payload; + const dict = parsePayload(payload); + const iterations = parseInt(dict.i, 10); + if (iterations && iterations < 4096) { + throw new error_1.MongoRuntimeError(`Server returned an invalid iteration count ${iterations}`); + } + const salt = dict.s; + const rnonce = dict.r; + if (rnonce.startsWith("nonce")) { + throw new error_1.MongoRuntimeError(`Server returned an invalid nonce: ${rnonce}`); + } + const withoutProof = `c=biws,r=${rnonce}`; + const saltedPassword = HI(processedPassword, Buffer.from(salt, "base64"), iterations, cryptoMethod); + const clientKey = HMAC(cryptoMethod, saltedPassword, "Client Key"); + const serverKey = HMAC(cryptoMethod, saltedPassword, "Server Key"); + const storedKey = H(cryptoMethod, clientKey); + const authMessage = [ + clientFirstMessageBare(username, nonce), + payload.toString("utf8"), + withoutProof + ].join(","); + const clientSignature = HMAC(cryptoMethod, storedKey, authMessage); + const clientProof = `p=${xor(clientKey, clientSignature)}`; + const clientFinal = [withoutProof, clientProof].join(","); + const serverSignature = HMAC(cryptoMethod, serverKey, authMessage); + const saslContinueCmd = { + saslContinue: 1, + conversationId: response.conversationId, + payload: new bson_1.Binary(Buffer.from(clientFinal)) + }; + const r = await connection.command((0, utils_1.ns)(`${db}.$cmd`), saslContinueCmd, void 0); + const parsedResponse = parsePayload(r.payload); + if (!compareDigest(Buffer.from(parsedResponse.v, "base64"), serverSignature)) { + throw new error_1.MongoRuntimeError("Server returned an invalid signature"); + } + if (r.done !== false) { + return; + } + const retrySaslContinueCmd = { + saslContinue: 1, + conversationId: r.conversationId, + payload: Buffer.alloc(0) + }; + await connection.command((0, utils_1.ns)(`${db}.$cmd`), retrySaslContinueCmd, void 0); + } + function parsePayload(payload) { + const payloadStr = payload.toString("utf8"); + const dict = {}; + const parts = payloadStr.split(","); + for (let i = 0; i < parts.length; i++) { + const valueParts = (parts[i].match(/^([^=]*)=(.*)$/) ?? []).slice(1); + dict[valueParts[0]] = valueParts[1]; + } + return dict; + } + function passwordDigest(username, password) { + if (typeof username !== "string") { + throw new error_1.MongoInvalidArgumentError("Username must be a string"); + } + if (typeof password !== "string") { + throw new error_1.MongoInvalidArgumentError("Password must be a string"); + } + if (password.length === 0) { + throw new error_1.MongoInvalidArgumentError("Password cannot be empty"); + } + let md5; + try { + md5 = crypto.createHash("md5"); + } catch (err) { + if (crypto.getFips()) { + throw new Error("Auth mechanism SCRAM-SHA-1 is not supported in FIPS mode"); + } + throw err; + } + md5.update(`${username}:mongo:${password}`, "utf8"); + return md5.digest("hex"); + } + function xor(a, b) { + if (!Buffer.isBuffer(a)) { + a = Buffer.from(a); + } + if (!Buffer.isBuffer(b)) { + b = Buffer.from(b); + } + const length = Math.max(a.length, b.length); + const res = []; + for (let i = 0; i < length; i += 1) { + res.push(a[i] ^ b[i]); + } + return Buffer.from(res).toString("base64"); + } + function H(method, text) { + return crypto.createHash(method).update(text).digest(); + } + function HMAC(method, key, text) { + return crypto.createHmac(method, key).update(text).digest(); + } + var _hiCache = {}; + var _hiCacheCount = 0; + function _hiCachePurge() { + _hiCache = {}; + _hiCacheCount = 0; + } + var hiLengthMap = { + sha256: 32, + sha1: 20 + }; + function HI(data, salt, iterations, cryptoMethod) { + const key = [data, salt.toString("base64"), iterations].join("_"); + if (_hiCache[key] != null) { + return _hiCache[key]; + } + const saltedData = crypto.pbkdf2Sync(data, salt, iterations, hiLengthMap[cryptoMethod], cryptoMethod); + if (_hiCacheCount >= 200) { + _hiCachePurge(); + } + _hiCache[key] = saltedData; + _hiCacheCount += 1; + return saltedData; + } + function compareDigest(lhs, rhs) { + if (lhs.length !== rhs.length) { + return false; + } + if (typeof crypto.timingSafeEqual === "function") { + return crypto.timingSafeEqual(lhs, rhs); + } + let result = 0; + for (let i = 0; i < lhs.length; i++) { + result |= lhs[i] ^ rhs[i]; + } + return result === 0; + } + var ScramSHA1 = class extends ScramSHA { + constructor() { + super("sha1"); + } + }; + exports2.ScramSHA1 = ScramSHA1; + var ScramSHA256 = class extends ScramSHA { + constructor() { + super("sha256"); + } + }; + exports2.ScramSHA256 = ScramSHA256; + } +}); + +// node_modules/mongodb/lib/cmap/auth/x509.js +var require_x509 = __commonJS({ + "node_modules/mongodb/lib/cmap/auth/x509.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.X509 = void 0; + var error_1 = require_error(); + var utils_1 = require_utils3(); + var auth_provider_1 = require_auth_provider(); + var X509 = class extends auth_provider_1.AuthProvider { + async prepare(handshakeDoc, authContext) { + const { credentials } = authContext; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + return { ...handshakeDoc, speculativeAuthenticate: x509AuthenticateCommand(credentials) }; + } + async auth(authContext) { + const connection = authContext.connection; + const credentials = authContext.credentials; + if (!credentials) { + throw new error_1.MongoMissingCredentialsError("AuthContext must provide credentials."); + } + const response = authContext.response; + if (response?.speculativeAuthenticate) { + return; + } + await connection.command((0, utils_1.ns)("$external.$cmd"), x509AuthenticateCommand(credentials), void 0); + } + }; + exports2.X509 = X509; + function x509AuthenticateCommand(credentials) { + const command = { authenticate: 1, mechanism: "MONGODB-X509" }; + if (credentials.username) { + command.user = credentials.username; + } + return command; + } + } +}); + +// node_modules/mongodb/lib/mongo_client_auth_providers.js +var require_mongo_client_auth_providers = __commonJS({ + "node_modules/mongodb/lib/mongo_client_auth_providers.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoClientAuthProviders = void 0; + var gssapi_1 = require_gssapi(); + var mongodb_aws_1 = require_mongodb_aws(); + var mongodb_oidc_1 = require_mongodb_oidc(); + var automated_callback_workflow_1 = require_automated_callback_workflow(); + var human_callback_workflow_1 = require_human_callback_workflow(); + var token_cache_1 = require_token_cache(); + var plain_1 = require_plain(); + var providers_1 = require_providers(); + var scram_1 = require_scram(); + var x509_1 = require_x509(); + var error_1 = require_error(); + var AUTH_PROVIDERS = /* @__PURE__ */ new Map([ + [ + providers_1.AuthMechanism.MONGODB_AWS, + ({ AWS_CREDENTIAL_PROVIDER }) => new mongodb_aws_1.MongoDBAWS(AWS_CREDENTIAL_PROVIDER) + ], + [ + providers_1.AuthMechanism.MONGODB_CR, + () => { + throw new error_1.MongoInvalidArgumentError("MONGODB-CR is no longer a supported auth mechanism in MongoDB 4.0+"); + } + ], + [providers_1.AuthMechanism.MONGODB_GSSAPI, () => new gssapi_1.GSSAPI()], + [providers_1.AuthMechanism.MONGODB_OIDC, (properties) => new mongodb_oidc_1.MongoDBOIDC(getWorkflow(properties))], + [providers_1.AuthMechanism.MONGODB_PLAIN, () => new plain_1.Plain()], + [providers_1.AuthMechanism.MONGODB_SCRAM_SHA1, () => new scram_1.ScramSHA1()], + [providers_1.AuthMechanism.MONGODB_SCRAM_SHA256, () => new scram_1.ScramSHA256()], + [providers_1.AuthMechanism.MONGODB_X509, () => new x509_1.X509()] + ]); + var MongoClientAuthProviders = class { + constructor() { + this.existingProviders = /* @__PURE__ */ new Map(); + } + /** + * Get or create an authentication provider based on the provided mechanism. + * We don't want to create all providers at once, as some providers may not be used. + * @param name - The name of the provider to get or create. + * @param credentials - The credentials. + * @returns The provider. + * @throws MongoInvalidArgumentError if the mechanism is not supported. + * @internal + */ + getOrCreateProvider(name, authMechanismProperties) { + const authProvider = this.existingProviders.get(name); + if (authProvider) { + return authProvider; + } + const providerFunction = AUTH_PROVIDERS.get(name); + if (!providerFunction) { + throw new error_1.MongoInvalidArgumentError(`authMechanism ${name} not supported`); + } + const provider = providerFunction(authMechanismProperties); + this.existingProviders.set(name, provider); + return provider; + } + }; + exports2.MongoClientAuthProviders = MongoClientAuthProviders; + function getWorkflow(authMechanismProperties) { + if (authMechanismProperties.OIDC_HUMAN_CALLBACK) { + return new human_callback_workflow_1.HumanCallbackWorkflow(new token_cache_1.TokenCache(), authMechanismProperties.OIDC_HUMAN_CALLBACK); + } else if (authMechanismProperties.OIDC_CALLBACK) { + return new automated_callback_workflow_1.AutomatedCallbackWorkflow(new token_cache_1.TokenCache(), authMechanismProperties.OIDC_CALLBACK); + } else { + const environment = authMechanismProperties.ENVIRONMENT; + const workflow = mongodb_oidc_1.OIDC_WORKFLOWS.get(environment)?.(); + if (!workflow) { + throw new error_1.MongoInvalidArgumentError(`Could not load workflow for environment ${authMechanismProperties.ENVIRONMENT}`); + } + return workflow; + } + } + } +}); + +// node_modules/mongodb/lib/operations/client_bulk_write/client_bulk_write.js +var require_client_bulk_write = __commonJS({ + "node_modules/mongodb/lib/operations/client_bulk_write/client_bulk_write.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientBulkWriteOperation = void 0; + var responses_1 = require_responses(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var ClientBulkWriteOperation = class extends command_1.CommandOperation { + get commandName() { + return "bulkWrite"; + } + constructor(commandBuilder, options) { + super(void 0, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.ClientBulkWriteCursorResponse; + this.commandBuilder = commandBuilder; + this.options = options; + this.ns = new utils_1.MongoDBNamespace("admin", "$cmd"); + } + resetBatch() { + return this.commandBuilder.resetBatch(); + } + get canRetryWrite() { + return this.commandBuilder.isBatchRetryable; + } + handleOk(response) { + return response; + } + buildCommandDocument(connection, _session) { + const command = this.commandBuilder.buildBatch(connection.description.maxMessageSizeBytes, connection.description.maxWriteBatchSize, connection.description.maxBsonObjectSize); + if (!this.canRetryWrite) { + this.options.willRetryWrite = false; + } + return command; + } + }; + exports2.ClientBulkWriteOperation = ClientBulkWriteOperation; + (0, operation_1.defineAspects)(ClientBulkWriteOperation, [ + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.SKIP_COLLATION, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.COMMAND_BATCHING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/cursor/client_bulk_write_cursor.js +var require_client_bulk_write_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/client_bulk_write_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientBulkWriteCursor = void 0; + var client_bulk_write_1 = require_client_bulk_write(); + var execute_operation_1 = require_execute_operation(); + var utils_1 = require_utils3(); + var abstract_cursor_1 = require_abstract_cursor(); + var ClientBulkWriteCursor = class _ClientBulkWriteCursor extends abstract_cursor_1.AbstractCursor { + /** @internal */ + constructor(client, commandBuilder, options = {}) { + super(client, new utils_1.MongoDBNamespace("admin", "$cmd"), options); + this.commandBuilder = commandBuilder; + this.clientBulkWriteOptions = options; + } + /** + * We need a way to get the top level cursor response fields for + * generating the bulk write result, so we expose this here. + */ + get response() { + if (this.cursorResponse) + return this.cursorResponse; + return null; + } + get operations() { + return this.commandBuilder.lastOperations; + } + clone() { + const clonedOptions = (0, utils_1.mergeOptions)({}, this.clientBulkWriteOptions); + delete clonedOptions.session; + return new _ClientBulkWriteCursor(this.client, this.commandBuilder, { + ...clonedOptions + }); + } + /** @internal */ + async _initialize(session) { + const clientBulkWriteOperation = new client_bulk_write_1.ClientBulkWriteOperation(this.commandBuilder, { + ...this.clientBulkWriteOptions, + ...this.cursorOptions, + session + }); + const response = await (0, execute_operation_1.executeOperation)(this.client, clientBulkWriteOperation, this.timeoutContext); + this.cursorResponse = response; + return { server: clientBulkWriteOperation.server, session, response }; + } + }; + exports2.ClientBulkWriteCursor = ClientBulkWriteCursor; + } +}); + +// node_modules/mongodb/lib/operations/client_bulk_write/command_builder.js +var require_command_builder = __commonJS({ + "node_modules/mongodb/lib/operations/client_bulk_write/command_builder.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.buildReplaceOneOperation = exports2.buildUpdateManyOperation = exports2.buildUpdateOneOperation = exports2.buildDeleteManyOperation = exports2.buildDeleteOneOperation = exports2.buildInsertOneOperation = exports2.ClientBulkWriteCommandBuilder = void 0; + exports2.buildOperation = buildOperation; + var bson_1 = require_bson2(); + var commands_1 = require_commands3(); + var error_1 = require_error(); + var sort_1 = require_sort(); + var utils_1 = require_utils3(); + var MESSAGE_OVERHEAD_BYTES = 1e3; + var ClientBulkWriteCommandBuilder = class { + /** + * Create the command builder. + * @param models - The client write models. + */ + constructor(models, options, pkFactory) { + this.models = models; + this.options = options; + this.pkFactory = pkFactory ?? utils_1.DEFAULT_PK_FACTORY; + this.currentModelIndex = 0; + this.previousModelIndex = 0; + this.lastOperations = []; + this.isBatchRetryable = true; + } + /** + * Gets the errorsOnly value for the command, which is the inverse of the + * user provided verboseResults option. Defaults to true. + */ + get errorsOnly() { + if ("verboseResults" in this.options) { + return !this.options.verboseResults; + } + return true; + } + /** + * Determines if there is another batch to process. + * @returns True if not all batches have been built. + */ + hasNextBatch() { + return this.currentModelIndex < this.models.length; + } + /** + * When we need to retry a command we need to set the current + * model index back to its previous value. + */ + resetBatch() { + this.currentModelIndex = this.previousModelIndex; + return true; + } + /** + * Build a single batch of a client bulk write command. + * @param maxMessageSizeBytes - The max message size in bytes. + * @param maxWriteBatchSize - The max write batch size. + * @returns The client bulk write command. + */ + buildBatch(maxMessageSizeBytes, maxWriteBatchSize, maxBsonObjectSize) { + this.isBatchRetryable = true; + let commandLength = 0; + let currentNamespaceIndex = 0; + const command = this.baseCommand(); + const namespaces = /* @__PURE__ */ new Map(); + this.previousModelIndex = this.currentModelIndex; + while (this.currentModelIndex < this.models.length) { + const model = this.models[this.currentModelIndex]; + const ns = model.namespace; + const nsIndex = namespaces.get(ns); + if (model.name === "deleteMany" || model.name === "updateMany") { + this.isBatchRetryable = false; + } + if (nsIndex != null) { + const operation = buildOperation(model, nsIndex, this.pkFactory, this.options); + let operationBuffer; + try { + operationBuffer = bson_1.BSON.serialize(operation); + } catch (cause) { + throw new error_1.MongoInvalidArgumentError(`Could not serialize operation to BSON`, { cause }); + } + validateBufferSize("ops", operationBuffer, maxBsonObjectSize); + if (commandLength + operationBuffer.length < maxMessageSizeBytes && command.ops.documents.length < maxWriteBatchSize) { + commandLength = MESSAGE_OVERHEAD_BYTES + command.ops.push(operation, operationBuffer); + this.currentModelIndex++; + } else { + break; + } + } else { + namespaces.set(ns, currentNamespaceIndex); + const nsInfo = { ns }; + const operation = buildOperation(model, currentNamespaceIndex, this.pkFactory, this.options); + let nsInfoBuffer; + let operationBuffer; + try { + nsInfoBuffer = bson_1.BSON.serialize(nsInfo); + operationBuffer = bson_1.BSON.serialize(operation); + } catch (cause) { + throw new error_1.MongoInvalidArgumentError(`Could not serialize ns info to BSON`, { cause }); + } + validateBufferSize("nsInfo", nsInfoBuffer, maxBsonObjectSize); + validateBufferSize("ops", operationBuffer, maxBsonObjectSize); + if (commandLength + nsInfoBuffer.length + operationBuffer.length < maxMessageSizeBytes && command.ops.documents.length < maxWriteBatchSize) { + commandLength = MESSAGE_OVERHEAD_BYTES + command.nsInfo.push(nsInfo, nsInfoBuffer) + command.ops.push(operation, operationBuffer); + currentNamespaceIndex++; + this.currentModelIndex++; + } else { + break; + } + } + } + this.lastOperations = command.ops.documents; + return command; + } + baseCommand() { + const command = { + bulkWrite: 1, + errorsOnly: this.errorsOnly, + ordered: this.options.ordered ?? true, + ops: new commands_1.DocumentSequence("ops"), + nsInfo: new commands_1.DocumentSequence("nsInfo") + }; + if (this.options.bypassDocumentValidation != null) { + command.bypassDocumentValidation = this.options.bypassDocumentValidation; + } + if (this.options.let) { + command.let = this.options.let; + } + if (this.options.comment !== void 0) { + command.comment = this.options.comment; + } + return command; + } + }; + exports2.ClientBulkWriteCommandBuilder = ClientBulkWriteCommandBuilder; + function validateBufferSize(name, buffer, maxBsonObjectSize) { + if (buffer.length > maxBsonObjectSize) { + throw new error_1.MongoInvalidArgumentError(`Client bulk write operation ${name} of length ${buffer.length} exceeds the max bson object size of ${maxBsonObjectSize}`); + } + } + var buildInsertOneOperation = (model, index, pkFactory) => { + const document = { + insert: index, + document: model.document + }; + document.document._id = model.document._id ?? pkFactory.createPk(); + return document; + }; + exports2.buildInsertOneOperation = buildInsertOneOperation; + var buildDeleteOneOperation = (model, index) => { + return createDeleteOperation(model, index, false); + }; + exports2.buildDeleteOneOperation = buildDeleteOneOperation; + var buildDeleteManyOperation = (model, index) => { + return createDeleteOperation(model, index, true); + }; + exports2.buildDeleteManyOperation = buildDeleteManyOperation; + function createDeleteOperation(model, index, multi) { + const document = { + delete: index, + multi, + filter: model.filter + }; + if (model.hint) { + document.hint = model.hint; + } + if (model.collation) { + document.collation = model.collation; + } + return document; + } + var buildUpdateOneOperation = (model, index, options) => { + return createUpdateOperation(model, index, false, options); + }; + exports2.buildUpdateOneOperation = buildUpdateOneOperation; + var buildUpdateManyOperation = (model, index, options) => { + return createUpdateOperation(model, index, true, options); + }; + exports2.buildUpdateManyOperation = buildUpdateManyOperation; + function validateUpdate(update, options) { + if (!(0, utils_1.hasAtomicOperators)(update, options)) { + throw new error_1.MongoAPIError("Client bulk write update models must only contain atomic modifiers (start with $) and must not be empty."); + } + } + function createUpdateOperation(model, index, multi, options) { + validateUpdate(model.update, options); + const document = { + update: index, + multi, + filter: model.filter, + updateMods: model.update + }; + if (model.hint) { + document.hint = model.hint; + } + if (model.upsert) { + document.upsert = model.upsert; + } + if (model.arrayFilters) { + document.arrayFilters = model.arrayFilters; + } + if (model.collation) { + document.collation = model.collation; + } + if (!multi && "sort" in model && model.sort != null) { + document.sort = (0, sort_1.formatSort)(model.sort); + } + return document; + } + var buildReplaceOneOperation = (model, index) => { + if ((0, utils_1.hasAtomicOperators)(model.replacement)) { + throw new error_1.MongoAPIError("Client bulk write replace models must not contain atomic modifiers (start with $) and must not be empty."); + } + const document = { + update: index, + multi: false, + filter: model.filter, + updateMods: model.replacement + }; + if (model.hint) { + document.hint = model.hint; + } + if (model.upsert) { + document.upsert = model.upsert; + } + if (model.collation) { + document.collation = model.collation; + } + if (model.sort != null) { + document.sort = (0, sort_1.formatSort)(model.sort); + } + return document; + }; + exports2.buildReplaceOneOperation = buildReplaceOneOperation; + function buildOperation(model, index, pkFactory, options) { + switch (model.name) { + case "insertOne": + return (0, exports2.buildInsertOneOperation)(model, index, pkFactory); + case "deleteOne": + return (0, exports2.buildDeleteOneOperation)(model, index); + case "deleteMany": + return (0, exports2.buildDeleteManyOperation)(model, index); + case "updateOne": + return (0, exports2.buildUpdateOneOperation)(model, index, options); + case "updateMany": + return (0, exports2.buildUpdateManyOperation)(model, index, options); + case "replaceOne": + return (0, exports2.buildReplaceOneOperation)(model, index); + } + } + } +}); + +// node_modules/mongodb/lib/operations/client_bulk_write/results_merger.js +var require_results_merger = __commonJS({ + "node_modules/mongodb/lib/operations/client_bulk_write/results_merger.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientBulkWriteResultsMerger = void 0; + var __1 = require_lib9(); + var error_1 = require_error(); + var UNACKNOWLEDGED = { + acknowledged: false, + insertedCount: 0, + upsertedCount: 0, + matchedCount: 0, + modifiedCount: 0, + deletedCount: 0, + insertResults: void 0, + updateResults: void 0, + deleteResults: void 0 + }; + var ClientBulkWriteResultsMerger = class { + /** + * @returns The standard unacknowledged bulk write result. + */ + static unacknowledged() { + return UNACKNOWLEDGED; + } + /** + * Instantiate the merger. + * @param options - The options. + */ + constructor(options) { + this.options = options; + this.currentBatchOffset = 0; + this.writeConcernErrors = []; + this.writeErrors = /* @__PURE__ */ new Map(); + this.result = { + acknowledged: true, + insertedCount: 0, + upsertedCount: 0, + matchedCount: 0, + modifiedCount: 0, + deletedCount: 0, + insertResults: void 0, + updateResults: void 0, + deleteResults: void 0 + }; + if (options.verboseResults) { + this.result.insertResults = /* @__PURE__ */ new Map(); + this.result.updateResults = /* @__PURE__ */ new Map(); + this.result.deleteResults = /* @__PURE__ */ new Map(); + } + } + /** + * Get the bulk write result object. + */ + get bulkWriteResult() { + return { + acknowledged: this.result.acknowledged, + insertedCount: this.result.insertedCount, + upsertedCount: this.result.upsertedCount, + matchedCount: this.result.matchedCount, + modifiedCount: this.result.modifiedCount, + deletedCount: this.result.deletedCount, + insertResults: this.result.insertResults, + updateResults: this.result.updateResults, + deleteResults: this.result.deleteResults + }; + } + /** + * Merge the results in the cursor to the existing result. + * @param currentBatchOffset - The offset index to the original models. + * @param response - The cursor response. + * @param documents - The documents in the cursor. + * @returns The current result. + */ + async merge(cursor) { + let writeConcernErrorResult; + try { + for await (const document of cursor) { + if (document.ok === 1) { + if (this.options.verboseResults) { + this.processDocument(cursor, document); + } + } else { + if (this.options.ordered) { + const error = new error_1.MongoClientBulkWriteError({ + message: "Mongo client ordered bulk write encountered a write error." + }); + error.writeErrors.set(document.idx + this.currentBatchOffset, { + code: document.code, + message: document.errmsg + }); + error.partialResult = this.result; + throw error; + } else { + this.writeErrors.set(document.idx + this.currentBatchOffset, { + code: document.code, + message: document.errmsg + }); + } + } + } + } catch (error) { + if (error instanceof __1.MongoWriteConcernError) { + const result = error.result; + writeConcernErrorResult = { + insertedCount: result.nInserted, + upsertedCount: result.nUpserted, + matchedCount: result.nMatched, + modifiedCount: result.nModified, + deletedCount: result.nDeleted, + writeConcernError: result.writeConcernError + }; + if (this.options.verboseResults && result.cursor.firstBatch) { + for (const document of result.cursor.firstBatch) { + if (document.ok === 1) { + this.processDocument(cursor, document); + } + } + } + } else { + throw error; + } + } finally { + if (cursor.response) { + const response = cursor.response; + this.incrementCounts(response); + } + this.currentBatchOffset += cursor.operations.length; + } + if (writeConcernErrorResult) { + const writeConcernError = writeConcernErrorResult.writeConcernError; + this.incrementCounts(writeConcernErrorResult); + this.writeConcernErrors.push({ + code: writeConcernError.code, + message: writeConcernError.errmsg + }); + } + return this.result; + } + /** + * Process an individual document in the results. + * @param cursor - The cursor. + * @param document - The document to process. + */ + processDocument(cursor, document) { + const operation = cursor.operations[document.idx]; + if ("insert" in operation) { + this.result.insertResults?.set(document.idx + this.currentBatchOffset, { + insertedId: operation.document._id + }); + } + if ("update" in operation) { + const result = { + matchedCount: document.n, + modifiedCount: document.nModified ?? 0, + // Check if the bulk did actually upsert. + didUpsert: document.upserted != null + }; + if (document.upserted) { + result.upsertedId = document.upserted._id; + } + this.result.updateResults?.set(document.idx + this.currentBatchOffset, result); + } + if ("delete" in operation) { + this.result.deleteResults?.set(document.idx + this.currentBatchOffset, { + deletedCount: document.n + }); + } + } + /** + * Increment the result counts. + * @param document - The document with the results. + */ + incrementCounts(document) { + this.result.insertedCount += document.insertedCount; + this.result.upsertedCount += document.upsertedCount; + this.result.matchedCount += document.matchedCount; + this.result.modifiedCount += document.modifiedCount; + this.result.deletedCount += document.deletedCount; + } + }; + exports2.ClientBulkWriteResultsMerger = ClientBulkWriteResultsMerger; + } +}); + +// node_modules/mongodb/lib/operations/client_bulk_write/executor.js +var require_executor = __commonJS({ + "node_modules/mongodb/lib/operations/client_bulk_write/executor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ClientBulkWriteExecutor = void 0; + var abstract_cursor_1 = require_abstract_cursor(); + var client_bulk_write_cursor_1 = require_client_bulk_write_cursor(); + var error_1 = require_error(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var execute_operation_1 = require_execute_operation(); + var client_bulk_write_1 = require_client_bulk_write(); + var command_builder_1 = require_command_builder(); + var results_merger_1 = require_results_merger(); + var ClientBulkWriteExecutor = class { + /** + * Instantiate the executor. + * @param client - The mongo client. + * @param operations - The user supplied bulk write models. + * @param options - The bulk write options. + */ + constructor(client, operations, options) { + if (operations.length === 0) { + throw new error_1.MongoClientBulkWriteExecutionError("No client bulk write models were provided."); + } + this.client = client; + this.operations = operations; + this.options = { + ordered: true, + bypassDocumentValidation: false, + verboseResults: false, + ...options + }; + if (!this.options.writeConcern) { + this.options.writeConcern = write_concern_1.WriteConcern.fromOptions(this.client.s.options); + } + if (this.options.writeConcern?.w === 0) { + if (this.options.verboseResults) { + throw new error_1.MongoInvalidArgumentError("Cannot request unacknowledged write concern and verbose results"); + } + if (this.options.ordered) { + throw new error_1.MongoInvalidArgumentError("Cannot request unacknowledged write concern and ordered writes"); + } + } + } + /** + * Execute the client bulk write. Will split commands into batches and exhaust the cursors + * for each, then merge the results into one. + * @returns The result. + */ + async execute() { + const pkFactory = this.client.s.options.pkFactory; + const commandBuilder = new command_builder_1.ClientBulkWriteCommandBuilder(this.operations, this.options, pkFactory); + const resolvedOptions = (0, utils_1.resolveTimeoutOptions)(this.client, this.options); + const context = timeout_1.TimeoutContext.create(resolvedOptions); + if (this.options.writeConcern?.w === 0) { + while (commandBuilder.hasNextBatch()) { + const operation = new client_bulk_write_1.ClientBulkWriteOperation(commandBuilder, this.options); + await (0, execute_operation_1.executeOperation)(this.client, operation, context); + } + return results_merger_1.ClientBulkWriteResultsMerger.unacknowledged(); + } else { + const resultsMerger = new results_merger_1.ClientBulkWriteResultsMerger(this.options); + while (commandBuilder.hasNextBatch()) { + const cursorContext = new abstract_cursor_1.CursorTimeoutContext(context, /* @__PURE__ */ Symbol()); + const options = { + ...this.options, + timeoutContext: cursorContext, + ...resolvedOptions.timeoutMS != null && { timeoutMode: abstract_cursor_1.CursorTimeoutMode.LIFETIME } + }; + const cursor = new client_bulk_write_cursor_1.ClientBulkWriteCursor(this.client, commandBuilder, options); + try { + await resultsMerger.merge(cursor); + } catch (error) { + if (error instanceof error_1.MongoServerError && !(error instanceof error_1.MongoClientBulkWriteError)) { + const bulkWriteError = new error_1.MongoClientBulkWriteError({ + message: "Mongo client bulk write encountered an error during execution" + }); + bulkWriteError.cause = error; + bulkWriteError.partialResult = resultsMerger.bulkWriteResult; + throw bulkWriteError; + } else { + throw error; + } + } + } + if (resultsMerger.writeConcernErrors.length > 0 || resultsMerger.writeErrors.size > 0) { + const error = new error_1.MongoClientBulkWriteError({ + message: "Mongo client bulk write encountered errors during execution." + }); + error.writeConcernErrors = resultsMerger.writeConcernErrors; + error.writeErrors = resultsMerger.writeErrors; + error.partialResult = resultsMerger.bulkWriteResult; + throw error; + } + return resultsMerger.bulkWriteResult; + } + } + }; + exports2.ClientBulkWriteExecutor = ClientBulkWriteExecutor; + } +}); + +// node_modules/mongodb/lib/sdam/server_selection_events.js +var require_server_selection_events = __commonJS({ + "node_modules/mongodb/lib/sdam/server_selection_events.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.WaitingForSuitableServerEvent = exports2.ServerSelectionSucceededEvent = exports2.ServerSelectionFailedEvent = exports2.ServerSelectionStartedEvent = exports2.ServerSelectionEvent = void 0; + var utils_1 = require_utils3(); + var constants_1 = require_constants2(); + var ServerSelectionEvent = class { + /** @internal */ + constructor(selector, topologyDescription, operation) { + this.selector = selector; + this.operation = operation; + this.topologyDescription = topologyDescription; + } + }; + exports2.ServerSelectionEvent = ServerSelectionEvent; + var ServerSelectionStartedEvent = class extends ServerSelectionEvent { + /** @internal */ + constructor(selector, topologyDescription, operation) { + super(selector, topologyDescription, operation); + this.name = constants_1.SERVER_SELECTION_STARTED; + this.message = "Server selection started"; + } + }; + exports2.ServerSelectionStartedEvent = ServerSelectionStartedEvent; + var ServerSelectionFailedEvent = class extends ServerSelectionEvent { + /** @internal */ + constructor(selector, topologyDescription, error, operation) { + super(selector, topologyDescription, operation); + this.name = constants_1.SERVER_SELECTION_FAILED; + this.message = "Server selection failed"; + this.failure = error; + } + }; + exports2.ServerSelectionFailedEvent = ServerSelectionFailedEvent; + var ServerSelectionSucceededEvent = class extends ServerSelectionEvent { + /** @internal */ + constructor(selector, topologyDescription, address, operation) { + super(selector, topologyDescription, operation); + this.name = constants_1.SERVER_SELECTION_SUCCEEDED; + this.message = "Server selection succeeded"; + const { host, port } = utils_1.HostAddress.fromString(address).toHostPort(); + this.serverHost = host; + this.serverPort = port; + } + }; + exports2.ServerSelectionSucceededEvent = ServerSelectionSucceededEvent; + var WaitingForSuitableServerEvent = class extends ServerSelectionEvent { + /** @internal */ + constructor(selector, topologyDescription, remainingTimeMS, operation) { + super(selector, topologyDescription, operation); + this.name = constants_1.WAITING_FOR_SUITABLE_SERVER; + this.message = "Waiting for suitable server to become available"; + this.remainingTimeMS = remainingTimeMS; + } + }; + exports2.WaitingForSuitableServerEvent = WaitingForSuitableServerEvent; + } +}); + +// node_modules/mongodb/lib/sdam/srv_polling.js +var require_srv_polling = __commonJS({ + "node_modules/mongodb/lib/sdam/srv_polling.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.SrvPoller = exports2.SrvPollingEvent = void 0; + var dns = require("dns"); + var timers_1 = require("timers"); + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var utils_1 = require_utils3(); + var SrvPollingEvent = class { + constructor(srvRecords) { + this.srvRecords = srvRecords; + } + hostnames() { + return new Set(this.srvRecords.map((r) => utils_1.HostAddress.fromSrvRecord(r).toString())); + } + }; + exports2.SrvPollingEvent = SrvPollingEvent; + var SrvPoller = class _SrvPoller extends mongo_types_1.TypedEventEmitter { + constructor(options) { + super(); + this.on("error", utils_1.noop); + if (!options || !options.srvHost) { + throw new error_1.MongoRuntimeError("Options for SrvPoller must exist and include srvHost"); + } + this.srvHost = options.srvHost; + this.srvMaxHosts = options.srvMaxHosts ?? 0; + this.srvServiceName = options.srvServiceName ?? "mongodb"; + this.rescanSrvIntervalMS = 6e4; + this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 1e4; + this.haMode = false; + this.generation = 0; + this._timeout = void 0; + } + get srvAddress() { + return `_${this.srvServiceName}._tcp.${this.srvHost}`; + } + get intervalMS() { + return this.haMode ? this.heartbeatFrequencyMS : this.rescanSrvIntervalMS; + } + start() { + if (!this._timeout) { + this.schedule(); + } + } + stop() { + if (this._timeout) { + (0, timers_1.clearTimeout)(this._timeout); + this.generation += 1; + this._timeout = void 0; + } + } + // TODO(NODE-4994): implement new logging logic for SrvPoller failures + schedule() { + if (this._timeout) { + (0, timers_1.clearTimeout)(this._timeout); + } + this._timeout = (0, timers_1.setTimeout)(() => { + this._poll().then(void 0, utils_1.squashError); + }, this.intervalMS); + } + success(srvRecords) { + this.haMode = false; + this.schedule(); + this.emit(_SrvPoller.SRV_RECORD_DISCOVERY, new SrvPollingEvent(srvRecords)); + } + failure() { + this.haMode = true; + this.schedule(); + } + async _poll() { + const generation = this.generation; + let srvRecords; + try { + srvRecords = await dns.promises.resolveSrv(this.srvAddress); + } catch { + this.failure(); + return; + } + if (generation !== this.generation) { + return; + } + const finalAddresses = []; + for (const record of srvRecords) { + try { + (0, utils_1.checkParentDomainMatch)(record.name, this.srvHost); + finalAddresses.push(record); + } catch (error) { + (0, utils_1.squashError)(error); + } + } + if (!finalAddresses.length) { + this.failure(); + return; + } + this.success(finalAddresses); + } + }; + exports2.SrvPoller = SrvPoller; + SrvPoller.SRV_RECORD_DISCOVERY = "srvRecordDiscovery"; + } +}); + +// node_modules/mongodb/lib/sdam/topology.js +var require_topology = __commonJS({ + "node_modules/mongodb/lib/sdam/topology.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ServerCapabilities = exports2.Topology = void 0; + var connection_string_1 = require_connection_string(); + var constants_1 = require_constants2(); + var error_1 = require_error(); + var mongo_logger_1 = require_mongo_logger(); + var mongo_types_1 = require_mongo_types(); + var read_preference_1 = require_read_preference(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var common_1 = require_common(); + var events_1 = require_events(); + var server_1 = require_server(); + var server_description_1 = require_server_description(); + var server_selection_1 = require_server_selection(); + var server_selection_events_1 = require_server_selection_events(); + var srv_polling_1 = require_srv_polling(); + var topology_description_1 = require_topology_description(); + var globalTopologyCounter = 0; + var stateTransition = (0, utils_1.makeStateMachine)({ + [common_1.STATE_CLOSED]: [common_1.STATE_CLOSED, common_1.STATE_CONNECTING], + [common_1.STATE_CONNECTING]: [common_1.STATE_CONNECTING, common_1.STATE_CLOSING, common_1.STATE_CONNECTED, common_1.STATE_CLOSED], + [common_1.STATE_CONNECTED]: [common_1.STATE_CONNECTED, common_1.STATE_CLOSING, common_1.STATE_CLOSED], + [common_1.STATE_CLOSING]: [common_1.STATE_CLOSING, common_1.STATE_CLOSED] + }); + var Topology = class _Topology extends mongo_types_1.TypedEventEmitter { + /** + * @param seedlist - a list of HostAddress instances to connect to + */ + constructor(client, seeds, options) { + super(); + this.on("error", utils_1.noop); + this.client = client; + options = options ?? { + hosts: [utils_1.HostAddress.fromString("localhost:27017")], + ...Object.fromEntries(connection_string_1.DEFAULT_OPTIONS.entries()) + }; + if (typeof seeds === "string") { + seeds = [utils_1.HostAddress.fromString(seeds)]; + } else if (!Array.isArray(seeds)) { + seeds = [seeds]; + } + const seedlist = []; + for (const seed of seeds) { + if (typeof seed === "string") { + seedlist.push(utils_1.HostAddress.fromString(seed)); + } else if (seed instanceof utils_1.HostAddress) { + seedlist.push(seed); + } else { + throw new error_1.MongoRuntimeError(`Topology cannot be constructed from ${JSON.stringify(seed)}`); + } + } + const topologyType = topologyTypeFromOptions(options); + const topologyId = globalTopologyCounter++; + const selectedHosts = options.srvMaxHosts == null || options.srvMaxHosts === 0 || options.srvMaxHosts >= seedlist.length ? seedlist : (0, utils_1.shuffle)(seedlist, options.srvMaxHosts); + const serverDescriptions = /* @__PURE__ */ new Map(); + for (const hostAddress of selectedHosts) { + serverDescriptions.set(hostAddress.toString(), new server_description_1.ServerDescription(hostAddress)); + } + this.waitQueue = new utils_1.List(); + this.s = { + // the id of this topology + id: topologyId, + // passed in options + options, + // initial seedlist of servers to connect to + seedlist, + // initial state + state: common_1.STATE_CLOSED, + // the topology description + description: new topology_description_1.TopologyDescription(topologyType, serverDescriptions, options.replicaSet, void 0, void 0, void 0, options), + serverSelectionTimeoutMS: options.serverSelectionTimeoutMS, + heartbeatFrequencyMS: options.heartbeatFrequencyMS, + minHeartbeatFrequencyMS: options.minHeartbeatFrequencyMS, + // a map of server instances to normalized addresses + servers: /* @__PURE__ */ new Map(), + credentials: options?.credentials, + clusterTime: void 0, + detectShardedTopology: (ev) => this.detectShardedTopology(ev), + detectSrvRecords: (ev) => this.detectSrvRecords(ev) + }; + this.mongoLogger = client.mongoLogger; + this.component = "topology"; + if (options.srvHost && !options.loadBalanced) { + this.s.srvPoller = options.srvPoller ?? new srv_polling_1.SrvPoller({ + heartbeatFrequencyMS: this.s.heartbeatFrequencyMS, + srvHost: options.srvHost, + srvMaxHosts: options.srvMaxHosts, + srvServiceName: options.srvServiceName + }); + this.on(_Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology); + } + this.connectionLock = void 0; + } + detectShardedTopology(event) { + const previousType = event.previousDescription.type; + const newType = event.newDescription.type; + const transitionToSharded = previousType !== common_1.TopologyType.Sharded && newType === common_1.TopologyType.Sharded; + const srvListeners = this.s.srvPoller?.listeners(srv_polling_1.SrvPoller.SRV_RECORD_DISCOVERY); + const listeningToSrvPolling = !!srvListeners?.includes(this.s.detectSrvRecords); + if (transitionToSharded && !listeningToSrvPolling) { + this.s.srvPoller?.on(srv_polling_1.SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords); + this.s.srvPoller?.start(); + } + } + detectSrvRecords(ev) { + const previousTopologyDescription = this.s.description; + this.s.description = this.s.description.updateFromSrvPollingEvent(ev, this.s.options.srvMaxHosts); + if (this.s.description === previousTopologyDescription) { + return; + } + updateServers(this); + this.emitAndLog(_Topology.TOPOLOGY_DESCRIPTION_CHANGED, new events_1.TopologyDescriptionChangedEvent(this.s.id, previousTopologyDescription, this.s.description)); + } + /** + * @returns A `TopologyDescription` for this topology + */ + get description() { + return this.s.description; + } + get loadBalanced() { + return this.s.options.loadBalanced; + } + get serverApi() { + return this.s.options.serverApi; + } + get capabilities() { + return new ServerCapabilities(this.lastHello()); + } + /** Initiate server connect */ + async connect(options) { + this.connectionLock ??= this._connect(options); + try { + await this.connectionLock; + return this; + } finally { + this.connectionLock = void 0; + } + } + async _connect(options) { + options = options ?? {}; + if (this.s.state === common_1.STATE_CONNECTED) { + return this; + } + stateTransition(this, common_1.STATE_CONNECTING); + this.emitAndLog(_Topology.TOPOLOGY_OPENING, new events_1.TopologyOpeningEvent(this.s.id)); + this.emitAndLog(_Topology.TOPOLOGY_DESCRIPTION_CHANGED, new events_1.TopologyDescriptionChangedEvent( + this.s.id, + new topology_description_1.TopologyDescription(common_1.TopologyType.Unknown), + // initial is always Unknown + this.s.description + )); + const serverDescriptions = Array.from(this.s.description.servers.values()); + this.s.servers = new Map(serverDescriptions.map((serverDescription) => [ + serverDescription.address, + createAndConnectServer(this, serverDescription) + ])); + if (this.s.options.loadBalanced) { + for (const description of serverDescriptions) { + const newDescription = new server_description_1.ServerDescription(description.hostAddress, void 0, { + loadBalanced: this.s.options.loadBalanced + }); + this.serverUpdateHandler(newDescription); + } + } + const serverSelectionTimeoutMS = this.client.s.options.serverSelectionTimeoutMS; + const readPreference = options.readPreference ?? read_preference_1.ReadPreference.primary; + const timeoutContext = timeout_1.TimeoutContext.create({ + // TODO(NODE-6448): auto-connect ignores timeoutMS; potential future feature + timeoutMS: void 0, + serverSelectionTimeoutMS, + waitQueueTimeoutMS: this.client.s.options.waitQueueTimeoutMS + }); + const selectServerOptions = { + operationName: "handshake", + ...options, + timeoutContext + }; + try { + const server = await this.selectServer((0, server_selection_1.readPreferenceServerSelector)(readPreference), selectServerOptions); + const skipPingOnConnect = this.s.options.__skipPingOnConnect === true; + if (!skipPingOnConnect && this.s.credentials) { + const connection = await server.pool.checkOut({ timeoutContext }); + server.pool.checkIn(connection); + stateTransition(this, common_1.STATE_CONNECTED); + this.emit(_Topology.OPEN, this); + this.emit(_Topology.CONNECT, this); + return this; + } + stateTransition(this, common_1.STATE_CONNECTED); + this.emit(_Topology.OPEN, this); + this.emit(_Topology.CONNECT, this); + return this; + } catch (error) { + this.close(); + throw error; + } + } + closeCheckedOutConnections() { + for (const server of this.s.servers.values()) { + return server.closeCheckedOutConnections(); + } + } + /** Close this topology */ + close() { + if (this.s.state === common_1.STATE_CLOSED || this.s.state === common_1.STATE_CLOSING) { + return; + } + for (const server of this.s.servers.values()) { + closeServer(server, this); + } + this.s.servers.clear(); + stateTransition(this, common_1.STATE_CLOSING); + drainWaitQueue(this.waitQueue, new error_1.MongoTopologyClosedError()); + if (this.s.srvPoller) { + this.s.srvPoller.stop(); + this.s.srvPoller.removeListener(srv_polling_1.SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords); + } + this.removeListener(_Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology); + stateTransition(this, common_1.STATE_CLOSED); + this.emitAndLog(_Topology.TOPOLOGY_CLOSED, new events_1.TopologyClosedEvent(this.s.id)); + } + /** + * Selects a server according to the selection predicate provided + * + * @param selector - An optional selector to select servers by, defaults to a random selection within a latency window + * @param options - Optional settings related to server selection + * @param callback - The callback used to indicate success or failure + * @returns An instance of a `Server` meeting the criteria of the predicate provided + */ + async selectServer(selector, options) { + let serverSelector; + if (typeof selector !== "function") { + if (typeof selector === "string") { + serverSelector = (0, server_selection_1.readPreferenceServerSelector)(read_preference_1.ReadPreference.fromString(selector)); + } else { + let readPreference; + if (selector instanceof read_preference_1.ReadPreference) { + readPreference = selector; + } else { + read_preference_1.ReadPreference.translate(options); + readPreference = options.readPreference || read_preference_1.ReadPreference.primary; + } + serverSelector = (0, server_selection_1.readPreferenceServerSelector)(readPreference); + } + } else { + serverSelector = selector; + } + options = { serverSelectionTimeoutMS: this.s.serverSelectionTimeoutMS, ...options }; + if (this.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + this.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionStartedEvent(selector, this.description, options.operationName)); + } + let timeout; + if (options.timeoutContext) + timeout = options.timeoutContext.serverSelectionTimeout; + else { + timeout = timeout_1.Timeout.expires(options.serverSelectionTimeoutMS ?? 0); + } + const isSharded = this.description.type === common_1.TopologyType.Sharded; + const session = options.session; + const transaction = session && session.transaction; + if (isSharded && transaction && transaction.server) { + if (this.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + this.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionSucceededEvent(selector, this.description, transaction.server.pool.address, options.operationName)); + } + if (options.timeoutContext?.clearServerSelectionTimeout) + timeout?.clear(); + return transaction.server; + } + const { promise: serverPromise, resolve, reject } = (0, utils_1.promiseWithResolvers)(); + const waitQueueMember = { + serverSelector, + topologyDescription: this.description, + mongoLogger: this.client.mongoLogger, + transaction, + resolve, + reject, + cancelled: false, + startTime: (0, utils_1.now)(), + operationName: options.operationName, + waitingLogged: false, + previousServer: options.previousServer + }; + const abortListener = (0, utils_1.addAbortListener)(options.signal, function() { + waitQueueMember.cancelled = true; + reject(this.reason); + }); + this.waitQueue.push(waitQueueMember); + processWaitQueue(this); + try { + timeout?.throwIfExpired(); + const server = await (timeout ? Promise.race([serverPromise, timeout]) : serverPromise); + if (options.timeoutContext?.csotEnabled() && server.description.minRoundTripTime !== 0) { + options.timeoutContext.minRoundTripTime = server.description.minRoundTripTime; + } + return server; + } catch (error) { + if (timeout_1.TimeoutError.is(error)) { + waitQueueMember.cancelled = true; + const timeoutError = new error_1.MongoServerSelectionError(`Server selection timed out after ${timeout?.duration} ms`, this.description); + if (this.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + this.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionFailedEvent(selector, this.description, timeoutError, options.operationName)); + } + if (options.timeoutContext?.csotEnabled()) { + throw new error_1.MongoOperationTimeoutError("Timed out during server selection", { + cause: timeoutError + }); + } + throw timeoutError; + } + throw error; + } finally { + abortListener?.[utils_1.kDispose](); + if (options.timeoutContext?.clearServerSelectionTimeout) + timeout?.clear(); + } + } + /** + * Update the internal TopologyDescription with a ServerDescription + * + * @param serverDescription - The server to update in the internal list of server descriptions + */ + serverUpdateHandler(serverDescription) { + if (!this.s.description.hasServer(serverDescription.address)) { + return; + } + if (isStaleServerDescription(this.s.description, serverDescription)) { + return; + } + const previousTopologyDescription = this.s.description; + const previousServerDescription = this.s.description.servers.get(serverDescription.address); + if (!previousServerDescription) { + return; + } + const clusterTime = serverDescription.$clusterTime; + if (clusterTime) { + (0, common_1._advanceClusterTime)(this, clusterTime); + } + const equalDescriptions = previousServerDescription && previousServerDescription.equals(serverDescription); + this.s.description = this.s.description.update(serverDescription); + if (this.s.description.compatibilityError) { + this.emit(_Topology.ERROR, new error_1.MongoCompatibilityError(this.s.description.compatibilityError)); + return; + } + if (!equalDescriptions) { + const newDescription = this.s.description.servers.get(serverDescription.address); + if (newDescription) { + this.emit(_Topology.SERVER_DESCRIPTION_CHANGED, new events_1.ServerDescriptionChangedEvent(this.s.id, serverDescription.address, previousServerDescription, newDescription)); + } + } + updateServers(this, serverDescription); + if (this.waitQueue.length > 0) { + processWaitQueue(this); + } + if (!equalDescriptions) { + this.emitAndLog(_Topology.TOPOLOGY_DESCRIPTION_CHANGED, new events_1.TopologyDescriptionChangedEvent(this.s.id, previousTopologyDescription, this.s.description)); + } + } + auth(credentials, callback) { + if (typeof credentials === "function") + callback = credentials, credentials = void 0; + if (typeof callback === "function") + callback(void 0, true); + } + get clientMetadata() { + return this.s.options.metadata; + } + isConnected() { + return this.s.state === common_1.STATE_CONNECTED; + } + isDestroyed() { + return this.s.state === common_1.STATE_CLOSED; + } + // NOTE: There are many places in code where we explicitly check the last hello + // to do feature support detection. This should be done any other way, but for + // now we will just return the first hello seen, which should suffice. + lastHello() { + const serverDescriptions = Array.from(this.description.servers.values()); + if (serverDescriptions.length === 0) + return {}; + const sd = serverDescriptions.filter((sd2) => sd2.type !== common_1.ServerType.Unknown)[0]; + const result = sd || { maxWireVersion: this.description.commonWireVersion }; + return result; + } + get commonWireVersion() { + return this.description.commonWireVersion; + } + get logicalSessionTimeoutMinutes() { + return this.description.logicalSessionTimeoutMinutes; + } + get clusterTime() { + return this.s.clusterTime; + } + set clusterTime(clusterTime) { + this.s.clusterTime = clusterTime; + } + }; + exports2.Topology = Topology; + Topology.SERVER_OPENING = constants_1.SERVER_OPENING; + Topology.SERVER_CLOSED = constants_1.SERVER_CLOSED; + Topology.SERVER_DESCRIPTION_CHANGED = constants_1.SERVER_DESCRIPTION_CHANGED; + Topology.TOPOLOGY_OPENING = constants_1.TOPOLOGY_OPENING; + Topology.TOPOLOGY_CLOSED = constants_1.TOPOLOGY_CLOSED; + Topology.TOPOLOGY_DESCRIPTION_CHANGED = constants_1.TOPOLOGY_DESCRIPTION_CHANGED; + Topology.ERROR = constants_1.ERROR; + Topology.OPEN = constants_1.OPEN; + Topology.CONNECT = constants_1.CONNECT; + Topology.CLOSE = constants_1.CLOSE; + Topology.TIMEOUT = constants_1.TIMEOUT; + function closeServer(server, topology) { + for (const event of constants_1.LOCAL_SERVER_EVENTS) { + server.removeAllListeners(event); + } + server.close(); + topology.emitAndLog(Topology.SERVER_CLOSED, new events_1.ServerClosedEvent(topology.s.id, server.description.address)); + for (const event of constants_1.SERVER_RELAY_EVENTS) { + server.removeAllListeners(event); + } + } + function topologyTypeFromOptions(options) { + if (options?.directConnection) { + return common_1.TopologyType.Single; + } + if (options?.replicaSet) { + return common_1.TopologyType.ReplicaSetNoPrimary; + } + if (options?.loadBalanced) { + return common_1.TopologyType.LoadBalanced; + } + return common_1.TopologyType.Unknown; + } + function createAndConnectServer(topology, serverDescription) { + topology.emitAndLog(Topology.SERVER_OPENING, new events_1.ServerOpeningEvent(topology.s.id, serverDescription.address)); + const server = new server_1.Server(topology, serverDescription, topology.s.options); + for (const event of constants_1.SERVER_RELAY_EVENTS) { + server.on(event, (e) => topology.emit(event, e)); + } + server.on(server_1.Server.DESCRIPTION_RECEIVED, (description) => topology.serverUpdateHandler(description)); + server.connect(); + return server; + } + function updateServers(topology, incomingServerDescription) { + if (incomingServerDescription && topology.s.servers.has(incomingServerDescription.address)) { + const server = topology.s.servers.get(incomingServerDescription.address); + if (server) { + server.s.description = incomingServerDescription; + if (incomingServerDescription.error instanceof error_1.MongoError && incomingServerDescription.error.hasErrorLabel(error_1.MongoErrorLabel.ResetPool)) { + const interruptInUseConnections = incomingServerDescription.error.hasErrorLabel(error_1.MongoErrorLabel.InterruptInUseConnections); + server.pool.clear({ interruptInUseConnections }); + } else if (incomingServerDescription.error == null) { + const newTopologyType = topology.s.description.type; + const shouldMarkPoolReady = incomingServerDescription.isDataBearing || incomingServerDescription.type !== common_1.ServerType.Unknown && newTopologyType === common_1.TopologyType.Single; + if (shouldMarkPoolReady) { + server.pool.ready(); + } + } + } + } + for (const serverDescription of topology.description.servers.values()) { + if (!topology.s.servers.has(serverDescription.address)) { + const server = createAndConnectServer(topology, serverDescription); + topology.s.servers.set(serverDescription.address, server); + } + } + for (const entry of topology.s.servers) { + const serverAddress = entry[0]; + if (topology.description.hasServer(serverAddress)) { + continue; + } + if (!topology.s.servers.has(serverAddress)) { + continue; + } + const server = topology.s.servers.get(serverAddress); + topology.s.servers.delete(serverAddress); + if (server) { + closeServer(server, topology); + } + } + } + function drainWaitQueue(queue, drainError) { + while (queue.length) { + const waitQueueMember = queue.shift(); + if (!waitQueueMember) { + continue; + } + if (!waitQueueMember.cancelled) { + if (waitQueueMember.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + waitQueueMember.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionFailedEvent(waitQueueMember.serverSelector, waitQueueMember.topologyDescription, drainError, waitQueueMember.operationName)); + } + waitQueueMember.reject(drainError); + } + } + } + function processWaitQueue(topology) { + if (topology.s.state === common_1.STATE_CLOSED) { + drainWaitQueue(topology.waitQueue, new error_1.MongoTopologyClosedError()); + return; + } + const isSharded = topology.description.type === common_1.TopologyType.Sharded; + const serverDescriptions = Array.from(topology.description.servers.values()); + const membersToProcess = topology.waitQueue.length; + for (let i = 0; i < membersToProcess; ++i) { + const waitQueueMember = topology.waitQueue.shift(); + if (!waitQueueMember) { + continue; + } + if (waitQueueMember.cancelled) { + continue; + } + let selectedDescriptions; + try { + const serverSelector = waitQueueMember.serverSelector; + const previousServer = waitQueueMember.previousServer; + selectedDescriptions = serverSelector ? serverSelector(topology.description, serverDescriptions, previousServer ? [previousServer] : []) : serverDescriptions; + } catch (selectorError) { + if (topology.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + topology.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionFailedEvent(waitQueueMember.serverSelector, topology.description, selectorError, waitQueueMember.operationName)); + } + waitQueueMember.reject(selectorError); + continue; + } + let selectedServer; + if (selectedDescriptions.length === 0) { + if (!waitQueueMember.waitingLogged) { + if (topology.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.INFORMATIONAL)) { + topology.client.mongoLogger?.info(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.WaitingForSuitableServerEvent(waitQueueMember.serverSelector, topology.description, topology.s.serverSelectionTimeoutMS !== 0 ? topology.s.serverSelectionTimeoutMS - ((0, utils_1.now)() - waitQueueMember.startTime) : -1, waitQueueMember.operationName)); + } + waitQueueMember.waitingLogged = true; + } + topology.waitQueue.push(waitQueueMember); + continue; + } else if (selectedDescriptions.length === 1) { + selectedServer = topology.s.servers.get(selectedDescriptions[0].address); + } else { + const descriptions = (0, utils_1.shuffle)(selectedDescriptions, 2); + const server1 = topology.s.servers.get(descriptions[0].address); + const server2 = topology.s.servers.get(descriptions[1].address); + selectedServer = server1 && server2 && server1.s.operationCount < server2.s.operationCount ? server1 : server2; + } + if (!selectedServer) { + const serverSelectionError = new error_1.MongoServerSelectionError("server selection returned a server description but the server was not found in the topology", topology.description); + if (topology.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + topology.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionFailedEvent(waitQueueMember.serverSelector, topology.description, serverSelectionError, waitQueueMember.operationName)); + } + waitQueueMember.reject(serverSelectionError); + return; + } + const transaction = waitQueueMember.transaction; + if (isSharded && transaction && transaction.isActive && selectedServer) { + transaction.pinServer(selectedServer); + } + if (topology.client.mongoLogger?.willLog(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, mongo_logger_1.SeverityLevel.DEBUG)) { + topology.client.mongoLogger?.debug(mongo_logger_1.MongoLoggableComponent.SERVER_SELECTION, new server_selection_events_1.ServerSelectionSucceededEvent(waitQueueMember.serverSelector, waitQueueMember.topologyDescription, selectedServer.pool.address, waitQueueMember.operationName)); + } + waitQueueMember.resolve(selectedServer); + } + if (topology.waitQueue.length > 0) { + for (const [, server] of topology.s.servers) { + process.nextTick(function scheduleServerCheck() { + return server.requestCheck(); + }); + } + } + } + function isStaleServerDescription(topologyDescription, incomingServerDescription) { + const currentServerDescription = topologyDescription.servers.get(incomingServerDescription.address); + const currentTopologyVersion = currentServerDescription?.topologyVersion; + return (0, server_description_1.compareTopologyVersion)(currentTopologyVersion, incomingServerDescription.topologyVersion) > 0; + } + var ServerCapabilities = class { + constructor(hello) { + this.minWireVersion = hello.minWireVersion || 0; + this.maxWireVersion = hello.maxWireVersion || 0; + } + get hasAggregationCursor() { + return true; + } + get hasWriteCommands() { + return true; + } + get hasTextSearch() { + return true; + } + get hasAuthCommands() { + return true; + } + get hasListCollectionsCommand() { + return true; + } + get hasListIndexesCommand() { + return true; + } + get supportsSnapshotReads() { + return this.maxWireVersion >= 13; + } + get commandsTakeWriteConcern() { + return true; + } + get commandsTakeCollation() { + return true; + } + }; + exports2.ServerCapabilities = ServerCapabilities; + } +}); + +// node_modules/mongodb/lib/mongo_client.js +var require_mongo_client = __commonJS({ + "node_modules/mongodb/lib/mongo_client.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoClient = exports2.ServerApiVersion = void 0; + var fs_1 = require("fs"); + var bson_1 = require_bson2(); + var change_stream_1 = require_change_stream(); + var mongo_credentials_1 = require_mongo_credentials(); + var providers_1 = require_providers(); + var client_metadata_1 = require_client_metadata(); + var responses_1 = require_responses(); + var connection_string_1 = require_connection_string(); + var constants_1 = require_constants2(); + var db_1 = require_db(); + var error_1 = require_error(); + var mongo_client_auth_providers_1 = require_mongo_client_auth_providers(); + var mongo_logger_1 = require_mongo_logger(); + var mongo_types_1 = require_mongo_types(); + var executor_1 = require_executor(); + var execute_operation_1 = require_execute_operation(); + var operation_1 = require_operation(); + var read_preference_1 = require_read_preference(); + var resource_management_1 = require_resource_management(); + var server_selection_1 = require_server_selection(); + var topology_1 = require_topology(); + var sessions_1 = require_sessions(); + var utils_1 = require_utils3(); + exports2.ServerApiVersion = Object.freeze({ + v1: "1" + }); + var MongoClient = class extends mongo_types_1.TypedEventEmitter { + constructor(url, options) { + super(); + this.driverInfoList = []; + this.on("error", utils_1.noop); + this.options = (0, connection_string_1.parseOptions)(url, this, options); + this.appendMetadata(this.options.driverInfo); + const shouldSetLogger = Object.values(this.options.mongoLoggerOptions.componentSeverities).some((value) => value !== mongo_logger_1.SeverityLevel.OFF); + this.mongoLogger = shouldSetLogger ? new mongo_logger_1.MongoLogger(this.options.mongoLoggerOptions) : void 0; + const client = this; + this.s = { + url, + bsonOptions: (0, bson_1.resolveBSONOptions)(this.options), + namespace: (0, utils_1.ns)("admin"), + hasBeenClosed: false, + sessionPool: new sessions_1.ServerSessionPool(this), + activeSessions: /* @__PURE__ */ new Set(), + activeCursors: /* @__PURE__ */ new Set(), + authProviders: new mongo_client_auth_providers_1.MongoClientAuthProviders(), + get options() { + return client.options; + }, + get readConcern() { + return client.options.readConcern; + }, + get writeConcern() { + return client.options.writeConcern; + }, + get readPreference() { + return client.options.readPreference; + }, + get isMongoClient() { + return true; + } + }; + this.checkForNonGenuineHosts(); + } + /** @internal */ + async asyncDispose() { + await this.close(); + } + /** + * Append metadata to the client metadata after instantiation. + * @param driverInfo - Information about the application or library. + */ + appendMetadata(driverInfo) { + const isDuplicateDriverInfo = this.driverInfoList.some((info) => (0, client_metadata_1.isDriverInfoEqual)(info, driverInfo)); + if (isDuplicateDriverInfo) + return; + this.driverInfoList.push(driverInfo); + this.options.metadata = (0, client_metadata_1.makeClientMetadata)(this.driverInfoList, this.options); + this.options.extendedMetadata = (0, client_metadata_1.addContainerMetadata)(this.options.metadata).then(void 0, utils_1.squashError).then((result) => result ?? {}); + } + /** @internal */ + checkForNonGenuineHosts() { + const documentDBHostnames = this.options.hosts.filter((hostAddress) => (0, utils_1.isHostMatch)(utils_1.DOCUMENT_DB_CHECK, hostAddress.host)); + const srvHostIsDocumentDB = (0, utils_1.isHostMatch)(utils_1.DOCUMENT_DB_CHECK, this.options.srvHost); + const cosmosDBHostnames = this.options.hosts.filter((hostAddress) => (0, utils_1.isHostMatch)(utils_1.COSMOS_DB_CHECK, hostAddress.host)); + const srvHostIsCosmosDB = (0, utils_1.isHostMatch)(utils_1.COSMOS_DB_CHECK, this.options.srvHost); + if (documentDBHostnames.length !== 0 || srvHostIsDocumentDB) { + this.mongoLogger?.info("client", utils_1.DOCUMENT_DB_MSG); + } else if (cosmosDBHostnames.length !== 0 || srvHostIsCosmosDB) { + this.mongoLogger?.info("client", utils_1.COSMOS_DB_MSG); + } + } + get serverApi() { + return this.options.serverApi && Object.freeze({ ...this.options.serverApi }); + } + /** + * Intended for APM use only + * @internal + */ + get monitorCommands() { + return this.options.monitorCommands; + } + set monitorCommands(value) { + this.options.monitorCommands = value; + } + /** @internal */ + get autoEncrypter() { + return this.options.autoEncrypter; + } + get readConcern() { + return this.s.readConcern; + } + get writeConcern() { + return this.s.writeConcern; + } + get readPreference() { + return this.s.readPreference; + } + get bsonOptions() { + return this.s.bsonOptions; + } + /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */ + get timeoutMS() { + return void 0; + } + /** + * Executes a client bulk write operation, available on server 8.0+. + * @param models - The client bulk write models. + * @param options - The client bulk write options. + * @returns A ClientBulkWriteResult for acknowledged writes and ok: 1 for unacknowledged writes. + */ + async bulkWrite(models, options) { + if (this.autoEncrypter) { + throw new error_1.MongoInvalidArgumentError("MongoClient bulkWrite does not currently support automatic encryption."); + } + return await new executor_1.ClientBulkWriteExecutor(this, models, (0, utils_1.resolveOptions)(this, options)).execute(); + } + /** + * Connect to MongoDB using a url + * + * @remarks + * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed. + * + * @remarks + * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`. + * If those look ups throw a DNS Timeout error, the driver will retry the look up once. + * + * @see docs.mongodb.org/manual/reference/connection-string/ + */ + async connect() { + if (this.connectionLock) { + return await this.connectionLock; + } + try { + this.connectionLock = this._connect(); + await this.connectionLock; + } finally { + this.connectionLock = void 0; + } + return this; + } + /** + * Create a topology to open the connection, must be locked to avoid topology leaks in concurrency scenario. + * Locking is enforced by the connect method. + * + * @internal + */ + async _connect() { + if (this.topology && this.topology.isConnected()) { + return this; + } + const options = this.options; + if (options.tls) { + if (typeof options.tlsCAFile === "string") { + options.ca ??= await fs_1.promises.readFile(options.tlsCAFile); + } + if (typeof options.tlsCRLFile === "string") { + options.crl ??= await fs_1.promises.readFile(options.tlsCRLFile); + } + if (typeof options.tlsCertificateKeyFile === "string") { + if (!options.key || !options.cert) { + const contents = await fs_1.promises.readFile(options.tlsCertificateKeyFile); + options.key ??= contents; + options.cert ??= contents; + } + } + } + if (typeof options.srvHost === "string") { + const hosts = await (0, connection_string_1.resolveSRVRecord)(options); + for (const [index, host] of hosts.entries()) { + options.hosts[index] = host; + } + } + if (options.credentials?.mechanism === providers_1.AuthMechanism.MONGODB_OIDC) { + const allowedHosts = options.credentials?.mechanismProperties?.ALLOWED_HOSTS || mongo_credentials_1.DEFAULT_ALLOWED_HOSTS; + const isServiceAuth = !!options.credentials?.mechanismProperties?.ENVIRONMENT; + if (!isServiceAuth) { + for (const host of options.hosts) { + if (!(0, utils_1.hostMatchesWildcards)(host.toHostPort().host, allowedHosts)) { + throw new error_1.MongoInvalidArgumentError(`Host '${host}' is not valid for OIDC authentication with ALLOWED_HOSTS of '${allowedHosts.join(",")}'`); + } + } + } + } + this.topology = new topology_1.Topology(this, options.hosts, options); + this.topology.once(topology_1.Topology.OPEN, () => this.emit("open", this)); + for (const event of constants_1.MONGO_CLIENT_EVENTS) { + this.topology.on(event, (...args) => this.emit(event, ...args)); + } + const topologyConnect = async () => { + try { + await this.topology?.connect(options); + } catch (error) { + this.topology?.close(); + throw error; + } + }; + if (this.autoEncrypter) { + await this.autoEncrypter?.init(); + await topologyConnect(); + await options.encrypter.connectInternalClient(); + } else { + await topologyConnect(); + } + return this; + } + /** + * Cleans up resources managed by the MongoClient. + * + * The close method clears and closes all resources whose lifetimes are managed by the MongoClient. + * Please refer to the `MongoClient` class documentation for a high level overview of the client's key features and responsibilities. + * + * **However,** the close method does not handle the cleanup of resources explicitly created by the user. + * Any user-created driver resource with its own `close()` method should be explicitly closed by the user before calling MongoClient.close(). + * This method is written as a "best effort" attempt to leave behind the least amount of resources server-side when possible. + * + * The following list defines ideal preconditions and consequent pitfalls if they are not met. + * The MongoClient, ClientSession, Cursors and ChangeStreams all support [explicit resource management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html). + * By using explicit resource management to manage the lifetime of driver resources instead of manually managing their lifetimes, the pitfalls outlined below can be avoided. + * + * The close method performs the following in the order listed: + * - Client-side: + * - **Close in-use connections**: Any connections that are currently waiting on a response from the server will be closed. + * This is performed _first_ to avoid reaching the next step (server-side clean up) and having no available connections to check out. + * - _Ideal_: All operations have been awaited or cancelled, and the outcomes, regardless of success or failure, have been processed before closing the client servicing the operation. + * - _Pitfall_: When `client.close()` is called and all connections are in use, after closing them, the client must create new connections for cleanup operations, which comes at the cost of new TLS/TCP handshakes and authentication steps. + * - Server-side: + * - **Close active cursors**: All cursors that haven't been completed will have a `killCursor` operation sent to the server they were initialized on, freeing the server-side resource. + * - _Ideal_: Cursors are explicitly closed or completed before `client.close()` is called. + * - _Pitfall_: `killCursors` may have to build a new connection if the in-use closure ended all pooled connections. + * - **End active sessions**: In-use sessions created with `client.startSession()` or `client.withSession()` or implicitly by the driver will have their `.endSession()` method called. + * Contrary to the name of the method, `endSession()` returns the session to the client's pool of sessions rather than end them on the server. + * - _Ideal_: Transaction outcomes are awaited and their corresponding explicit sessions are ended before `client.close()` is called. + * - _Pitfall_: **This step aborts in-progress transactions**. It is advisable to observe the outcome of a transaction before closing your client. + * - **End all pooled sessions**: The `endSessions` command with all session IDs the client has pooled is sent to the server to inform the cluster it can clean them up. + * - _Ideal_: No user intervention is expected. + * - _Pitfall_: None. + * + * The remaining shutdown is of the MongoClient resources that are intended to be entirely internal but is documented here as their existence relates to the JS event loop. + * + * - Client-side (again): + * - **Stop all server monitoring**: Connections kept live for detecting cluster changes and roundtrip time measurements are shutdown. + * - **Close all pooled connections**: Each server node in the cluster has a corresponding connection pool and all connections in the pool are closed. Any operations waiting to check out a connection will have an error thrown instead of a connection returned. + * - **Clear out server selection queue**: Any operations that are in the process of waiting for a server to be selected will have an error thrown instead of a server returned. + * - **Close encryption-related resources**: An internal MongoClient created for communicating with `mongocryptd` or other encryption purposes is closed. (Using this same method of course!) + * + * After the close method completes there should be no MongoClient related resources [ref-ed in Node.js' event loop](https://docs.libuv.org/en/v1.x/handle.html#reference-counting). + * This should allow Node.js to exit gracefully if MongoClient resources were the only active handles in the event loop. + * + * @param _force - currently an unused flag that has no effect. Defaults to `false`. + */ + async close(_force = false) { + if (this.closeLock) { + return await this.closeLock; + } + try { + this.closeLock = this._close(); + await this.closeLock; + } finally { + this.closeLock = void 0; + } + } + /* @internal */ + async _close() { + Object.defineProperty(this.s, "hasBeenClosed", { + value: true, + enumerable: true, + configurable: false, + writable: false + }); + this.topology?.closeCheckedOutConnections(); + const activeCursorCloses = Array.from(this.s.activeCursors, (cursor) => cursor.close()); + this.s.activeCursors.clear(); + await Promise.all(activeCursorCloses); + const activeSessionEnds = Array.from(this.s.activeSessions, (session) => session.endSession()); + this.s.activeSessions.clear(); + await Promise.all(activeSessionEnds); + if (this.topology == null) { + return; + } + const selector = (0, server_selection_1.readPreferenceServerSelector)(read_preference_1.ReadPreference.primaryPreferred); + const topologyDescription = this.topology.description; + const serverDescriptions = Array.from(topologyDescription.servers.values()); + const servers = selector(topologyDescription, serverDescriptions); + if (servers.length !== 0) { + const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id); + if (endSessions.length !== 0) { + try { + class EndSessionsOperation extends operation_1.AbstractOperation { + constructor() { + super(...arguments); + this.ns = utils_1.MongoDBNamespace.fromString("admin.$cmd"); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + } + buildCommand(_connection, _session) { + return { + endSessions + }; + } + buildOptions(timeoutContext) { + return { + timeoutContext, + readPreference: read_preference_1.ReadPreference.primaryPreferred, + noResponse: true + }; + } + get commandName() { + return "endSessions"; + } + } + await (0, execute_operation_1.executeOperation)(this, new EndSessionsOperation()); + } catch (error) { + (0, utils_1.squashError)(error); + } + } + } + const topology = this.topology; + this.topology = void 0; + topology.close(); + const { encrypter } = this.options; + if (encrypter) { + await encrypter.close(this); + } + } + /** + * Create a new Db instance sharing the current socket connections. + * + * @param dbName - The name of the database we want to use. If not provided, use database name from connection string. + * @param options - Optional settings for Db construction + */ + db(dbName, options) { + options = options ?? {}; + if (!dbName) { + dbName = this.s.options.dbName; + } + const finalOptions = Object.assign({}, this.options, options); + const db = new db_1.Db(this, dbName, finalOptions); + return db; + } + /** + * Connect to MongoDB using a url + * + * @remarks + * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed. + * + * @remarks + * The programmatically provided options take precedence over the URI options. + * + * @remarks + * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`. + * If those look ups throw a DNS Timeout error, the driver will retry the look up once. + * + * @see https://www.mongodb.com/docs/manual/reference/connection-string/ + */ + static async connect(url, options) { + const client = new this(url, options); + return await client.connect(); + } + /** + * Creates a new ClientSession. When using the returned session in an operation + * a corresponding ServerSession will be created. + * + * @remarks + * A ClientSession instance may only be passed to operations being performed on the same + * MongoClient it was started from. + */ + startSession(options) { + const session = new sessions_1.ClientSession(this, this.s.sessionPool, { explicit: true, ...options }, this.options); + this.s.activeSessions.add(session); + session.once("ended", () => { + this.s.activeSessions.delete(session); + }); + return session; + } + async withSession(optionsOrExecutor, executor) { + const options = { + // Always define an owner + owner: /* @__PURE__ */ Symbol(), + // If it's an object inherit the options + ...typeof optionsOrExecutor === "object" ? optionsOrExecutor : {} + }; + const withSessionCallback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor; + if (withSessionCallback == null) { + throw new error_1.MongoInvalidArgumentError("Missing required callback parameter"); + } + const session = this.startSession(options); + try { + return await withSessionCallback(session); + } finally { + try { + await session.endSession(); + } catch (error) { + (0, utils_1.squashError)(error); + } + } + } + /** + * Create a new Change Stream, watching for new changes (insertions, updates, + * replacements, deletions, and invalidations) in this cluster. Will ignore all + * changes to system collections, as well as the local, admin, and config databases. + * + * @remarks + * watch() accepts two generic arguments for distinct use cases: + * - The first is to provide the schema that may be defined for all the data within the current cluster + * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument + * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents. + * @param options - Optional settings for the command + * @typeParam TSchema - Type of the data being detected by the change stream + * @typeParam TChange - Type of the whole change stream document emitted + */ + watch(pipeline = [], options = {}) { + if (!Array.isArray(pipeline)) { + options = pipeline; + pipeline = []; + } + return new change_stream_1.ChangeStream(this, pipeline, (0, utils_1.resolveOptions)(this, options)); + } + }; + exports2.MongoClient = MongoClient; + (0, resource_management_1.configureResourceManagement)(MongoClient.prototype); + } +}); + +// node_modules/mongodb/lib/resource_management.js +var require_resource_management = __commonJS({ + "node_modules/mongodb/lib/resource_management.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.configureResourceManagement = configureResourceManagement; + exports2.configureExplicitResourceManagement = configureExplicitResourceManagement; + function configureResourceManagement(target) { + Symbol.asyncDispose && Object.defineProperty(target, Symbol.asyncDispose, { + value: async function asyncDispose() { + await this.asyncDispose(); + }, + enumerable: false, + configurable: true, + writable: true + }); + } + function configureExplicitResourceManagement() { + const { MongoClient } = require_mongo_client(); + const { ClientSession } = require_sessions(); + const { AbstractCursor } = require_abstract_cursor(); + const { ChangeStream } = require_change_stream(); + configureResourceManagement(MongoClient.prototype); + configureResourceManagement(ClientSession.prototype); + configureResourceManagement(AbstractCursor.prototype); + configureResourceManagement(ChangeStream.prototype); + } + } +}); + +// node_modules/mongodb/lib/cursor/abstract_cursor.js +var require_abstract_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/abstract_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CursorTimeoutContext = exports2.AbstractCursor = exports2.CursorTimeoutMode = exports2.CURSOR_FLAGS = void 0; + var stream_1 = require("stream"); + var bson_1 = require_bson2(); + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var execute_operation_1 = require_execute_operation(); + var get_more_1 = require_get_more(); + var kill_cursors_1 = require_kill_cursors(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var resource_management_1 = require_resource_management(); + var sessions_1 = require_sessions(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + exports2.CURSOR_FLAGS = [ + "tailable", + "oplogReplay", + "noCursorTimeout", + "awaitData", + "exhaust", + "partial" + ]; + function removeActiveCursor() { + this.client.s.activeCursors.delete(this); + } + exports2.CursorTimeoutMode = Object.freeze({ + ITERATION: "iteration", + LIFETIME: "cursorLifetime" + }); + var AbstractCursor = class extends mongo_types_1.TypedEventEmitter { + /** @internal */ + constructor(client, namespace, options = {}) { + super(); + this.documents = null; + this.hasEmittedClose = false; + this.on("error", utils_1.noop); + options.timeoutMS = void 0; + options.timeoutMode = void 0; + if (!client.s.isMongoClient) { + throw new error_1.MongoRuntimeError("Cursor must be constructed with MongoClient"); + } + this.cursorClient = client; + this.cursorNamespace = namespace; + this.cursorId = null; + this.initialized = false; + this.isClosed = false; + this.isKilled = false; + this.cursorOptions = { + readPreference: options.readPreference && options.readPreference instanceof read_preference_1.ReadPreference ? options.readPreference : read_preference_1.ReadPreference.primary, + ...(0, bson_1.pluckBSONSerializeOptions)(options), + tailable: options.tailable, + awaitData: options.awaitData + }; + const readConcern = read_concern_1.ReadConcern.fromOptions(options); + if (readConcern) { + this.cursorOptions.readConcern = readConcern; + } + if (typeof options.batchSize === "number") { + this.cursorOptions.batchSize = options.batchSize; + } + if (options.comment !== void 0) { + this.cursorOptions.comment = options.comment; + } + if (typeof options.maxTimeMS === "number") { + this.cursorOptions.maxTimeMS = options.maxTimeMS; + } + if (typeof options.maxAwaitTimeMS === "number") { + this.cursorOptions.maxAwaitTimeMS = options.maxAwaitTimeMS; + } + this.cursorSession = options.session ?? null; + this.deserializationOptions = { + ...this.cursorOptions, + validation: { + utf8: options?.enableUtf8Validation === false ? false : true + } + }; + this.timeoutContext = options.timeoutContext; + this.signal = options.signal; + this.abortListener = (0, utils_1.addAbortListener)(this.signal, () => void this.close().then(void 0, utils_1.squashError)); + this.trackCursor(); + } + /** + * The cursor has no id until it receives a response from the initial cursor creating command. + * + * It is non-zero for as long as the database has an open cursor. + * + * The initiating command may receive a zero id if the entire result is in the `firstBatch`. + */ + get id() { + return this.cursorId ?? void 0; + } + /** @internal */ + get isDead() { + return (this.cursorId?.isZero() ?? false) || this.isClosed || this.isKilled; + } + /** @internal */ + get client() { + return this.cursorClient; + } + /** @internal */ + get server() { + return this.selectedServer; + } + get namespace() { + return this.cursorNamespace; + } + get readPreference() { + return this.cursorOptions.readPreference; + } + get readConcern() { + return this.cursorOptions.readConcern; + } + /** @internal */ + get session() { + return this.cursorSession; + } + set session(clientSession) { + this.cursorSession = clientSession; + } + /** + * The cursor is closed and all remaining locally buffered documents have been iterated. + */ + get closed() { + return this.isClosed && (this.documents?.length ?? 0) === 0; + } + /** + * A `killCursors` command was attempted on this cursor. + * This is performed if the cursor id is non zero. + */ + get killed() { + return this.isKilled; + } + get loadBalanced() { + return !!this.cursorClient.topology?.loadBalanced; + } + /** @internal */ + async asyncDispose() { + await this.close(); + } + /** Adds cursor to client's tracking so it will be closed by MongoClient.close() */ + trackCursor() { + this.cursorClient.s.activeCursors.add(this); + if (!this.listeners("close").includes(removeActiveCursor)) { + this.once("close", removeActiveCursor); + } + } + /** Returns current buffered documents length */ + bufferedCount() { + return this.documents?.length ?? 0; + } + /** Returns current buffered documents */ + readBufferedDocuments(number) { + const bufferedDocs = []; + const documentsToRead = Math.min(number ?? this.documents?.length ?? 0, this.documents?.length ?? 0); + for (let count = 0; count < documentsToRead; count++) { + const document = this.documents?.shift(this.deserializationOptions); + if (document != null) { + bufferedDocs.push(document); + } + } + return bufferedDocs; + } + async *[Symbol.asyncIterator]() { + this.signal?.throwIfAborted(); + if (this.closed) { + return; + } + try { + while (true) { + if (this.isKilled) { + return; + } + if (this.closed) { + return; + } + if (this.cursorId != null && this.isDead && (this.documents?.length ?? 0) === 0) { + return; + } + const document = await this.next(); + if (document === null) { + return; + } + yield document; + this.signal?.throwIfAborted(); + } + } finally { + if (!this.isClosed) { + try { + await this.close(); + } catch (error) { + (0, utils_1.squashError)(error); + } + } + } + } + stream(options) { + const readable = new ReadableCursorStream(this); + const abortListener = (0, utils_1.addAbortListener)(this.signal, function() { + readable.destroy(this.reason); + }); + readable.once("end", () => { + abortListener?.[utils_1.kDispose](); + }); + if (options?.transform) { + const transform = options.transform; + const transformedStream = readable.pipe(new stream_1.Transform({ + objectMode: true, + highWaterMark: 1, + transform(chunk, _, callback) { + try { + const transformed = transform(chunk); + callback(void 0, transformed); + } catch (err) { + callback(err); + } + } + })); + readable.on("error", (err) => transformedStream.emit("error", err)); + return transformedStream; + } + return readable; + } + async hasNext() { + this.signal?.throwIfAborted(); + if (this.cursorId === bson_1.Long.ZERO) { + return false; + } + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION && this.cursorId != null) { + this.timeoutContext?.refresh(); + } + try { + do { + if ((this.documents?.length ?? 0) !== 0) { + return true; + } + await this.fetchBatch(); + } while (!this.isDead || (this.documents?.length ?? 0) !== 0); + } finally { + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION) { + this.timeoutContext?.clear(); + } + } + return false; + } + /** Get the next available document from the cursor, returns null if no more documents are available. */ + async next() { + this.signal?.throwIfAborted(); + if (this.cursorId === bson_1.Long.ZERO) { + throw new error_1.MongoCursorExhaustedError(); + } + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION && this.cursorId != null) { + this.timeoutContext?.refresh(); + } + try { + do { + const doc = this.documents?.shift(this.deserializationOptions); + if (doc != null) { + if (this.transform != null) + return await this.transformDocument(doc); + return doc; + } + await this.fetchBatch(); + } while (!this.isDead || (this.documents?.length ?? 0) !== 0); + } finally { + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION) { + this.timeoutContext?.clear(); + } + } + return null; + } + /** + * Try to get the next available document from the cursor or `null` if an empty batch is returned + */ + async tryNext() { + this.signal?.throwIfAborted(); + if (this.cursorId === bson_1.Long.ZERO) { + throw new error_1.MongoCursorExhaustedError(); + } + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION && this.cursorId != null) { + this.timeoutContext?.refresh(); + } + try { + let doc = this.documents?.shift(this.deserializationOptions); + if (doc != null) { + if (this.transform != null) + return await this.transformDocument(doc); + return doc; + } + await this.fetchBatch(); + doc = this.documents?.shift(this.deserializationOptions); + if (doc != null) { + if (this.transform != null) + return await this.transformDocument(doc); + return doc; + } + } finally { + if (this.cursorOptions.timeoutMode === exports2.CursorTimeoutMode.ITERATION) { + this.timeoutContext?.clear(); + } + } + return null; + } + /** + * Iterates over all the documents for this cursor using the iterator, callback pattern. + * + * If the iterator returns `false`, iteration will stop. + * + * @param iterator - The iteration callback. + * @deprecated - Will be removed in a future release. Use for await...of instead. + */ + async forEach(iterator) { + this.signal?.throwIfAborted(); + if (typeof iterator !== "function") { + throw new error_1.MongoInvalidArgumentError('Argument "iterator" must be a function'); + } + for await (const document of this) { + const result = iterator(document); + if (result === false) { + break; + } + } + } + /** + * Frees any client-side resources used by the cursor. + * + * @param _options - `timeoutMS` is deprecated and has no effect + */ + async close(_options) { + await this.cleanup(); + } + /** + * Returns an array of documents. The caller is responsible for making sure that there + * is enough memory to store the results. Note that the array only contains partial + * results when this cursor had been previously accessed. In that case, + * cursor.rewind() can be used to reset the cursor. + */ + async toArray() { + this.signal?.throwIfAborted(); + const array = []; + for await (const document of this) { + array.push(document); + const docs = this.readBufferedDocuments(); + if (this.transform != null) { + for (const doc of docs) { + array.push(await this.transformDocument(doc)); + } + } else { + array.push(...docs); + } + } + return array; + } + /** + * Add a cursor flag to the cursor + * + * @param flag - The flag to set, must be one of following ['tailable', 'oplogReplay', 'noCursorTimeout', 'awaitData', 'partial' -. + * @param value - The flag boolean value. + */ + addCursorFlag(flag, value) { + this.throwIfInitialized(); + if (!exports2.CURSOR_FLAGS.includes(flag)) { + throw new error_1.MongoInvalidArgumentError(`Flag ${flag} is not one of ${exports2.CURSOR_FLAGS}`); + } + if (typeof value !== "boolean") { + throw new error_1.MongoInvalidArgumentError(`Flag ${flag} must be a boolean value`); + } + this.cursorOptions[flag] = value; + return this; + } + /** + * Map all documents using the provided function + * If there is a transform set on the cursor, that will be called first and the result passed to + * this function's transform. + * + * @remarks + * + * **Note** Cursors use `null` internally to indicate that there are no more documents in the cursor. Providing a mapping + * function that maps values to `null` will result in the cursor closing itself before it has finished iterating + * all documents. This will **not** result in a memory leak, just surprising behavior. For example: + * + * ```typescript + * const cursor = collection.find({}); + * cursor.map(() => null); + * + * const documents = await cursor.toArray(); + * // documents is always [], regardless of how many documents are in the collection. + * ``` + * + * Other falsey values are allowed: + * + * ```typescript + * const cursor = collection.find({}); + * cursor.map(() => ''); + * + * const documents = await cursor.toArray(); + * // documents is now an array of empty strings + * ``` + * + * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor, + * it **does not** return a new instance of a cursor. This means when calling map, + * you should always assign the result to a new variable in order to get a correctly typed cursor variable. + * Take note of the following example: + * + * @example + * ```typescript + * const cursor: FindCursor = coll.find(); + * const mappedCursor: FindCursor = cursor.map(doc => Object.keys(doc).length); + * const keyCounts: number[] = await mappedCursor.toArray(); // cursor.toArray() still returns Document[] + * ``` + * @param transform - The mapping transformation method. + */ + map(transform) { + this.throwIfInitialized(); + const oldTransform = this.transform; + if (oldTransform) { + this.transform = (doc) => { + return transform(oldTransform(doc)); + }; + } else { + this.transform = transform; + } + return this; + } + /** + * Set the ReadPreference for the cursor. + * + * @param readPreference - The new read preference for the cursor. + */ + withReadPreference(readPreference) { + this.throwIfInitialized(); + if (readPreference instanceof read_preference_1.ReadPreference) { + this.cursorOptions.readPreference = readPreference; + } else if (typeof readPreference === "string") { + this.cursorOptions.readPreference = read_preference_1.ReadPreference.fromString(readPreference); + } else { + throw new error_1.MongoInvalidArgumentError(`Invalid read preference: ${readPreference}`); + } + return this; + } + /** + * Set the ReadPreference for the cursor. + * + * @param readPreference - The new read preference for the cursor. + */ + withReadConcern(readConcern) { + this.throwIfInitialized(); + const resolvedReadConcern = read_concern_1.ReadConcern.fromOptions({ readConcern }); + if (resolvedReadConcern) { + this.cursorOptions.readConcern = resolvedReadConcern; + } + return this; + } + /** + * Set a maxTimeMS on the cursor query, allowing for hard timeout limits on queries (Only supported on MongoDB 2.6 or higher) + * + * @param value - Number of milliseconds to wait before aborting the query. + */ + maxTimeMS(value) { + this.throwIfInitialized(); + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError("Argument for maxTimeMS must be a number"); + } + this.cursorOptions.maxTimeMS = value; + return this; + } + /** + * Set the batch size for the cursor. + * + * @param value - The number of documents to return per batch. See {@link https://www.mongodb.com/docs/manual/reference/command/find/|find command documentation}. + */ + batchSize(value) { + this.throwIfInitialized(); + if (this.cursorOptions.tailable) { + throw new error_1.MongoTailableCursorError("Tailable cursor does not support batchSize"); + } + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError('Operation "batchSize" requires an integer'); + } + this.cursorOptions.batchSize = value; + return this; + } + /** + * Rewind this cursor to its uninitialized state. Any options that are present on the cursor will + * remain in effect. Iterating this cursor will cause new queries to be sent to the server, even + * if the resultant data has already been retrieved by this cursor. + */ + rewind() { + if (this.timeoutContext && this.timeoutContext.owner !== this) { + throw new error_1.MongoAPIError(`Cannot rewind cursor that does not own its timeout context.`); + } + if (!this.initialized) { + return; + } + this.cursorId = null; + this.documents?.clear(); + this.timeoutContext?.clear(); + this.timeoutContext = void 0; + this.isClosed = false; + this.isKilled = false; + this.initialized = false; + this.hasEmittedClose = false; + this.trackCursor(); + if (this.cursorSession?.explicit === false) { + if (!this.cursorSession.hasEnded) { + this.cursorSession.endSession().then(void 0, utils_1.squashError); + } + this.cursorSession = null; + } + } + /** @internal */ + async getMore(batchSize) { + if (this.cursorId == null) { + throw new error_1.MongoRuntimeError("Unexpected null cursor id. A cursor creating command should have set this"); + } + if (this.selectedServer == null) { + throw new error_1.MongoRuntimeError("Unexpected null selectedServer. A cursor creating command should have set this"); + } + if (this.cursorSession == null) { + throw new error_1.MongoRuntimeError("Unexpected null session. A cursor creating command should have set this"); + } + const getMoreOptions = { + ...this.cursorOptions, + session: this.cursorSession, + batchSize + }; + const getMoreOperation = new get_more_1.GetMoreOperation(this.cursorNamespace, this.cursorId, this.selectedServer, getMoreOptions); + return await (0, execute_operation_1.executeOperation)(this.cursorClient, getMoreOperation, this.timeoutContext); + } + /** + * @internal + * + * This function is exposed for the unified test runner's createChangeStream + * operation. We cannot refactor to use the abstract _initialize method without + * a significant refactor. + */ + async cursorInit() { + if (this.cursorOptions.timeoutMS != null) { + this.timeoutContext ??= new CursorTimeoutContext(timeout_1.TimeoutContext.create({ + serverSelectionTimeoutMS: this.client.s.options.serverSelectionTimeoutMS, + timeoutMS: this.cursorOptions.timeoutMS + }), this); + } + try { + this.cursorSession ??= this.cursorClient.startSession({ owner: this, explicit: false }); + const state = await this._initialize(this.cursorSession); + this.cursorOptions.omitMaxTimeMS = this.cursorOptions.timeoutMS != null; + const response = state.response; + this.selectedServer = state.server; + this.cursorId = response.id; + this.cursorNamespace = response.ns ?? this.namespace; + this.documents = response; + this.initialized = true; + } catch (error) { + this.initialized = true; + await this.cleanup(void 0, error); + throw error; + } + if (this.isDead) { + await this.cleanup(); + } + return; + } + /** @internal Attempt to obtain more documents */ + async fetchBatch() { + if (this.isClosed) { + return; + } + if (this.isDead) { + await this.cleanup(); + return; + } + if (this.cursorId == null) { + await this.cursorInit(); + if ((this.documents?.length ?? 0) !== 0 || this.isDead) + return; + } + const batchSize = this.cursorOptions.batchSize || 1e3; + try { + const response = await this.getMore(batchSize); + this.cursorId = response.id; + this.documents = response; + } catch (error) { + try { + await this.cleanup(void 0, error); + } catch (cleanupError) { + (0, utils_1.squashError)(cleanupError); + } + throw error; + } + if (this.isDead) { + await this.cleanup(); + } + } + /** @internal */ + async cleanup(timeoutMS, error) { + this.abortListener?.[utils_1.kDispose](); + this.isClosed = true; + const timeoutContextForKillCursors = () => { + if (timeoutMS != null) { + this.timeoutContext?.clear(); + return new CursorTimeoutContext(timeout_1.TimeoutContext.create({ + serverSelectionTimeoutMS: this.client.s.options.serverSelectionTimeoutMS, + timeoutMS + }), this); + } else { + return this.timeoutContext?.refreshed(); + } + }; + const withEmitClose = async (fn) => { + try { + await fn(); + } finally { + this.emitClose(); + } + }; + const close = async () => { + const session = this.cursorSession; + if (!session) + return; + try { + if (!this.isKilled && this.cursorId && !this.cursorId.isZero() && this.cursorNamespace && this.selectedServer && !session.hasEnded) { + this.isKilled = true; + const cursorId = this.cursorId; + this.cursorId = bson_1.Long.ZERO; + await (0, execute_operation_1.executeOperation)(this.cursorClient, new kill_cursors_1.KillCursorsOperation(cursorId, this.cursorNamespace, this.selectedServer, { + session + }), timeoutContextForKillCursors()); + } + } catch (error2) { + (0, utils_1.squashError)(error2); + } finally { + if (session.owner === this) { + await session.endSession({ error }); + } + if (!session.inTransaction()) { + (0, sessions_1.maybeClearPinnedConnection)(session, { error }); + } + } + }; + await withEmitClose(close); + } + /** @internal */ + emitClose() { + try { + if (!this.hasEmittedClose && ((this.documents?.length ?? 0) === 0 || this.isClosed)) { + this.emit("close"); + } + } finally { + this.hasEmittedClose = true; + } + } + /** @internal */ + async transformDocument(document) { + if (this.transform == null) + return document; + try { + const transformedDocument = this.transform(document); + if (transformedDocument === null) { + const TRANSFORM_TO_NULL_ERROR = "Cursor returned a `null` document, but the cursor is not exhausted. Mapping documents to `null` is not supported in the cursor transform."; + throw new error_1.MongoAPIError(TRANSFORM_TO_NULL_ERROR); + } + return transformedDocument; + } catch (transformError) { + try { + await this.close(); + } catch (closeError) { + (0, utils_1.squashError)(closeError); + } + throw transformError; + } + } + /** @internal */ + throwIfInitialized() { + if (this.initialized) + throw new error_1.MongoCursorInUseError(); + } + }; + exports2.AbstractCursor = AbstractCursor; + AbstractCursor.CLOSE = "close"; + var ReadableCursorStream = class extends stream_1.Readable { + constructor(cursor) { + super({ + objectMode: true, + autoDestroy: false, + highWaterMark: 1 + }); + this._readInProgress = false; + this._cursor = cursor; + } + // eslint-disable-next-line @typescript-eslint/no-unused-vars + _read(size) { + if (!this._readInProgress) { + this._readInProgress = true; + this._readNext(); + } + } + _destroy(error, callback) { + this._cursor.close().then(() => callback(error), (closeError) => callback(closeError)); + } + _readNext() { + if (this._cursor.id === bson_1.Long.ZERO) { + this.push(null); + return; + } + this._cursor.next().then( + // result from next() + (result) => { + if (result == null) { + this.push(null); + } else if (this.destroyed) { + this._cursor.close().then(void 0, utils_1.squashError); + } else { + if (this.push(result)) { + return this._readNext(); + } + this._readInProgress = false; + } + }, + // error from next() + (err) => { + if (err.message.match(/server is closed/)) { + this._cursor.close().then(void 0, utils_1.squashError); + return this.push(null); + } + if (err.message.match(/operation was interrupted/)) { + return this.push(null); + } + return this.destroy(err); + } + ).catch((error) => { + this._readInProgress = false; + this.destroy(error); + }); + } + }; + (0, resource_management_1.configureResourceManagement)(AbstractCursor.prototype); + var CursorTimeoutContext = class _CursorTimeoutContext extends timeout_1.TimeoutContext { + constructor(timeoutContext, owner) { + super(); + this.timeoutContext = timeoutContext; + this.owner = owner; + } + get serverSelectionTimeout() { + return this.timeoutContext.serverSelectionTimeout; + } + get connectionCheckoutTimeout() { + return this.timeoutContext.connectionCheckoutTimeout; + } + get clearServerSelectionTimeout() { + return this.timeoutContext.clearServerSelectionTimeout; + } + get timeoutForSocketWrite() { + return this.timeoutContext.timeoutForSocketWrite; + } + get timeoutForSocketRead() { + return this.timeoutContext.timeoutForSocketRead; + } + csotEnabled() { + return this.timeoutContext.csotEnabled(); + } + refresh() { + if (typeof this.owner !== "symbol") + return this.timeoutContext.refresh(); + } + clear() { + if (typeof this.owner !== "symbol") + return this.timeoutContext.clear(); + } + get maxTimeMS() { + return this.timeoutContext.maxTimeMS; + } + get timeoutMS() { + return this.timeoutContext.csotEnabled() ? this.timeoutContext.timeoutMS : null; + } + refreshed() { + return new _CursorTimeoutContext(this.timeoutContext.refreshed(), this.owner); + } + addMaxTimeMSToCommand(command, options) { + this.timeoutContext.addMaxTimeMSToCommand(command, options); + } + getSocketTimeoutMS() { + return this.timeoutContext.getSocketTimeoutMS(); + } + }; + exports2.CursorTimeoutContext = CursorTimeoutContext; + } +}); + +// node_modules/mongodb/lib/cursor/explainable_cursor.js +var require_explainable_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/explainable_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ExplainableCursor = void 0; + var abstract_cursor_1 = require_abstract_cursor(); + var ExplainableCursor = class extends abstract_cursor_1.AbstractCursor { + resolveExplainTimeoutOptions(verbosity, options) { + let explain; + let timeout; + if (verbosity == null && options == null) { + explain = void 0; + timeout = void 0; + } else if (verbosity != null && options == null) { + explain = typeof verbosity !== "object" ? verbosity : "verbosity" in verbosity ? verbosity : void 0; + timeout = typeof verbosity === "object" && "timeoutMS" in verbosity ? verbosity : void 0; + } else { + explain = verbosity; + timeout = options; + } + return { timeout, explain }; + } + }; + exports2.ExplainableCursor = ExplainableCursor; + } +}); + +// node_modules/mongodb/lib/cursor/aggregation_cursor.js +var require_aggregation_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/aggregation_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.AggregationCursor = void 0; + var error_1 = require_error(); + var aggregate_1 = require_aggregate(); + var execute_operation_1 = require_execute_operation(); + var utils_1 = require_utils3(); + var abstract_cursor_1 = require_abstract_cursor(); + var explainable_cursor_1 = require_explainable_cursor(); + var AggregationCursor = class _AggregationCursor extends explainable_cursor_1.ExplainableCursor { + /** @internal */ + constructor(client, namespace, pipeline = [], options = {}) { + super(client, namespace, options); + this.pipeline = pipeline; + this.aggregateOptions = options; + const lastStage = this.pipeline[this.pipeline.length - 1]; + if (this.cursorOptions.timeoutMS != null && this.cursorOptions.timeoutMode === abstract_cursor_1.CursorTimeoutMode.ITERATION && (lastStage?.$merge != null || lastStage?.$out != null)) + throw new error_1.MongoAPIError("Cannot use $out or $merge stage with ITERATION timeoutMode"); + } + clone() { + const clonedOptions = (0, utils_1.mergeOptions)({}, this.aggregateOptions); + delete clonedOptions.session; + return new _AggregationCursor(this.client, this.namespace, this.pipeline, { + ...clonedOptions + }); + } + map(transform) { + return super.map(transform); + } + /** @internal */ + async _initialize(session) { + const options = { + ...this.aggregateOptions, + ...this.cursorOptions, + session, + signal: this.signal + }; + const aggregateOperation = new aggregate_1.AggregateOperation(this.namespace, this.pipeline, options); + const response = await (0, execute_operation_1.executeOperation)(this.client, aggregateOperation, this.timeoutContext); + return { server: aggregateOperation.server, session, response }; + } + async explain(verbosity, options) { + const { explain, timeout } = this.resolveExplainTimeoutOptions(verbosity, options); + return (await (0, execute_operation_1.executeOperation)(this.client, new aggregate_1.AggregateOperation(this.namespace, this.pipeline, { + ...this.aggregateOptions, + // NOTE: order matters here, we may need to refine this + ...this.cursorOptions, + ...timeout, + explain: explain ?? true + }))).shift(this.deserializationOptions); + } + addStage(stage) { + this.throwIfInitialized(); + if (this.cursorOptions.timeoutMS != null && this.cursorOptions.timeoutMode === abstract_cursor_1.CursorTimeoutMode.ITERATION && (stage.$out != null || stage.$merge != null)) { + throw new error_1.MongoAPIError("Cannot use $out or $merge stage with ITERATION timeoutMode"); + } + this.pipeline.push(stage); + return this; + } + group($group) { + return this.addStage({ $group }); + } + /** Add a limit stage to the aggregation pipeline */ + limit($limit) { + return this.addStage({ $limit }); + } + /** Add a match stage to the aggregation pipeline */ + match($match) { + return this.addStage({ $match }); + } + /** Add an out stage to the aggregation pipeline */ + out($out) { + return this.addStage({ $out }); + } + /** + * Add a project stage to the aggregation pipeline + * + * @remarks + * In order to strictly type this function you must provide an interface + * that represents the effect of your projection on the result documents. + * + * By default chaining a projection to your cursor changes the returned type to the generic {@link Document} type. + * You should specify a parameterized type to have assertions on your final results. + * + * @example + * ```typescript + * // Best way + * const docs: AggregationCursor<{ a: number }> = cursor.project<{ a: number }>({ _id: 0, a: true }); + * // Flexible way + * const docs: AggregationCursor = cursor.project({ _id: 0, a: true }); + * ``` + * + * @remarks + * In order to strictly type this function you must provide an interface + * that represents the effect of your projection on the result documents. + * + * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor, + * it **does not** return a new instance of a cursor. This means when calling project, + * you should always assign the result to a new variable in order to get a correctly typed cursor variable. + * Take note of the following example: + * + * @example + * ```typescript + * const cursor: AggregationCursor<{ a: number; b: string }> = coll.aggregate([]); + * const projectCursor = cursor.project<{ a: number }>({ _id: 0, a: true }); + * const aPropOnlyArray: {a: number}[] = await projectCursor.toArray(); + * + * // or always use chaining and save the final cursor + * + * const cursor = coll.aggregate().project<{ a: string }>({ + * _id: 0, + * a: { $convert: { input: '$a', to: 'string' } + * }}); + * ``` + */ + project($project) { + return this.addStage({ $project }); + } + /** Add a lookup stage to the aggregation pipeline */ + lookup($lookup) { + return this.addStage({ $lookup }); + } + /** Add a redact stage to the aggregation pipeline */ + redact($redact) { + return this.addStage({ $redact }); + } + /** Add a skip stage to the aggregation pipeline */ + skip($skip) { + return this.addStage({ $skip }); + } + /** Add a sort stage to the aggregation pipeline */ + sort($sort) { + return this.addStage({ $sort }); + } + /** Add a unwind stage to the aggregation pipeline */ + unwind($unwind) { + return this.addStage({ $unwind }); + } + /** Add a geoNear stage to the aggregation pipeline */ + geoNear($geoNear) { + return this.addStage({ $geoNear }); + } + }; + exports2.AggregationCursor = AggregationCursor; + } +}); + +// node_modules/mongodb/lib/operations/count.js +var require_count = __commonJS({ + "node_modules/mongodb/lib/operations/count.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CountOperation = void 0; + var responses_1 = require_responses(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var CountOperation = class extends command_1.CommandOperation { + constructor(namespace, filter, options) { + super({ s: { namespace } }, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.collectionName = namespace.collection; + this.query = filter; + } + get commandName() { + return "count"; + } + buildCommandDocument(_connection, _session) { + const options = this.options; + const cmd = { + count: this.collectionName, + query: this.query + }; + if (typeof options.limit === "number") { + cmd.limit = options.limit; + } + if (typeof options.skip === "number") { + cmd.skip = options.skip; + } + if (options.hint != null) { + cmd.hint = options.hint; + } + if (typeof options.maxTimeMS === "number") { + cmd.maxTimeMS = options.maxTimeMS; + } + return cmd; + } + handleOk(response) { + return response.getNumber("n") ?? 0; + } + }; + exports2.CountOperation = CountOperation; + (0, operation_1.defineAspects)(CountOperation, [operation_1.Aspect.READ_OPERATION, operation_1.Aspect.RETRYABLE, operation_1.Aspect.SUPPORTS_RAW_DATA]); + } +}); + +// node_modules/mongodb/lib/operations/find.js +var require_find = __commonJS({ + "node_modules/mongodb/lib/operations/find.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.FindOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var sort_1 = require_sort(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var FindOperation = class extends command_1.CommandOperation { + constructor(ns, filter = {}, options = {}) { + super(void 0, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.CursorResponse; + this.options = { ...options }; + delete this.options.writeConcern; + this.ns = ns; + if (typeof filter !== "object" || Array.isArray(filter)) { + throw new error_1.MongoInvalidArgumentError("Query filter must be a plain object or ObjectId"); + } + this.filter = filter != null && filter._bsontype === "ObjectId" ? { _id: filter } : filter; + this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? responses_1.ExplainedCursorResponse : responses_1.CursorResponse; + } + get commandName() { + return "find"; + } + buildOptions(timeoutContext) { + return { + ...this.options, + ...this.bsonOptions, + documentsReturnedIn: "firstBatch", + session: this.session, + timeoutContext + }; + } + handleOk(response) { + return response; + } + buildCommandDocument() { + return makeFindCommand(this.ns, this.filter, this.options); + } + }; + exports2.FindOperation = FindOperation; + function makeFindCommand(ns, filter, options) { + const findCommand = { + find: ns.collection, + filter + }; + if (options.sort) { + findCommand.sort = (0, sort_1.formatSort)(options.sort); + } + if (options.projection) { + let projection = options.projection; + if (projection && Array.isArray(projection)) { + projection = projection.length ? projection.reduce((result, field) => { + result[field] = 1; + return result; + }, {}) : { _id: 1 }; + } + findCommand.projection = projection; + } + if (options.hint) { + findCommand.hint = (0, utils_1.normalizeHintField)(options.hint); + } + if (typeof options.skip === "number") { + findCommand.skip = options.skip; + } + if (typeof options.limit === "number") { + if (options.limit < 0) { + findCommand.limit = -options.limit; + findCommand.singleBatch = true; + } else { + findCommand.limit = options.limit; + } + } + if (typeof options.batchSize === "number") { + if (options.batchSize < 0) { + findCommand.limit = -options.batchSize; + } else { + if (options.batchSize === options.limit) { + findCommand.batchSize = options.batchSize + 1; + } else { + findCommand.batchSize = options.batchSize; + } + } + } + if (typeof options.singleBatch === "boolean") { + findCommand.singleBatch = options.singleBatch; + } + if (options.comment !== void 0) { + findCommand.comment = options.comment; + } + if (options.max) { + findCommand.max = options.max; + } + if (options.min) { + findCommand.min = options.min; + } + if (typeof options.returnKey === "boolean") { + findCommand.returnKey = options.returnKey; + } + if (typeof options.showRecordId === "boolean") { + findCommand.showRecordId = options.showRecordId; + } + if (typeof options.tailable === "boolean") { + findCommand.tailable = options.tailable; + } + if (typeof options.oplogReplay === "boolean") { + findCommand.oplogReplay = options.oplogReplay; + } + if (typeof options.timeout === "boolean") { + findCommand.noCursorTimeout = !options.timeout; + } else if (typeof options.noCursorTimeout === "boolean") { + findCommand.noCursorTimeout = options.noCursorTimeout; + } + if (typeof options.awaitData === "boolean") { + findCommand.awaitData = options.awaitData; + } + if (typeof options.allowPartialResults === "boolean") { + findCommand.allowPartialResults = options.allowPartialResults; + } + if (typeof options.allowDiskUse === "boolean") { + findCommand.allowDiskUse = options.allowDiskUse; + } + if (options.let) { + findCommand.let = options.let; + } + return findCommand; + } + (0, operation_1.defineAspects)(FindOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/cursor/find_cursor.js +var require_find_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/find_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.FindCursor = exports2.FLAGS = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var count_1 = require_count(); + var execute_operation_1 = require_execute_operation(); + var find_1 = require_find(); + var sort_1 = require_sort(); + var utils_1 = require_utils3(); + var explainable_cursor_1 = require_explainable_cursor(); + exports2.FLAGS = [ + "tailable", + "oplogReplay", + "noCursorTimeout", + "awaitData", + "exhaust", + "partial" + ]; + var FindCursor = class _FindCursor extends explainable_cursor_1.ExplainableCursor { + /** @internal */ + constructor(client, namespace, filter = {}, options = {}) { + super(client, namespace, options); + this.numReturned = 0; + this.cursorFilter = filter; + this.findOptions = options; + if (options.sort != null) { + this.findOptions.sort = (0, sort_1.formatSort)(options.sort); + } + } + clone() { + const clonedOptions = (0, utils_1.mergeOptions)({}, this.findOptions); + delete clonedOptions.session; + return new _FindCursor(this.client, this.namespace, this.cursorFilter, { + ...clonedOptions + }); + } + map(transform) { + return super.map(transform); + } + /** @internal */ + async _initialize(session) { + const options = { + ...this.findOptions, + // NOTE: order matters here, we may need to refine this + ...this.cursorOptions, + session, + signal: this.signal + }; + const findOperation = new find_1.FindOperation(this.namespace, this.cursorFilter, options); + const response = await (0, execute_operation_1.executeOperation)(this.client, findOperation, this.timeoutContext); + this.numReturned = response.batchSize; + return { server: findOperation.server, session, response }; + } + /** @internal */ + async getMore(batchSize) { + const numReturned = this.numReturned; + if (numReturned) { + const limit = this.findOptions.limit; + batchSize = limit && limit > 0 && numReturned + batchSize > limit ? limit - numReturned : batchSize; + if (batchSize <= 0) { + try { + await this.close(); + } catch (error) { + (0, utils_1.squashError)(error); + } + return responses_1.CursorResponse.emptyGetMore; + } + } + const response = await super.getMore(batchSize); + this.numReturned = this.numReturned + response.batchSize; + return response; + } + /** + * Get the count of documents for this cursor + * @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead + */ + async count(options) { + (0, utils_1.emitWarningOnce)("cursor.count is deprecated and will be removed in the next major version, please use `collection.estimatedDocumentCount` or `collection.countDocuments` instead "); + if (typeof options === "boolean") { + throw new error_1.MongoInvalidArgumentError("Invalid first parameter to count"); + } + return await (0, execute_operation_1.executeOperation)(this.client, new count_1.CountOperation(this.namespace, this.cursorFilter, { + ...this.findOptions, + // NOTE: order matters here, we may need to refine this + ...this.cursorOptions, + ...options + })); + } + async explain(verbosity, options) { + const { explain, timeout } = this.resolveExplainTimeoutOptions(verbosity, options); + return (await (0, execute_operation_1.executeOperation)(this.client, new find_1.FindOperation(this.namespace, this.cursorFilter, { + ...this.findOptions, + // NOTE: order matters here, we may need to refine this + ...this.cursorOptions, + ...timeout, + explain: explain ?? true + }))).shift(this.deserializationOptions); + } + /** Set the cursor query */ + filter(filter) { + this.throwIfInitialized(); + this.cursorFilter = filter; + return this; + } + /** + * Set the cursor hint + * + * @param hint - If specified, then the query system will only consider plans using the hinted index. + */ + hint(hint) { + this.throwIfInitialized(); + this.findOptions.hint = hint; + return this; + } + /** + * Set the cursor min + * + * @param min - Specify a $min value to specify the inclusive lower bound for a specific index in order to constrain the results of find(). The $min specifies the lower bound for all keys of a specific index in order. + */ + min(min) { + this.throwIfInitialized(); + this.findOptions.min = min; + return this; + } + /** + * Set the cursor max + * + * @param max - Specify a $max value to specify the exclusive upper bound for a specific index in order to constrain the results of find(). The $max specifies the upper bound for all keys of a specific index in order. + */ + max(max) { + this.throwIfInitialized(); + this.findOptions.max = max; + return this; + } + /** + * Set the cursor returnKey. + * If set to true, modifies the cursor to only return the index field or fields for the results of the query, rather than documents. + * If set to true and the query does not use an index to perform the read operation, the returned documents will not contain any fields. + * + * @param value - the returnKey value. + */ + returnKey(value) { + this.throwIfInitialized(); + this.findOptions.returnKey = value; + return this; + } + /** + * Modifies the output of a query by adding a field $recordId to matching documents. $recordId is the internal key which uniquely identifies a document in a collection. + * + * @param value - The $showDiskLoc option has now been deprecated and replaced with the showRecordId field. $showDiskLoc will still be accepted for OP_QUERY stye find. + */ + showRecordId(value) { + this.throwIfInitialized(); + this.findOptions.showRecordId = value; + return this; + } + /** + * Add a query modifier to the cursor query + * + * @param name - The query modifier (must start with $, such as $orderby etc) + * @param value - The modifier value. + */ + addQueryModifier(name, value) { + this.throwIfInitialized(); + if (name[0] !== "$") { + throw new error_1.MongoInvalidArgumentError(`${name} is not a valid query modifier`); + } + const field = name.substr(1); + switch (field) { + case "comment": + this.findOptions.comment = value; + break; + case "explain": + this.findOptions.explain = value; + break; + case "hint": + this.findOptions.hint = value; + break; + case "max": + this.findOptions.max = value; + break; + case "maxTimeMS": + this.findOptions.maxTimeMS = value; + break; + case "min": + this.findOptions.min = value; + break; + case "orderby": + this.findOptions.sort = (0, sort_1.formatSort)(value); + break; + case "query": + this.cursorFilter = value; + break; + case "returnKey": + this.findOptions.returnKey = value; + break; + case "showDiskLoc": + this.findOptions.showRecordId = value; + break; + default: + throw new error_1.MongoInvalidArgumentError(`Invalid query modifier: ${name}`); + } + return this; + } + /** + * Add a comment to the cursor query allowing for tracking the comment in the log. + * + * @param value - The comment attached to this query. + */ + comment(value) { + this.throwIfInitialized(); + this.findOptions.comment = value; + return this; + } + /** + * Set a maxAwaitTimeMS on a tailing cursor query to allow to customize the timeout value for the option awaitData (Only supported on MongoDB 3.2 or higher, ignored otherwise) + * + * @param value - Number of milliseconds to wait before aborting the tailed query. + */ + maxAwaitTimeMS(value) { + this.throwIfInitialized(); + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError("Argument for maxAwaitTimeMS must be a number"); + } + this.findOptions.maxAwaitTimeMS = value; + return this; + } + /** + * Set a maxTimeMS on the cursor query, allowing for hard timeout limits on queries (Only supported on MongoDB 2.6 or higher) + * + * @param value - Number of milliseconds to wait before aborting the query. + */ + maxTimeMS(value) { + this.throwIfInitialized(); + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError("Argument for maxTimeMS must be a number"); + } + this.findOptions.maxTimeMS = value; + return this; + } + /** + * Add a project stage to the aggregation pipeline + * + * @remarks + * In order to strictly type this function you must provide an interface + * that represents the effect of your projection on the result documents. + * + * By default chaining a projection to your cursor changes the returned type to the generic + * {@link Document} type. + * You should specify a parameterized type to have assertions on your final results. + * + * @example + * ```typescript + * // Best way + * const docs: FindCursor<{ a: number }> = cursor.project<{ a: number }>({ _id: 0, a: true }); + * // Flexible way + * const docs: FindCursor = cursor.project({ _id: 0, a: true }); + * ``` + * + * @remarks + * + * **Note for Typescript Users:** adding a transform changes the return type of the iteration of this cursor, + * it **does not** return a new instance of a cursor. This means when calling project, + * you should always assign the result to a new variable in order to get a correctly typed cursor variable. + * Take note of the following example: + * + * @example + * ```typescript + * const cursor: FindCursor<{ a: number; b: string }> = coll.find(); + * const projectCursor = cursor.project<{ a: number }>({ _id: 0, a: true }); + * const aPropOnlyArray: {a: number}[] = await projectCursor.toArray(); + * + * // or always use chaining and save the final cursor + * + * const cursor = coll.find().project<{ a: string }>({ + * _id: 0, + * a: { $convert: { input: '$a', to: 'string' } + * }}); + * ``` + */ + project(value) { + this.throwIfInitialized(); + this.findOptions.projection = value; + return this; + } + /** + * Sets the sort order of the cursor query. + * + * @param sort - The key or keys set for the sort. + * @param direction - The direction of the sorting (1 or -1). + */ + sort(sort, direction) { + this.throwIfInitialized(); + if (this.findOptions.tailable) { + throw new error_1.MongoTailableCursorError("Tailable cursor does not support sorting"); + } + this.findOptions.sort = (0, sort_1.formatSort)(sort, direction); + return this; + } + /** + * Allows disk use for blocking sort operations exceeding 100MB memory. (MongoDB 3.2 or higher) + * + * @remarks + * {@link https://www.mongodb.com/docs/manual/reference/command/find/#find-cmd-allowdiskuse | find command allowDiskUse documentation} + */ + allowDiskUse(allow = true) { + this.throwIfInitialized(); + if (!this.findOptions.sort) { + throw new error_1.MongoInvalidArgumentError('Option "allowDiskUse" requires a sort specification'); + } + if (!allow) { + this.findOptions.allowDiskUse = false; + return this; + } + this.findOptions.allowDiskUse = true; + return this; + } + /** + * Set the collation options for the cursor. + * + * @param value - The cursor collation options (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields). + */ + collation(value) { + this.throwIfInitialized(); + this.findOptions.collation = value; + return this; + } + /** + * Set the limit for the cursor. + * + * @param value - The limit for the cursor query. + */ + limit(value) { + this.throwIfInitialized(); + if (this.findOptions.tailable) { + throw new error_1.MongoTailableCursorError("Tailable cursor does not support limit"); + } + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError('Operation "limit" requires an integer'); + } + this.findOptions.limit = value; + return this; + } + /** + * Set the skip for the cursor. + * + * @param value - The skip for the cursor query. + */ + skip(value) { + this.throwIfInitialized(); + if (this.findOptions.tailable) { + throw new error_1.MongoTailableCursorError("Tailable cursor does not support skip"); + } + if (typeof value !== "number") { + throw new error_1.MongoInvalidArgumentError('Operation "skip" requires an integer'); + } + this.findOptions.skip = value; + return this; + } + }; + exports2.FindCursor = FindCursor; + } +}); + +// node_modules/mongodb/lib/cursor/list_indexes_cursor.js +var require_list_indexes_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/list_indexes_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListIndexesCursor = void 0; + var execute_operation_1 = require_execute_operation(); + var indexes_1 = require_indexes(); + var abstract_cursor_1 = require_abstract_cursor(); + var ListIndexesCursor = class _ListIndexesCursor extends abstract_cursor_1.AbstractCursor { + constructor(collection, options) { + super(collection.client, collection.s.namespace, { ...options }); + this.parent = collection; + this.options = options; + } + clone() { + return new _ListIndexesCursor(this.parent, { + ...this.options, + ...this.cursorOptions + }); + } + /** @internal */ + async _initialize(session) { + const operation = new indexes_1.ListIndexesOperation(this.parent, { + ...this.cursorOptions, + ...this.options, + session + }); + const response = await (0, execute_operation_1.executeOperation)(this.parent.client, operation, this.timeoutContext); + return { server: operation.server, session, response }; + } + }; + exports2.ListIndexesCursor = ListIndexesCursor; + } +}); + +// node_modules/mongodb/lib/cursor/list_search_indexes_cursor.js +var require_list_search_indexes_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/list_search_indexes_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ListSearchIndexesCursor = void 0; + var aggregation_cursor_1 = require_aggregation_cursor(); + var ListSearchIndexesCursor = class extends aggregation_cursor_1.AggregationCursor { + /** @internal */ + constructor({ fullNamespace: ns, client }, name, options = {}) { + const pipeline = name == null ? [{ $listSearchIndexes: {} }] : [{ $listSearchIndexes: { name } }]; + super(client, ns, pipeline, options); + } + }; + exports2.ListSearchIndexesCursor = ListSearchIndexesCursor; + } +}); + +// node_modules/mongodb/lib/operations/distinct.js +var require_distinct = __commonJS({ + "node_modules/mongodb/lib/operations/distinct.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DistinctOperation = void 0; + var responses_1 = require_responses(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var DistinctOperation = class extends command_1.CommandOperation { + /** + * Construct a Distinct operation. + * + * @param collection - Collection instance. + * @param key - Field of the document to find distinct values for. + * @param query - The query for filtering the set of documents to which we apply the distinct filter. + * @param options - Optional settings. See Collection.prototype.distinct for a list of options. + */ + constructor(collection, key, query, options) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options ?? {}; + this.collection = collection; + this.key = key; + this.query = query; + } + get commandName() { + return "distinct"; + } + buildCommandDocument(_connection) { + const command = { + distinct: this.collection.collectionName, + key: this.key, + query: this.query + }; + if (this.options.comment !== void 0) { + command.comment = this.options.comment; + } + if (this.options.hint != null) { + command.hint = this.options.hint; + } + return command; + } + handleOk(response) { + if (this.explain) { + return response.toObject(this.bsonOptions); + } + return response.toObject(this.bsonOptions).values; + } + }; + exports2.DistinctOperation = DistinctOperation; + (0, operation_1.defineAspects)(DistinctOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/operations/estimated_document_count.js +var require_estimated_document_count = __commonJS({ + "node_modules/mongodb/lib/operations/estimated_document_count.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.EstimatedDocumentCountOperation = void 0; + var responses_1 = require_responses(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + var EstimatedDocumentCountOperation = class extends command_1.CommandOperation { + constructor(collection, options = {}) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.collectionName = collection.collectionName; + } + get commandName() { + return "count"; + } + buildCommandDocument(_connection, _session) { + const cmd = { count: this.collectionName }; + if (typeof this.options.maxTimeMS === "number") { + cmd.maxTimeMS = this.options.maxTimeMS; + } + if (this.options.comment !== void 0) { + cmd.comment = this.options.comment; + } + return cmd; + } + handleOk(response) { + return response.getNumber("n") ?? 0; + } + }; + exports2.EstimatedDocumentCountOperation = EstimatedDocumentCountOperation; + (0, operation_1.defineAspects)(EstimatedDocumentCountOperation, [ + operation_1.Aspect.READ_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.CURSOR_CREATING, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/operations/find_and_modify.js +var require_find_and_modify = __commonJS({ + "node_modules/mongodb/lib/operations/find_and_modify.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.FindOneAndUpdateOperation = exports2.FindOneAndReplaceOperation = exports2.FindOneAndDeleteOperation = exports2.FindAndModifyOperation = exports2.ReturnDocument = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var read_preference_1 = require_read_preference(); + var sort_1 = require_sort(); + var utils_1 = require_utils3(); + var command_1 = require_command2(); + var operation_1 = require_operation(); + exports2.ReturnDocument = Object.freeze({ + BEFORE: "before", + AFTER: "after" + }); + function configureFindAndModifyCmdBaseUpdateOpts(cmdBase, options) { + cmdBase.new = options.returnDocument === exports2.ReturnDocument.AFTER; + cmdBase.upsert = options.upsert === true; + if (options.bypassDocumentValidation === true) { + cmdBase.bypassDocumentValidation = options.bypassDocumentValidation; + } + return cmdBase; + } + var FindAndModifyOperation = class extends command_1.CommandOperation { + constructor(collection, query, options) { + super(collection, options); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.options = options; + this.readPreference = read_preference_1.ReadPreference.primary; + this.collection = collection; + this.query = query; + } + get commandName() { + return "findAndModify"; + } + buildCommandDocument(connection, _session) { + const options = this.options; + const command = { + findAndModify: this.collection.collectionName, + query: this.query, + remove: false, + new: false, + upsert: false + }; + options.includeResultMetadata ??= false; + const sort = (0, sort_1.formatSort)(options.sort); + if (sort) { + command.sort = sort; + } + if (options.projection) { + command.fields = options.projection; + } + if (options.maxTimeMS) { + command.maxTimeMS = options.maxTimeMS; + } + if (options.writeConcern) { + command.writeConcern = options.writeConcern; + } + if (options.let) { + command.let = options.let; + } + if (options.comment !== void 0) { + command.comment = options.comment; + } + (0, utils_1.decorateWithCollation)(command, options); + if (options.hint) { + const unacknowledgedWrite = this.writeConcern?.w === 0; + if (unacknowledgedWrite && (0, utils_1.maxWireVersion)(connection) < 9) { + throw new error_1.MongoCompatibilityError("hint for the findAndModify command is only supported on MongoDB 4.4+"); + } + command.hint = options.hint; + } + return command; + } + handleOk(response) { + const result = super.handleOk(response); + return this.options.includeResultMetadata ? result : result.value ?? null; + } + }; + exports2.FindAndModifyOperation = FindAndModifyOperation; + var FindOneAndDeleteOperation = class extends FindAndModifyOperation { + constructor(collection, filter, options) { + if (filter == null || typeof filter !== "object") { + throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object'); + } + super(collection, filter, options); + } + buildCommandDocument(connection, session) { + const document = super.buildCommandDocument(connection, session); + document.remove = true; + return document; + } + }; + exports2.FindOneAndDeleteOperation = FindOneAndDeleteOperation; + var FindOneAndReplaceOperation = class extends FindAndModifyOperation { + constructor(collection, filter, replacement, options) { + if (filter == null || typeof filter !== "object") { + throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object'); + } + if (replacement == null || typeof replacement !== "object") { + throw new error_1.MongoInvalidArgumentError('Argument "replacement" must be an object'); + } + if ((0, utils_1.hasAtomicOperators)(replacement)) { + throw new error_1.MongoInvalidArgumentError("Replacement document must not contain atomic operators"); + } + super(collection, filter, options); + this.replacement = replacement; + } + buildCommandDocument(connection, session) { + const document = super.buildCommandDocument(connection, session); + document.update = this.replacement; + configureFindAndModifyCmdBaseUpdateOpts(document, this.options); + return document; + } + }; + exports2.FindOneAndReplaceOperation = FindOneAndReplaceOperation; + var FindOneAndUpdateOperation = class extends FindAndModifyOperation { + constructor(collection, filter, update, options) { + if (filter == null || typeof filter !== "object") { + throw new error_1.MongoInvalidArgumentError('Argument "filter" must be an object'); + } + if (update == null || typeof update !== "object") { + throw new error_1.MongoInvalidArgumentError('Argument "update" must be an object'); + } + if (!(0, utils_1.hasAtomicOperators)(update, options)) { + throw new error_1.MongoInvalidArgumentError("Update document requires atomic operators"); + } + super(collection, filter, options); + this.update = update; + this.options = options; + } + buildCommandDocument(connection, session) { + const document = super.buildCommandDocument(connection, session); + document.update = this.update; + configureFindAndModifyCmdBaseUpdateOpts(document, this.options); + if (this.options.arrayFilters) { + document.arrayFilters = this.options.arrayFilters; + } + return document; + } + }; + exports2.FindOneAndUpdateOperation = FindOneAndUpdateOperation; + (0, operation_1.defineAspects)(FindAndModifyOperation, [ + operation_1.Aspect.WRITE_OPERATION, + operation_1.Aspect.RETRYABLE, + operation_1.Aspect.EXPLAINABLE, + operation_1.Aspect.SUPPORTS_RAW_DATA + ]); + } +}); + +// node_modules/mongodb/lib/operations/search_indexes/create.js +var require_create = __commonJS({ + "node_modules/mongodb/lib/operations/search_indexes/create.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.CreateSearchIndexesOperation = void 0; + var responses_1 = require_responses(); + var operation_1 = require_operation(); + var CreateSearchIndexesOperation = class extends operation_1.AbstractOperation { + constructor(collection, descriptions) { + super(); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.collection = collection; + this.descriptions = descriptions; + this.ns = collection.fullNamespace; + } + get commandName() { + return "createSearchIndexes"; + } + buildCommand(_connection, _session) { + const namespace = this.collection.fullNamespace; + return { + createSearchIndexes: namespace.collection, + indexes: this.descriptions + }; + } + handleOk(response) { + return super.handleOk(response).indexesCreated.map((val) => val.name); + } + buildOptions(timeoutContext) { + return { session: this.session, timeoutContext }; + } + }; + exports2.CreateSearchIndexesOperation = CreateSearchIndexesOperation; + } +}); + +// node_modules/mongodb/lib/operations/search_indexes/drop.js +var require_drop2 = __commonJS({ + "node_modules/mongodb/lib/operations/search_indexes/drop.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.DropSearchIndexOperation = void 0; + var responses_1 = require_responses(); + var error_1 = require_error(); + var operation_1 = require_operation(); + var DropSearchIndexOperation = class extends operation_1.AbstractOperation { + constructor(collection, name) { + super(); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.collection = collection; + this.name = name; + this.ns = collection.fullNamespace; + } + get commandName() { + return "dropSearchIndex"; + } + buildCommand(_connection, _session) { + const namespace = this.collection.fullNamespace; + const command = { + dropSearchIndex: namespace.collection + }; + if (typeof this.name === "string") { + command.name = this.name; + } + return command; + } + handleOk(_response) { + } + buildOptions(timeoutContext) { + return { session: this.session, timeoutContext }; + } + handleError(error) { + const isNamespaceNotFoundError = error instanceof error_1.MongoServerError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound; + if (!isNamespaceNotFoundError) { + throw error; + } + } + }; + exports2.DropSearchIndexOperation = DropSearchIndexOperation; + } +}); + +// node_modules/mongodb/lib/operations/search_indexes/update.js +var require_update2 = __commonJS({ + "node_modules/mongodb/lib/operations/search_indexes/update.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.UpdateSearchIndexOperation = void 0; + var responses_1 = require_responses(); + var operation_1 = require_operation(); + var UpdateSearchIndexOperation = class extends operation_1.AbstractOperation { + constructor(collection, name, definition) { + super(); + this.SERVER_COMMAND_RESPONSE_TYPE = responses_1.MongoDBResponse; + this.collection = collection; + this.name = name; + this.definition = definition; + this.ns = collection.fullNamespace; + } + get commandName() { + return "updateSearchIndex"; + } + buildCommand(_connection, _session) { + const namespace = this.collection.fullNamespace; + return { + updateSearchIndex: namespace.collection, + name: this.name, + definition: this.definition + }; + } + handleOk(_response) { + } + buildOptions(timeoutContext) { + return { session: this.session, timeoutContext }; + } + }; + exports2.UpdateSearchIndexOperation = UpdateSearchIndexOperation; + } +}); + +// node_modules/mongodb/lib/collection.js +var require_collection = __commonJS({ + "node_modules/mongodb/lib/collection.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.Collection = void 0; + var bson_1 = require_bson2(); + var ordered_1 = require_ordered(); + var unordered_1 = require_unordered(); + var change_stream_1 = require_change_stream(); + var aggregation_cursor_1 = require_aggregation_cursor(); + var find_cursor_1 = require_find_cursor(); + var list_indexes_cursor_1 = require_list_indexes_cursor(); + var list_search_indexes_cursor_1 = require_list_search_indexes_cursor(); + var error_1 = require_error(); + var count_1 = require_count(); + var delete_1 = require_delete(); + var distinct_1 = require_distinct(); + var estimated_document_count_1 = require_estimated_document_count(); + var execute_operation_1 = require_execute_operation(); + var find_and_modify_1 = require_find_and_modify(); + var indexes_1 = require_indexes(); + var insert_1 = require_insert(); + var rename_1 = require_rename(); + var create_1 = require_create(); + var drop_1 = require_drop2(); + var update_1 = require_update2(); + var update_2 = require_update(); + var read_concern_1 = require_read_concern(); + var read_preference_1 = require_read_preference(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var Collection = class { + /** + * Create a new Collection instance + * @internal + */ + constructor(db, name, options) { + this.db = db; + this.s = { + db, + options, + namespace: new utils_1.MongoDBCollectionNamespace(db.databaseName, name), + pkFactory: db.options?.pkFactory ?? utils_1.DEFAULT_PK_FACTORY, + readPreference: read_preference_1.ReadPreference.fromOptions(options), + bsonOptions: (0, bson_1.resolveBSONOptions)(options, db), + readConcern: read_concern_1.ReadConcern.fromOptions(options), + writeConcern: write_concern_1.WriteConcern.fromOptions(options) + }; + this.client = db.client; + } + /** + * The name of the database this collection belongs to + */ + get dbName() { + return this.s.namespace.db; + } + /** + * The name of this collection + */ + get collectionName() { + return this.s.namespace.collection; + } + /** + * The namespace of this collection, in the format `${this.dbName}.${this.collectionName}` + */ + get namespace() { + return this.fullNamespace.toString(); + } + /** + * @internal + * + * The `MongoDBNamespace` for the collection. + */ + get fullNamespace() { + return this.s.namespace; + } + /** + * The current readConcern of the collection. If not explicitly defined for + * this collection, will be inherited from the parent DB + */ + get readConcern() { + if (this.s.readConcern == null) { + return this.db.readConcern; + } + return this.s.readConcern; + } + /** + * The current readPreference of the collection. If not explicitly defined for + * this collection, will be inherited from the parent DB + */ + get readPreference() { + if (this.s.readPreference == null) { + return this.db.readPreference; + } + return this.s.readPreference; + } + get bsonOptions() { + return this.s.bsonOptions; + } + /** + * The current writeConcern of the collection. If not explicitly defined for + * this collection, will be inherited from the parent DB + */ + get writeConcern() { + if (this.s.writeConcern == null) { + return this.db.writeConcern; + } + return this.s.writeConcern; + } + /** The current index hint for the collection */ + get hint() { + return this.s.collectionHint; + } + set hint(v) { + this.s.collectionHint = (0, utils_1.normalizeHintField)(v); + } + /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */ + get timeoutMS() { + return void 0; + } + /** + * Inserts a single document into MongoDB. If documents passed in do not contain the **_id** field, + * one will be added to each of the documents missing it by the driver, mutating the document. This behavior + * can be overridden by setting the **forceServerObjectId** flag. + * + * @param doc - The document to insert + * @param options - Optional settings for the command + */ + async insertOne(doc, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new insert_1.InsertOneOperation(this, doc, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Inserts an array of documents into MongoDB. If documents passed in do not contain the **_id** field, + * one will be added to each of the documents missing it by the driver, mutating the document. This behavior + * can be overridden by setting the **forceServerObjectId** flag. + * + * @param docs - The documents to insert + * @param options - Optional settings for the command + */ + async insertMany(docs, options) { + if (!Array.isArray(docs)) { + throw new error_1.MongoInvalidArgumentError('Argument "docs" must be an array of documents'); + } + options = (0, utils_1.resolveOptions)(this, options ?? {}); + const acknowledged = write_concern_1.WriteConcern.fromOptions(options)?.w !== 0; + try { + const res = await this.bulkWrite(docs.map((doc) => ({ insertOne: { document: doc } })), options); + return { + acknowledged, + insertedCount: res.insertedCount, + insertedIds: res.insertedIds + }; + } catch (err) { + if (err && err.message === "Operation must be an object with an operation key") { + throw new error_1.MongoInvalidArgumentError("Collection.insertMany() cannot be called with an array that has null/undefined values"); + } + throw err; + } + } + /** + * Perform a bulkWrite operation without a fluent API + * + * Legal operation types are + * - `insertOne` + * - `replaceOne` + * - `updateOne` + * - `updateMany` + * - `deleteOne` + * - `deleteMany` + * + * If documents passed in do not contain the **_id** field, + * one will be added to each of the documents missing it by the driver, mutating the document. This behavior + * can be overridden by setting the **forceServerObjectId** flag. + * + * @param operations - Bulk operations to perform + * @param options - Optional settings for the command + * @throws MongoDriverError if operations is not an array + */ + async bulkWrite(operations, options) { + if (!Array.isArray(operations)) { + throw new error_1.MongoInvalidArgumentError('Argument "operations" must be an array of documents'); + } + options = (0, utils_1.resolveOptions)(this, options ?? {}); + const isConnected = this.client.topology != null; + if (!isConnected) { + await (0, execute_operation_1.autoConnect)(this.client); + } + const bulk = options.ordered === false ? this.initializeUnorderedBulkOp(options) : this.initializeOrderedBulkOp(options); + for (const operation of operations) { + bulk.raw(operation); + } + return await bulk.execute({ ...options }); + } + /** + * Update a single document in a collection + * + * The value of `update` can be either: + * - UpdateFilter - A document that contains update operator expressions, + * - Document[] - an aggregation pipeline. + * + * @param filter - The filter used to select the document to update + * @param update - The modifications to apply + * @param options - Optional settings for the command + */ + async updateOne(filter, update, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new update_2.UpdateOneOperation(this.s.namespace, filter, update, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Replace a document in a collection with another document + * + * @param filter - The filter used to select the document to replace + * @param replacement - The Document that replaces the matching document + * @param options - Optional settings for the command + */ + async replaceOne(filter, replacement, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new update_2.ReplaceOneOperation(this.s.namespace, filter, replacement, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Update multiple documents in a collection + * + * The value of `update` can be either: + * - UpdateFilter - A document that contains update operator expressions, + * - Document[] - an aggregation pipeline. + * + * @param filter - The filter used to select the document to update + * @param update - The modifications to apply + * @param options - Optional settings for the command + */ + async updateMany(filter, update, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new update_2.UpdateManyOperation(this.s.namespace, filter, update, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Delete a document from a collection + * + * @param filter - The filter used to select the document to remove + * @param options - Optional settings for the command + */ + async deleteOne(filter = {}, options = {}) { + return await (0, execute_operation_1.executeOperation)(this.client, new delete_1.DeleteOneOperation(this.s.namespace, filter, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Delete multiple documents from a collection + * + * @param filter - The filter used to select the documents to remove + * @param options - Optional settings for the command + */ + async deleteMany(filter = {}, options = {}) { + return await (0, execute_operation_1.executeOperation)(this.client, new delete_1.DeleteManyOperation(this.s.namespace, filter, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Rename the collection. + * + * @remarks + * This operation does not inherit options from the Db or MongoClient. + * + * @param newName - New name of of the collection. + * @param options - Optional settings for the command + */ + async rename(newName, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new rename_1.RenameOperation(this, newName, (0, utils_1.resolveOptions)(void 0, { + ...options, + readPreference: read_preference_1.ReadPreference.PRIMARY + }))); + } + /** + * Drop the collection from the database, removing it permanently. New accesses will create a new collection. + * + * @param options - Optional settings for the command + */ + async drop(options) { + return await this.db.dropCollection(this.collectionName, options); + } + async findOne(filter = {}, options = {}) { + const { batchSize: _batchSize, noCursorTimeout: _noCursorTimeout, ...opts } = options; + opts.singleBatch = true; + const cursor = this.find(filter, opts).limit(1); + const result = await cursor.next(); + await cursor.close(); + return result; + } + find(filter = {}, options = {}) { + return new find_cursor_1.FindCursor(this.client, this.s.namespace, filter, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Returns the options of the collection. + * + * @param options - Optional settings for the command + */ + async options(options) { + options = (0, utils_1.resolveOptions)(this, options); + const [collection] = await this.db.listCollections({ name: this.collectionName }, { ...options, nameOnly: false }).toArray(); + if (collection == null || collection.options == null) { + throw new error_1.MongoAPIError(`collection ${this.namespace} not found`); + } + return collection.options; + } + /** + * Returns if the collection is a capped collection + * + * @param options - Optional settings for the command + */ + async isCapped(options) { + const { capped } = await this.options(options); + return Boolean(capped); + } + /** + * Creates an index on the db and collection collection. + * + * @param indexSpec - The field name or index specification to create an index for + * @param options - Optional settings for the command + * + * @example + * ```ts + * const collection = client.db('foo').collection('bar'); + * + * await collection.createIndex({ a: 1, b: -1 }); + * + * // Alternate syntax for { c: 1, d: -1 } that ensures order of indexes + * await collection.createIndex([ [c, 1], [d, -1] ]); + * + * // Equivalent to { e: 1 } + * await collection.createIndex('e'); + * + * // Equivalent to { f: 1, g: 1 } + * await collection.createIndex(['f', 'g']) + * + * // Equivalent to { h: 1, i: -1 } + * await collection.createIndex([ { h: 1 }, { i: -1 } ]); + * + * // Equivalent to { j: 1, k: -1, l: 2d } + * await collection.createIndex(['j', ['k', -1], { l: '2d' }]) + * ``` + */ + async createIndex(indexSpec, options) { + const indexes = await (0, execute_operation_1.executeOperation)(this.client, indexes_1.CreateIndexesOperation.fromIndexSpecification(this, this.collectionName, indexSpec, (0, utils_1.resolveOptions)(this, options))); + return indexes[0]; + } + /** + * Creates multiple indexes in the collection, this method is only supported for + * MongoDB 2.6 or higher. Earlier version of MongoDB will throw a command not supported + * error. + * + * **Note**: Unlike {@link Collection#createIndex| createIndex}, this function takes in raw index specifications. + * Index specifications are defined {@link https://www.mongodb.com/docs/manual/reference/command/createIndexes/| here}. + * + * @param indexSpecs - An array of index specifications to be created + * @param options - Optional settings for the command + * + * @example + * ```ts + * const collection = client.db('foo').collection('bar'); + * await collection.createIndexes([ + * // Simple index on field fizz + * { + * key: { fizz: 1 }, + * } + * // wildcard index + * { + * key: { '$**': 1 } + * }, + * // named index on darmok and jalad + * { + * key: { darmok: 1, jalad: -1 } + * name: 'tanagra' + * } + * ]); + * ``` + */ + async createIndexes(indexSpecs, options) { + return await (0, execute_operation_1.executeOperation)(this.client, indexes_1.CreateIndexesOperation.fromIndexDescriptionArray(this, this.collectionName, indexSpecs, (0, utils_1.resolveOptions)(this, { ...options, maxTimeMS: void 0 }))); + } + /** + * Drops an index from this collection. + * + * @param indexName - Name of the index to drop. + * @param options - Optional settings for the command + */ + async dropIndex(indexName, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new indexes_1.DropIndexOperation(this, indexName, { + ...(0, utils_1.resolveOptions)(this, options), + readPreference: read_preference_1.ReadPreference.primary + })); + } + /** + * Drops all indexes from this collection. + * + * @param options - Optional settings for the command + */ + async dropIndexes(options) { + try { + await (0, execute_operation_1.executeOperation)(this.client, new indexes_1.DropIndexOperation(this, "*", (0, utils_1.resolveOptions)(this, options))); + return true; + } catch (error) { + if (error instanceof error_1.MongoOperationTimeoutError) + throw error; + return false; + } + } + /** + * Get the list of all indexes information for the collection. + * + * @param options - Optional settings for the command + */ + listIndexes(options) { + return new list_indexes_cursor_1.ListIndexesCursor(this, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Checks if one or more indexes exist on the collection, fails on first non-existing index + * + * @param indexes - One or more index names to check. + * @param options - Optional settings for the command + */ + async indexExists(indexes, options) { + const indexNames = Array.isArray(indexes) ? indexes : [indexes]; + const allIndexes = new Set(await this.listIndexes(options).map(({ name }) => name).toArray()); + return indexNames.every((name) => allIndexes.has(name)); + } + async indexInformation(options) { + return await this.indexes({ + ...options, + full: options?.full ?? false + }); + } + /** + * Gets an estimate of the count of documents in a collection using collection metadata. + * This will always run a count command on all server versions. + * + * due to an oversight in versions 5.0.0-5.0.8 of MongoDB, the count command, + * which estimatedDocumentCount uses in its implementation, was not included in v1 of + * the Stable API, and so users of the Stable API with estimatedDocumentCount are + * recommended to upgrade their server version to 5.0.9+ or set apiStrict: false to avoid + * encountering errors. + * + * @see {@link https://www.mongodb.com/docs/manual/reference/command/count/#behavior|Count: Behavior} + * @param options - Optional settings for the command + */ + async estimatedDocumentCount(options) { + return await (0, execute_operation_1.executeOperation)(this.client, new estimated_document_count_1.EstimatedDocumentCountOperation(this, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Gets the number of documents matching the filter. + * For a fast count of the total documents in a collection see {@link Collection#estimatedDocumentCount| estimatedDocumentCount}. + * + * Due to countDocuments using the $match aggregation pipeline stage, certain query operators cannot be used in countDocuments. This includes the $where and $near query operators, among others. Details can be found in the documentation for the $match aggregation pipeline stage. + * + * **Note**: When migrating from {@link Collection#count| count} to {@link Collection#countDocuments| countDocuments} + * the following query operators must be replaced: + * + * | Operator | Replacement | + * | -------- | ----------- | + * | `$where` | [`$expr`][1] | + * | `$near` | [`$geoWithin`][2] with [`$center`][3] | + * | `$nearSphere` | [`$geoWithin`][2] with [`$centerSphere`][4] | + * + * [1]: https://www.mongodb.com/docs/manual/reference/operator/query/expr/ + * [2]: https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/ + * [3]: https://www.mongodb.com/docs/manual/reference/operator/query/center/#op._S_center + * [4]: https://www.mongodb.com/docs/manual/reference/operator/query/centerSphere/#op._S_centerSphere + * + * @param filter - The filter for the count + * @param options - Optional settings for the command + * + * @see https://www.mongodb.com/docs/manual/reference/operator/query/expr/ + * @see https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/ + * @see https://www.mongodb.com/docs/manual/reference/operator/query/center/#op._S_center + * @see https://www.mongodb.com/docs/manual/reference/operator/query/centerSphere/#op._S_centerSphere + */ + async countDocuments(filter = {}, options = {}) { + const pipeline = []; + pipeline.push({ $match: filter }); + if (typeof options.skip === "number") { + pipeline.push({ $skip: options.skip }); + } + if (typeof options.limit === "number") { + pipeline.push({ $limit: options.limit }); + } + pipeline.push({ $group: { _id: 1, n: { $sum: 1 } } }); + const cursor = this.aggregate(pipeline, options); + const doc = await cursor.next(); + await cursor.close(); + return doc?.n ?? 0; + } + async distinct(key, filter = {}, options = {}) { + return await (0, execute_operation_1.executeOperation)(this.client, new distinct_1.DistinctOperation(this, key, filter, (0, utils_1.resolveOptions)(this, options))); + } + async indexes(options) { + const indexes = await this.listIndexes(options).toArray(); + const full = options?.full ?? true; + if (full) { + return indexes; + } + const object = Object.fromEntries(indexes.map(({ name, key }) => [name, Object.entries(key)])); + return object; + } + async findOneAndDelete(filter, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new find_and_modify_1.FindOneAndDeleteOperation(this, filter, (0, utils_1.resolveOptions)(this, options))); + } + async findOneAndReplace(filter, replacement, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new find_and_modify_1.FindOneAndReplaceOperation(this, filter, replacement, (0, utils_1.resolveOptions)(this, options))); + } + async findOneAndUpdate(filter, update, options) { + return await (0, execute_operation_1.executeOperation)(this.client, new find_and_modify_1.FindOneAndUpdateOperation(this, filter, update, (0, utils_1.resolveOptions)(this, options))); + } + /** + * Execute an aggregation framework pipeline against the collection, needs MongoDB \>= 2.2 + * + * @param pipeline - An array of aggregation pipelines to execute + * @param options - Optional settings for the command + */ + aggregate(pipeline = [], options) { + if (!Array.isArray(pipeline)) { + throw new error_1.MongoInvalidArgumentError('Argument "pipeline" must be an array of aggregation stages'); + } + return new aggregation_cursor_1.AggregationCursor(this.client, this.s.namespace, pipeline, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Create a new Change Stream, watching for new changes (insertions, updates, replacements, deletions, and invalidations) in this collection. + * + * @remarks + * watch() accepts two generic arguments for distinct use cases: + * - The first is to override the schema that may be defined for this specific collection + * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument + * @example + * By just providing the first argument I can type the change to be `ChangeStreamDocument<{ _id: number }>` + * ```ts + * collection.watch<{ _id: number }>() + * .on('change', change => console.log(change._id.toFixed(4))); + * ``` + * + * @example + * Passing a second argument provides a way to reflect the type changes caused by an advanced pipeline. + * Here, we are using a pipeline to have MongoDB filter for insert changes only and add a comment. + * No need start from scratch on the ChangeStreamInsertDocument type! + * By using an intersection we can save time and ensure defaults remain the same type! + * ```ts + * collection + * .watch & { comment: string }>([ + * { $addFields: { comment: 'big changes' } }, + * { $match: { operationType: 'insert' } } + * ]) + * .on('change', change => { + * change.comment.startsWith('big'); + * change.operationType === 'insert'; + * // No need to narrow in code because the generics did that for us! + * expectType(change.fullDocument); + * }); + * ``` + * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents. + * @param options - Optional settings for the command + * @typeParam TLocal - Type of the data being detected by the change stream + * @typeParam TChange - Type of the whole change stream document emitted + */ + watch(pipeline = [], options = {}) { + if (!Array.isArray(pipeline)) { + options = pipeline; + pipeline = []; + } + return new change_stream_1.ChangeStream(this, pipeline, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Initiate an Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order. + * + * @throws MongoNotConnectedError + * @remarks + * **NOTE:** MongoClient must be connected prior to calling this method due to a known limitation in this legacy implementation. + * However, `collection.bulkWrite()` provides an equivalent API that does not require prior connecting. + */ + initializeUnorderedBulkOp(options) { + return new unordered_1.UnorderedBulkOperation(this, (0, utils_1.resolveOptions)(this, options)); + } + /** + * Initiate an In order bulk write operation. Operations will be serially executed in the order they are added, creating a new operation for each switch in types. + * + * @throws MongoNotConnectedError + * @remarks + * **NOTE:** MongoClient must be connected prior to calling this method due to a known limitation in this legacy implementation. + * However, `collection.bulkWrite()` provides an equivalent API that does not require prior connecting. + */ + initializeOrderedBulkOp(options) { + return new ordered_1.OrderedBulkOperation(this, (0, utils_1.resolveOptions)(this, options)); + } + /** + * An estimated count of matching documents in the db to a filter. + * + * **NOTE:** This method has been deprecated, since it does not provide an accurate count of the documents + * in a collection. To obtain an accurate count of documents in the collection, use {@link Collection#countDocuments| countDocuments}. + * To obtain an estimated count of all documents in the collection, use {@link Collection#estimatedDocumentCount| estimatedDocumentCount}. + * + * @deprecated use {@link Collection#countDocuments| countDocuments} or {@link Collection#estimatedDocumentCount| estimatedDocumentCount} instead + * + * @param filter - The filter for the count. + * @param options - Optional settings for the command + */ + async count(filter = {}, options = {}) { + return await (0, execute_operation_1.executeOperation)(this.client, new count_1.CountOperation(this.fullNamespace, filter, (0, utils_1.resolveOptions)(this, options))); + } + listSearchIndexes(indexNameOrOptions, options) { + options = typeof indexNameOrOptions === "object" ? indexNameOrOptions : options == null ? {} : options; + const indexName = indexNameOrOptions == null ? null : typeof indexNameOrOptions === "object" ? null : indexNameOrOptions; + return new list_search_indexes_cursor_1.ListSearchIndexesCursor(this, indexName, { ...options }); + } + /** + * Creates a single search index for the collection. + * + * @param description - The index description for the new search index. + * @returns A promise that resolves to the name of the new search index. + * + * @remarks Only available when used against a 7.0+ Atlas cluster. + */ + async createSearchIndex(description) { + const [index] = await this.createSearchIndexes([description]); + return index; + } + /** + * Creates multiple search indexes for the current collection. + * + * @param descriptions - An array of `SearchIndexDescription`s for the new search indexes. + * @returns A promise that resolves to an array of the newly created search index names. + * + * @remarks Only available when used against a 7.0+ Atlas cluster. + * @returns + */ + async createSearchIndexes(descriptions) { + return await (0, execute_operation_1.executeOperation)(this.client, new create_1.CreateSearchIndexesOperation(this, descriptions)); + } + /** + * Deletes a search index by index name. + * + * @param name - The name of the search index to be deleted. + * + * @remarks Only available when used against a 7.0+ Atlas cluster. + */ + async dropSearchIndex(name) { + return await (0, execute_operation_1.executeOperation)(this.client, new drop_1.DropSearchIndexOperation(this, name)); + } + /** + * Updates a search index by replacing the existing index definition with the provided definition. + * + * @param name - The name of the search index to update. + * @param definition - The new search index definition. + * + * @remarks Only available when used against a 7.0+ Atlas cluster. + */ + async updateSearchIndex(name, definition) { + return await (0, execute_operation_1.executeOperation)(this.client, new update_1.UpdateSearchIndexOperation(this, name, definition)); + } + }; + exports2.Collection = Collection; + } +}); + +// node_modules/mongodb/lib/cursor/change_stream_cursor.js +var require_change_stream_cursor = __commonJS({ + "node_modules/mongodb/lib/cursor/change_stream_cursor.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ChangeStreamCursor = void 0; + var change_stream_1 = require_change_stream(); + var constants_1 = require_constants2(); + var aggregate_1 = require_aggregate(); + var execute_operation_1 = require_execute_operation(); + var utils_1 = require_utils3(); + var abstract_cursor_1 = require_abstract_cursor(); + var ChangeStreamCursor = class _ChangeStreamCursor extends abstract_cursor_1.AbstractCursor { + constructor(client, namespace, pipeline = [], options = {}) { + super(client, namespace, { ...options, tailable: true, awaitData: true }); + this.pipeline = pipeline; + this.changeStreamCursorOptions = options; + this._resumeToken = null; + this.startAtOperationTime = options.startAtOperationTime ?? null; + if (options.startAfter) { + this.resumeToken = options.startAfter; + } else if (options.resumeAfter) { + this.resumeToken = options.resumeAfter; + } + } + set resumeToken(token) { + this._resumeToken = token; + this.emit(change_stream_1.ChangeStream.RESUME_TOKEN_CHANGED, token); + } + get resumeToken() { + return this._resumeToken; + } + get resumeOptions() { + const options = { + ...this.changeStreamCursorOptions + }; + for (const key of ["resumeAfter", "startAfter", "startAtOperationTime"]) { + delete options[key]; + } + if (this.resumeToken != null) { + if (this.changeStreamCursorOptions.startAfter && !this.hasReceived) { + options.startAfter = this.resumeToken; + } else { + options.resumeAfter = this.resumeToken; + } + } else if (this.startAtOperationTime != null) { + options.startAtOperationTime = this.startAtOperationTime; + } + return options; + } + cacheResumeToken(resumeToken) { + if (this.bufferedCount() === 0 && this.postBatchResumeToken) { + this.resumeToken = this.postBatchResumeToken; + } else { + this.resumeToken = resumeToken; + } + this.hasReceived = true; + } + _processBatch(response) { + const { postBatchResumeToken } = response; + if (postBatchResumeToken) { + this.postBatchResumeToken = postBatchResumeToken; + if (response.batchSize === 0) { + this.resumeToken = postBatchResumeToken; + } + } + } + clone() { + return new _ChangeStreamCursor(this.client, this.namespace, this.pipeline, { + ...this.cursorOptions + }); + } + async _initialize(session) { + const aggregateOperation = new aggregate_1.AggregateOperation(this.namespace, this.pipeline, { + ...this.cursorOptions, + ...this.changeStreamCursorOptions, + session + }); + const response = await (0, execute_operation_1.executeOperation)(session.client, aggregateOperation, this.timeoutContext); + const server = aggregateOperation.server; + this.maxWireVersion = (0, utils_1.maxWireVersion)(server); + if (this.startAtOperationTime == null && this.changeStreamCursorOptions.resumeAfter == null && this.changeStreamCursorOptions.startAfter == null) { + this.startAtOperationTime = response.operationTime; + } + this._processBatch(response); + this.emit(constants_1.INIT, response); + this.emit(constants_1.RESPONSE); + return { server, session, response }; + } + async getMore(batchSize) { + const response = await super.getMore(batchSize); + this.maxWireVersion = (0, utils_1.maxWireVersion)(this.server); + this._processBatch(response); + this.emit(change_stream_1.ChangeStream.MORE, response); + this.emit(change_stream_1.ChangeStream.RESPONSE); + return response; + } + }; + exports2.ChangeStreamCursor = ChangeStreamCursor; + } +}); + +// node_modules/mongodb/lib/change_stream.js +var require_change_stream = __commonJS({ + "node_modules/mongodb/lib/change_stream.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.ChangeStream = void 0; + var collection_1 = require_collection(); + var constants_1 = require_constants2(); + var abstract_cursor_1 = require_abstract_cursor(); + var change_stream_cursor_1 = require_change_stream_cursor(); + var db_1 = require_db(); + var error_1 = require_error(); + var mongo_client_1 = require_mongo_client(); + var mongo_types_1 = require_mongo_types(); + var resource_management_1 = require_resource_management(); + var utils_1 = require_utils3(); + var CHANGE_STREAM_OPTIONS = [ + "resumeAfter", + "startAfter", + "startAtOperationTime", + "fullDocument", + "fullDocumentBeforeChange", + "showExpandedEvents" + ]; + var CHANGE_DOMAIN_TYPES = { + COLLECTION: /* @__PURE__ */ Symbol("Collection"), + DATABASE: /* @__PURE__ */ Symbol("Database"), + CLUSTER: /* @__PURE__ */ Symbol("Cluster") + }; + var CHANGE_STREAM_EVENTS = [constants_1.RESUME_TOKEN_CHANGED, constants_1.END, constants_1.CLOSE]; + var NO_RESUME_TOKEN_ERROR = "A change stream document has been received that lacks a resume token (_id)."; + var CHANGESTREAM_CLOSED_ERROR = "ChangeStream is closed"; + var ChangeStream = class _ChangeStream extends mongo_types_1.TypedEventEmitter { + /** @internal */ + async asyncDispose() { + await this.close(); + } + /** + * @internal + * + * @param parent - The parent object that created this change stream + * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents + */ + constructor(parent, pipeline = [], options = {}) { + super(); + this.pipeline = pipeline; + this.options = { ...options }; + this.options.timeoutMS = void 0; + this.options.timeoutMode = void 0; + delete this.options.writeConcern; + if (parent instanceof collection_1.Collection) { + this.type = CHANGE_DOMAIN_TYPES.COLLECTION; + } else if (parent instanceof db_1.Db) { + this.type = CHANGE_DOMAIN_TYPES.DATABASE; + } else if (parent instanceof mongo_client_1.MongoClient) { + this.type = CHANGE_DOMAIN_TYPES.CLUSTER; + } else { + throw new error_1.MongoChangeStreamError("Parent provided to ChangeStream constructor must be an instance of Collection, Db, or MongoClient"); + } + this.contextOwner = /* @__PURE__ */ Symbol(); + this.parent = parent; + this.namespace = parent.s.namespace; + if (!this.options.readPreference && parent.readPreference) { + this.options.readPreference = parent.readPreference; + } + this.cursor = this._createChangeStreamCursor(options); + this.isClosed = false; + this.mode = false; + this.on("newListener", (eventName) => { + if (eventName === "change" && this.cursor && this.listenerCount("change") === 0) { + this._streamEvents(this.cursor); + } + }); + this.on("removeListener", (eventName) => { + if (eventName === "change" && this.listenerCount("change") === 0 && this.cursor) { + this.cursorStream?.removeAllListeners("data"); + } + }); + } + /** The cached resume token that is used to resume after the most recently returned change. */ + get resumeToken() { + return this.cursor?.resumeToken; + } + /** Check if there is any document still available in the Change Stream */ + async hasNext() { + this._setIsIterator(); + this.timeoutContext?.refresh(); + try { + while (true) { + try { + const hasNext = await this.cursor.hasNext(); + return hasNext; + } catch (error) { + try { + await this._processErrorIteratorMode(error, this.cursor.id != null); + } catch (error2) { + if (error2 instanceof error_1.MongoOperationTimeoutError && this.cursor.id == null) { + throw error2; + } + try { + await this.close(); + } catch (error3) { + (0, utils_1.squashError)(error3); + } + throw error2; + } + } + } + } finally { + this.timeoutContext?.clear(); + } + } + /** Get the next available document from the Change Stream. */ + async next() { + this._setIsIterator(); + this.timeoutContext?.refresh(); + try { + while (true) { + try { + const change = await this.cursor.next(); + const processedChange = this._processChange(change ?? null); + return processedChange; + } catch (error) { + try { + await this._processErrorIteratorMode(error, this.cursor.id != null); + } catch (error2) { + if (error2 instanceof error_1.MongoOperationTimeoutError && this.cursor.id == null) { + throw error2; + } + try { + await this.close(); + } catch (error3) { + (0, utils_1.squashError)(error3); + } + throw error2; + } + } + } + } finally { + this.timeoutContext?.clear(); + } + } + /** + * Try to get the next available document from the Change Stream's cursor or `null` if an empty batch is returned + */ + async tryNext() { + this._setIsIterator(); + this.timeoutContext?.refresh(); + try { + while (true) { + try { + const change = await this.cursor.tryNext(); + if (!change) { + return null; + } + const processedChange = this._processChange(change); + return processedChange; + } catch (error) { + try { + await this._processErrorIteratorMode(error, this.cursor.id != null); + } catch (error2) { + if (error2 instanceof error_1.MongoOperationTimeoutError && this.cursor.id == null) + throw error2; + try { + await this.close(); + } catch (error3) { + (0, utils_1.squashError)(error3); + } + throw error2; + } + } + } + } finally { + this.timeoutContext?.clear(); + } + } + async *[Symbol.asyncIterator]() { + if (this.closed) { + return; + } + try { + while (true) { + yield await this.next(); + } + } finally { + try { + await this.close(); + } catch (error) { + (0, utils_1.squashError)(error); + } + } + } + /** Is the cursor closed */ + get closed() { + return this.isClosed || this.cursor.closed; + } + /** + * Frees the internal resources used by the change stream. + */ + async close() { + this.timeoutContext?.clear(); + this.timeoutContext = void 0; + this.isClosed = true; + const cursor = this.cursor; + try { + await cursor.close(); + } finally { + this._endStream(); + } + } + /** + * Return a modified Readable stream including a possible transform method. + * + * NOTE: When using a Stream to process change stream events, the stream will + * NOT automatically resume in the case a resumable error is encountered. + * + * @throws MongoChangeStreamError if the underlying cursor or the change stream is closed + */ + stream(options) { + if (this.closed) { + throw new error_1.MongoChangeStreamError(CHANGESTREAM_CLOSED_ERROR); + } + this.streamOptions = options; + return this.cursor.stream(options); + } + /** @internal */ + _setIsEmitter() { + if (this.mode === "iterator") { + throw new error_1.MongoAPIError("ChangeStream cannot be used as an EventEmitter after being used as an iterator"); + } + this.mode = "emitter"; + } + /** @internal */ + _setIsIterator() { + if (this.mode === "emitter") { + throw new error_1.MongoAPIError("ChangeStream cannot be used as an iterator after being used as an EventEmitter"); + } + this.mode = "iterator"; + } + /** + * Create a new change stream cursor based on self's configuration + * @internal + */ + _createChangeStreamCursor(options) { + const changeStreamStageOptions = (0, utils_1.filterOptions)(options, CHANGE_STREAM_OPTIONS); + if (this.type === CHANGE_DOMAIN_TYPES.CLUSTER) { + changeStreamStageOptions.allChangesForCluster = true; + } + const pipeline = [{ $changeStream: changeStreamStageOptions }, ...this.pipeline]; + const client = this.type === CHANGE_DOMAIN_TYPES.CLUSTER ? this.parent : this.type === CHANGE_DOMAIN_TYPES.DATABASE ? this.parent.client : this.type === CHANGE_DOMAIN_TYPES.COLLECTION ? this.parent.client : null; + if (client == null) { + throw new error_1.MongoRuntimeError(`Changestream type should only be one of cluster, database, collection. Found ${this.type.toString()}`); + } + const changeStreamCursor = new change_stream_cursor_1.ChangeStreamCursor(client, this.namespace, pipeline, { + ...options, + timeoutContext: this.timeoutContext ? new abstract_cursor_1.CursorTimeoutContext(this.timeoutContext, this.contextOwner) : void 0 + }); + for (const event of CHANGE_STREAM_EVENTS) { + changeStreamCursor.on(event, (e) => this.emit(event, e)); + } + if (this.listenerCount(_ChangeStream.CHANGE) > 0) { + this._streamEvents(changeStreamCursor); + } + return changeStreamCursor; + } + /** @internal */ + _closeEmitterModeWithError(error) { + this.emit(_ChangeStream.ERROR, error); + this.close().then(void 0, utils_1.squashError); + } + /** @internal */ + _streamEvents(cursor) { + this._setIsEmitter(); + const stream = this.cursorStream ?? cursor.stream(); + this.cursorStream = stream; + stream.on("data", (change) => { + try { + const processedChange = this._processChange(change); + this.emit(_ChangeStream.CHANGE, processedChange); + } catch (error) { + this.emit(_ChangeStream.ERROR, error); + } + this.timeoutContext?.refresh(); + }); + stream.on("error", (error) => this._processErrorStreamMode(error, this.cursor.id != null)); + } + /** @internal */ + _endStream() { + this.cursorStream?.removeAllListeners("data"); + this.cursorStream?.removeAllListeners("close"); + this.cursorStream?.removeAllListeners("end"); + this.cursorStream?.destroy(); + this.cursorStream = void 0; + } + /** @internal */ + _processChange(change) { + if (this.isClosed) { + throw new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR); + } + if (change == null) { + throw new error_1.MongoRuntimeError(CHANGESTREAM_CLOSED_ERROR); + } + if (change && !change._id) { + throw new error_1.MongoChangeStreamError(NO_RESUME_TOKEN_ERROR); + } + this.cursor.cacheResumeToken(change._id); + this.options.startAtOperationTime = void 0; + return change; + } + /** @internal */ + _processErrorStreamMode(changeStreamError, cursorInitialized) { + if (this.isClosed) + return; + if (cursorInitialized && ((0, error_1.isResumableError)(changeStreamError, this.cursor.maxWireVersion) || changeStreamError instanceof error_1.MongoOperationTimeoutError)) { + this._endStream(); + this.cursor.close().then(() => this._resume(changeStreamError), (e) => { + (0, utils_1.squashError)(e); + return this._resume(changeStreamError); + }).then(() => { + if (changeStreamError instanceof error_1.MongoOperationTimeoutError) + this.emit(_ChangeStream.ERROR, changeStreamError); + }, () => this._closeEmitterModeWithError(changeStreamError)); + } else { + this._closeEmitterModeWithError(changeStreamError); + } + } + /** @internal */ + async _processErrorIteratorMode(changeStreamError, cursorInitialized) { + if (this.isClosed) { + throw new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR); + } + if (cursorInitialized && ((0, error_1.isResumableError)(changeStreamError, this.cursor.maxWireVersion) || changeStreamError instanceof error_1.MongoOperationTimeoutError)) { + try { + await this.cursor.close(); + } catch (error) { + (0, utils_1.squashError)(error); + } + await this._resume(changeStreamError); + if (changeStreamError instanceof error_1.MongoOperationTimeoutError) + throw changeStreamError; + } else { + try { + await this.close(); + } catch (error) { + (0, utils_1.squashError)(error); + } + throw changeStreamError; + } + } + async _resume(changeStreamError) { + this.timeoutContext?.refresh(); + const topology = (0, utils_1.getTopology)(this.parent); + try { + await topology.selectServer(this.cursor.readPreference, { + operationName: "reconnect topology in change stream", + timeoutContext: this.timeoutContext + }); + this.cursor = this._createChangeStreamCursor(this.cursor.resumeOptions); + } catch { + await this.close(); + throw changeStreamError; + } + } + }; + exports2.ChangeStream = ChangeStream; + ChangeStream.RESPONSE = constants_1.RESPONSE; + ChangeStream.MORE = constants_1.MORE; + ChangeStream.INIT = constants_1.INIT; + ChangeStream.CLOSE = constants_1.CLOSE; + ChangeStream.CHANGE = constants_1.CHANGE; + ChangeStream.END = constants_1.END; + ChangeStream.ERROR = constants_1.ERROR; + ChangeStream.RESUME_TOKEN_CHANGED = constants_1.RESUME_TOKEN_CHANGED; + (0, resource_management_1.configureResourceManagement)(ChangeStream.prototype); + } +}); + +// node_modules/mongodb/lib/gridfs/download.js +var require_download = __commonJS({ + "node_modules/mongodb/lib/gridfs/download.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GridFSBucketReadStream = void 0; + var stream_1 = require("stream"); + var error_1 = require_error(); + var GridFSBucketReadStream = class extends stream_1.Readable { + /** + * @param chunks - Handle for chunks collection + * @param files - Handle for files collection + * @param readPreference - The read preference to use + * @param filter - The filter to use to find the file document + * @internal + */ + constructor(chunks, files, readPreference, filter, options) { + super({ emitClose: true }); + this.s = { + bytesToTrim: 0, + bytesToSkip: 0, + bytesRead: 0, + chunks, + expected: 0, + files, + filter, + init: false, + expectedEnd: 0, + options: { + start: 0, + end: 0, + ...options + }, + readPreference + }; + } + /** + * Reads from the cursor and pushes to the stream. + * Private Impl, do not call directly + * @internal + */ + _read() { + if (this.destroyed) + return; + waitForFile(this, () => doRead(this)); + } + /** + * Sets the 0-based offset in bytes to start streaming from. Throws + * an error if this stream has entered flowing mode + * (e.g. if you've already called `on('data')`) + * + * @param start - 0-based offset in bytes to start streaming from + */ + start(start = 0) { + throwIfInitialized(this); + this.s.options.start = start; + return this; + } + /** + * Sets the 0-based offset in bytes to start streaming from. Throws + * an error if this stream has entered flowing mode + * (e.g. if you've already called `on('data')`) + * + * @param end - Offset in bytes to stop reading at + */ + end(end = 0) { + throwIfInitialized(this); + this.s.options.end = end; + return this; + } + /** + * Marks this stream as aborted (will never push another `data` event) + * and kills the underlying cursor. Will emit the 'end' event, and then + * the 'close' event once the cursor is successfully killed. + */ + async abort() { + this.push(null); + this.destroy(); + const remainingTimeMS = this.s.timeoutContext?.getRemainingTimeMSOrThrow(); + await this.s.cursor?.close({ timeoutMS: remainingTimeMS }); + } + }; + exports2.GridFSBucketReadStream = GridFSBucketReadStream; + GridFSBucketReadStream.FILE = "file"; + function throwIfInitialized(stream) { + if (stream.s.init) { + throw new error_1.MongoGridFSStreamError("Options cannot be changed after the stream is initialized"); + } + } + function doRead(stream) { + if (stream.destroyed) + return; + if (!stream.s.cursor) + return; + if (!stream.s.file) + return; + const handleReadResult = (doc) => { + if (stream.destroyed) + return; + if (!doc) { + stream.push(null); + stream.s.cursor?.close().then(void 0, (error) => stream.destroy(error)); + return; + } + if (!stream.s.file) + return; + const bytesRemaining = stream.s.file.length - stream.s.bytesRead; + const expectedN = stream.s.expected++; + const expectedLength = Math.min(stream.s.file.chunkSize, bytesRemaining); + if (doc.n > expectedN) { + return stream.destroy(new error_1.MongoGridFSChunkError(`ChunkIsMissing: Got unexpected n: ${doc.n}, expected: ${expectedN}`)); + } + if (doc.n < expectedN) { + return stream.destroy(new error_1.MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}, expected: ${expectedN}`)); + } + let buf = Buffer.isBuffer(doc.data) ? doc.data : doc.data.buffer; + if (buf.byteLength !== expectedLength) { + if (bytesRemaining <= 0) { + return stream.destroy(new error_1.MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}, expected file length ${stream.s.file.length} bytes but already read ${stream.s.bytesRead} bytes`)); + } + return stream.destroy(new error_1.MongoGridFSChunkError(`ChunkIsWrongSize: Got unexpected length: ${buf.byteLength}, expected: ${expectedLength}`)); + } + stream.s.bytesRead += buf.byteLength; + if (buf.byteLength === 0) { + return stream.push(null); + } + let sliceStart = null; + let sliceEnd = null; + if (stream.s.bytesToSkip != null) { + sliceStart = stream.s.bytesToSkip; + stream.s.bytesToSkip = 0; + } + const atEndOfStream = expectedN === stream.s.expectedEnd - 1; + const bytesLeftToRead = stream.s.options.end - stream.s.bytesToSkip; + if (atEndOfStream && stream.s.bytesToTrim != null) { + sliceEnd = stream.s.file.chunkSize - stream.s.bytesToTrim; + } else if (stream.s.options.end && bytesLeftToRead < doc.data.byteLength) { + sliceEnd = bytesLeftToRead; + } + if (sliceStart != null || sliceEnd != null) { + buf = buf.slice(sliceStart || 0, sliceEnd || buf.byteLength); + } + stream.push(buf); + return; + }; + stream.s.cursor.next().then(handleReadResult, (error) => { + if (stream.destroyed) + return; + stream.destroy(error); + }); + } + function init(stream) { + const findOneOptions = {}; + if (stream.s.readPreference) { + findOneOptions.readPreference = stream.s.readPreference; + } + if (stream.s.options && stream.s.options.sort) { + findOneOptions.sort = stream.s.options.sort; + } + if (stream.s.options && stream.s.options.skip) { + findOneOptions.skip = stream.s.options.skip; + } + const handleReadResult = (doc) => { + if (stream.destroyed) + return; + if (!doc) { + const identifier = stream.s.filter._id ? stream.s.filter._id.toString() : stream.s.filter.filename; + const errmsg = `FileNotFound: file ${identifier} was not found`; + const err = new error_1.MongoRuntimeError(errmsg); + err.code = "ENOENT"; + return stream.destroy(err); + } + if (doc.length <= 0) { + stream.push(null); + return; + } + if (stream.destroyed) { + stream.destroy(); + return; + } + try { + stream.s.bytesToSkip = handleStartOption(stream, doc, stream.s.options); + } catch (error) { + return stream.destroy(error); + } + const filter = { files_id: doc._id }; + if (stream.s.options && stream.s.options.start != null) { + const skip = Math.floor(stream.s.options.start / doc.chunkSize); + if (skip > 0) { + filter["n"] = { $gte: skip }; + } + } + let remainingTimeMS2; + try { + remainingTimeMS2 = stream.s.timeoutContext?.getRemainingTimeMSOrThrow(`Download timed out after ${stream.s.timeoutContext?.timeoutMS}ms`); + } catch (error) { + return stream.destroy(error); + } + stream.s.cursor = stream.s.chunks.find(filter, { + timeoutMS: remainingTimeMS2 + }).sort({ n: 1 }); + if (stream.s.readPreference) { + stream.s.cursor.withReadPreference(stream.s.readPreference); + } + stream.s.expectedEnd = Math.ceil(doc.length / doc.chunkSize); + stream.s.file = doc; + try { + stream.s.bytesToTrim = handleEndOption(stream, doc, stream.s.cursor, stream.s.options); + } catch (error) { + return stream.destroy(error); + } + stream.emit(GridFSBucketReadStream.FILE, doc); + return; + }; + let remainingTimeMS; + try { + remainingTimeMS = stream.s.timeoutContext?.getRemainingTimeMSOrThrow(`Download timed out after ${stream.s.timeoutContext?.timeoutMS}ms`); + } catch (error) { + if (!stream.destroyed) + stream.destroy(error); + return; + } + findOneOptions.timeoutMS = remainingTimeMS; + stream.s.files.findOne(stream.s.filter, findOneOptions).then(handleReadResult, (error) => { + if (stream.destroyed) + return; + stream.destroy(error); + }); + } + function waitForFile(stream, callback) { + if (stream.s.file) { + return callback(); + } + if (!stream.s.init) { + init(stream); + stream.s.init = true; + } + stream.once("file", () => { + callback(); + }); + } + function handleStartOption(stream, doc, options) { + if (options && options.start != null) { + if (options.start > doc.length) { + throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be more than the length of the file (${doc.length})`); + } + if (options.start < 0) { + throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be negative`); + } + if (options.end != null && options.end < options.start) { + throw new error_1.MongoInvalidArgumentError(`Stream start (${options.start}) must not be greater than stream end (${options.end})`); + } + stream.s.bytesRead = Math.floor(options.start / doc.chunkSize) * doc.chunkSize; + stream.s.expected = Math.floor(options.start / doc.chunkSize); + return options.start - stream.s.bytesRead; + } + throw new error_1.MongoInvalidArgumentError("Start option must be defined"); + } + function handleEndOption(stream, doc, cursor, options) { + if (options && options.end != null) { + if (options.end > doc.length) { + throw new error_1.MongoInvalidArgumentError(`Stream end (${options.end}) must not be more than the length of the file (${doc.length})`); + } + if (options.start == null || options.start < 0) { + throw new error_1.MongoInvalidArgumentError(`Stream end (${options.end}) must not be negative`); + } + const start = options.start != null ? Math.floor(options.start / doc.chunkSize) : 0; + cursor.limit(Math.ceil(options.end / doc.chunkSize) - start); + stream.s.expectedEnd = Math.ceil(options.end / doc.chunkSize); + return Math.ceil(options.end / doc.chunkSize) * doc.chunkSize - options.end; + } + throw new error_1.MongoInvalidArgumentError("End option must be defined"); + } + } +}); + +// node_modules/mongodb/lib/gridfs/upload.js +var require_upload = __commonJS({ + "node_modules/mongodb/lib/gridfs/upload.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GridFSBucketWriteStream = void 0; + var stream_1 = require("stream"); + var bson_1 = require_bson2(); + var error_1 = require_error(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var GridFSBucketWriteStream = class extends stream_1.Writable { + /** + * @param bucket - Handle for this stream's corresponding bucket + * @param filename - The value of the 'filename' key in the files doc + * @param options - Optional settings. + * @internal + */ + constructor(bucket, filename, options) { + super(); + this.gridFSFile = null; + options = options ?? {}; + this.bucket = bucket; + this.chunks = bucket.s._chunksCollection; + this.filename = filename; + this.files = bucket.s._filesCollection; + this.options = options; + this.writeConcern = write_concern_1.WriteConcern.fromOptions(options) || bucket.s.options.writeConcern; + this.done = false; + this.id = options.id ? options.id : new bson_1.ObjectId(); + this.chunkSizeBytes = options.chunkSizeBytes || this.bucket.s.options.chunkSizeBytes; + this.bufToStore = Buffer.alloc(this.chunkSizeBytes); + this.length = 0; + this.n = 0; + this.pos = 0; + this.state = { + streamEnd: false, + outstandingRequests: 0, + errored: false, + aborted: false + }; + } + /** + * @internal + * + * The stream is considered constructed when the indexes are done being created + */ + _construct(callback) { + if (!this.bucket.s.calledOpenUploadStream) { + this.bucket.s.calledOpenUploadStream = true; + checkIndexes(this).then(() => { + this.bucket.s.checkedIndexes = true; + this.bucket.emit("index"); + callback(); + }, (error) => { + if (error instanceof error_1.MongoOperationTimeoutError) { + return handleError(this, error, callback); + } + (0, utils_1.squashError)(error); + callback(); + }); + } else { + return process.nextTick(callback); + } + } + /** + * @internal + * Write a buffer to the stream. + * + * @param chunk - Buffer to write + * @param encoding - Optional encoding for the buffer + * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush. + */ + _write(chunk, encoding, callback) { + doWrite(this, chunk, encoding, callback); + } + /** @internal */ + _final(callback) { + if (this.state.streamEnd) { + return process.nextTick(callback); + } + this.state.streamEnd = true; + writeRemnant(this, callback); + } + /** + * Places this write stream into an aborted state (all future writes fail) + * and deletes all chunks that have already been written. + */ + async abort() { + if (this.state.streamEnd) { + throw new error_1.MongoAPIError("Cannot abort a stream that has already completed"); + } + if (this.state.aborted) { + throw new error_1.MongoAPIError("Cannot call abort() on a stream twice"); + } + this.state.aborted = true; + const remainingTimeMS = this.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${this.timeoutContext?.timeoutMS}ms`); + await this.chunks.deleteMany({ files_id: this.id }, { timeoutMS: remainingTimeMS }); + } + }; + exports2.GridFSBucketWriteStream = GridFSBucketWriteStream; + function handleError(stream, error, callback) { + if (stream.state.errored) { + process.nextTick(callback); + return; + } + stream.state.errored = true; + process.nextTick(callback, error); + } + function createChunkDoc(filesId, n, data) { + return { + _id: new bson_1.ObjectId(), + files_id: filesId, + n, + data + }; + } + async function checkChunksIndex(stream) { + const index = { files_id: 1, n: 1 }; + let remainingTimeMS; + remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`); + let indexes; + try { + indexes = await stream.chunks.listIndexes({ + timeoutMS: remainingTimeMS + }).toArray(); + } catch (error) { + if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound) { + indexes = []; + } else { + throw error; + } + } + const hasChunksIndex = !!indexes.find((index2) => { + const keys = Object.keys(index2.key); + if (keys.length === 2 && index2.key.files_id === 1 && index2.key.n === 1) { + return true; + } + return false; + }); + if (!hasChunksIndex) { + remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`); + await stream.chunks.createIndex(index, { + ...stream.writeConcern, + background: true, + unique: true, + timeoutMS: remainingTimeMS + }); + } + } + function checkDone(stream, callback) { + if (stream.done) { + return process.nextTick(callback); + } + if (stream.state.streamEnd && stream.state.outstandingRequests === 0 && !stream.state.errored) { + stream.done = true; + const gridFSFile = createFilesDoc(stream.id, stream.length, stream.chunkSizeBytes, stream.filename, stream.options.contentType, stream.options.aliases, stream.options.metadata); + if (isAborted(stream, callback)) { + return; + } + const remainingTimeMS = stream.timeoutContext?.remainingTimeMS; + if (remainingTimeMS != null && remainingTimeMS <= 0) { + return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback); + } + stream.files.insertOne(gridFSFile, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS }).then(() => { + stream.gridFSFile = gridFSFile; + callback(); + }, (error) => { + return handleError(stream, error, callback); + }); + return; + } + process.nextTick(callback); + } + async function checkIndexes(stream) { + let remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`); + const doc = await stream.files.findOne({}, { + projection: { _id: 1 }, + timeoutMS: remainingTimeMS + }); + if (doc != null) { + return; + } + const index = { filename: 1, uploadDate: 1 }; + let indexes; + remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`); + const listIndexesOptions = { + timeoutMS: remainingTimeMS + }; + try { + indexes = await stream.files.listIndexes(listIndexesOptions).toArray(); + } catch (error) { + if (error instanceof error_1.MongoError && error.code === error_1.MONGODB_ERROR_CODES.NamespaceNotFound) { + indexes = []; + } else { + throw error; + } + } + const hasFileIndex = !!indexes.find((index2) => { + const keys = Object.keys(index2.key); + if (keys.length === 2 && index2.key.filename === 1 && index2.key.uploadDate === 1) { + return true; + } + return false; + }); + if (!hasFileIndex) { + remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`); + await stream.files.createIndex(index, { background: false, timeoutMS: remainingTimeMS }); + } + await checkChunksIndex(stream); + } + function createFilesDoc(_id, length, chunkSize, filename, contentType, aliases, metadata) { + const ret = { + _id, + length, + chunkSize, + uploadDate: /* @__PURE__ */ new Date(), + filename + }; + if (contentType) { + ret.contentType = contentType; + } + if (aliases) { + ret.aliases = aliases; + } + if (metadata) { + ret.metadata = metadata; + } + return ret; + } + function doWrite(stream, chunk, encoding, callback) { + if (isAborted(stream, callback)) { + return; + } + const inputBuf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding); + stream.length += inputBuf.length; + if (stream.pos + inputBuf.length < stream.chunkSizeBytes) { + inputBuf.copy(stream.bufToStore, stream.pos); + stream.pos += inputBuf.length; + process.nextTick(callback); + return; + } + let inputBufRemaining = inputBuf.length; + let spaceRemaining = stream.chunkSizeBytes - stream.pos; + let numToCopy = Math.min(spaceRemaining, inputBuf.length); + let outstandingRequests = 0; + while (inputBufRemaining > 0) { + const inputBufPos = inputBuf.length - inputBufRemaining; + inputBuf.copy(stream.bufToStore, stream.pos, inputBufPos, inputBufPos + numToCopy); + stream.pos += numToCopy; + spaceRemaining -= numToCopy; + let doc; + if (spaceRemaining === 0) { + doc = createChunkDoc(stream.id, stream.n, Buffer.from(stream.bufToStore)); + const remainingTimeMS = stream.timeoutContext?.remainingTimeMS; + if (remainingTimeMS != null && remainingTimeMS <= 0) { + return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback); + } + ++stream.state.outstandingRequests; + ++outstandingRequests; + if (isAborted(stream, callback)) { + return; + } + stream.chunks.insertOne(doc, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS }).then(() => { + --stream.state.outstandingRequests; + --outstandingRequests; + if (!outstandingRequests) { + checkDone(stream, callback); + } + }, (error) => { + return handleError(stream, error, callback); + }); + spaceRemaining = stream.chunkSizeBytes; + stream.pos = 0; + ++stream.n; + } + inputBufRemaining -= numToCopy; + numToCopy = Math.min(spaceRemaining, inputBufRemaining); + } + } + function writeRemnant(stream, callback) { + if (stream.pos === 0) { + return checkDone(stream, callback); + } + const remnant = Buffer.alloc(stream.pos); + stream.bufToStore.copy(remnant, 0, 0, stream.pos); + const doc = createChunkDoc(stream.id, stream.n, remnant); + if (isAborted(stream, callback)) { + return; + } + const remainingTimeMS = stream.timeoutContext?.remainingTimeMS; + if (remainingTimeMS != null && remainingTimeMS <= 0) { + return handleError(stream, new error_1.MongoOperationTimeoutError(`Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`), callback); + } + ++stream.state.outstandingRequests; + stream.chunks.insertOne(doc, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS }).then(() => { + --stream.state.outstandingRequests; + checkDone(stream, callback); + }, (error) => { + return handleError(stream, error, callback); + }); + } + function isAborted(stream, callback) { + if (stream.state.aborted) { + process.nextTick(callback, new error_1.MongoAPIError("Stream has been aborted")); + return true; + } + return false; + } + } +}); + +// node_modules/mongodb/lib/gridfs/index.js +var require_gridfs = __commonJS({ + "node_modules/mongodb/lib/gridfs/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.GridFSBucket = void 0; + var error_1 = require_error(); + var mongo_types_1 = require_mongo_types(); + var timeout_1 = require_timeout(); + var utils_1 = require_utils3(); + var write_concern_1 = require_write_concern(); + var download_1 = require_download(); + var upload_1 = require_upload(); + var DEFAULT_GRIDFS_BUCKET_OPTIONS = { + bucketName: "fs", + chunkSizeBytes: 255 * 1024 + }; + var GridFSBucket = class extends mongo_types_1.TypedEventEmitter { + constructor(db, options) { + super(); + this.on("error", utils_1.noop); + this.setMaxListeners(0); + const privateOptions = (0, utils_1.resolveOptions)(db, { + ...DEFAULT_GRIDFS_BUCKET_OPTIONS, + ...options, + writeConcern: write_concern_1.WriteConcern.fromOptions(options) + }); + this.s = { + db, + options: privateOptions, + _chunksCollection: db.collection(privateOptions.bucketName + ".chunks"), + _filesCollection: db.collection(privateOptions.bucketName + ".files"), + checkedIndexes: false, + calledOpenUploadStream: false + }; + } + /** + * Returns a writable stream (GridFSBucketWriteStream) for writing + * buffers to GridFS. The stream's 'id' property contains the resulting + * file's id. + * + * @param filename - The value of the 'filename' key in the files doc + * @param options - Optional settings. + */ + openUploadStream(filename, options) { + return new upload_1.GridFSBucketWriteStream(this, filename, { + timeoutMS: this.s.options.timeoutMS, + ...options + }); + } + /** + * Returns a writable stream (GridFSBucketWriteStream) for writing + * buffers to GridFS for a custom file id. The stream's 'id' property contains the resulting + * file's id. + */ + openUploadStreamWithId(id, filename, options) { + return new upload_1.GridFSBucketWriteStream(this, filename, { + timeoutMS: this.s.options.timeoutMS, + ...options, + id + }); + } + /** Returns a readable stream (GridFSBucketReadStream) for streaming file data from GridFS. */ + openDownloadStream(id, options) { + return new download_1.GridFSBucketReadStream(this.s._chunksCollection, this.s._filesCollection, this.s.options.readPreference, { _id: id }, { timeoutMS: this.s.options.timeoutMS, ...options }); + } + /** + * Deletes a file with the given id + * + * @param id - The id of the file doc + */ + async delete(id, options) { + const { timeoutMS } = (0, utils_1.resolveOptions)(this.s.db, options); + let timeoutContext = void 0; + if (timeoutMS) { + timeoutContext = new timeout_1.CSOTTimeoutContext({ + timeoutMS, + serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS + }); + } + const { deletedCount } = await this.s._filesCollection.deleteOne({ _id: id }, { timeoutMS: timeoutContext?.remainingTimeMS }); + const remainingTimeMS = timeoutContext?.remainingTimeMS; + if (remainingTimeMS != null && remainingTimeMS <= 0) + throw new error_1.MongoOperationTimeoutError(`Timed out after ${timeoutMS}ms`); + await this.s._chunksCollection.deleteMany({ files_id: id }, { timeoutMS: remainingTimeMS }); + if (deletedCount === 0) { + throw new error_1.MongoRuntimeError(`File not found for id ${id}`); + } + } + /** Convenience wrapper around find on the files collection */ + find(filter = {}, options = {}) { + return this.s._filesCollection.find(filter, options); + } + /** + * Returns a readable stream (GridFSBucketReadStream) for streaming the + * file with the given name from GridFS. If there are multiple files with + * the same name, this will stream the most recent file with the given name + * (as determined by the `uploadDate` field). You can set the `revision` + * option to change this behavior. + */ + openDownloadStreamByName(filename, options) { + let sort = { uploadDate: -1 }; + let skip = void 0; + if (options && options.revision != null) { + if (options.revision >= 0) { + sort = { uploadDate: 1 }; + skip = options.revision; + } else { + skip = -options.revision - 1; + } + } + return new download_1.GridFSBucketReadStream(this.s._chunksCollection, this.s._filesCollection, this.s.options.readPreference, { filename }, { timeoutMS: this.s.options.timeoutMS, ...options, sort, skip }); + } + /** + * Renames the file with the given _id to the given string + * + * @param id - the id of the file to rename + * @param filename - new name for the file + */ + async rename(id, filename, options) { + const filter = { _id: id }; + const update = { $set: { filename } }; + const { matchedCount } = await this.s._filesCollection.updateOne(filter, update, options); + if (matchedCount === 0) { + throw new error_1.MongoRuntimeError(`File with id ${id} not found`); + } + } + /** Removes this bucket's files collection, followed by its chunks collection. */ + async drop(options) { + const { timeoutMS } = (0, utils_1.resolveOptions)(this.s.db, options); + let timeoutContext = void 0; + if (timeoutMS) { + timeoutContext = new timeout_1.CSOTTimeoutContext({ + timeoutMS, + serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS + }); + } + if (timeoutContext) { + await this.s._filesCollection.drop({ timeoutMS: timeoutContext.remainingTimeMS }); + const remainingTimeMS = timeoutContext.getRemainingTimeMSOrThrow(`Timed out after ${timeoutMS}ms`); + await this.s._chunksCollection.drop({ timeoutMS: remainingTimeMS }); + } else { + await this.s._filesCollection.drop(); + await this.s._chunksCollection.drop(); + } + } + }; + exports2.GridFSBucket = GridFSBucket; + GridFSBucket.INDEX = "index"; + } +}); + +// node_modules/mongodb/lib/index.js +var require_lib9 = __commonJS({ + "node_modules/mongodb/lib/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.MongoRuntimeError = exports2.MongoParseError = exports2.MongoOperationTimeoutError = exports2.MongoOIDCError = exports2.MongoNotConnectedError = exports2.MongoNetworkTimeoutError = exports2.MongoNetworkError = exports2.MongoMissingDependencyError = exports2.MongoMissingCredentialsError = exports2.MongoKerberosError = exports2.MongoInvalidArgumentError = exports2.MongoGridFSStreamError = exports2.MongoGridFSChunkError = exports2.MongoGCPError = exports2.MongoExpiredSessionError = exports2.MongoError = exports2.MongoDriverError = exports2.MongoDecompressionError = exports2.MongoCursorInUseError = exports2.MongoCursorExhaustedError = exports2.MongoCompatibilityError = exports2.MongoClientClosedError = exports2.MongoClientBulkWriteExecutionError = exports2.MongoClientBulkWriteError = exports2.MongoClientBulkWriteCursorError = exports2.MongoChangeStreamError = exports2.MongoBatchReExecutionError = exports2.MongoAzureError = exports2.MongoAWSError = exports2.MongoAPIError = exports2.ExplainableCursor = exports2.ChangeStreamCursor = exports2.ClientEncryption = exports2.MongoBulkWriteError = exports2.UUID = exports2.Timestamp = exports2.ObjectId = exports2.MinKey = exports2.MaxKey = exports2.Long = exports2.Int32 = exports2.Double = exports2.Decimal128 = exports2.DBRef = exports2.Code = exports2.BSONType = exports2.BSONSymbol = exports2.BSONRegExp = exports2.Binary = exports2.BSON = void 0; + exports2.CommandFailedEvent = exports2.WriteConcern = exports2.ReadPreference = exports2.ReadConcern = exports2.TopologyType = exports2.ServerType = exports2.ReadPreferenceMode = exports2.ReadConcernLevel = exports2.ProfilingLevel = exports2.ReturnDocument = exports2.SeverityLevel = exports2.MongoLoggableComponent = exports2.ServerApiVersion = exports2.ExplainVerbosity = exports2.MongoErrorLabel = exports2.CursorTimeoutMode = exports2.CURSOR_FLAGS = exports2.Compressor = exports2.AuthMechanism = exports2.GSSAPICanonicalizationValue = exports2.AutoEncryptionLoggerLevel = exports2.BatchType = exports2.UnorderedBulkOperation = exports2.OrderedBulkOperation = exports2.MongoClient = exports2.ListIndexesCursor = exports2.ListCollectionsCursor = exports2.GridFSBucketWriteStream = exports2.GridFSBucketReadStream = exports2.GridFSBucket = exports2.FindCursor = exports2.Db = exports2.Collection = exports2.ClientSession = exports2.ChangeStream = exports2.CancellationToken = exports2.AggregationCursor = exports2.Admin = exports2.AbstractCursor = exports2.configureExplicitResourceManagement = exports2.MongoWriteConcernError = exports2.MongoUnexpectedServerResponseError = exports2.MongoTransactionError = exports2.MongoTopologyClosedError = exports2.MongoTailableCursorError = exports2.MongoSystemError = exports2.MongoStalePrimaryError = exports2.MongoServerSelectionError = exports2.MongoServerError = exports2.MongoServerClosedError = void 0; + exports2.MongoClientAuthProviders = exports2.MongoCryptKMSRequestNetworkTimeoutError = exports2.MongoCryptInvalidArgumentError = exports2.MongoCryptError = exports2.MongoCryptCreateEncryptedCollectionError = exports2.MongoCryptCreateDataKeyError = exports2.MongoCryptAzureKMSRequestError = exports2.SrvPollingEvent = exports2.WaitingForSuitableServerEvent = exports2.ServerSelectionSucceededEvent = exports2.ServerSelectionStartedEvent = exports2.ServerSelectionFailedEvent = exports2.ServerSelectionEvent = exports2.TopologyOpeningEvent = exports2.TopologyDescriptionChangedEvent = exports2.TopologyClosedEvent = exports2.ServerOpeningEvent = exports2.ServerHeartbeatSucceededEvent = exports2.ServerHeartbeatStartedEvent = exports2.ServerHeartbeatFailedEvent = exports2.ServerDescriptionChangedEvent = exports2.ServerClosedEvent = exports2.ConnectionReadyEvent = exports2.ConnectionPoolReadyEvent = exports2.ConnectionPoolMonitoringEvent = exports2.ConnectionPoolCreatedEvent = exports2.ConnectionPoolClosedEvent = exports2.ConnectionPoolClearedEvent = exports2.ConnectionCreatedEvent = exports2.ConnectionClosedEvent = exports2.ConnectionCheckOutStartedEvent = exports2.ConnectionCheckOutFailedEvent = exports2.ConnectionCheckedOutEvent = exports2.ConnectionCheckedInEvent = exports2.CommandSucceededEvent = exports2.CommandStartedEvent = void 0; + var admin_1 = require_admin(); + Object.defineProperty(exports2, "Admin", { enumerable: true, get: function() { + return admin_1.Admin; + } }); + var ordered_1 = require_ordered(); + Object.defineProperty(exports2, "OrderedBulkOperation", { enumerable: true, get: function() { + return ordered_1.OrderedBulkOperation; + } }); + var unordered_1 = require_unordered(); + Object.defineProperty(exports2, "UnorderedBulkOperation", { enumerable: true, get: function() { + return unordered_1.UnorderedBulkOperation; + } }); + var change_stream_1 = require_change_stream(); + Object.defineProperty(exports2, "ChangeStream", { enumerable: true, get: function() { + return change_stream_1.ChangeStream; + } }); + var collection_1 = require_collection(); + Object.defineProperty(exports2, "Collection", { enumerable: true, get: function() { + return collection_1.Collection; + } }); + var abstract_cursor_1 = require_abstract_cursor(); + Object.defineProperty(exports2, "AbstractCursor", { enumerable: true, get: function() { + return abstract_cursor_1.AbstractCursor; + } }); + var aggregation_cursor_1 = require_aggregation_cursor(); + Object.defineProperty(exports2, "AggregationCursor", { enumerable: true, get: function() { + return aggregation_cursor_1.AggregationCursor; + } }); + var find_cursor_1 = require_find_cursor(); + Object.defineProperty(exports2, "FindCursor", { enumerable: true, get: function() { + return find_cursor_1.FindCursor; + } }); + var list_collections_cursor_1 = require_list_collections_cursor(); + Object.defineProperty(exports2, "ListCollectionsCursor", { enumerable: true, get: function() { + return list_collections_cursor_1.ListCollectionsCursor; + } }); + var list_indexes_cursor_1 = require_list_indexes_cursor(); + Object.defineProperty(exports2, "ListIndexesCursor", { enumerable: true, get: function() { + return list_indexes_cursor_1.ListIndexesCursor; + } }); + var db_1 = require_db(); + Object.defineProperty(exports2, "Db", { enumerable: true, get: function() { + return db_1.Db; + } }); + var gridfs_1 = require_gridfs(); + Object.defineProperty(exports2, "GridFSBucket", { enumerable: true, get: function() { + return gridfs_1.GridFSBucket; + } }); + var download_1 = require_download(); + Object.defineProperty(exports2, "GridFSBucketReadStream", { enumerable: true, get: function() { + return download_1.GridFSBucketReadStream; + } }); + var upload_1 = require_upload(); + Object.defineProperty(exports2, "GridFSBucketWriteStream", { enumerable: true, get: function() { + return upload_1.GridFSBucketWriteStream; + } }); + var mongo_client_1 = require_mongo_client(); + Object.defineProperty(exports2, "MongoClient", { enumerable: true, get: function() { + return mongo_client_1.MongoClient; + } }); + var mongo_types_1 = require_mongo_types(); + Object.defineProperty(exports2, "CancellationToken", { enumerable: true, get: function() { + return mongo_types_1.CancellationToken; + } }); + var sessions_1 = require_sessions(); + Object.defineProperty(exports2, "ClientSession", { enumerable: true, get: function() { + return sessions_1.ClientSession; + } }); + var bson_1 = require_bson2(); + Object.defineProperty(exports2, "BSON", { enumerable: true, get: function() { + return bson_1.BSON; + } }); + var bson_2 = require_bson2(); + Object.defineProperty(exports2, "Binary", { enumerable: true, get: function() { + return bson_2.Binary; + } }); + Object.defineProperty(exports2, "BSONRegExp", { enumerable: true, get: function() { + return bson_2.BSONRegExp; + } }); + Object.defineProperty(exports2, "BSONSymbol", { enumerable: true, get: function() { + return bson_2.BSONSymbol; + } }); + Object.defineProperty(exports2, "BSONType", { enumerable: true, get: function() { + return bson_2.BSONType; + } }); + Object.defineProperty(exports2, "Code", { enumerable: true, get: function() { + return bson_2.Code; + } }); + Object.defineProperty(exports2, "DBRef", { enumerable: true, get: function() { + return bson_2.DBRef; + } }); + Object.defineProperty(exports2, "Decimal128", { enumerable: true, get: function() { + return bson_2.Decimal128; + } }); + Object.defineProperty(exports2, "Double", { enumerable: true, get: function() { + return bson_2.Double; + } }); + Object.defineProperty(exports2, "Int32", { enumerable: true, get: function() { + return bson_2.Int32; + } }); + Object.defineProperty(exports2, "Long", { enumerable: true, get: function() { + return bson_2.Long; + } }); + Object.defineProperty(exports2, "MaxKey", { enumerable: true, get: function() { + return bson_2.MaxKey; + } }); + Object.defineProperty(exports2, "MinKey", { enumerable: true, get: function() { + return bson_2.MinKey; + } }); + Object.defineProperty(exports2, "ObjectId", { enumerable: true, get: function() { + return bson_2.ObjectId; + } }); + Object.defineProperty(exports2, "Timestamp", { enumerable: true, get: function() { + return bson_2.Timestamp; + } }); + Object.defineProperty(exports2, "UUID", { enumerable: true, get: function() { + return bson_2.UUID; + } }); + var common_1 = require_common2(); + Object.defineProperty(exports2, "MongoBulkWriteError", { enumerable: true, get: function() { + return common_1.MongoBulkWriteError; + } }); + var client_encryption_1 = require_client_encryption(); + Object.defineProperty(exports2, "ClientEncryption", { enumerable: true, get: function() { + return client_encryption_1.ClientEncryption; + } }); + var change_stream_cursor_1 = require_change_stream_cursor(); + Object.defineProperty(exports2, "ChangeStreamCursor", { enumerable: true, get: function() { + return change_stream_cursor_1.ChangeStreamCursor; + } }); + var explainable_cursor_1 = require_explainable_cursor(); + Object.defineProperty(exports2, "ExplainableCursor", { enumerable: true, get: function() { + return explainable_cursor_1.ExplainableCursor; + } }); + var error_1 = require_error(); + Object.defineProperty(exports2, "MongoAPIError", { enumerable: true, get: function() { + return error_1.MongoAPIError; + } }); + Object.defineProperty(exports2, "MongoAWSError", { enumerable: true, get: function() { + return error_1.MongoAWSError; + } }); + Object.defineProperty(exports2, "MongoAzureError", { enumerable: true, get: function() { + return error_1.MongoAzureError; + } }); + Object.defineProperty(exports2, "MongoBatchReExecutionError", { enumerable: true, get: function() { + return error_1.MongoBatchReExecutionError; + } }); + Object.defineProperty(exports2, "MongoChangeStreamError", { enumerable: true, get: function() { + return error_1.MongoChangeStreamError; + } }); + Object.defineProperty(exports2, "MongoClientBulkWriteCursorError", { enumerable: true, get: function() { + return error_1.MongoClientBulkWriteCursorError; + } }); + Object.defineProperty(exports2, "MongoClientBulkWriteError", { enumerable: true, get: function() { + return error_1.MongoClientBulkWriteError; + } }); + Object.defineProperty(exports2, "MongoClientBulkWriteExecutionError", { enumerable: true, get: function() { + return error_1.MongoClientBulkWriteExecutionError; + } }); + Object.defineProperty(exports2, "MongoClientClosedError", { enumerable: true, get: function() { + return error_1.MongoClientClosedError; + } }); + Object.defineProperty(exports2, "MongoCompatibilityError", { enumerable: true, get: function() { + return error_1.MongoCompatibilityError; + } }); + Object.defineProperty(exports2, "MongoCursorExhaustedError", { enumerable: true, get: function() { + return error_1.MongoCursorExhaustedError; + } }); + Object.defineProperty(exports2, "MongoCursorInUseError", { enumerable: true, get: function() { + return error_1.MongoCursorInUseError; + } }); + Object.defineProperty(exports2, "MongoDecompressionError", { enumerable: true, get: function() { + return error_1.MongoDecompressionError; + } }); + Object.defineProperty(exports2, "MongoDriverError", { enumerable: true, get: function() { + return error_1.MongoDriverError; + } }); + Object.defineProperty(exports2, "MongoError", { enumerable: true, get: function() { + return error_1.MongoError; + } }); + Object.defineProperty(exports2, "MongoExpiredSessionError", { enumerable: true, get: function() { + return error_1.MongoExpiredSessionError; + } }); + Object.defineProperty(exports2, "MongoGCPError", { enumerable: true, get: function() { + return error_1.MongoGCPError; + } }); + Object.defineProperty(exports2, "MongoGridFSChunkError", { enumerable: true, get: function() { + return error_1.MongoGridFSChunkError; + } }); + Object.defineProperty(exports2, "MongoGridFSStreamError", { enumerable: true, get: function() { + return error_1.MongoGridFSStreamError; + } }); + Object.defineProperty(exports2, "MongoInvalidArgumentError", { enumerable: true, get: function() { + return error_1.MongoInvalidArgumentError; + } }); + Object.defineProperty(exports2, "MongoKerberosError", { enumerable: true, get: function() { + return error_1.MongoKerberosError; + } }); + Object.defineProperty(exports2, "MongoMissingCredentialsError", { enumerable: true, get: function() { + return error_1.MongoMissingCredentialsError; + } }); + Object.defineProperty(exports2, "MongoMissingDependencyError", { enumerable: true, get: function() { + return error_1.MongoMissingDependencyError; + } }); + Object.defineProperty(exports2, "MongoNetworkError", { enumerable: true, get: function() { + return error_1.MongoNetworkError; + } }); + Object.defineProperty(exports2, "MongoNetworkTimeoutError", { enumerable: true, get: function() { + return error_1.MongoNetworkTimeoutError; + } }); + Object.defineProperty(exports2, "MongoNotConnectedError", { enumerable: true, get: function() { + return error_1.MongoNotConnectedError; + } }); + Object.defineProperty(exports2, "MongoOIDCError", { enumerable: true, get: function() { + return error_1.MongoOIDCError; + } }); + Object.defineProperty(exports2, "MongoOperationTimeoutError", { enumerable: true, get: function() { + return error_1.MongoOperationTimeoutError; + } }); + Object.defineProperty(exports2, "MongoParseError", { enumerable: true, get: function() { + return error_1.MongoParseError; + } }); + Object.defineProperty(exports2, "MongoRuntimeError", { enumerable: true, get: function() { + return error_1.MongoRuntimeError; + } }); + Object.defineProperty(exports2, "MongoServerClosedError", { enumerable: true, get: function() { + return error_1.MongoServerClosedError; + } }); + Object.defineProperty(exports2, "MongoServerError", { enumerable: true, get: function() { + return error_1.MongoServerError; + } }); + Object.defineProperty(exports2, "MongoServerSelectionError", { enumerable: true, get: function() { + return error_1.MongoServerSelectionError; + } }); + Object.defineProperty(exports2, "MongoStalePrimaryError", { enumerable: true, get: function() { + return error_1.MongoStalePrimaryError; + } }); + Object.defineProperty(exports2, "MongoSystemError", { enumerable: true, get: function() { + return error_1.MongoSystemError; + } }); + Object.defineProperty(exports2, "MongoTailableCursorError", { enumerable: true, get: function() { + return error_1.MongoTailableCursorError; + } }); + Object.defineProperty(exports2, "MongoTopologyClosedError", { enumerable: true, get: function() { + return error_1.MongoTopologyClosedError; + } }); + Object.defineProperty(exports2, "MongoTransactionError", { enumerable: true, get: function() { + return error_1.MongoTransactionError; + } }); + Object.defineProperty(exports2, "MongoUnexpectedServerResponseError", { enumerable: true, get: function() { + return error_1.MongoUnexpectedServerResponseError; + } }); + Object.defineProperty(exports2, "MongoWriteConcernError", { enumerable: true, get: function() { + return error_1.MongoWriteConcernError; + } }); + var resource_management_1 = require_resource_management(); + Object.defineProperty(exports2, "configureExplicitResourceManagement", { enumerable: true, get: function() { + return resource_management_1.configureExplicitResourceManagement; + } }); + var common_2 = require_common2(); + Object.defineProperty(exports2, "BatchType", { enumerable: true, get: function() { + return common_2.BatchType; + } }); + var auto_encrypter_1 = require_auto_encrypter(); + Object.defineProperty(exports2, "AutoEncryptionLoggerLevel", { enumerable: true, get: function() { + return auto_encrypter_1.AutoEncryptionLoggerLevel; + } }); + var gssapi_1 = require_gssapi(); + Object.defineProperty(exports2, "GSSAPICanonicalizationValue", { enumerable: true, get: function() { + return gssapi_1.GSSAPICanonicalizationValue; + } }); + var providers_1 = require_providers(); + Object.defineProperty(exports2, "AuthMechanism", { enumerable: true, get: function() { + return providers_1.AuthMechanism; + } }); + var compression_1 = require_compression(); + Object.defineProperty(exports2, "Compressor", { enumerable: true, get: function() { + return compression_1.Compressor; + } }); + var abstract_cursor_2 = require_abstract_cursor(); + Object.defineProperty(exports2, "CURSOR_FLAGS", { enumerable: true, get: function() { + return abstract_cursor_2.CURSOR_FLAGS; + } }); + Object.defineProperty(exports2, "CursorTimeoutMode", { enumerable: true, get: function() { + return abstract_cursor_2.CursorTimeoutMode; + } }); + var error_2 = require_error(); + Object.defineProperty(exports2, "MongoErrorLabel", { enumerable: true, get: function() { + return error_2.MongoErrorLabel; + } }); + var explain_1 = require_explain(); + Object.defineProperty(exports2, "ExplainVerbosity", { enumerable: true, get: function() { + return explain_1.ExplainVerbosity; + } }); + var mongo_client_2 = require_mongo_client(); + Object.defineProperty(exports2, "ServerApiVersion", { enumerable: true, get: function() { + return mongo_client_2.ServerApiVersion; + } }); + var mongo_logger_1 = require_mongo_logger(); + Object.defineProperty(exports2, "MongoLoggableComponent", { enumerable: true, get: function() { + return mongo_logger_1.MongoLoggableComponent; + } }); + Object.defineProperty(exports2, "SeverityLevel", { enumerable: true, get: function() { + return mongo_logger_1.SeverityLevel; + } }); + var find_and_modify_1 = require_find_and_modify(); + Object.defineProperty(exports2, "ReturnDocument", { enumerable: true, get: function() { + return find_and_modify_1.ReturnDocument; + } }); + var set_profiling_level_1 = require_set_profiling_level(); + Object.defineProperty(exports2, "ProfilingLevel", { enumerable: true, get: function() { + return set_profiling_level_1.ProfilingLevel; + } }); + var read_concern_1 = require_read_concern(); + Object.defineProperty(exports2, "ReadConcernLevel", { enumerable: true, get: function() { + return read_concern_1.ReadConcernLevel; + } }); + var read_preference_1 = require_read_preference(); + Object.defineProperty(exports2, "ReadPreferenceMode", { enumerable: true, get: function() { + return read_preference_1.ReadPreferenceMode; + } }); + var common_3 = require_common(); + Object.defineProperty(exports2, "ServerType", { enumerable: true, get: function() { + return common_3.ServerType; + } }); + Object.defineProperty(exports2, "TopologyType", { enumerable: true, get: function() { + return common_3.TopologyType; + } }); + var read_concern_2 = require_read_concern(); + Object.defineProperty(exports2, "ReadConcern", { enumerable: true, get: function() { + return read_concern_2.ReadConcern; + } }); + var read_preference_2 = require_read_preference(); + Object.defineProperty(exports2, "ReadPreference", { enumerable: true, get: function() { + return read_preference_2.ReadPreference; + } }); + var write_concern_1 = require_write_concern(); + Object.defineProperty(exports2, "WriteConcern", { enumerable: true, get: function() { + return write_concern_1.WriteConcern; + } }); + var command_monitoring_events_1 = require_command_monitoring_events(); + Object.defineProperty(exports2, "CommandFailedEvent", { enumerable: true, get: function() { + return command_monitoring_events_1.CommandFailedEvent; + } }); + Object.defineProperty(exports2, "CommandStartedEvent", { enumerable: true, get: function() { + return command_monitoring_events_1.CommandStartedEvent; + } }); + Object.defineProperty(exports2, "CommandSucceededEvent", { enumerable: true, get: function() { + return command_monitoring_events_1.CommandSucceededEvent; + } }); + var connection_pool_events_1 = require_connection_pool_events(); + Object.defineProperty(exports2, "ConnectionCheckedInEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionCheckedInEvent; + } }); + Object.defineProperty(exports2, "ConnectionCheckedOutEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionCheckedOutEvent; + } }); + Object.defineProperty(exports2, "ConnectionCheckOutFailedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionCheckOutFailedEvent; + } }); + Object.defineProperty(exports2, "ConnectionCheckOutStartedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionCheckOutStartedEvent; + } }); + Object.defineProperty(exports2, "ConnectionClosedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionClosedEvent; + } }); + Object.defineProperty(exports2, "ConnectionCreatedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionCreatedEvent; + } }); + Object.defineProperty(exports2, "ConnectionPoolClearedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionPoolClearedEvent; + } }); + Object.defineProperty(exports2, "ConnectionPoolClosedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionPoolClosedEvent; + } }); + Object.defineProperty(exports2, "ConnectionPoolCreatedEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionPoolCreatedEvent; + } }); + Object.defineProperty(exports2, "ConnectionPoolMonitoringEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionPoolMonitoringEvent; + } }); + Object.defineProperty(exports2, "ConnectionPoolReadyEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionPoolReadyEvent; + } }); + Object.defineProperty(exports2, "ConnectionReadyEvent", { enumerable: true, get: function() { + return connection_pool_events_1.ConnectionReadyEvent; + } }); + var events_1 = require_events(); + Object.defineProperty(exports2, "ServerClosedEvent", { enumerable: true, get: function() { + return events_1.ServerClosedEvent; + } }); + Object.defineProperty(exports2, "ServerDescriptionChangedEvent", { enumerable: true, get: function() { + return events_1.ServerDescriptionChangedEvent; + } }); + Object.defineProperty(exports2, "ServerHeartbeatFailedEvent", { enumerable: true, get: function() { + return events_1.ServerHeartbeatFailedEvent; + } }); + Object.defineProperty(exports2, "ServerHeartbeatStartedEvent", { enumerable: true, get: function() { + return events_1.ServerHeartbeatStartedEvent; + } }); + Object.defineProperty(exports2, "ServerHeartbeatSucceededEvent", { enumerable: true, get: function() { + return events_1.ServerHeartbeatSucceededEvent; + } }); + Object.defineProperty(exports2, "ServerOpeningEvent", { enumerable: true, get: function() { + return events_1.ServerOpeningEvent; + } }); + Object.defineProperty(exports2, "TopologyClosedEvent", { enumerable: true, get: function() { + return events_1.TopologyClosedEvent; + } }); + Object.defineProperty(exports2, "TopologyDescriptionChangedEvent", { enumerable: true, get: function() { + return events_1.TopologyDescriptionChangedEvent; + } }); + Object.defineProperty(exports2, "TopologyOpeningEvent", { enumerable: true, get: function() { + return events_1.TopologyOpeningEvent; + } }); + var server_selection_events_1 = require_server_selection_events(); + Object.defineProperty(exports2, "ServerSelectionEvent", { enumerable: true, get: function() { + return server_selection_events_1.ServerSelectionEvent; + } }); + Object.defineProperty(exports2, "ServerSelectionFailedEvent", { enumerable: true, get: function() { + return server_selection_events_1.ServerSelectionFailedEvent; + } }); + Object.defineProperty(exports2, "ServerSelectionStartedEvent", { enumerable: true, get: function() { + return server_selection_events_1.ServerSelectionStartedEvent; + } }); + Object.defineProperty(exports2, "ServerSelectionSucceededEvent", { enumerable: true, get: function() { + return server_selection_events_1.ServerSelectionSucceededEvent; + } }); + Object.defineProperty(exports2, "WaitingForSuitableServerEvent", { enumerable: true, get: function() { + return server_selection_events_1.WaitingForSuitableServerEvent; + } }); + var srv_polling_1 = require_srv_polling(); + Object.defineProperty(exports2, "SrvPollingEvent", { enumerable: true, get: function() { + return srv_polling_1.SrvPollingEvent; + } }); + var errors_1 = require_errors2(); + Object.defineProperty(exports2, "MongoCryptAzureKMSRequestError", { enumerable: true, get: function() { + return errors_1.MongoCryptAzureKMSRequestError; + } }); + Object.defineProperty(exports2, "MongoCryptCreateDataKeyError", { enumerable: true, get: function() { + return errors_1.MongoCryptCreateDataKeyError; + } }); + Object.defineProperty(exports2, "MongoCryptCreateEncryptedCollectionError", { enumerable: true, get: function() { + return errors_1.MongoCryptCreateEncryptedCollectionError; + } }); + Object.defineProperty(exports2, "MongoCryptError", { enumerable: true, get: function() { + return errors_1.MongoCryptError; + } }); + Object.defineProperty(exports2, "MongoCryptInvalidArgumentError", { enumerable: true, get: function() { + return errors_1.MongoCryptInvalidArgumentError; + } }); + Object.defineProperty(exports2, "MongoCryptKMSRequestNetworkTimeoutError", { enumerable: true, get: function() { + return errors_1.MongoCryptKMSRequestNetworkTimeoutError; + } }); + var mongo_client_auth_providers_1 = require_mongo_client_auth_providers(); + Object.defineProperty(exports2, "MongoClientAuthProviders", { enumerable: true, get: function() { + return mongo_client_auth_providers_1.MongoClientAuthProviders; + } }); + } +}); + +// dist/drivers.js +var require_drivers = __commonJS({ + "dist/drivers.js"(exports2) { + "use strict"; + var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + }) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + })); + var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }); + var __importStar2 = exports2 && exports2.__importStar || /* @__PURE__ */ (function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]); + } + __setModuleDefault2(result, mod); + return result; + }; + })(); + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.sqlQuery = sqlQuery; + exports2.testConnection = testConnection; + exports2.listTables = listTables; + exports2.describeTable = describeTable; + exports2.mongoFind = mongoFind; + exports2.mongoAggregate = mongoAggregate; + exports2.jsonSafe = jsonSafe; + var mysql = __importStar2(require_promise()); + var pg_1 = require_lib6(); + var mongodb_1 = require_lib9(); + function withTimeout(p, ms, onTimeout) { + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + onTimeout(); + reject(new Error(`\u67E5\u8BE2\u8D85\u8FC7 ${ms}ms \u8D85\u65F6\uFF0C\u5DF2\u4E2D\u6B62`)); + }, ms); + p.then((v) => { + clearTimeout(timer); + resolve(v); + }, (e) => { + clearTimeout(timer); + reject(e); + }); + }); + } + function jsonSafe(value, depth = 0) { + if (depth > 20) + return "[\u6DF1\u5EA6\u8D85\u9650]"; + if (typeof value === "bigint") + return value.toString(); + if (value instanceof Date) + return value.toISOString(); + if (Buffer.isBuffer(value)) { + const hex = value.toString("hex"); + return `0x${hex.length > 64 ? hex.slice(0, 64) + `\u2026(${value.length} bytes)` : hex}`; + } + if (value instanceof Uint8Array) + return `(binary ${value.length} bytes)`; + if (value === null || value === void 0) + return value; + if (Array.isArray(value)) + return value.map((v) => jsonSafe(v, depth + 1)); + if (typeof value === "object") { + const ctor = value.constructor?.name; + if (ctor && ctor !== "Object" && ctor !== "Array") + return String(value); + const out = {}; + for (const k of Object.keys(value)) { + out[k] = jsonSafe(value[k], depth + 1); + } + return out; + } + return value; + } + function truncate(rows, limit) { + if (rows.length > limit) + return { rows: rows.slice(0, limit), truncated: true }; + return { rows, truncated: false }; + } + function friendlyConnError(e, cfg) { + const msg = e?.message ?? String(e); + const code = e?.code; + if (code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "ENOTFOUND") { + return new Error(`\u65E0\u6CD5\u8FDE\u63A5 ${cfg.host ?? cfg.url ?? ""}:${cfg.port ?? ""}\uFF08${code}\uFF09\uFF1A\u8BF7\u786E\u8BA4\u5730\u5740/\u7AEF\u53E3\u4E0E\u6570\u636E\u5E93\u662F\u5426\u8FD0\u884C`); + } + if (/access denied|password authentication|authentication failed/i.test(msg)) { + return new Error(`\u8BA4\u8BC1\u5931\u8D25\uFF1A\u8BF7\u68C0\u67E5\u7528\u6237\u540D/\u5BC6\u7801\uFF08\u5BC6\u7801\u6765\u81EA\u73AF\u5883\u53D8\u91CF\uFF0C\u786E\u8BA4\u53D8\u91CF\u503C\u6B63\u786E\uFF09\uFF1A${msg}`); + } + return new Error(msg); + } + async function mysqlConnect(cfg, timeoutMs) { + const options = { + connectTimeout: Math.min(timeoutMs, 2e4), + dateStrings: true, + multipleStatements: false, + supportBigNumbers: true + }; + if (cfg.url) + options.uri = cfg.url; + else { + options.host = cfg.host; + options.port = cfg.port; + options.user = cfg.user; + options.password = cfg.password; + options.database = cfg.database; + } + try { + return await withTimeout(mysql.createConnection(options), timeoutMs, () => void 0); + } catch (e) { + throw friendlyConnError(e, cfg); + } + } + async function mysqlRun(cfg, opts, fn) { + const conn = await mysqlConnect(cfg, opts.timeoutMs); + let out; + try { + out = await withTimeout(fn(conn), opts.timeoutMs, () => { + conn.destroy(); + }); + } finally { + try { + await conn.end(); + } catch { + } + } + return out; + } + async function mysqlQuery(cfg, sql, params, opts) { + const started = Date.now(); + const rows = (await mysqlRun(cfg, opts, (conn) => conn.query(sql, params)))[0]; + const t = truncate(Array.isArray(rows) ? rows : [rows], opts.limit); + return { ...t, elapsedMs: Date.now() - started }; + } + async function pgConnect(cfg, timeoutMs) { + const config = { + connectionTimeoutMillis: timeoutMs, + statement_timeout: timeoutMs, + query_timeout: timeoutMs + }; + if (cfg.url) + config.connectionString = cfg.url; + else { + config.host = cfg.host; + config.port = cfg.port; + config.user = cfg.user; + config.password = cfg.password; + config.database = cfg.database; + } + const client = new pg_1.Client(config); + try { + await withTimeout(client.connect(), timeoutMs, () => { + client.end().catch(() => void 0); + }); + } catch (e) { + throw friendlyConnError(e, cfg); + } + return client; + } + async function pgRun(cfg, opts, fn) { + const client = await pgConnect(cfg, opts.timeoutMs); + try { + return await fn(client); + } finally { + await client.end().catch(() => void 0); + } + } + async function pgQuery(cfg, sql, params, opts) { + const started = Date.now(); + const res = await pgRun(cfg, opts, (client) => client.query({ text: sql, values: params })); + const t = truncate(res.rows ?? [], opts.limit); + return { ...t, elapsedMs: Date.now() - started }; + } + async function mongoConnect(cfg, timeoutMs) { + if (!cfg.url) + throw new Error("MongoDB \u8FDE\u63A5\u9700\u8981 url \u5B57\u6BB5"); + const client = new mongodb_1.MongoClient(cfg.url, { + serverSelectionTimeoutMS: timeoutMs, + connectTimeoutMS: timeoutMs + }); + try { + await withTimeout(client.connect(), timeoutMs, () => { + client.close().catch(() => void 0); + }); + } catch (e) { + throw friendlyConnError(e, cfg); + } + const db = cfg.database ? client.db(cfg.database) : client.db(); + return { client, db }; + } + async function mongoRun(cfg, opts, fn) { + const { client, db } = await mongoConnect(cfg, opts.timeoutMs); + try { + return await withTimeout(fn(db), opts.timeoutMs, () => { + client.close().catch(() => void 0); + }); + } finally { + await client.close().catch(() => void 0); + } + } + function sqlQuery(type, cfg, sql, params, opts) { + return type === "mysql" ? mysqlQuery(cfg, sql, params, opts) : pgQuery(cfg, sql, params, opts); + } + async function testConnection(cfg, timeoutMs) { + const started = Date.now(); + if (cfg.type === "mysql") { + const rows = await mysqlRun(cfg, { timeoutMs, limit: 1 }, (conn) => conn.query("SELECT VERSION() AS version")); + const r = rows[0][0]; + return { serverInfo: `MySQL ${r?.version ?? "\u672A\u77E5\u7248\u672C"}`, elapsedMs: Date.now() - started }; + } + if (cfg.type === "postgres") { + const res = await pgRun(cfg, { timeoutMs, limit: 1 }, (c) => c.query("SELECT version() AS version")); + return { serverInfo: String(res.rows[0]?.version ?? "\u672A\u77E5\u7248\u672C").split(" (")[0], elapsedMs: Date.now() - started }; + } + const info = await mongoRun(cfg, { timeoutMs, limit: 1 }, async (db) => { + const ping = await db.command({ ping: 1 }); + let version = "\u672A\u77E5\u7248\u672C"; + try { + const build = await db.command({ buildInfo: 1 }); + version = String(build.version ?? version); + } catch { + } + return { ping, version }; + }); + return { serverInfo: `MongoDB ${info.version}\uFF08ping ${info.ping?.ok === 1 ? "\u901A\u8FC7" : "\u5931\u8D25"}\uFF09`, elapsedMs: Date.now() - started }; + } + async function listTables(cfg, opts) { + const started = Date.now(); + if (cfg.type === "mysql") { + const rows = await mysqlRun(cfg, opts, (conn) => conn.query("SELECT TABLE_NAME AS name, TABLE_ROWS AS rowEstimate, TABLE_TYPE AS kind FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME")); + const list2 = rows[0]; + return { rows: list2, truncated: false, elapsedMs: Date.now() - started }; + } + if (cfg.type === "postgres") { + const res = await pgRun(cfg, opts, (c) => c.query(`SELECT c.relname AS name, c.reltuples::bigint AS "rowEstimate", + CASE c.relkind WHEN 'r' THEN 'BASE TABLE' WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'MATERIALIZED VIEW' WHEN 'p' THEN 'PARTITIONED TABLE' ELSE c.relkind::text END AS kind + FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = current_schema() AND c.relkind IN ('r','v','m','p') + ORDER BY c.relname`)); + return { rows: res.rows, truncated: false, elapsedMs: Date.now() - started }; + } + const list = await mongoRun(cfg, opts, async (db) => { + const cols = await db.listCollections().toArray(); + const out = []; + for (const col of cols.slice(0, opts.limit)) { + let est = -1; + try { + est = await db.collection(col.name).estimatedDocumentCount(); + } catch { + } + out.push({ name: col.name, kind: String(col.type ?? "collection"), rowEstimate: est }); + } + return out; + }); + return { rows: list, truncated: false, elapsedMs: Date.now() - started }; + } + async function describeTable(cfg, table, opts) { + if (cfg.type === "mysql") { + const res = await mysqlRun(cfg, opts, async (conn) => { + const columns = (await conn.query("SELECT COLUMN_NAME AS name, COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_KEY AS keyInfo, EXTRA AS extra, COLUMN_COMMENT AS comment FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION", [table]))[0]; + const idxRows = (await conn.query("SELECT INDEX_NAME AS name, COLUMN_NAME AS column_name, NON_UNIQUE AS nonUnique, SEQ_IN_INDEX AS seq FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? ORDER BY INDEX_NAME, SEQ_IN_INDEX", [table]))[0]; + const indexMap = /* @__PURE__ */ new Map(); + for (const r of idxRows) { + const entry = indexMap.get(r.name) ?? { name: r.name, unique: r.nonUnique === 0, columns: [] }; + entry.columns.push(r.column_name); + indexMap.set(r.name, entry); + } + return { columns, indexes: [...indexMap.values()] }; + }); + return res; + } + if (cfg.type === "postgres") { + return pgRun(cfg, opts, async (c) => { + const columns = (await c.query('SELECT column_name AS name, data_type AS type, is_nullable AS nullable, column_default AS "default" FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = $1 ORDER BY ordinal_position', [table])).rows; + const indexes = (await c.query("SELECT indexname AS name, indexdef AS def FROM pg_indexes WHERE schemaname = current_schema() AND tablename = $1 ORDER BY indexname", [table])).rows; + return { columns, indexes }; + }); + } + return mongoRun(cfg, opts, async (db) => { + const coll = db.collection(table); + const sampleDoc = await coll.findOne({}, { timeoutMs: opts.timeoutMs }); + const fields = []; + const infer = (obj, prefix = "") => { + for (const [k, v] of Object.entries(obj)) { + const label = prefix ? `${prefix}.${k}` : k; + const t = v === null ? "null" : Array.isArray(v) ? `array<${typeof v[0]}>` : v instanceof Date ? "date" : typeof v; + fields.push({ field: label, type: t }); + if (v !== null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date) && prefix.split(".").length < 2) { + infer(v, label); + } + } + }; + if (sampleDoc) + infer(sampleDoc); + let indexes = []; + try { + indexes = await coll.indexes(); + } catch { + } + return { fields, indexes, sample: sampleDoc }; + }); + } + async function mongoFind(cfg, collection, filter, projection, sort, opts) { + const started = Date.now(); + const rows = await mongoRun(cfg, opts, async (db) => { + let cursor = db.collection(collection).find(filter).limit(opts.limit + 1); + if (projection) + cursor = cursor.project(projection); + if (sort) + cursor = cursor.sort(sort); + cursor = cursor.maxTimeMS(opts.timeoutMs); + return cursor.toArray(); + }); + const t = truncate(rows, opts.limit); + return { ...t, elapsedMs: Date.now() - started }; + } + async function mongoAggregate(cfg, collection, pipeline, opts) { + const started = Date.now(); + const rows = await mongoRun(cfg, opts, async (db) => { + const stages = [...pipeline, { $limit: opts.limit + 1 }]; + return db.collection(collection).aggregate(stages, { maxTimeMS: opts.timeoutMs }).toArray(); + }); + const t = truncate(rows, opts.limit); + return { ...t, elapsedMs: Date.now() - started }; + } + } +}); + +// dist/tools.js +var require_tools = __commonJS({ + "dist/tools.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.TOOL_DEFINITIONS = void 0; + exports2.handleToolCall = handleToolCall; + var config_1 = require_config(); + var sqlguard_1 = require_sqlguard(); + var drivers_1 = require_drivers(); + var str = (description) => ({ type: "string", description }); + exports2.TOOL_DEFINITIONS = [ + { + name: "db_list_connections", + description: "\u6309\u73AF\u5883\u5206\u7EC4\u5217\u51FA\u6240\u6709\u5DF2\u914D\u7F6E\u7684\u6570\u636E\u5E93\u8FDE\u63A5\uFF08\u51ED\u8BC1\u8131\u654F\uFF09\uFF0C\u6807\u6CE8\u6D3B\u52A8\u73AF\u5883\u4E0E protected \u6807\u8BB0\u3002\u65E0\u914D\u7F6E\u65F6\u8FD4\u56DE\u521B\u5EFA\u5F15\u5BFC\u3002", + inputSchema: { type: "object", properties: {}, additionalProperties: false } + }, + { + name: "db_test_connection", + description: '\u6D4B\u8BD5\u6307\u5B9A\u8FDE\u63A5\u7684\u8FDE\u901A\u6027\uFF0C\u8FD4\u56DE\u670D\u52A1\u5668\u7248\u672C\u4E0E\u8017\u65F6\u3002connection \u7528 "\u8FDE\u63A5\u540D"\uFF08\u6D3B\u52A8\u73AF\u5883\uFF09\u6216 "\u73AF\u5883\u540D/\u8FDE\u63A5\u540D"\uFF08\u5982 prod/mysql-main\uFF09\u3002', + inputSchema: { + type: "object", + properties: { connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D") }, + required: ["connection"], + additionalProperties: false + } + }, + { + name: "db_list_tables", + description: "\u5217\u51FA\u6307\u5B9A\u8FDE\u63A5\u4E2D\u7684\u6240\u6709\u8868/\u96C6\u5408\u53CA\u884C\u6570\u4F30\u8BA1\u3002", + inputSchema: { + type: "object", + properties: { connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D") }, + required: ["connection"], + additionalProperties: false + } + }, + { + name: "db_describe_table", + description: "\u67E5\u770B\u8868\u7ED3\u6784\uFF1A\u5217\u540D/\u7C7B\u578B/\u53EF\u7A7A/\u952E/\u7D22\u5F15\uFF08MongoDB \u4E3A\u91C7\u6837\u5B57\u6BB5\u63A8\u65AD + \u7D22\u5F15\u5217\u8868\uFF09\u3002", + inputSchema: { + type: "object", + properties: { + connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D"), + table: str("\u8868\u540D\u6216\u96C6\u5408\u540D") + }, + required: ["connection", "table"], + additionalProperties: false + } + }, + { + name: "db_query", + description: "\u5BF9 MySQL/PostgreSQL \u6267\u884C\u53EA\u8BFB SQL\uFF08\u4EC5 SELECT/WITH/EXPLAIN/SHOW/DESCRIBE\uFF09\u3002\u503C\u5FC5\u987B\u901A\u8FC7 params \u53C2\u6570\u7ED1\u5B9A\u4F20\u5165\uFF1AMySQL \u7528 ? \u5360\u4F4D\u7B26\uFF0CPostgreSQL \u7528 $1/$2 \u5360\u4F4D\u7B26\uFF0C\u7981\u6B62\u5728 SQL \u6587\u672C\u4E2D\u62FC\u63A5\u503C\u3002", + inputSchema: { + type: "object", + properties: { + connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D"), + sql: str("\u5355\u6761\u53EA\u8BFB SQL \u8BED\u53E5"), + params: { type: "array", items: {}, description: "\u5360\u4F4D\u7B26\u5BF9\u5E94\u7684\u503C\u6570\u7EC4\uFF0C\u6309\u987A\u5E8F\u7ED1\u5B9A" }, + limit: { type: "number", description: "\u672C\u6B21\u8FD4\u56DE\u884C\u6570\u4E0A\u9650\uFF08\u4E0D\u8D85\u8FC7\u914D\u7F6E\u7684 maxRowLimit\uFF0C\u7F3A\u7701 1000\uFF09" } + }, + required: ["connection", "sql"], + additionalProperties: false + } + }, + { + name: "db_find", + description: "MongoDB \u53EA\u8BFB\u67E5\u8BE2\uFF08\u5BF9\u5E94 find\uFF09\uFF0C\u652F\u6301 filter/projection/sort/limit\u3002\u7981\u6B62 $where \u7B49\u811A\u672C\u8FD0\u7B97\u7B26\u3002", + inputSchema: { + type: "object", + properties: { + connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D"), + collection: str("\u96C6\u5408\u540D"), + filter: { type: "object", description: "\u67E5\u8BE2\u6761\u4EF6\uFF08MongoDB \u67E5\u8BE2\u6587\u6863\uFF09" }, + projection: { type: "object", description: "\u5B57\u6BB5\u6295\u5F71" }, + sort: { type: "object", description: '\u6392\u5E8F\uFF0C\u5982 {"field": -1}' }, + limit: { type: "number", description: "\u8FD4\u56DE\u6587\u6863\u6570\u4E0A\u9650" } + }, + required: ["connection", "collection"], + additionalProperties: false + } + }, + { + name: "db_aggregate", + description: "MongoDB \u805A\u5408\u7BA1\u9053\uFF08\u53EA\u8BFB\u9636\u6BB5\uFF1B$out/$merge/$where/$function \u88AB\u62D2\u7EDD\uFF09\u3002", + inputSchema: { + type: "object", + properties: { + connection: str("\u8FDE\u63A5\u5F15\u7528\uFF1A\u8FDE\u63A5\u540D \u6216 \u73AF\u5883\u540D/\u8FDE\u63A5\u540D"), + collection: str("\u96C6\u5408\u540D"), + pipeline: { type: "array", items: {}, description: "\u805A\u5408\u9636\u6BB5\u6570\u7EC4" }, + limit: { type: "number", description: "\u8FD4\u56DE\u6587\u6863\u6570\u4E0A\u9650" } + }, + required: ["connection", "collection", "pipeline"], + additionalProperties: false + } + }, + { + name: "db_add_connection", + description: "\u65B0\u589E\u6570\u636E\u5E93\u8FDE\u63A5\u5E76\u6301\u4E45\u5316\uFF08\u4F1A\u8BDD\u5F0F\u914D\u7F6E\uFF09\u3002\u5BC6\u7801\u53EA\u63A5\u53D7\u73AF\u5883\u53D8\u91CF\u540D\uFF08passwordEnvVar\uFF09\uFF0C\u5199\u5165\u4E3A ${VAR} \u5F15\u7528\uFF0C\u62D2\u7EDD\u660E\u6587\u5BC6\u7801\u3002config \u542B type(mysql/postgres/mongodb) \u53CA host/port/user/database \u6216 url \u7B49\u5B57\u6BB5\u3002scope\uFF1Aworkspace\uFF08\u9ED8\u8BA4\uFF0C\u5DE5\u4F5C\u533A db-connections.json\uFF09\u6216 user\uFF08\u7528\u6237\u7EA7\u5168\u5C40\u914D\u7F6E\uFF09\u3002", + inputSchema: { + type: "object", + properties: { + environment: str("\u73AF\u5883\u540D\uFF0C\u5982 dev/test/prod"), + name: str("\u8FDE\u63A5\u540D\uFF0C\u5982 mysql-main"), + config: { + type: "object", + description: "\u8FDE\u63A5\u914D\u7F6E\uFF1Atype \u5FC5\u586B\uFF1BMySQL/PG \u53EF\u7ED9 host/port/user/password(\u4EC5${VAR}\u5F62\u5F0F)/database \u6216 url\uFF1BMongoDB \u7ED9 url(\u53EF\u542B${VAR}) \u53CA\u53EF\u9009 database" + }, + passwordEnvVar: str("\u5BC6\u7801\u53D8\u91CF\u540D\uFF08\u5728 .env \u6587\u4EF6\u4E2D\u5B9A\u4E49\uFF09\uFF0C\u5199\u5165\u4E3A ${VAR} \u5F15\u7528"), + scope: { type: "string", enum: ["workspace", "user"], description: "\u6301\u4E45\u5316\u4F4D\u7F6E\uFF0C\u7F3A\u7701 workspace" } + }, + required: ["environment", "name", "config"], + additionalProperties: false + } + }, + { + name: "db_remove_connection", + description: "\u5220\u9664\u6307\u5B9A\u73AF\u5883\u4E2D\u7684\u8FDE\u63A5\uFF08\u4F18\u5148\u4ECE\u5DE5\u4F5C\u533A\u6587\u4EF6\u5220\u9664\uFF0C\u5176\u6B21\u7528\u6237\u7EA7\u6587\u4EF6\uFF09\u3002", + inputSchema: { + type: "object", + properties: { + environment: str("\u73AF\u5883\u540D"), + name: str("\u8FDE\u63A5\u540D") + }, + required: ["environment", "name"], + additionalProperties: false + } + }, + { + name: "db_set_active_environment", + description: "\u5207\u6362\u6D3B\u52A8\u73AF\u5883\uFF08\u5DE5\u5177\u9ED8\u8BA4\u4F7F\u7528\u7684\u73AF\u5883\uFF09\u5E76\u6301\u4E45\u5316\u3002", + inputSchema: { + type: "object", + properties: { environment: str("\u73AF\u5883\u540D\uFF0C\u5982 dev/prod") }, + required: ["environment"], + additionalProperties: false + } + } + ]; + function computeLimit(effective, requested) { + const base = typeof requested === "number" && requested > 0 ? requested : effective.rowLimit; + return Math.max(1, Math.min(base, effective.maxRowLimit)); + } + function protectedBanner(envProtected) { + return envProtected ? "\u26A0\uFE0F \u53D7\u4FDD\u62A4\u73AF\u5883\uFF08protected\uFF09\uFF1A\u672C\u67E5\u8BE2\u4F5C\u7528\u4E8E\u751F\u4EA7/\u53D7\u4FDD\u62A4\u6570\u636E\uFF0C\u8BF7\u8C28\u614E\u5206\u4EAB\u7ED3\u679C" : void 0; + } + async function handleToolCall(name, args) { + const merged = (0, config_1.loadMergedConfig)(); + switch (name) { + case "db_list_connections": { + const envKeys = Object.keys(merged.environments); + if (envKeys.length === 0) { + return { + status: "no_config", + message: "\u5C1A\u672A\u914D\u7F6E\u4EFB\u4F55\u6570\u636E\u5E93\u8FDE\u63A5\u3002\u53EF\u7528 db_add_connection \u6DFB\u52A0\uFF08\u63D0\u4F9B environment\u3001name\u3001config\u3001passwordEnvVar\uFF09\uFF0C\u6216\u624B\u5DE5\u521B\u5EFA db-connections.json\u3002" + }; + } + return { + activeEnvironment: merged.activeEnvironment ?? null, + defaults: merged.defaults, + envSources: merged.envSources, + workspaceConfig: merged.workspaceFile ? merged.workspacePath : null, + userConfig: merged.userFile ? merged.userPath : null, + environments: Object.fromEntries(Object.entries(merged.environments).map(([envName, env]) => [ + envName, + { + description: env.description ?? null, + protected: !!env.protected, + active: envName === merged.activeEnvironment, + connections: Object.entries(env.connections).map(([connName, conn]) => ({ + name: connName, + ...(0, config_1.maskConnection)(conn) + })) + } + ])) + }; + } + case "db_test_connection": { + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const { serverInfo, elapsedMs } = await (0, drivers_1.testConnection)(cfg, ref.effective.timeoutMs); + return { connection: `${ref.environment}/${ref.name}`, serverInfo, elapsedMs, warning: protectedBanner(ref.envProtected) }; + } + case "db_list_tables": { + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const outcome = await (0, drivers_1.listTables)(cfg, { timeoutMs: ref.effective.timeoutMs, limit: computeLimit(ref.effective) }); + return { + connection: `${ref.environment}/${ref.name}`, + tableCount: outcome.rows.length, + tables: (0, drivers_1.jsonSafe)(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected) + }; + } + case "db_describe_table": { + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const table = String(args.table ?? ""); + if (!table.trim()) + throw new Error("table \u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A"); + const detail = await (0, drivers_1.describeTable)(cfg, table, { timeoutMs: ref.effective.timeoutMs, limit: computeLimit(ref.effective) }); + return { + connection: `${ref.environment}/${ref.name}`, + table, + ...(0, drivers_1.jsonSafe)(detail), + warning: protectedBanner(ref.envProtected) + }; + } + case "db_query": { + const sql = (0, sqlguard_1.validateReadOnlySql)(String(args.sql ?? "")); + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + if (ref.config.type === "mongodb") { + throw new Error("MongoDB \u8FDE\u63A5\u8BF7\u4F7F\u7528 db_find / db_aggregate\uFF0C\u4E0D\u652F\u6301 SQL"); + } + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const params = Array.isArray(args.params) ? args.params : []; + const limit = computeLimit(ref.effective, args.limit); + const outcome = await (0, drivers_1.sqlQuery)(ref.config.type, cfg, sql, params, { + timeoutMs: ref.effective.timeoutMs, + limit + }); + return { + connection: `${ref.environment}/${ref.name}`, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + rowLimit: limit, + rows: (0, drivers_1.jsonSafe)(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected) + }; + } + case "db_find": { + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + if (ref.config.type !== "mongodb") + throw new Error("db_find \u4EC5\u7528\u4E8E MongoDB \u8FDE\u63A5\uFF1BSQL \u6570\u636E\u5E93\u8BF7\u4F7F\u7528 db_query"); + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const collection = String(args.collection ?? ""); + if (!collection.trim()) + throw new Error("collection \u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A"); + const filter = args.filter ?? {}; + (0, sqlguard_1.validateMongoReadDocument)(filter, "filter"); + const projection = args.projection; + if (projection) + (0, sqlguard_1.validateMongoReadDocument)(projection, "projection"); + const sort = args.sort; + if (sort) + (0, sqlguard_1.validateMongoReadDocument)(sort, "sort"); + const limit = computeLimit(ref.effective, args.limit); + const outcome = await (0, drivers_1.mongoFind)(cfg, collection, filter, projection, sort, { + timeoutMs: ref.effective.timeoutMs, + limit + }); + return { + connection: `${ref.environment}/${ref.name}`, + collection, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + documents: (0, drivers_1.jsonSafe)(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected) + }; + } + case "db_aggregate": { + const ref = (0, config_1.resolveConnectionRef)(merged, String(args.connection ?? "")); + if (ref.config.type !== "mongodb") + throw new Error("db_aggregate \u4EC5\u7528\u4E8E MongoDB \u8FDE\u63A5"); + const cfg = (0, config_1.resolveEnvPlaceholders)(ref.config, merged.env); + const collection = String(args.collection ?? ""); + if (!collection.trim()) + throw new Error("collection \u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A"); + const pipeline = args.pipeline; + (0, sqlguard_1.validateMongoStages)(pipeline); + const limit = computeLimit(ref.effective, args.limit); + const outcome = await (0, drivers_1.mongoAggregate)(cfg, collection, pipeline, { + timeoutMs: ref.effective.timeoutMs, + limit + }); + return { + connection: `${ref.environment}/${ref.name}`, + collection, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + documents: (0, drivers_1.jsonSafe)(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected) + }; + } + case "db_add_connection": { + const envName = String(args.environment ?? ""); + const connName = String(args.name ?? ""); + (0, config_1.validateIdentifier)("\u73AF\u5883\u540D", envName); + (0, config_1.validateIdentifier)("\u8FDE\u63A5\u540D", connName); + const configArg = args.config; + if (!configArg || typeof configArg !== "object") + throw new Error("config \u5FC5\u987B\u662F\u5BF9\u8C61"); + const { config, warnings } = (0, config_1.sanitizeConnectionForWrite)(configArg, args.passwordEnvVar); + const scope = args.scope === "user" ? "user" : "workspace"; + const { file } = (0, config_1.persistAddConnection)(scope, merged, envName, connName, config); + return { ok: true, connection: `${envName}/${connName}`, scope, file, warnings }; + } + case "db_remove_connection": { + const envName = String(args.environment ?? ""); + const connName = String(args.name ?? ""); + const { file } = (0, config_1.persistRemoveConnection)(merged, envName, connName); + return { ok: true, removed: `${envName}/${connName}`, file }; + } + case "db_set_active_environment": { + const envName = String(args.environment ?? ""); + const { file } = (0, config_1.persistSetActiveEnvironment)(merged, envName); + return { ok: true, activeEnvironment: envName, file }; + } + default: + throw new Error(`\u672A\u77E5\u5DE5\u5177\uFF1A${name}`); + } + } + } +}); + +// dist/db-connect-server.js +var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + } + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +var readline = __importStar(require("readline")); +var tools_1 = require_tools(); +var SERVER_NAME = "db-connector"; +var SERVER_VERSION = "0.1.0"; +var PROTOCOL_VERSION = "2024-11-05"; +function send(obj) { + process.stdout.write(JSON.stringify(obj) + "\n"); +} +function reply(id, result) { + send({ jsonrpc: "2.0", id, result }); +} +function replyError(id, code, message) { + send({ jsonrpc: "2.0", id, error: { code, message } }); +} +function log(...parts) { + process.stderr.write(`[db-connector] ${parts.join(" ")} +`); +} +async function handleMessage(msg) { + const { method, id, params } = msg; + if (id === void 0 || id === null) { + return; + } + try { + switch (method) { + case "initialize": { + const requested = params?.protocolVersion ?? PROTOCOL_VERSION; + reply(id, { + protocolVersion: requested, + capabilities: { tools: {} }, + serverInfo: { name: SERVER_NAME, version: SERVER_VERSION } + }); + return; + } + case "ping": { + reply(id, {}); + return; + } + case "tools/list": { + reply(id, { tools: tools_1.TOOL_DEFINITIONS }); + return; + } + case "tools/call": { + const name = String(params?.name ?? ""); + const args = params?.arguments ?? {}; + try { + const result = await (0, tools_1.handleToolCall)(name, args); + reply(id, { + content: [{ type: "text", text: JSON.stringify(result, null, 2) }], + isError: false + }); + } catch (toolError) { + reply(id, { + content: [{ type: "text", text: `\u5DE5\u5177\u6267\u884C\u5931\u8D25\uFF1A${toolError.message}` }], + isError: true + }); + } + return; + } + default: + replyError(id, -32601, `Method not found: ${method}`); + } + } catch (e) { + replyError(id, -32603, `Internal error: ${e.message}`); + } +} +async function main() { + const rl = readline.createInterface({ input: process.stdin, terminal: false }); + rl.on("line", (line) => { + const text = line.trim(); + if (!text) + return; + let msg; + try { + msg = JSON.parse(text); + } catch { + log("\u5FFD\u7565\u65E0\u6CD5\u89E3\u6790\u7684\u8F93\u5165\u884C"); + return; + } + if (!msg.method) + return; + void handleMessage(msg).catch((e) => log("\u6D88\u606F\u5904\u7406\u5F02\u5E38:", e.message)); + }); + rl.on("close", () => { + log("stdin \u5DF2\u5173\u95ED\uFF0C\u670D\u52A1\u5668\u9000\u51FA"); + process.exit(0); + }); + process.on("uncaughtException", (e) => log("\u672A\u6355\u83B7\u5F02\u5E38:", e.message)); + process.on("unhandledRejection", (r) => log("\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD:", String(r))); +} +void main(); diff --git a/external_plugins/db-connector/mcp/package-lock.json b/external_plugins/db-connector/mcp/package-lock.json new file mode 100644 index 00000000..7c3775fa --- /dev/null +++ b/external_plugins/db-connector/mcp/package-lock.json @@ -0,0 +1,959 @@ +{ + "name": "db-connector-mcp", + "version": "0.1.2", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "db-connector-mcp", + "version": "0.1.2", + "dependencies": { + "mongodb": "^6.10.0", + "mysql2": "^3.11.0", + "pg": "^8.13.0" + }, + "devDependencies": { + "@types/node": "^22.0.0", + "@types/pg": "^8.11.0", + "esbuild": "^0.28.2", + "typescript": "^5.6.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz", + "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm/-/android-arm-0.28.2.tgz", + "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz", + "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/android-x64/-/android-x64-0.28.2.tgz", + "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz", + "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz", + "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz", + "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz", + "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz", + "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz", + "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz", + "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz", + "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz", + "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz", + "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz", + "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz", + "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz", + "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz", + "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz", + "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz", + "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz", + "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz", + "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz", + "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz", + "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz", + "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@mongodb-js/saslprep": { + "version": "1.6.3", + "resolved": "https://registry.npmmirror.com/@mongodb-js/saslprep/-/saslprep-1.6.3.tgz", + "integrity": "sha512-aHGFvT95c82CoQ7hb6qXpz8Hcc5PJb3ZtQ+P01QDBbyQday0mjcrJPeNJOHCgWe0pGX0zKmKP+1mWi/I/BCX9Q==", + "license": "MIT", + "dependencies": { + "sparse-bitfield": "^3.0.3" + } + }, + "node_modules/@types/node": { + "version": "22.20.5", + "resolved": "https://registry.npmmirror.com/@types/node/-/node-22.20.5.tgz", + "integrity": "sha512-U2+DNr+wSjpsTS/wZGYHq7GcwfuSmKiKvoPvK22zwTlRhU91yOniN4qRR5KhIjvif7ysw/dz/hKmfDH0Ris4aA==", + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/pg": { + "version": "8.23.1", + "resolved": "https://registry.npmmirror.com/@types/pg/-/pg-8.23.1.tgz", + "integrity": "sha512-fKVHpikPdg4GKks3JuLEhvwSyvwzF23hnabPy6DD8ljVbC7+6J5dQzdv4arV6jqq57djnMgs1HKBxX4P8aBI3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "pg-protocol": "*", + "pg-types": "^2.2.0" + } + }, + "node_modules/@types/webidl-conversions": { + "version": "7.0.3", + "resolved": "https://registry.npmmirror.com/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz", + "integrity": "sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==", + "license": "MIT" + }, + "node_modules/@types/whatwg-url": { + "version": "11.0.5", + "resolved": "https://registry.npmmirror.com/@types/whatwg-url/-/whatwg-url-11.0.5.tgz", + "integrity": "sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==", + "license": "MIT", + "dependencies": { + "@types/webidl-conversions": "*" + } + }, + "node_modules/aws-ssl-profiles": { + "version": "1.1.2", + "resolved": "https://registry.npmmirror.com/aws-ssl-profiles/-/aws-ssl-profiles-1.1.2.tgz", + "integrity": "sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==", + "license": "MIT", + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/bson": { + "version": "6.10.4", + "resolved": "https://registry.npmmirror.com/bson/-/bson-6.10.4.tgz", + "integrity": "sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==", + "license": "Apache-2.0", + "engines": { + "node": ">=16.20.1" + } + }, + "node_modules/esbuild": { + "version": "0.28.2", + "resolved": "https://registry.npmmirror.com/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" + } + }, + "node_modules/generate-function": { + "version": "2.3.1", + "resolved": "https://registry.npmmirror.com/generate-function/-/generate-function-2.3.1.tgz", + "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==", + "license": "MIT", + "dependencies": { + "is-property": "^1.0.2" + } + }, + "node_modules/iconv-lite": { + "version": "0.7.3", + "resolved": "https://registry.npmmirror.com/iconv-lite/-/iconv-lite-0.7.3.tgz", + "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/is-property": { + "version": "1.0.2", + "resolved": "https://registry.npmmirror.com/is-property/-/is-property-1.0.2.tgz", + "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==", + "license": "MIT" + }, + "node_modules/long": { + "version": "5.3.2", + "resolved": "https://registry.npmmirror.com/long/-/long-5.3.2.tgz", + "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==", + "license": "Apache-2.0" + }, + "node_modules/lru.min": { + "version": "1.1.5", + "resolved": "https://registry.npmmirror.com/lru.min/-/lru.min-1.1.5.tgz", + "integrity": "sha512-5J9ysMYUpYIg9RF2vJpy9SinEmSviFSe0GyPpCQ4L5QSkLAgeLXlTAOu2ZwWUU5m+0SBl6gUU1R1ZQB3aKypfA==", + "license": "MIT", + "engines": { + "bun": ">=1.0.0", + "deno": ">=1.30.0", + "node": ">=8.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wellwelwel" + } + }, + "node_modules/memory-pager": { + "version": "1.5.0", + "resolved": "https://registry.npmmirror.com/memory-pager/-/memory-pager-1.5.0.tgz", + "integrity": "sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==", + "license": "MIT" + }, + "node_modules/mongodb": { + "version": "6.22.0", + "resolved": "https://registry.npmmirror.com/mongodb/-/mongodb-6.22.0.tgz", + "integrity": "sha512-k9YPpPXZEVyT4kjglCen99LCDToxzM+R89x3cMp8kSWb1gnXDvrsEJQh3FQ4t4jS9+ZA4yBOojHNS1oAB5qwQg==", + "license": "Apache-2.0", + "dependencies": { + "@mongodb-js/saslprep": "^1.3.0", + "bson": "^6.10.4", + "mongodb-connection-string-url": "^3.0.2" + }, + "engines": { + "node": ">=16.20.1" + }, + "peerDependencies": { + "@aws-sdk/credential-providers": "^3.188.0", + "@mongodb-js/zstd": "^1.1.0 || ^2.0.0", + "gcp-metadata": "^5.2.0", + "kerberos": "^2.0.1", + "mongodb-client-encryption": ">=6.0.0 <7", + "snappy": "^7.3.2", + "socks": "^2.7.1" + }, + "peerDependenciesMeta": { + "@aws-sdk/credential-providers": { + "optional": true + }, + "@mongodb-js/zstd": { + "optional": true + }, + "gcp-metadata": { + "optional": true + }, + "kerberos": { + "optional": true + }, + "mongodb-client-encryption": { + "optional": true + }, + "snappy": { + "optional": true + }, + "socks": { + "optional": true + } + } + }, + "node_modules/mongodb-connection-string-url": { + "version": "3.0.2", + "resolved": "https://registry.npmmirror.com/mongodb-connection-string-url/-/mongodb-connection-string-url-3.0.2.tgz", + "integrity": "sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==", + "license": "Apache-2.0", + "dependencies": { + "@types/whatwg-url": "^11.0.2", + "whatwg-url": "^14.1.0 || ^13.0.0" + } + }, + "node_modules/mysql2": { + "version": "3.24.6", + "resolved": "https://registry.npmmirror.com/mysql2/-/mysql2-3.24.6.tgz", + "integrity": "sha512-enu73KhbAua2L3dIxjc6qg6ZJ7H3pt1BImZASWNWY5xSsmJ1ZuUPULTDGXgmJbI61vb+nJAG19IZclIq19UidQ==", + "license": "MIT", + "dependencies": { + "aws-ssl-profiles": "^1.1.2", + "generate-function": "^2.3.1", + "iconv-lite": "^0.7.3", + "long": "^5.3.2", + "lru.min": "^1.1.4", + "named-placeholders": "^1.1.6", + "sql-escaper": "^1.5.1" + }, + "engines": { + "node": ">= 8.0" + }, + "peerDependencies": { + "@types/node": ">= 8" + } + }, + "node_modules/named-placeholders": { + "version": "1.1.6", + "resolved": "https://registry.npmmirror.com/named-placeholders/-/named-placeholders-1.1.6.tgz", + "integrity": "sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==", + "license": "MIT", + "dependencies": { + "lru.min": "^1.1.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/pg": { + "version": "8.23.1", + "resolved": "https://registry.npmmirror.com/pg/-/pg-8.23.1.tgz", + "integrity": "sha512-aL96AHANtWjPLDOLqnhx+ngp9+UK7ETEU8VJrDCGvsSSi/mGLcWYsS6Herg7lmaBJe4uwrfqsa7gTEFaSizDoQ==", + "license": "MIT", + "dependencies": { + "pg-connection-string": "^2.14.1", + "pg-pool": "^3.14.0", + "pg-protocol": "^1.16.1", + "pg-types": "2.2.0", + "pgpass": "1.0.5" + }, + "engines": { + "node": ">= 16.0.0" + }, + "optionalDependencies": { + "pg-cloudflare": "^1.4.1" + }, + "peerDependencies": { + "pg-native": ">=3.0.1" + }, + "peerDependenciesMeta": { + "pg-native": { + "optional": true + } + } + }, + "node_modules/pg-cloudflare": { + "version": "1.4.1", + "resolved": "https://registry.npmmirror.com/pg-cloudflare/-/pg-cloudflare-1.4.1.tgz", + "integrity": "sha512-6PQbsFWZcp9EmJEwy5cGQ2La+AMWpP46lgbb8X+U/XsHIUweYDNCpeuKck5RxL2MdVFi7krbbEi5nX4Zh7JhrQ==", + "license": "MIT", + "optional": true + }, + "node_modules/pg-connection-string": { + "version": "2.14.1", + "resolved": "https://registry.npmmirror.com/pg-connection-string/-/pg-connection-string-2.14.1.tgz", + "integrity": "sha512-qR3kGNPBLpCNtz0evbKA0Y/MRFXwSSdT+pTJvYp/bXTcReZbvX1kzF0IyTc1QnxqF7AZbOeBhNL8R5mYQZV/MA==", + "license": "MIT" + }, + "node_modules/pg-int8": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/pg-int8/-/pg-int8-1.0.1.tgz", + "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==", + "license": "ISC", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/pg-pool": { + "version": "3.14.0", + "resolved": "https://registry.npmmirror.com/pg-pool/-/pg-pool-3.14.0.tgz", + "integrity": "sha512-gKtPkFdQPU3DksooVLi9LsjZxrsBUZIpa+7aVx+LV5pNh0KzP4Zleud2po+ConrxbuXGBJ6Hfer6hdgpIBpBaw==", + "license": "MIT", + "peerDependencies": { + "pg": ">=8.0" + } + }, + "node_modules/pg-protocol": { + "version": "1.16.1", + "resolved": "https://registry.npmmirror.com/pg-protocol/-/pg-protocol-1.16.1.tgz", + "integrity": "sha512-p9VOFMiHB/ZbJATetbg+99PxssTVSQRnyuPSQ67mN1+1KBOjZaZ83ZQzltnxPhJwSsC3nwVjJ10DVJlerbFzLg==", + "license": "MIT" + }, + "node_modules/pg-types": { + "version": "2.2.0", + "resolved": "https://registry.npmmirror.com/pg-types/-/pg-types-2.2.0.tgz", + "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==", + "license": "MIT", + "dependencies": { + "pg-int8": "1.0.1", + "postgres-array": "~2.0.0", + "postgres-bytea": "~1.0.0", + "postgres-date": "~1.0.4", + "postgres-interval": "^1.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pgpass": { + "version": "1.0.5", + "resolved": "https://registry.npmmirror.com/pgpass/-/pgpass-1.0.5.tgz", + "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==", + "license": "MIT", + "dependencies": { + "split2": "^4.1.0" + } + }, + "node_modules/postgres-array": { + "version": "2.0.0", + "resolved": "https://registry.npmmirror.com/postgres-array/-/postgres-array-2.0.0.tgz", + "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/postgres-bytea": { + "version": "1.0.1", + "resolved": "https://registry.npmmirror.com/postgres-bytea/-/postgres-bytea-1.0.1.tgz", + "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-date": { + "version": "1.0.7", + "resolved": "https://registry.npmmirror.com/postgres-date/-/postgres-date-1.0.7.tgz", + "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-interval": { + "version": "1.2.0", + "resolved": "https://registry.npmmirror.com/postgres-interval/-/postgres-interval-1.2.0.tgz", + "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==", + "license": "MIT", + "dependencies": { + "xtend": "^4.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmmirror.com/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmmirror.com/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/sparse-bitfield": { + "version": "3.0.3", + "resolved": "https://registry.npmmirror.com/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz", + "integrity": "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==", + "license": "MIT", + "dependencies": { + "memory-pager": "^1.0.2" + } + }, + "node_modules/split2": { + "version": "4.2.0", + "resolved": "https://registry.npmmirror.com/split2/-/split2-4.2.0.tgz", + "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==", + "license": "ISC", + "engines": { + "node": ">= 10.x" + } + }, + "node_modules/sql-escaper": { + "version": "1.5.2", + "resolved": "https://registry.npmmirror.com/sql-escaper/-/sql-escaper-1.5.2.tgz", + "integrity": "sha512-6CKD38c31SENivxOADeMNLdukOnUxUcflKtzVWzace7Riv1v7cAEym5Cx9Q7gYZ3ezIJI7ZpqecQq8cqNeSSFg==", + "license": "MIT", + "engines": { + "bun": ">=1.0.0", + "deno": ">=2.0.0", + "node": ">=12.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/mysqljs/sql-escaper?sponsor=1" + } + }, + "node_modules/tr46": { + "version": "5.1.1", + "resolved": "https://registry.npmmirror.com/tr46/-/tr46-5.1.1.tgz", + "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==", + "license": "MIT", + "dependencies": { + "punycode": "^2.3.1" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmmirror.com/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "license": "MIT" + }, + "node_modules/webidl-conversions": { + "version": "7.0.0", + "resolved": "https://registry.npmmirror.com/webidl-conversions/-/webidl-conversions-7.0.0.tgz", + "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/whatwg-url": { + "version": "14.2.0", + "resolved": "https://registry.npmmirror.com/whatwg-url/-/whatwg-url-14.2.0.tgz", + "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==", + "license": "MIT", + "dependencies": { + "tr46": "^5.1.0", + "webidl-conversions": "^7.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmmirror.com/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + } + } +} diff --git a/external_plugins/db-connector/mcp/package.json b/external_plugins/db-connector/mcp/package.json new file mode 100644 index 00000000..513bba7b --- /dev/null +++ b/external_plugins/db-connector/mcp/package.json @@ -0,0 +1,26 @@ +{ + "name": "db-connector-mcp", + "version": "0.1.2", + "private": true, + "description": "db-connector MCP server (stdio): read-only MySQL/PostgreSQL/MongoDB access", + "engines": { + "node": ">=18" + }, + "scripts": { + "build": "tsc -p tsconfig.json", + "bundle": "tsc -p tsconfig.json && esbuild dist/db-connect-server.js --bundle --platform=node --format=cjs --target=node18 --legal-comments=inline --outfile=dist/db-connect-server.bundle.cjs", + "test": "node test/smoke.mjs", + "test:real": "node test/real-mysql.mjs" + }, + "dependencies": { + "mongodb": "^6.10.0", + "mysql2": "^3.11.0", + "pg": "^8.13.0" + }, + "devDependencies": { + "@types/node": "^22.0.0", + "@types/pg": "^8.11.0", + "esbuild": "^0.28.2", + "typescript": "^5.6.0" + } +} diff --git a/external_plugins/db-connector/mcp/src/config.ts b/external_plugins/db-connector/mcp/src/config.ts new file mode 100644 index 00000000..3eec32bc --- /dev/null +++ b/external_plugins/db-connector/mcp/src/config.ts @@ -0,0 +1,420 @@ +/** + * config：多环境多连接配置的加载、合并、环境变量占位符解析与持久化。 + * 对应 REQUIREMENTS §4： + * - 工作区 /db-connections.json 与用户级 ~/.zcode/db-connector/connections.json + * - 按"环境名+连接名"合并，工作区优先 + * - 凭证只允许 ${ENV_VAR} 占位符，缺变量时报出变量名 + * - 持久化仅限白名单路径，原子写入 + */ +import * as fs from 'fs'; +import * as path from 'path'; +import * as os from 'os'; + +export type DbType = 'mysql' | 'postgres' | 'mongodb'; + +export const DB_TYPES: DbType[] = ['mysql', 'postgres', 'mongodb']; + +export interface ConnectionConfig { + type: DbType; + host?: string; + port?: number; + user?: string; + password?: string; + database?: string; + url?: string; + rowLimit?: number; + maxRowLimit?: number; + timeoutMs?: number; + [key: string]: unknown; +} + +export interface EnvironmentConfig { + description?: string; + protected?: boolean; + connections: Record; +} + +export interface Defaults { + rowLimit?: number; + maxRowLimit?: number; + timeoutMs?: number; +} + +export interface ConfigFile { + configVersion?: number; + activeEnvironment?: string; + defaults?: Defaults; + environments: Record; +} + +export const DEFAULT_ROW_LIMIT = 200; +export const DEFAULT_MAX_ROW_LIMIT = 1000; +export const DEFAULT_TIMEOUT_MS = 10000; + +const ENV_REF_PATTERN = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/; + +export function emptyConfigFile(): ConfigFile { + return { configVersion: 1, environments: {} }; +} + +/** 工作区配置路径：从 cwd 向上最多查 4 层，找不到则以 cwd 下文件作为写入目标 */ +export function findWorkspaceConfigPath(startDir: string = process.cwd()): string { + let dir = path.resolve(startDir); + for (let i = 0; i < 4; i++) { + const candidate = path.join(dir, 'db-connections.json'); + if (fs.existsSync(candidate)) return candidate; + const parent = path.dirname(dir); + if (parent === dir) break; + dir = parent; + } + return path.join(path.resolve(startDir), 'db-connections.json'); +} + +export function userConfigPath(): string { + return path.join(os.homedir(), '.zcode', 'db-connector', 'connections.json'); +} + +/* -------- .env 密码文件支持（v0.1.1）-------- */ + +/** 解析 dotenv 风格 .env 内容：支持注释、引号值、行内注释、export 前缀 */ +export function parseEnvFile(content: string): Record { + const out: Record = {}; + for (let line of content.split(/\r?\n/)) { + line = line.trim(); + if (!line || line.startsWith('#')) continue; + if (line.startsWith('export ')) line = line.slice(7).trim(); + const eq = line.indexOf('='); + if (eq <= 0) continue; + const key = line.slice(0, eq).trim(); + if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue; + let value = line.slice(eq + 1).trim(); + if ( + (value.startsWith('"') && value.endsWith('"') && value.length >= 2) || + (value.startsWith("'") && value.endsWith("'") && value.length >= 2) + ) { + value = value.slice(1, -1); + } else { + const hash = value.indexOf(' #'); + if (hash >= 0) value = value.slice(0, hash).trimEnd(); + } + out[key] = value; + } + return out; +} + +/** 从 startDir 向上查找工作区 .env（最多 4 层） */ +export function findWorkspaceEnvPath(startDir: string = process.cwd()): string | null { + let dir = path.resolve(startDir); + for (let i = 0; i < 4; i++) { + const candidate = path.join(dir, '.env'); + if (fs.existsSync(candidate)) return candidate; + const parent = path.dirname(dir); + if (parent === dir) break; + dir = parent; + } + return null; +} + +export function userEnvPath(): string { + return path.join(os.homedir(), '.zcode', 'db-connector', '.env'); +} + +/** + * ${VAR} 解析用的变量表，仅来自 .env 文件（v0.1.2 起不读取系统环境变量）。 + * 优先级：工作区 .env > 用户级 .env；保存即生效（每次工具调用重新读取），无需重启。 + */ +export function loadEnvVars(startDir: string = process.cwd()): { vars: NodeJS.ProcessEnv; sources: string[] } { + const sources: string[] = []; + const vars: Record = {}; + for (const file of [userEnvPath(), findWorkspaceEnvPath(startDir)]) { + if (!file || !fs.existsSync(file)) continue; + try { + Object.assign(vars, parseEnvFile(fs.readFileSync(file, 'utf8'))); + sources.push(file); + } catch { + /* 读取失败的 .env 跳过，不阻断查询 */ + } + } + return { vars, sources }; +} + +function readFileIfExists(file: string): ConfigFile | null { + if (!fs.existsSync(file)) return null; + let raw: string; + try { + raw = fs.readFileSync(file, 'utf8'); + } catch (e) { + throw new Error(`无法读取配置文件 ${file}：${(e as Error).message}`); + } + if (!raw.trim()) return null; + try { + const parsed = JSON.parse(raw) as Partial; + if (!parsed || typeof parsed !== 'object' || typeof parsed.environments !== 'object' || parsed.environments === null) { + throw new Error('缺少 environments 对象'); + } + return parsed as ConfigFile; + } catch (e) { + throw new Error(`配置文件 ${file} 不是合法 JSON 或结构不符：${(e as Error).message}`); + } +} + +/** 原子写入：先写临时文件再 rename */ +function atomicWrite(file: string, data: ConfigFile): void { + const dir = path.dirname(file); + fs.mkdirSync(dir, { recursive: true }); + const tmp = path.join(dir, `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`); + fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8'); + fs.renameSync(tmp, file); +} + +export interface MergedConfig { + workspacePath: string; + userPath: string; + workspaceFile: ConfigFile | null; + userFile: ConfigFile | null; + activeEnvironment?: string; + defaults: Required>; + environments: Record; + /** ${VAR} 解析变量表（工作区 .env > 用户级 .env，不读取系统环境变量） */ + env: NodeJS.ProcessEnv; + /** 实际读取到的 .env 文件路径 */ + envSources: string[]; +} + +function mergeDefaults(ws?: Defaults, us?: Defaults) { + const d = { ...us, ...ws }; + return { + rowLimit: d.rowLimit ?? DEFAULT_ROW_LIMIT, + maxRowLimit: d.maxRowLimit ?? DEFAULT_MAX_ROW_LIMIT, + timeoutMs: d.timeoutMs ?? DEFAULT_TIMEOUT_MS, + }; +} + +/** 合并工作区与用户级配置：环境按名合并，连接按名合并，工作区优先 */ +export function mergeConfigFiles(ws: ConfigFile | null, us: ConfigFile | null): Omit { + const environments: Record = {}; + for (const [name, env] of Object.entries(us?.environments ?? {})) { + environments[name] = { ...env, connections: { ...env.connections } }; + } + for (const [name, env] of Object.entries(ws?.environments ?? {})) { + const base = environments[name] ?? { connections: {} }; + environments[name] = { + ...base, + ...env, + connections: { ...base.connections, ...env.connections }, + }; + } + const activeEnvironment = ws?.activeEnvironment ?? us?.activeEnvironment; + return { activeEnvironment, defaults: mergeDefaults(ws?.defaults, us?.defaults), environments }; +} + +export function loadMergedConfig(startDir: string = process.cwd()): MergedConfig { + const workspacePath = findWorkspaceConfigPath(startDir); + const userPath = userConfigPath(); + const workspaceFile = readFileIfExists(workspacePath); + const userFile = readFileIfExists(userPath); + const merged = mergeConfigFiles(workspaceFile, userFile); + const { vars, sources } = loadEnvVars(startDir); + return { workspacePath, userPath, workspaceFile, userFile, ...merged, env: vars, envSources: sources }; +} + +/** 递归解析字符串中的 ${VAR} 占位符；缺失则报出全部缺失变量名 */ +export function resolveEnvPlaceholders(value: T, env: NodeJS.ProcessEnv): T { + const missing = new Set(); + const walk = (v: unknown): unknown => { + if (typeof v === 'string') { + return v.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name: string) => { + const val = env[name]; + if (val === undefined) { + missing.add(name); + return ''; + } + return val; + }); + } + if (Array.isArray(v)) return v.map(walk); + if (v !== null && typeof v === 'object') { + const out: Record = {}; + for (const k of Object.keys(v as Record)) { + out[k] = walk((v as Record)[k]); + } + return out; + } + return v; + }; + const result = walk(value) as T; + if (missing.size > 0) { + throw new Error( + `密码变量未定义：${[...missing].join(', ')}。请在 .env 文件中定义（工作区 .env 或 ~/.zcode/db-connector/.env，保存即生效无需重启；系统环境变量不参与解析）` + ); + } + return result; +} + +export interface ResolvedConnection { + environment: string; + name: string; + config: ConnectionConfig; + envProtected: boolean; + effective: { rowLimit: number; maxRowLimit: number; timeoutMs: number }; +} + +/** 解析 "name" 或 "env/name" 引用到具体连接（不解析占位符，调用方按需 resolveEnvPlaceholders） */ +export function resolveConnectionRef(merged: MergedConfig, ref: string): ResolvedConnection { + if (typeof ref !== 'string' || !ref.trim()) { + throw new Error('connection 参数不能为空'); + } + let envName: string; + let connName: string; + const slash = ref.indexOf('/'); + if (slash >= 0) { + envName = ref.slice(0, slash); + connName = ref.slice(slash + 1); + } else { + envName = merged.activeEnvironment ?? ''; + connName = ref; + if (!envName) { + throw new Error( + '未设置活动环境：请在配置中设置 activeEnvironment，或使用 "环境名/连接名" 的完整写法（如 prod/mysql-main）' + ); + } + } + const env = merged.environments[envName]; + if (!env) { + throw new Error( + `环境 "${envName}" 不存在。可用环境：${Object.keys(merged.environments).join(', ') || '（无）'}` + ); + } + const conn = env.connections[connName]; + if (!conn) { + const available = Object.keys(env.connections).join(', ') || '（无）'; + throw new Error(`连接 "${connName}" 在环境 "${envName}" 中不存在。可用连接：${available}`); + } + const effective = { + rowLimit: conn.rowLimit ?? merged.defaults.rowLimit, + maxRowLimit: conn.maxRowLimit ?? merged.defaults.maxRowLimit, + timeoutMs: conn.timeoutMs ?? merged.defaults.timeoutMs, + }; + return { environment: envName, name: connName, config: conn, envProtected: !!env.protected, effective }; +} + +/** 校验环境名/连接名标识符 */ +export function validateIdentifier(kind: string, value: string): void { + if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(value)) { + throw new Error(`${kind} "${value}" 不合法：需以字母或数字开头，仅含字母/数字/-/_，最长 64 字符`); + } +} + +export interface SanitizeResult { + config: ConnectionConfig; + warnings: string[]; +} + +/** + * 配置工具写入前的清洗：只接受 ${ENV} 形式的 password；type 白名单； + * URL 内联凭证允许但返回告警（与手工编辑口径一致）。 + */ +export function sanitizeConnectionForWrite(input: Record, passwordEnvVar?: string): SanitizeResult { + const warnings: string[] = []; + const cfg: Record = { ...input }; + if (passwordEnvVar !== undefined) { + if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(passwordEnvVar)) { + throw new Error(`passwordEnvVar "${passwordEnvVar}" 不是合法的环境变量名`); + } + cfg.password = `\${${passwordEnvVar}}`; + } + if (cfg.type !== undefined && !DB_TYPES.includes(cfg.type as DbType)) { + throw new Error(`type 必须是 ${DB_TYPES.join(' / ')} 之一`); + } + if (cfg.type === undefined) { + throw new Error('缺少 type 字段（mysql / postgres / mongodb）'); + } + if (cfg.password !== undefined && cfg.password !== null) { + const pw = String(cfg.password); + if (!ENV_REF_PATTERN.test(pw)) { + throw new Error( + '拒绝写入明文密码：请改用 passwordEnvVar 参数传入密码变量名（在 .env 文件中定义，写入为 ${VAR} 引用），或手工编辑文件时写成 "${VAR}"' + ); + } + } + const url = typeof cfg.url === 'string' ? cfg.url : undefined; + if (url) { + const inline = url.match(/:\/\/[^/@\s:]+:([^/@\s]*)@/); + if (inline && !ENV_REF_PATTERN.test(inline[1] || '')) { + warnings.push( + 'URL 中包含内联密码：建议改用 ${ENV_VAR} 占位符（如 mongodb://user:${DB_PW}@host），当前写法将明文凭证保存在配置文件里' + ); + } + } + delete cfg.passwordEnvVar; + return { config: cfg as ConnectionConfig, warnings }; +} + +/** 写入指定 scope 的配置文件 */ +export function persistAddConnection( + scope: 'workspace' | 'user', + merged: MergedConfig, + envName: string, + connName: string, + config: ConnectionConfig +): { file: string } { + const file = scope === 'workspace' ? merged.workspacePath : merged.userPath; + const current = readFileIfExists(file) ?? emptyConfigFile(); + if (!current.environments[envName]) { + current.environments[envName] = { connections: {} }; + } + if (current.environments[envName].connections[connName]) { + throw new Error(`连接 "${envName}/${connName}" 已存在于 ${file}，如需覆盖请先删除`); + } + current.environments[envName].connections[connName] = config; + atomicWrite(file, current); + return { file }; +} + +/** 删除连接：优先工作区文件，其次用户级文件 */ +export function persistRemoveConnection( + merged: MergedConfig, + envName: string, + connName: string +): { file: string } { + for (const file of [merged.workspacePath, merged.userPath]) { + const current = readFileIfExists(file); + if (!current) continue; + const env = current.environments[envName]; + if (env && env.connections && env.connections[connName]) { + delete env.connections[connName]; + if (Object.keys(env.connections).length === 0 && !env.description && !env.protected) { + delete current.environments[envName]; + } + atomicWrite(file, current); + return { file }; + } + } + throw new Error(`连接 "${envName}/${connName}" 不存在，未做任何修改`); +} + +/** 切换活动环境：工作区文件存在则写入工作区，否则写入用户级 */ +export function persistSetActiveEnvironment(merged: MergedConfig, envName: string): { file: string } { + if (!merged.environments[envName]) { + throw new Error(`环境 "${envName}" 不存在。可用环境：${Object.keys(merged.environments).join(', ') || '（无）'}`); + } + const file = merged.workspaceFile ? merged.workspacePath : merged.userPath; + const current = readFileIfExists(file) ?? emptyConfigFile(); + current.activeEnvironment = envName; + atomicWrite(file, current); + return { file }; +} + +/** 脱敏展示（list 用） */ +export function maskConnection(conn: ConnectionConfig): Record { + const out: Record = { type: conn.type }; + if (conn.database) out.database = conn.database; + if (conn.host) out.host = conn.host; + if (conn.port) out.port = conn.port; + if (conn.user) out.user = conn.user; + if (conn.url) { + out.url = (conn.url as string).replace(/(:[^/@\s]*)@/, ':***@').replace(/\$\{[^}]+\}/g, '${…}'); + } + if (conn.password) out.password = '${…}'; + return out; +} diff --git a/external_plugins/db-connector/mcp/src/db-connect-server.ts b/external_plugins/db-connector/mcp/src/db-connect-server.ts new file mode 100644 index 00000000..3aae4112 --- /dev/null +++ b/external_plugins/db-connector/mcp/src/db-connect-server.ts @@ -0,0 +1,111 @@ +/** + * db-connector MCP 服务器入口：stdio 上的 JSON-RPC 2.0（每行一个消息）。 + * 支持 initialize / notifications/* / ping / tools/list / tools/call。 + */ +import * as readline from 'readline'; +import { TOOL_DEFINITIONS, handleToolCall } from './tools'; + +const SERVER_NAME = 'db-connector'; +const SERVER_VERSION = '0.1.0'; +const PROTOCOL_VERSION = '2024-11-05'; + +interface JsonRpcMessage { + jsonrpc?: string; + id?: number | string | null; + method?: string; + params?: Record; +} + +function send(obj: unknown): void { + process.stdout.write(JSON.stringify(obj) + '\n'); +} + +function reply(id: number | string, result: unknown): void { + send({ jsonrpc: '2.0', id, result }); +} + +function replyError(id: number | string, code: number, message: string): void { + send({ jsonrpc: '2.0', id, error: { code, message } }); +} + +function log(...parts: unknown[]): void { + process.stderr.write(`[db-connector] ${parts.join(' ')}\n`); +} + +async function handleMessage(msg: JsonRpcMessage): Promise { + const { method, id, params } = msg; + + // 通知（无 id）：静默接收 + if (id === undefined || id === null) { + return; + } + + try { + switch (method) { + case 'initialize': { + const requested = (params?.protocolVersion as string) ?? PROTOCOL_VERSION; + reply(id, { + protocolVersion: requested, + capabilities: { tools: {} }, + serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }, + }); + return; + } + case 'ping': { + reply(id, {}); + return; + } + case 'tools/list': { + reply(id, { tools: TOOL_DEFINITIONS }); + return; + } + case 'tools/call': { + const name = String(params?.name ?? ''); + const args = (params?.arguments as Record) ?? {}; + try { + const result = await handleToolCall(name, args); + reply(id, { + content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], + isError: false, + }); + } catch (toolError) { + // 工具级错误：按 MCP 惯例返回 isError 内容而非协议错误，AI 可读取原因 + reply(id, { + content: [{ type: 'text', text: `工具执行失败：${(toolError as Error).message}` }], + isError: true, + }); + } + return; + } + default: + replyError(id, -32601, `Method not found: ${method}`); + } + } catch (e) { + replyError(id, -32603, `Internal error: ${(e as Error).message}`); + } +} + +async function main(): Promise { + const rl = readline.createInterface({ input: process.stdin, terminal: false }); + rl.on('line', (line) => { + const text = line.trim(); + if (!text) return; + let msg: JsonRpcMessage; + try { + msg = JSON.parse(text) as JsonRpcMessage; + } catch { + log('忽略无法解析的输入行'); + return; + } + if (!msg.method) return; + void handleMessage(msg).catch((e) => log('消息处理异常:', (e as Error).message)); + }); + rl.on('close', () => { + log('stdin 已关闭，服务器退出'); + process.exit(0); + }); + process.on('uncaughtException', (e) => log('未捕获异常:', e.message)); + process.on('unhandledRejection', (r) => log('未处理的 Promise 拒绝:', String(r))); +} + +void main(); diff --git a/external_plugins/db-connector/mcp/src/drivers.ts b/external_plugins/db-connector/mcp/src/drivers.ts new file mode 100644 index 00000000..92ca227a --- /dev/null +++ b/external_plugins/db-connector/mcp/src/drivers.ts @@ -0,0 +1,372 @@ +/** + * drivers：MySQL / PostgreSQL / MongoDB 执行层。 + * 约定（REQUIREMENTS §5/§6）： + * - 每次调用建立连接、用完即关，不做常驻连接池； + * - 值只经驱动参数绑定传入（MySQL 用 ?，PostgreSQL 用 $n；Mongo 传文档对象）； + * - 查询超时（timeoutMs）与行数上限（limit+1 探测截断）在驱动层强制； + * - 表结构浏览走 information_schema，表名作为"值"参数绑定，不做标识符拼接。 + */ +import * as mysql from 'mysql2/promise'; +import { Client } from 'pg'; +import { MongoClient } from 'mongodb'; +import { ConnectionConfig } from './config'; + +export interface ExecOptions { + timeoutMs: number; + limit: number; +} + +export interface QueryOutcome { + rows: unknown[]; + truncated: boolean; + elapsedMs: number; +} + +function withTimeout(p: Promise, ms: number, onTimeout: () => void): Promise { + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + onTimeout(); + reject(new Error(`查询超过 ${ms}ms 超时，已中止`)); + }, ms); + p.then( + (v) => { clearTimeout(timer); resolve(v); }, + (e) => { clearTimeout(timer); reject(e); } + ); + }); +} + +/** 行数据 JSON 安全化：Date→ISO、BigInt→字符串、Buffer→hex 摘要 */ +function jsonSafe(value: unknown, depth = 0): unknown { + if (depth > 20) return '[深度超限]'; + if (typeof value === 'bigint') return value.toString(); + if (value instanceof Date) return value.toISOString(); + if (Buffer.isBuffer(value)) { + const hex = value.toString('hex'); + return `0x${hex.length > 64 ? hex.slice(0, 64) + `…(${value.length} bytes)` : hex}`; + } + if (value instanceof Uint8Array) return `(binary ${value.length} bytes)`; + if (value === null || value === undefined) return value; + if (Array.isArray(value)) return value.map((v) => jsonSafe(v, depth + 1)); + if (typeof value === 'object') { + const ctor = (value as object).constructor?.name; + if (ctor && ctor !== 'Object' && ctor !== 'Array') return String(value); + const out: Record = {}; + for (const k of Object.keys(value as Record)) { + out[k] = jsonSafe((value as Record)[k], depth + 1); + } + return out; + } + return value; +} + +function truncate(rows: unknown[], limit: number): { rows: unknown[]; truncated: boolean } { + if (rows.length > limit) return { rows: rows.slice(0, limit), truncated: true }; + return { rows, truncated: false }; +} + +function friendlyConnError(e: unknown, cfg: ConnectionConfig): Error { + const msg = (e as Error)?.message ?? String(e); + const code = (e as { code?: string })?.code; + if (code === 'ECONNREFUSED' || code === 'ETIMEDOUT' || code === 'ENOTFOUND') { + return new Error(`无法连接 ${cfg.host ?? cfg.url ?? ''}:${cfg.port ?? ''}（${code}）：请确认地址/端口与数据库是否运行`); + } + if (/access denied|password authentication|authentication failed/i.test(msg)) { + return new Error(`认证失败：请检查用户名/密码（密码来自环境变量，确认变量值正确）：${msg}`); + } + return new Error(msg); +} + +/* ------------------------- MySQL ------------------------- */ + +async function mysqlConnect(cfg: ConnectionConfig, timeoutMs: number): Promise { + const options: mysql.ConnectionOptions = { + connectTimeout: Math.min(timeoutMs, 20000), + dateStrings: true, + multipleStatements: false, + supportBigNumbers: true, + }; + if (cfg.url) options.uri = cfg.url as string; + else { + options.host = cfg.host as string; + options.port = cfg.port as number; + options.user = cfg.user as string; + options.password = cfg.password as string; + options.database = cfg.database as string; + } + try { + return await withTimeout(mysql.createConnection(options), timeoutMs, () => undefined); + } catch (e) { + throw friendlyConnError(e, cfg); + } +} + +async function mysqlRun( + cfg: ConnectionConfig, + opts: ExecOptions, + fn: (conn: mysql.Connection) => Promise +): Promise { + const conn = await mysqlConnect(cfg, opts.timeoutMs); + let out: T; + try { + out = await withTimeout(fn(conn), opts.timeoutMs, () => { conn.destroy(); }); + } finally { + try { await conn.end(); } catch { /* 连接可能已被 destroy */ } + } + return out; +} + +async function mysqlQuery(cfg: ConnectionConfig, sql: string, params: unknown[], opts: ExecOptions): Promise { + const started = Date.now(); + const rows = (await mysqlRun(cfg, opts, (conn) => conn.query(sql, params)) as unknown[])[0] as unknown[]; + const t = truncate(Array.isArray(rows) ? rows : [rows], opts.limit); + return { ...t, elapsedMs: Date.now() - started }; +} + +/* ------------------------- PostgreSQL ------------------------- */ + +async function pgConnect(cfg: ConnectionConfig, timeoutMs: number): Promise { + const config: Record = { + connectionTimeoutMillis: timeoutMs, + statement_timeout: timeoutMs, + query_timeout: timeoutMs, + }; + if (cfg.url) config.connectionString = cfg.url; + else { + config.host = cfg.host; + config.port = cfg.port; + config.user = cfg.user; + config.password = cfg.password; + config.database = cfg.database; + } + const client = new Client(config as ConstructorParameters[0]); + try { + await withTimeout(client.connect(), timeoutMs, () => { client.end().catch(() => undefined); }); + } catch (e) { + throw friendlyConnError(e, cfg); + } + return client; +} + +async function pgRun(cfg: ConnectionConfig, opts: ExecOptions, fn: (client: Client) => Promise): Promise { + const client = await pgConnect(cfg, opts.timeoutMs); + try { + return await fn(client); + } finally { + await client.end().catch(() => undefined); + } +} + +async function pgQuery(cfg: ConnectionConfig, sql: string, params: unknown[], opts: ExecOptions): Promise { + const started = Date.now(); + const res = await pgRun(cfg, opts, (client) => client.query({ text: sql, values: params })); + const t = truncate(res.rows ?? [], opts.limit); + return { ...t, elapsedMs: Date.now() - started }; +} + +/* ------------------------- MongoDB ------------------------- */ + +async function mongoConnect(cfg: ConnectionConfig, timeoutMs: number): Promise<{ client: MongoClient; db: ReturnType }> { + if (!cfg.url) throw new Error('MongoDB 连接需要 url 字段'); + const client = new MongoClient(cfg.url as string, { + serverSelectionTimeoutMS: timeoutMs, + connectTimeoutMS: timeoutMs, + }); + try { + await withTimeout(client.connect(), timeoutMs, () => { client.close().catch(() => undefined); }); + } catch (e) { + throw friendlyConnError(e, cfg); + } + const db = cfg.database ? client.db(cfg.database as string) : client.db(); + return { client, db }; +} + +async function mongoRun( + cfg: ConnectionConfig, + opts: ExecOptions, + fn: (db: ReturnType) => Promise +): Promise { + const { client, db } = await mongoConnect(cfg, opts.timeoutMs); + try { + return await withTimeout(fn(db), opts.timeoutMs, () => { client.close().catch(() => undefined); }); + } finally { + await client.close().catch(() => undefined); + } +} + +/* ------------------------- 统一入口 ------------------------- */ + +export function sqlQuery( + type: 'mysql' | 'postgres', + cfg: ConnectionConfig, + sql: string, + params: unknown[], + opts: ExecOptions +): Promise { + return type === 'mysql' ? mysqlQuery(cfg, sql, params, opts) : pgQuery(cfg, sql, params, opts); +} + +export async function testConnection(cfg: ConnectionConfig, timeoutMs: number): Promise<{ serverInfo: string; elapsedMs: number }> { + const started = Date.now(); + if (cfg.type === 'mysql') { + const rows = await mysqlRun(cfg, { timeoutMs, limit: 1 }, (conn) => conn.query('SELECT VERSION() AS version')); + const r = (rows[0] as Array<{ version: string }>)[0]; + return { serverInfo: `MySQL ${r?.version ?? '未知版本'}`, elapsedMs: Date.now() - started }; + } + if (cfg.type === 'postgres') { + const res = await pgRun(cfg, { timeoutMs, limit: 1 }, (c) => c.query('SELECT version() AS version')); + return { serverInfo: String(res.rows[0]?.version ?? '未知版本').split(' (')[0], elapsedMs: Date.now() - started }; + } + // mongodb + const info = await mongoRun(cfg, { timeoutMs, limit: 1 }, async (db) => { + const ping = await db.command({ ping: 1 }); + let version = '未知版本'; + try { + const build = await db.command({ buildInfo: 1 }); + version = String((build as { version?: string }).version ?? version); + } catch { /* 部分权限下 buildInfo 不可用 */ } + return { ping, version }; + }); + return { serverInfo: `MongoDB ${info.version}（ping ${info.ping?.ok === 1 ? '通过' : '失败'}）`, elapsedMs: Date.now() - started }; +} + +export async function listTables(cfg: ConnectionConfig, opts: ExecOptions): Promise { + const started = Date.now(); + if (cfg.type === 'mysql') { + const rows = await mysqlRun(cfg, opts, (conn) => + conn.query( + 'SELECT TABLE_NAME AS name, TABLE_ROWS AS rowEstimate, TABLE_TYPE AS kind FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME' + ) + ); + const list = rows[0] as unknown[]; + return { rows: list, truncated: false, elapsedMs: Date.now() - started }; + } + if (cfg.type === 'postgres') { + const res = await pgRun(cfg, opts, (c) => + c.query( + `SELECT c.relname AS name, c.reltuples::bigint AS "rowEstimate", + CASE c.relkind WHEN 'r' THEN 'BASE TABLE' WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'MATERIALIZED VIEW' WHEN 'p' THEN 'PARTITIONED TABLE' ELSE c.relkind::text END AS kind + FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace + WHERE n.nspname = current_schema() AND c.relkind IN ('r','v','m','p') + ORDER BY c.relname` + ) + ); + return { rows: res.rows, truncated: false, elapsedMs: Date.now() - started }; + } + // mongodb：列出集合与文档数估计 + const list = await mongoRun(cfg, opts, async (db) => { + const cols = await db.listCollections().toArray(); + const out: Array<{ name: string; kind: string; rowEstimate: number }> = []; + for (const col of cols.slice(0, opts.limit)) { + let est = -1; + try { est = await db.collection(col.name).estimatedDocumentCount(); } catch { /* 忽略单个集合计数失败 */ } + out.push({ name: col.name, kind: String(col.type ?? 'collection'), rowEstimate: est }); + } + return out; + }); + return { rows: list, truncated: false, elapsedMs: Date.now() - started }; +} + +export async function describeTable( + cfg: ConnectionConfig, + table: string, + opts: ExecOptions +): Promise<{ columns?: unknown[]; indexes?: unknown[]; sample?: unknown; fields?: unknown[] }> { + if (cfg.type === 'mysql') { + const res = await mysqlRun(cfg, opts, async (conn) => { + const columns = ( + await conn.query( + 'SELECT COLUMN_NAME AS name, COLUMN_TYPE AS type, IS_NULLABLE AS nullable, COLUMN_KEY AS keyInfo, EXTRA AS extra, COLUMN_COMMENT AS comment FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION', + [table] + ) + )[0] as unknown[]; + const idxRows = ( + await conn.query( + 'SELECT INDEX_NAME AS name, COLUMN_NAME AS column_name, NON_UNIQUE AS nonUnique, SEQ_IN_INDEX AS seq FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? ORDER BY INDEX_NAME, SEQ_IN_INDEX', + [table] + ) + )[0] as Array<{ name: string; column_name: string; nonUnique: number; seq: number }>; + const indexMap = new Map(); + for (const r of idxRows) { + const entry = indexMap.get(r.name) ?? { name: r.name, unique: r.nonUnique === 0, columns: [] }; + entry.columns.push(r.column_name); + indexMap.set(r.name, entry); + } + return { columns, indexes: [...indexMap.values()] }; + }); + return res; + } + if (cfg.type === 'postgres') { + return pgRun(cfg, opts, async (c) => { + const columns = ( + await c.query( + 'SELECT column_name AS name, data_type AS type, is_nullable AS nullable, column_default AS "default" FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = $1 ORDER BY ordinal_position', + [table] + ) + ).rows; + const indexes = ( + await c.query( + 'SELECT indexname AS name, indexdef AS def FROM pg_indexes WHERE schemaname = current_schema() AND tablename = $1 ORDER BY indexname', + [table] + ) + ).rows; + return { columns, indexes }; + }); + } + // mongodb：采样文档推断字段 + 索引列表 + return mongoRun(cfg, opts, async (db) => { + const coll = db.collection(table); + const sampleDoc = await coll.findOne({}, { timeoutMs: opts.timeoutMs } as never); + const fields: Array<{ field: string; type: string }> = []; + const infer = (obj: Record, prefix = '') => { + for (const [k, v] of Object.entries(obj)) { + const label = prefix ? `${prefix}.${k}` : k; + const t = v === null ? 'null' : Array.isArray(v) ? `array<${typeof v[0]}>` : v instanceof Date ? 'date' : typeof v; + fields.push({ field: label, type: t }); + if (v !== null && typeof v === 'object' && !Array.isArray(v) && !(v instanceof Date) && prefix.split('.').length < 2) { + infer(v as Record, label); + } + } + }; + if (sampleDoc) infer(sampleDoc); + let indexes: unknown[] = []; + try { indexes = await coll.indexes(); } catch { /* 权限不足时忽略 */ } + return { fields, indexes, sample: sampleDoc }; + }); +} + +export async function mongoFind( + cfg: ConnectionConfig, + collection: string, + filter: Record, + projection: Record | undefined, + sort: Record | undefined, + opts: ExecOptions +): Promise { + const started = Date.now(); + const rows = await mongoRun(cfg, opts, async (db) => { + let cursor = db.collection(collection).find(filter).limit(opts.limit + 1); + if (projection) cursor = cursor.project(projection); + if (sort) cursor = cursor.sort(sort as never); + cursor = cursor.maxTimeMS(opts.timeoutMs); + return cursor.toArray(); + }); + const t = truncate(rows, opts.limit); + return { ...t, elapsedMs: Date.now() - started }; +} + +export async function mongoAggregate( + cfg: ConnectionConfig, + collection: string, + pipeline: unknown[], + opts: ExecOptions +): Promise { + const started = Date.now(); + const rows = await mongoRun(cfg, opts, async (db) => { + const stages = [...pipeline, { $limit: opts.limit + 1 }]; + return db.collection(collection).aggregate(stages as never[], { maxTimeMS: opts.timeoutMs }).toArray(); + }); + const t = truncate(rows, opts.limit); + return { ...t, elapsedMs: Date.now() - started }; +} + +export { jsonSafe }; diff --git a/external_plugins/db-connector/mcp/src/sqlguard.ts b/external_plugins/db-connector/mcp/src/sqlguard.ts new file mode 100644 index 00000000..d671a34a --- /dev/null +++ b/external_plugins/db-connector/mcp/src/sqlguard.ts @@ -0,0 +1,133 @@ +/** + * sqlguard：只读 SQL 白名单校验。 + * 硬性规则（对应 REQUIREMENTS §6）： + * 1. 仅放行单条 SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / DESC 语句； + * 2. 拒绝多语句（任何分号）； + * 3. 对原始文本做写/DDL 关键词与危险函数扫描——即使出现在子查询或注释中同样拒绝； + * 4. 锁定子句（FOR UPDATE / FOR SHARE 等）与文件/锁/延时类函数拒绝。 + */ +export class SqlRejectedError extends Error { + constructor(reason: string) { + super(`SQL 被只读校验拒绝：${reason}`); + this.name = 'SqlRejectedError'; + } +} + +/** 语句必须以这些关键词之一开头 */ +const ALLOWED_STARTERS = /^\s*(select|with|explain(\s+analyze|\s+analyse)?|show|describe|desc)\b/i; + +/** 原文全词扫描的写/DDL/会话类关键词（含子查询与注释中出现的情况） */ +const FORBIDDEN_KEYWORDS = [ + 'insert', 'update', 'delete', 'drop', 'alter', 'create', 'truncate', + 'grant', 'revoke', 'replace', 'merge', 'call', 'execute', 'exec', + 'lock', 'unlock', 'load', 'rename', 'use', 'set', 'into', 'outfile', + 'dumpfile', 'prepare', 'handler', 'do', 'copy', 'vacuum', 'reindex', + 'cluster', 'listen', 'notify', 'refresh', 'attach', 'detach', + 'checkpoint', 'kill', 'reset', 'flush', 'optimize', 'repair', + 'shutdown', 'purge', 'start', 'begin', 'commit', 'rollback', 'savepoint', +]; + +/** 危险函数（服务端文件读写 / 锁 / 延时 / 跨库执行 / 终止会话） */ +const FORBIDDEN_FUNCTIONS = [ + 'load_file', 'get_lock', 'release_lock', 'benchmark', 'sleep', + 'sys_eval', 'sys_exec', + 'pg_sleep', 'pg_read_file', 'pg_read_binary_file', 'pg_ls_dir', + 'pg_stat_file', 'pg_terminate_backend', 'pg_cancel_backend', + 'dblink', 'lo_import', 'lo_export', 'pg_switch_wal', 'pg_ls_waldir', +]; + +/** 行级锁子句 */ +const LOCK_CLAUSE = /\bfor\s+(update|share|no\s+key\s+update|key\s+share)\b/i; + +function escapeRegExp(s: string): string { + return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); +} + +const forbiddenKeywordRegex = FORBIDDEN_KEYWORDS.map( + (w) => new RegExp(`(^|[^a-zA-Z0-9_])${escapeRegExp(w)}([^a-zA-Z0-9_]|$)`, 'i') +); +const forbiddenFunctionRegex = FORBIDDEN_FUNCTIONS.map( + (w) => new RegExp(`(^|[^a-zA-Z0-9_])${escapeRegExp(w)}\\s*\\(`, 'i') +); + +/** 校验入口：合法返回清理后的 SQL，非法抛 SqlRejectedError */ +export function validateReadOnlySql(rawSql: string): string { + if (typeof rawSql !== 'string') { + throw new SqlRejectedError('sql 必须是字符串'); + } + const trimmed = rawSql.trim(); + // 去掉末尾多余分号后必须非空 + const stripped = trimmed.replace(/;+\s*$/, ''); + if (!stripped) { + throw new SqlRejectedError('SQL 为空'); + } + // 多语句拒绝：任何残留分号（包括注释里藏语句的写法） + if (stripped.includes(';')) { + throw new SqlRejectedError('不允许一次执行多条语句（检测到分号）'); + } + // 语句类型白名单 + if (!ALLOWED_STARTERS.test(stripped)) { + throw new SqlRejectedError( + '仅允许 SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / DESC 开头的单条只读语句' + ); + } + // 写/DDL 关键词全词扫描（含子查询、注释） + for (let i = 0; i < FORBIDDEN_KEYWORDS.length; i++) { + if (forbiddenKeywordRegex[i].test(stripped)) { + throw new SqlRejectedError( + `检测到禁止的关键词 "${FORBIDDEN_KEYWORDS[i].toUpperCase()}"（含子查询/注释中的出现）` + ); + } + } + // 危险函数扫描 + for (let i = 0; i < FORBIDDEN_FUNCTIONS.length; i++) { + if (forbiddenFunctionRegex[i].test(stripped)) { + throw new SqlRejectedError(`检测到禁止的函数 "${FORBIDDEN_FUNCTIONS[i]}"`); + } + } + // 行级锁子句 + if (LOCK_CLAUSE.test(stripped)) { + throw new SqlRejectedError('检测到锁定子句（FOR UPDATE/FOR SHARE 等），只读模式不允许'); + } + return stripped; +} + +/** MongoDB 校验：拒绝 $out/$merge/$load 等写阶段与 $where/$function 等脚本执行 */ +const FORBIDDEN_MONGO_KEYS = [ + '$out', '$merge', '$load', '$where', '$function', '$accumulator', '$db', '$eval', +]; + +export function validateMongoStages(pipeline: unknown): void { + if (!Array.isArray(pipeline)) { + throw new SqlRejectedError('pipeline 必须是数组'); + } + for (const stage of pipeline) { + scanMongoObject(stage, 'pipeline 阶段'); + } +} + +export function validateMongoReadDocument(doc: unknown, what: string): void { + scanMongoObject(doc, what); +} + +function scanMongoObject(value: unknown, where: string, depth = 0): void { + if (depth > 30) { + throw new SqlRejectedError(`${where} 嵌套过深`); + } + if (value === null || value === undefined) return; + if (typeof value === 'function') { + throw new SqlRejectedError(`${where} 不允许包含函数`); + } + if (Array.isArray(value)) { + for (const item of value) scanMongoObject(item, where, depth + 1); + return; + } + if (typeof value === 'object') { + for (const key of Object.keys(value as Record)) { + if (FORBIDDEN_MONGO_KEYS.includes(key)) { + throw new SqlRejectedError(`${where} 检测到禁止的运算符 "${key}"`); + } + scanMongoObject((value as Record)[key], where, depth + 1); + } + } +} diff --git a/external_plugins/db-connector/mcp/src/tools.ts b/external_plugins/db-connector/mcp/src/tools.ts new file mode 100644 index 00000000..2bfd6741 --- /dev/null +++ b/external_plugins/db-connector/mcp/src/tools.ts @@ -0,0 +1,343 @@ +/** + * tools：MCP 工具定义与处理器（10 个，REQUIREMENTS §5）。 + * 处理顺序约定：db_query 先做只读 SQL 校验再解析连接——校验无需数据库即可测试。 + */ +import { + loadMergedConfig, + resolveConnectionRef, + resolveEnvPlaceholders, + sanitizeConnectionForWrite, + persistAddConnection, + persistRemoveConnection, + persistSetActiveEnvironment, + validateIdentifier, + maskConnection, + MergedConfig, +} from './config'; +import { validateReadOnlySql, validateMongoStages, validateMongoReadDocument } from './sqlguard'; +import { sqlQuery, testConnection, listTables, describeTable, mongoFind, mongoAggregate, jsonSafe } from './drivers'; + +export interface ToolDef { + name: string; + description: string; + inputSchema: Record; +} + +const str = (description: string) => ({ type: 'string', description }); + +export const TOOL_DEFINITIONS: ToolDef[] = [ + { + name: 'db_list_connections', + description: '按环境分组列出所有已配置的数据库连接（凭证脱敏），标注活动环境与 protected 标记。无配置时返回创建引导。', + inputSchema: { type: 'object', properties: {}, additionalProperties: false }, + }, + { + name: 'db_test_connection', + description: '测试指定连接的连通性，返回服务器版本与耗时。connection 用 "连接名"（活动环境）或 "环境名/连接名"（如 prod/mysql-main）。', + inputSchema: { + type: 'object', + properties: { connection: str('连接引用：连接名 或 环境名/连接名') }, + required: ['connection'], + additionalProperties: false, + }, + }, + { + name: 'db_list_tables', + description: '列出指定连接中的所有表/集合及行数估计。', + inputSchema: { + type: 'object', + properties: { connection: str('连接引用：连接名 或 环境名/连接名') }, + required: ['connection'], + additionalProperties: false, + }, + }, + { + name: 'db_describe_table', + description: '查看表结构：列名/类型/可空/键/索引（MongoDB 为采样字段推断 + 索引列表）。', + inputSchema: { + type: 'object', + properties: { + connection: str('连接引用：连接名 或 环境名/连接名'), + table: str('表名或集合名'), + }, + required: ['connection', 'table'], + additionalProperties: false, + }, + }, + { + name: 'db_query', + description: '对 MySQL/PostgreSQL 执行只读 SQL（仅 SELECT/WITH/EXPLAIN/SHOW/DESCRIBE）。值必须通过 params 参数绑定传入：MySQL 用 ? 占位符，PostgreSQL 用 $1/$2 占位符，禁止在 SQL 文本中拼接值。', + inputSchema: { + type: 'object', + properties: { + connection: str('连接引用：连接名 或 环境名/连接名'), + sql: str('单条只读 SQL 语句'), + params: { type: 'array', items: {}, description: '占位符对应的值数组，按顺序绑定' }, + limit: { type: 'number', description: '本次返回行数上限（不超过配置的 maxRowLimit，缺省 1000）' }, + }, + required: ['connection', 'sql'], + additionalProperties: false, + }, + }, + { + name: 'db_find', + description: 'MongoDB 只读查询（对应 find），支持 filter/projection/sort/limit。禁止 $where 等脚本运算符。', + inputSchema: { + type: 'object', + properties: { + connection: str('连接引用：连接名 或 环境名/连接名'), + collection: str('集合名'), + filter: { type: 'object', description: '查询条件（MongoDB 查询文档）' }, + projection: { type: 'object', description: '字段投影' }, + sort: { type: 'object', description: '排序，如 {"field": -1}' }, + limit: { type: 'number', description: '返回文档数上限' }, + }, + required: ['connection', 'collection'], + additionalProperties: false, + }, + }, + { + name: 'db_aggregate', + description: 'MongoDB 聚合管道（只读阶段；$out/$merge/$where/$function 被拒绝）。', + inputSchema: { + type: 'object', + properties: { + connection: str('连接引用：连接名 或 环境名/连接名'), + collection: str('集合名'), + pipeline: { type: 'array', items: {}, description: '聚合阶段数组' }, + limit: { type: 'number', description: '返回文档数上限' }, + }, + required: ['connection', 'collection', 'pipeline'], + additionalProperties: false, + }, + }, + { + name: 'db_add_connection', + description: '新增数据库连接并持久化（会话式配置）。密码只接受环境变量名（passwordEnvVar），写入为 ${VAR} 引用，拒绝明文密码。config 含 type(mysql/postgres/mongodb) 及 host/port/user/database 或 url 等字段。scope：workspace（默认，工作区 db-connections.json）或 user（用户级全局配置）。', + inputSchema: { + type: 'object', + properties: { + environment: str('环境名，如 dev/test/prod'), + name: str('连接名，如 mysql-main'), + config: { + type: 'object', + description: '连接配置：type 必填；MySQL/PG 可给 host/port/user/password(仅${VAR}形式)/database 或 url；MongoDB 给 url(可含${VAR}) 及可选 database', + }, + passwordEnvVar: str('密码变量名（在 .env 文件中定义），写入为 ${VAR} 引用'), + scope: { type: 'string', enum: ['workspace', 'user'], description: '持久化位置，缺省 workspace' }, + }, + required: ['environment', 'name', 'config'], + additionalProperties: false, + }, + }, + { + name: 'db_remove_connection', + description: '删除指定环境中的连接（优先从工作区文件删除，其次用户级文件）。', + inputSchema: { + type: 'object', + properties: { + environment: str('环境名'), + name: str('连接名'), + }, + required: ['environment', 'name'], + additionalProperties: false, + }, + }, + { + name: 'db_set_active_environment', + description: '切换活动环境（工具默认使用的环境）并持久化。', + inputSchema: { + type: 'object', + properties: { environment: str('环境名，如 dev/prod') }, + required: ['environment'], + additionalProperties: false, + }, + }, +]; + +function computeLimit(effective: { rowLimit: number; maxRowLimit: number; timeoutMs: number }, requested?: number): number { + const base = typeof requested === 'number' && requested > 0 ? requested : effective.rowLimit; + return Math.max(1, Math.min(base, effective.maxRowLimit)); +} + +function protectedBanner(envProtected: boolean): string | undefined { + return envProtected ? '⚠️ 受保护环境（protected）：本查询作用于生产/受保护数据，请谨慎分享结果' : undefined; +} + +/** 统一处理器：返回 JSON 文本；抛错由 server 层转为 isError 内容 */ +export async function handleToolCall(name: string, args: Record): Promise { + const merged: MergedConfig = loadMergedConfig(); + + switch (name) { + case 'db_list_connections': { + const envKeys = Object.keys(merged.environments); + if (envKeys.length === 0) { + return { + status: 'no_config', + message: + '尚未配置任何数据库连接。可用 db_add_connection 添加（提供 environment、name、config、passwordEnvVar），或手工创建 db-connections.json。', + }; + } + return { + activeEnvironment: merged.activeEnvironment ?? null, + defaults: merged.defaults, + envSources: merged.envSources, + workspaceConfig: merged.workspaceFile ? merged.workspacePath : null, + userConfig: merged.userFile ? merged.userPath : null, + environments: Object.fromEntries( + Object.entries(merged.environments).map(([envName, env]) => [ + envName, + { + description: env.description ?? null, + protected: !!env.protected, + active: envName === merged.activeEnvironment, + connections: Object.entries(env.connections).map(([connName, conn]) => ({ + name: connName, + ...maskConnection(conn), + })), + }, + ]) + ), + }; + } + + case 'db_test_connection': { + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const { serverInfo, elapsedMs } = await testConnection(cfg, ref.effective.timeoutMs); + return { connection: `${ref.environment}/${ref.name}`, serverInfo, elapsedMs, warning: protectedBanner(ref.envProtected) }; + } + + case 'db_list_tables': { + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const outcome = await listTables(cfg, { timeoutMs: ref.effective.timeoutMs, limit: computeLimit(ref.effective) }); + return { + connection: `${ref.environment}/${ref.name}`, + tableCount: outcome.rows.length, + tables: jsonSafe(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected), + }; + } + + case 'db_describe_table': { + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const table = String(args.table ?? ''); + if (!table.trim()) throw new Error('table 参数不能为空'); + const detail = await describeTable(cfg, table, { timeoutMs: ref.effective.timeoutMs, limit: computeLimit(ref.effective) }); + return { + connection: `${ref.environment}/${ref.name}`, + table, + ...jsonSafe(detail) as object, + warning: protectedBanner(ref.envProtected), + }; + } + + case 'db_query': { + const sql = validateReadOnlySql(String(args.sql ?? '')); // 先校验，无需数据库即可拒绝 + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + if (ref.config.type === 'mongodb') { + throw new Error('MongoDB 连接请使用 db_find / db_aggregate，不支持 SQL'); + } + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const params = Array.isArray(args.params) ? args.params : []; + const limit = computeLimit(ref.effective, args.limit as number | undefined); + const outcome = await sqlQuery(ref.config.type, cfg, sql, params, { + timeoutMs: ref.effective.timeoutMs, + limit, + }); + return { + connection: `${ref.environment}/${ref.name}`, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + rowLimit: limit, + rows: jsonSafe(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected), + }; + } + + case 'db_find': { + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + if (ref.config.type !== 'mongodb') throw new Error('db_find 仅用于 MongoDB 连接；SQL 数据库请使用 db_query'); + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const collection = String(args.collection ?? ''); + if (!collection.trim()) throw new Error('collection 参数不能为空'); + const filter = (args.filter as Record) ?? {}; + validateMongoReadDocument(filter, 'filter'); + const projection = args.projection as Record | undefined; + if (projection) validateMongoReadDocument(projection, 'projection'); + const sort = args.sort as Record | undefined; + if (sort) validateMongoReadDocument(sort, 'sort'); + const limit = computeLimit(ref.effective, args.limit as number | undefined); + const outcome = await mongoFind(cfg, collection, filter, projection, sort, { + timeoutMs: ref.effective.timeoutMs, + limit, + }); + return { + connection: `${ref.environment}/${ref.name}`, + collection, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + documents: jsonSafe(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected), + }; + } + + case 'db_aggregate': { + const ref = resolveConnectionRef(merged, String(args.connection ?? '')); + if (ref.config.type !== 'mongodb') throw new Error('db_aggregate 仅用于 MongoDB 连接'); + const cfg = resolveEnvPlaceholders(ref.config, merged.env); + const collection = String(args.collection ?? ''); + if (!collection.trim()) throw new Error('collection 参数不能为空'); + const pipeline = args.pipeline; + validateMongoStages(pipeline); + const limit = computeLimit(ref.effective, args.limit as number | undefined); + const outcome = await mongoAggregate(cfg, collection, pipeline as unknown[], { + timeoutMs: ref.effective.timeoutMs, + limit, + }); + return { + connection: `${ref.environment}/${ref.name}`, + collection, + rowCount: outcome.rows.length, + truncated: outcome.truncated, + documents: jsonSafe(outcome.rows), + elapsedMs: outcome.elapsedMs, + warning: protectedBanner(ref.envProtected), + }; + } + + case 'db_add_connection': { + const envName = String(args.environment ?? ''); + const connName = String(args.name ?? ''); + validateIdentifier('环境名', envName); + validateIdentifier('连接名', connName); + const configArg = args.config; + if (!configArg || typeof configArg !== 'object') throw new Error('config 必须是对象'); + const { config, warnings } = sanitizeConnectionForWrite(configArg as Record, args.passwordEnvVar as string | undefined); + const scope = args.scope === 'user' ? 'user' : 'workspace'; + const { file } = persistAddConnection(scope, merged, envName, connName, config); + return { ok: true, connection: `${envName}/${connName}`, scope, file, warnings }; + } + + case 'db_remove_connection': { + const envName = String(args.environment ?? ''); + const connName = String(args.name ?? ''); + const { file } = persistRemoveConnection(merged, envName, connName); + return { ok: true, removed: `${envName}/${connName}`, file }; + } + + case 'db_set_active_environment': { + const envName = String(args.environment ?? ''); + const { file } = persistSetActiveEnvironment(merged, envName); + return { ok: true, activeEnvironment: envName, file }; + } + + default: + throw new Error(`未知工具：${name}`); + } +} diff --git a/external_plugins/db-connector/mcp/test/check-official-rules.py b/external_plugins/db-connector/mcp/test/check-official-rules.py new file mode 100644 index 00000000..cea5cf33 --- /dev/null +++ b/external_plugins/db-connector/mcp/test/check-official-rules.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +"""官方市场（zai-org/zcode-plugins）规则自检脚本。 + +按 scripts/validate.py 的公开规则逐项校验插件目录与 marketplace 条目， +供发版前本地自查（原版脚本位于官方仓库，网络受限时用本脚本等价校验）： + + python mcp/test/check-official-rules.py <插件目录> + +规则来源：zai-org/zcode-plugins scripts/validate.py（stdlib only） +""" +from __future__ import annotations + +import json +import re +import sys +from pathlib import Path + +KEBAB = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$") +SEMVER = re.compile(r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$") +LOCALE = re.compile(r"^[a-z]{2}(-[A-Za-z0-9]+)*$") +CATEGORIES = {"游戏/3D", "developer-tools", "productivity", "utilities", "guides", "finance", "template", "other"} +MAX_PLUGIN_FILES = 5000 +MAX_PLUGIN_BYTES = 256 * 1024 * 1024 + +errors: list[str] = [] + + +def err(msg: str) -> None: + errors.append(msg) + + +def validate_i18n(label: str, obj: dict, field: str) -> None: + value = obj.get(field) + if not isinstance(value, dict): + err(f"{label}: '{field}' 必须是对象") + return + for locale in ("en", "zh-CN"): + text = value.get(locale) + if not isinstance(text, str) or not text.strip(): + err(f"{label}: '{field}.{locale}' 必须是非空字符串") + for locale, text in value.items(): + if not isinstance(locale, str) or not LOCALE.match(locale): + err(f"{label}: '{field}' locale 键 '{locale}' 非法") + if not isinstance(text, str) or not text.strip(): + err(f"{label}: '{field}.{locale}' 必须是非空字符串") + + +def main() -> int: + if len(sys.argv) != 3: + print(__doc__) + return 2 + plugin_dir = Path(sys.argv[1]).resolve() + marketplace_path = Path(sys.argv[2]) + + # --- marketplace 条目规则 --- + entry = json.loads(marketplace_path.read_text(encoding="utf-8")) + name = entry.get("name") + if not name or not KEBAB.match(name): + err(f"entry: name '{name}' 必须是 kebab-case") + for field in ("source", "description", "version"): + if not entry.get(field): + err(f"entry: 缺少 '{field}'") + if entry.get("version") and not SEMVER.match(entry["version"]): + err(f"entry: version '{entry['version']}' 不是 semver") + category = entry.get("category") + if not category: + err("entry: 缺少 'category'") + elif category not in CATEGORIES: + err(f"entry: category '{category}' 不在允许集合内") + expected_source = f"./external_plugins/{name}" + if entry.get("source") != expected_source: + err(f"entry: source 必须是 {expected_source}") + validate_i18n("entry", entry, "description_i18n") + + # --- 插件目录规则 --- + if plugin_dir.name != name: + err(f"目录名 '{plugin_dir.name}' 与插件名 '{name}' 不一致") + if plugin_dir.is_symlink(): + err("插件目录是符号链接") + files = 0 + total = 0 + for path in sorted(plugin_dir.rglob("*")): + rel = path.relative_to(plugin_dir).as_posix() + if path.is_symlink(): + err(f"{rel} 是符号链接") + continue + if path.is_file(): + files += 1 + total += path.stat().st_size + if files > MAX_PLUGIN_FILES: + err(f"{files} 个文件超过上限 {MAX_PLUGIN_FILES}") + if total > MAX_PLUGIN_BYTES: + err(f"{total} 字节超过上限 {MAX_PLUGIN_BYTES}") + print(f"目录统计: {files} 文件, {total} 字节（上限 {MAX_PLUGIN_FILES} / {MAX_PLUGIN_BYTES}）") + + # --- plugin.json 与条目一致性 --- + manifest_path = plugin_dir / ".zcode-plugin" / "plugin.json" + if not manifest_path.is_file(): + manifest_path = plugin_dir / ".claude-plugin" / "plugin.json" + manifest = json.loads(manifest_path.read_text(encoding="utf-8")) + if manifest.get("name") != name: + err(f"plugin.json name '{manifest.get('name')}' 与条目不一致") + if manifest.get("version") != entry.get("version"): + err(f"plugin.json version '{manifest.get('version')}' 与条目 '{entry.get('version')}' 不一致") + if not manifest.get("description"): + err("plugin.json 缺少 description") + validate_i18n("plugin.json", manifest, "description_i18n") + if manifest.get("description_i18n") != entry.get("description_i18n"): + err("plugin.json description_i18n 与条目不一致") + + # --- 关键文件存在性 --- + for required in (".mcp.json", "README.md", "README_CN.md", "LICENSE", + "mcp/dist/db-connect-server.bundle.cjs", "skills/db-connector/SKILL.md"): + if not (plugin_dir / required).is_file(): + err(f"缺少关键文件 {required}") + + if errors: + print(f"FAIL: {len(errors)} 处问题") + for e in errors: + print(f" - {e}") + return 1 + print("OK: 官方规则自检全部通过") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/external_plugins/db-connector/mcp/test/real-mysql.mjs b/external_plugins/db-connector/mcp/test/real-mysql.mjs new file mode 100644 index 00000000..44179934 --- /dev/null +++ b/external_plugins/db-connector/mcp/test/real-mysql.mjs @@ -0,0 +1,226 @@ +/** + * 真实 MySQL 集成测试：对可用的 MySQL 实例走完整插件链路。 + * 凭证通过环境变量传入（脚本本身不含任何密码）： + * TEST_MYSQL_HOST / TEST_MYSQL_PORT / TEST_MYSQL_USER / TEST_MYSQL_PW + * 夹具库默认 db_connector_test（结束后删除），测试通过插件只读工具完成。 + * 运行（在 mcp/ 目录下，需先 npm run build）： + * TEST_MYSQL_HOST=... TEST_MYSQL_USER=root TEST_MYSQL_PW=... node test/real-mysql.mjs + */ +import { spawn } from 'node:child_process'; +import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import * as path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { createRequire } from 'node:module'; + +const mcpDir = path.dirname(path.dirname(fileURLToPath(import.meta.url))); +const require_ = createRequire(path.join(mcpDir, 'package.json')); +const mysql = require_('mysql2/promise'); + +const HOST = process.env.TEST_MYSQL_HOST; +const PORT = Number(process.env.TEST_MYSQL_PORT || 3306); +const USER = process.env.TEST_MYSQL_USER || 'root'; +const PW = process.env.TEST_MYSQL_PW; +const DB = process.env.TEST_MYSQL_DB || 'db_connector_test'; + +if (!HOST || PW === undefined) { + console.error('缺少 TEST_MYSQL_HOST / TEST_MYSQL_PW 环境变量'); + process.exit(2); +} +if (!/^db_connector_test/.test(DB)) { + console.error('夹具库名必须以 db_connector_test 开头（安全保护）'); + process.exit(2); +} + +const serverPath = path.join(mcpDir, 'dist', 'db-connect-server.js'); +const workspace = mkdtempSync(path.join(tmpdir(), 'dbconn-real-')); + +/* ---- 测试工作区：.env（密码） + db-connections.json（多环境 + 三层行数配置） ---- */ +writeFileSync(path.join(workspace, '.env'), `DB_TEST_PW=${PW}\n`); +writeFileSync( + path.join(workspace, 'db-connections.json'), + JSON.stringify( + { + configVersion: 1, + activeEnvironment: 'dev', + defaults: { rowLimit: 2, maxRowLimit: 5, timeoutMs: 8000 }, + environments: { + dev: { + description: '测试环境', + connections: { + 'mysql-test': { + type: 'mysql', host: HOST, port: PORT, user: USER, + password: '${DB_TEST_PW}', database: DB, + }, + }, + }, + 'prod-sim': { + protected: true, + connections: { + 'mysql-test': { + type: 'mysql', host: HOST, port: PORT, user: USER, + password: '${DB_TEST_PW}', database: DB, + }, + }, + }, + }, + }, + null, + 2 + ) +); + +/* ---- 夹具：直接用 mysql2 建库建表插数据（插件自身只读，不用于建夹具） ---- */ +async function setupFixture() { + const conn = await mysql.createConnection({ host: HOST, port: PORT, user: USER, password: PW, multipleStatements: false }); + await conn.query(`CREATE DATABASE IF NOT EXISTS \`${DB}\` CHARACTER SET utf8mb4`); + await conn.query(`CREATE TABLE IF NOT EXISTS \`${DB}\`.users ( + id INT AUTO_INCREMENT PRIMARY KEY, + name VARCHAR(100) NOT NULL, + email VARCHAR(100), + created_at DATETIME DEFAULT CURRENT_TIMESTAMP + )`); + await conn.query(`CREATE TABLE IF NOT EXISTS \`${DB}\`.orders ( + id INT AUTO_INCREMENT PRIMARY KEY, + user_id INT NOT NULL, + amount DECIMAL(10,2) + )`); + await conn.query(`DELETE FROM \`${DB}\`.users`); + await conn.query(`DELETE FROM \`${DB}\`.orders`); + const names = ['alice', 'bob', 'carol', "O'Brien", `x' OR '1'='1`]; + for (const n of names) { + await conn.query(`INSERT INTO \`${DB}\`.users (name, email) VALUES (?, ?)`, [n, `${n.replace(/[^a-zA-Z]/g, '') || 'u'}@test.local`]); + } + const [rows] = await conn.query(`SELECT id FROM \`${DB}\`.users WHERE name = ?`, ['alice']); + for (const amt of [9.9, 19.9, 29.9]) { + await conn.query(`INSERT INTO \`${DB}\`.orders (user_id, amount) VALUES (?, ?)`, [rows[0].id, amt]); + } + await conn.end(); +} + +async function teardownFixture() { + const conn = await mysql.createConnection({ host: HOST, port: PORT, user: USER, password: PW }); + await conn.query(`DROP DATABASE IF EXISTS \`${DB}\``); + await conn.end(); +} + +/* ---- MCP 服务器进程与 JSON-RPC 通道 ---- */ +const child = spawn(process.execPath, [serverPath], { cwd: workspace, stdio: ['pipe', 'pipe', 'pipe'] }); +child.stderr.on('data', (d) => process.stderr.write(`[server] ${d}`)); +let nextId = 1; +const pending = new Map(); +let buffer = ''; +child.stdout.on('data', (chunk) => { + buffer += chunk.toString('utf8'); + let idx; + while ((idx = buffer.indexOf('\n')) >= 0) { + const line = buffer.slice(0, idx).trim(); + buffer = buffer.slice(idx + 1); + if (!line) continue; + const msg = JSON.parse(line); + if (msg.id !== undefined && pending.has(msg.id)) { + pending.get(msg.id)(msg); + pending.delete(msg.id); + } + } +}); +function request(method, params) { + const id = nextId++; + return new Promise((resolve, reject) => { + pending.set(id, (msg) => (msg.error ? reject(new Error(JSON.stringify(msg.error))) : resolve(msg.result))); + child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n'); + }); +} +function notify(method) { + child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method }) + '\n'); +} +async function callTool(name, args) { + const result = await request('tools/call', { name, arguments: args }); + return { isError: result.isError, text: result.content?.[0]?.text ?? '' }; +} +async function callToolJson(name, args) { + const r = await callTool(name, args); + if (r.isError) throw new Error(`${name} 失败: ${r.text.slice(0, 200)}`); + return JSON.parse(r.text); +} + +let passed = 0, failed = 0; +function check(label, cond, detail = '') { + if (cond) { passed++; console.log(` PASS ${label}`); } + else { failed++; console.log(` FAIL ${label} ${detail}`); } +} + +try { + console.log(`目标：${HOST}:${PORT}/${DB}（夹具库，测后删除）\n`); + await setupFixture(); + + const init = await request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'real-test', version: '0' } }); + notify('notifications/initialized'); + check('initialize 握手', init.serverInfo?.name === 'db-connector'); + + // 1. 连接列表与 .env 来源 + const conns = await callToolJson('db_list_connections', {}); + check('列表含 dev 与 prod-sim 环境', !!conns.environments.dev && !!conns.environments['prod-sim']); + check('envSources 显示 .env', (conns.envSources ?? []).some((s) => s.endsWith('.env'))); + check('连接密码脱敏为 ${…}', conns.environments.dev.connections[0].password === '${…}'); + + // 2. 连通性 + const t = await callToolJson('db_test_connection', { connection: 'mysql-test' }); + check('连通性返回 MySQL 版本：' + t.serverInfo, /MySQL|MariaDB/i.test(t.serverInfo)); + + // 3. 表列表 + const tables = await callToolJson('db_list_tables', { connection: 'mysql-test' }); + const tableNames = tables.tables.map((x) => x.name).sort(); + check('表列表含 users 与 orders', tableNames.includes('orders') && tableNames.includes('users'), JSON.stringify(tableNames)); + + // 4. 表结构 + const desc = await callToolJson('db_describe_table', { connection: 'mysql-test', table: 'users' }); + const colNames = desc.columns.map((c) => c.name); + check('users 结构含 id/name/email', ['id', 'name', 'email'].every((c) => colNames.includes(c)), JSON.stringify(colNames)); + + // 5. 聚合 + 参数绑定 + const cnt = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT COUNT(*) AS c FROM users' }); + check('COUNT(*) = 5', cnt.rows[0].c === 5, JSON.stringify(cnt.rows)); + + const byName = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT name FROM users WHERE name = ?', params: ['alice'] }); + check("参数绑定：name=? ['alice'] 命中 1 行", byName.rowCount === 1 && byName.rows[0].name === 'alice'); + + const quote = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT name FROM users WHERE name = ?', params: ["O'Brien"] }); + check("参数绑定：单引号值 O'Brien 安全命中", quote.rowCount === 1 && quote.rows[0].name === "O'Brien"); + + const inj = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT name FROM users WHERE name = ?', params: [`x' OR '1'='1`] }); + check('注入载荷作为参数值仅精确匹配 1 行（非拼接）', inj.rowCount === 1, `实际 ${inj.rowCount} 行`); + + const agg = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT u.name, SUM(o.amount) AS total FROM users u JOIN orders o ON o.user_id = u.id GROUP BY u.name ORDER BY total DESC' }); + check('JOIN + GROUP BY 聚合正常', agg.rows.length === 1 && Number(agg.rows[0].total) === 59.7, JSON.stringify(agg.rows)); + + // 6. 三层行数配置：defaults.rowLimit=2 → maxRowLimit=5 + const l1 = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT id FROM users ORDER BY id' }); + check('未传 limit 时按 defaults.rowLimit=2 截断', l1.rowCount === 2 && l1.truncated === true); + const l2 = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT id FROM users ORDER BY id', limit: 4 }); + check('limit=4 生效（截断标记）', l2.rowCount === 4 && l2.truncated === true); + const l3 = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT id FROM users ORDER BY id', limit: 99 }); + check('limit=99 被 maxRowLimit=5 封顶', l3.rowCount === 5 && l3.truncated === false); + + // 7. 只读校验（真实服务器在场仍拒绝） + const upd = await callTool('db_query', { connection: 'mysql-test', sql: `UPDATE users SET name = 'hacked' WHERE id = 1` }); + check('UPDATE 被拒（未触达服务器）', upd.isError && upd.text.includes('只读校验拒绝')); + const del = await callTool('db_query', { connection: 'mysql-test', sql: `DELETE FROM users WHERE id = 1` }); + check('DELETE 被拒', del.isError && del.text.includes('只读校验拒绝')); + + // 8. protected 环境提示条 + const prod = await callToolJson('db_query', { connection: 'prod-sim/mysql-test', sql: 'SELECT COUNT(*) AS c FROM users' }); + check('protected 环境返回受保护提示', typeof prod.warning === 'string' && prod.warning.includes('受保护')); + + // 9. 只读不变式：全程跑完后夹具数据未被改动 + const after = await callToolJson('db_query', { connection: 'mysql-test', sql: 'SELECT COUNT(*) AS c FROM users' }); + check('测试全程数据零改动（仍为 5 行）', after.rows[0].c === 5); + + console.log(`\n结果：${passed} 通过，${failed} 失败`); +} finally { + child.stdin.end(); + await new Promise((r) => child.on('exit', r)); + try { await teardownFixture(); console.log('夹具库已清理'); } catch (e) { console.error('夹具清理失败（请手动删除）:', e.message); } + try { rmSync(workspace, { recursive: true, force: true }); } catch { /* 忽略 */ } +} +process.exit(failed > 0 ? 1 : 0); diff --git a/external_plugins/db-connector/mcp/test/smoke.mjs b/external_plugins/db-connector/mcp/test/smoke.mjs new file mode 100644 index 00000000..7ccfc0cb --- /dev/null +++ b/external_plugins/db-connector/mcp/test/smoke.mjs @@ -0,0 +1,192 @@ +/** + * 冒烟测试：spawn MCP 服务器，走完整 JSON-RPC 流程。 + * 无需真实数据库——SQL 校验在连接解析前执行，配置工具仅落盘。 + * 运行：node test/smoke.mjs（在 mcp/ 目录下，需先 npm run build） + */ +import { spawn } from 'node:child_process'; +import { mkdtempSync, readFileSync, writeFileSync, existsSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import * as path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { createRequire } from 'node:module'; + +const mcpDir = path.dirname(path.dirname(fileURLToPath(import.meta.url))); +const serverPath = path.join(mcpDir, 'dist', 'db-connect-server.js'); +const workspace = mkdtempSync(path.join(tmpdir(), 'dbconn-smoke-')); + +if (!existsSync(serverPath)) { + console.error('未找到 dist/db-connect-server.js，请先 npm run build'); + process.exit(1); +} + +// 预置系统环境变量 DB_SMOKE_PW：若服务器错误地读取 process.env，测试 10 将失败 +const child = spawn(process.execPath, [serverPath], { + cwd: workspace, + stdio: ['pipe', 'pipe', 'pipe'], + env: { ...process.env, DB_SMOKE_PW: 'from-process-env' }, +}); +child.stderr.on('data', (d) => process.stderr.write(`[server] ${d}`)); + +let nextId = 1; +const pending = new Map(); +let buffer = ''; +child.stdout.on('data', (chunk) => { + buffer += chunk.toString('utf8'); + let idx; + while ((idx = buffer.indexOf('\n')) >= 0) { + const line = buffer.slice(0, idx).trim(); + buffer = buffer.slice(idx + 1); + if (!line) continue; + const msg = JSON.parse(line); + if (msg.id !== undefined && pending.has(msg.id)) { + pending.get(msg.id)(msg); + pending.delete(msg.id); + } + } +}); + +function request(method, params) { + const id = nextId++; + return new Promise((resolve, reject) => { + pending.set(id, (msg) => (msg.error ? reject(new Error(JSON.stringify(msg.error))) : resolve(msg.result))); + child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n'); + }); +} +function notify(method, params) { + child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n'); +} +async function callTool(name, args) { + const result = await request('tools/call', { name, arguments: args }); + return { isError: result.isError, text: result.content?.[0]?.text ?? '' }; +} + +let passed = 0, failed = 0; +function check(label, cond, detail = '') { + if (cond) { passed++; console.log(` PASS ${label}`); } + else { failed++; console.log(` FAIL ${label} ${detail}`); } +} + +try { + console.log(`工作区：${workspace}\n`); + + // 1. 握手 + const init = await request('initialize', { + protocolVersion: '2024-11-05', + capabilities: {}, + clientInfo: { name: 'smoke', version: '0.0.0' }, + }); + check('initialize 返回 serverInfo', init.serverInfo?.name === 'db-connector'); + notify('notifications/initialized'); + + // 2. 工具列表 + const list = await request('tools/list', {}); + const names = (list.tools ?? []).map((t) => t.name); + check(`tools/list 返回 10 个工具（实际 ${names.length}）`, names.length === 10); + check('工具定义完整', list.tools.every((t) => t.description && t.inputSchema)); + + // 3. 无配置引导 + const noCfg = await callTool('db_list_connections', {}); + check('无配置时返回 no_config 引导', !noCfg.isError && noCfg.text.includes('no_config')); + + // 4. 只读校验（无需数据库） + const badCases = [ + ['DROP', { connection: 'x', sql: 'DROP TABLE users' }], + ['UPDATE', { connection: 'x', sql: 'UPDATE users SET name = 1' }], + ['多语句', { connection: 'x', sql: 'SELECT 1; DROP TABLE users' }], + ['注释藏关键词', { connection: 'x', sql: 'SELECT 1 /* DROP TABLE users */ AS x' }], + ['CTE 藏写入', { connection: 'x', sql: 'WITH t AS (DELETE FROM users RETURNING *) SELECT * FROM t' }], + ['FOR UPDATE', { connection: 'x', sql: 'SELECT * FROM users FOR UPDATE' }], + ['危险函数 pg_sleep', { connection: 'x', sql: 'SELECT pg_sleep(10)' }], + ['危险函数 load_file', { connection: 'x', sql: "SELECT load_file('/etc/passwd')" }], + ['INTO OUTFILE', { connection: 'x', sql: "SELECT * FROM users INTO OUTFILE '/tmp/x'" }], + ]; + for (const [label, args] of badCases) { + const r = await callTool('db_query', args); + check(`拒绝：${label}`, r.isError && r.text.includes('只读校验拒绝'), r.text.slice(0, 120)); + } + + // 5. 合法 SQL + 不存在的连接 → 错误应是"连接不存在"而非校验拒绝（证明校验先行通过） + const noConn = await callTool('db_query', { connection: 'ghost', sql: 'SELECT 1 AS x' }); + check('合法 SQL 优先通过校验（报连接/环境错误）', noConn.isError && !noConn.text.includes('只读校验拒绝'), noConn.text.slice(0, 120)); + + // 6. 配置工具：拒绝明文密码 + const plain = await callTool('db_add_connection', { + environment: 'dev', name: 'mysql-main', + config: { type: 'mysql', host: 'localhost', port: 3306, user: 'root', password: 'plain-secret', database: 'shop' }, + }); + check('db_add_connection 拒绝明文密码', plain.isError && plain.text.includes('明文密码'), plain.text.slice(0, 120)); + + // 7. 配置工具：合法写入（passwordEnvVar） + const add = await callTool('db_add_connection', { + environment: 'dev', name: 'mysql-main', + config: { type: 'mysql', host: 'localhost', port: 3306, user: 'root', database: 'shop' }, + passwordEnvVar: 'DB_SMOKE_PW', + }); + check('db_add_connection 写入成功', !add.isError && add.text.includes('"ok": true'), add.text.slice(0, 160)); + + const wsFile = path.join(workspace, 'db-connections.json'); + const raw = existsSync(wsFile) ? readFileSync(wsFile, 'utf8') : ''; + check('配置文件落盘且密码为 ${VAR} 引用', raw.includes('${DB_SMOKE_PW}') && !raw.includes('plain-secret')); + check('配置为多环境结构', raw.includes('"environments"') && raw.includes('"dev"')); + + // 8. 列表可见 + 活动环境 + const lst = await callTool('db_list_connections', {}); + check('db_list_connections 显示新连接', !lst.isError && lst.text.includes('mysql-main')); + const act = await callTool('db_set_active_environment', { environment: 'dev' }); + check('db_set_active_environment 成功', !act.isError && act.text.includes('"ok": true')); + + // 9. 合法 SQL + 已存在连接 → 应到达驱动层（连接失败即可，证明校验与解析已通过） + const drive = await callTool('db_query', { connection: 'mysql-main', sql: 'SELECT 1 AS x' }); + check( + '查询到达驱动层（连接级错误，非校验错误）', + drive.isError && !drive.text.includes('只读校验拒绝') && !drive.text.includes('不存在'), + drive.text.slice(0, 160) + ); + + // 10. 系统环境变量不参与解析：进程 env 里有 DB_SMOKE_PW 仍应报缺失并点名 + const missEnv = await callTool('db_test_connection', { connection: 'mysql-main' }); + check('系统环境变量不参与解析（.env 未定义时报缺失并点名 DB_SMOKE_PW）', missEnv.isError && missEnv.text.includes('DB_SMOKE_PW'), missEnv.text.slice(0, 160)); + + // 10b. .env 支持：写入工作区 .env 后变量可用（错误应推进到连接层而非变量缺失） + writeFileSync(path.join(workspace, '.env'), '# 冒烟测试\nexport DB_SMOKE_PW="secret-value" # 行内注释\n'); + const withEnv = await callTool('db_test_connection', { connection: 'mysql-main' }); + check('.env 提供变量后不再报环境变量缺失', withEnv.isError && !withEnv.text.includes('环境变量未定义'), withEnv.text.slice(0, 160)); + const lstEnv = await callTool('db_list_connections', {}); + check('db_list_connections 显示 .env 来源', !lstEnv.isError && lstEnv.text.includes('.env')); + + // 11. 删除连接 + const rm = await callTool('db_remove_connection', { environment: 'dev', name: 'mysql-main' }); + check('db_remove_connection 成功', !rm.isError && rm.text.includes('"ok": true'), rm.text.slice(0, 120)); + + // 12. .env 解析器单元测试（直接测 dist/config.js） + const require_ = createRequire(import.meta.url); + const { parseEnvFile } = require_(path.join(mcpDir, 'dist', 'config.js')); + const parsed = parseEnvFile( + [ + '# 全行注释', + '', + 'export A=1', + 'B="quoted # not comment"', + "C='single'", + 'D=bare # 行内注释', + 'invalid-key=x', + 'E=', + ].join('\n') + ); + check( + '.env 解析器：注释/引号/行内注释/export/非法键', + parsed.A === '1' && + parsed.B === 'quoted # not comment' && + parsed.C === 'single' && + parsed.D === 'bare' && + parsed['invalid-key'] === undefined && + parsed.E === '' + ); + + console.log(`\n结果：${passed} 通过，${failed} 失败`); +} finally { + child.stdin.end(); + await new Promise((r) => child.on('exit', r)); + try { rmSync(workspace, { recursive: true, force: true }); } catch { /* Windows 临时目录清理失败忽略 */ } +} +process.exit(failed > 0 ? 1 : 0); diff --git a/external_plugins/db-connector/mcp/tsconfig.json b/external_plugins/db-connector/mcp/tsconfig.json new file mode 100644 index 00000000..3e065973 --- /dev/null +++ b/external_plugins/db-connector/mcp/tsconfig.json @@ -0,0 +1,17 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "CommonJS", + "moduleResolution": "Node", + "lib": ["ES2022"], + "outDir": "dist", + "rootDir": "src", + "strict": true, + "esModuleInterop": true, + "forceConsistentCasingInFileNames": true, + "skipLibCheck": true, + "sourceMap": false, + "declaration": false + }, + "include": ["src/**/*.ts"] +} diff --git a/external_plugins/db-connector/skills/db-connector/SKILL.md b/external_plugins/db-connector/skills/db-connector/SKILL.md new file mode 100644 index 00000000..226997e9 --- /dev/null +++ b/external_plugins/db-connector/skills/db-connector/SKILL.md @@ -0,0 +1,55 @@ +--- +name: db-connector +description: 只读连接 MySQL/PostgreSQL/MongoDB 数据库：查询数据、浏览表结构、多环境连接配置管理。当用户提到查数据、看表结构/字段/索引、连接数据库、配置数据库连接、对比 dev/prod 数据、统计/分析库中数据时使用。 +--- + +# db-connector 数据库只读访问 + +通过 MCP 工具安全访问用户的数据库（MySQL/MariaDB、PostgreSQL、MongoDB），**严格只读**，支持多环境（dev/test/prod…）多连接配置。 + +## 工具总览 + +**配置管理**：`db_list_connections` / `db_add_connection` / `db_remove_connection` / `db_set_active_environment` +**查询浏览**：`db_test_connection` / `db_list_tables` / `db_describe_table` / `db_query` / `db_find` / `db_aggregate` + +## 标准查询流程 + +1. `db_list_connections` —— 确认连接名与环境（返回 `status: "no_config"` 时走下方首次配置流程） +2. 跨环境查询用限定名 `"环境名/连接名"`（如 `prod/mysql-main`）；同环境可用裸连接名 +3. 不熟悉结构先 `db_list_tables` → `db_describe_table`，再写查询 +4. SQL 数据库用 `db_query`；MongoDB 用 `db_find` / `db_aggregate` + +## 硬性安全规范 + +- **值必须走 `params` 参数绑定**：MySQL 用 `?`，PostgreSQL 用 `$1`，禁止把值拼进 SQL 文本 +- 只读白名单外的一切语句（UPDATE/DELETE/DROP/INSERT/注释中藏关键词/多语句/锁定子句）都会被服务器拒绝——不要尝试绕过 +- 大结果集主动传较小的 `limit`（如 50），默认上限受 `maxRowLimit` 封顶 +- `protected: true` 环境（通常是生产）的查询结果必须向用户明示来源环境 +- 建议用户为每个环境配置只读数据库账号 + +## 首次配置流程（会话式配置） + +无配置时引导用户提供：环境名（如 dev）、连接名（如 mysql-main）、数据库类型、地址/端口/库名，以及**存放密码的环境变量名**。然后： + +``` +db_add_connection( + environment="dev", name="mysql-main", + config={type:"mysql", host:"localhost", port:3306, user:"root", database:"shop"}, + passwordEnvVar="DB_DEV_PW" # 密码只接受环境变量名，写入为 ${DB_DEV_PW} +) +→ db_test_connection(connection="dev/mysql-main") 验证 +``` + +密码明文会被拒绝——先让用户把密码写入 `.env` 文件（工作区 `.env` 或 `~/.zcode/db-connector/.env`，保存即生效无需重启；系统环境变量不参与解析），再传入变量名。`db_list_connections` 返回的 `envSources` 会显示当前生效的 `.env` 文件。 + +## 配置文件（高级用法/直接编辑） + +- 工作区：`/db-connections.json`（项目相关，可提交 git） +- 用户级：`~/.zcode/db-connector/connections.json`（跨项目） +- 两文件按"环境名+连接名"合并，工作区优先；`activeEnvironment` 决定裸连接名解析到哪个环境 +- 行数/超时三层可配置：`defaults.rowLimit`（缺省 200）→ 连接级 `rowLimit` → 查询参数 `limit`，生效值受 `maxRowLimit`（缺省 1000）封顶 + +## 错误处理 + +- 连接失败/环境变量缺失：向用户**复述缺失项**（哪个变量、哪个地址），不要盲目重试 +- 工具返回 `isError: true` 时读失败原因，属于校验拒绝的改写查询，属于配置问题的引导用户修正 diff --git a/marketplace.json b/marketplace.json index c7f09a06..908f71fd 100644 --- a/marketplace.json +++ b/marketplace.json @@ -1443,6 +1443,28 @@ "mcp", "verification" ] + }, + { + "name": "db-connector", + "source": "./external_plugins/db-connector", + "description": "Read-only access to MySQL/PostgreSQL/MongoDB: multi-environment connections, parameter-bound safe queries and schema browsing", + "description_i18n": { + "en": "Read-only access to MySQL/PostgreSQL/MongoDB: multi-environment connections, parameter-bound safe queries and schema browsing", + "zh-CN": "只读连接 MySQL/PostgreSQL/MongoDB：多环境多连接配置、参数绑定安全查询与结构浏览" + }, + "version": "0.1.2", + "author": { + "name": "mojianjjun" + }, + "category": "developer-tools", + "keywords": [ + "database", + "mysql", + "postgresql", + "mongodb", + "readonly", + "mcp" + ] } ] } \ No newline at end of file