diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..09e2252 Binary files /dev/null and b/.DS_Store differ diff --git a/cc_mcp_config.json b/cc_mcp_config.json new file mode 100644 index 0000000..2ffb747 --- /dev/null +++ b/cc_mcp_config.json @@ -0,0 +1,87 @@ +{ + "mcpServers": { + "exa-mcp-server": { + "command": "node", + "args": [ + "/Users/b.c.nims/glassBead-MASTER/Exa/market-insights/exa-mcp-server/.smithery/index.cjs" + ], + "env": { + "EXA_API_KEY": "04d84ad6-726b-450d-9274-4050b08ab052" + }, + "autoApprove": [ + "web_search_exa", + "deep_researcher_start", + "deep_researcher_check", + "linkedin_search_exa", + "crawling_exa", + "company_research_exa" + ] + }, + "firecrawl-mcp-server": { + "command": "node", + "args": [ + "/Users/b.c.nims/glassBead-MASTER/Exa/market-insights/firecrawl-mcp-server/dist/index.js" + ], + "env": { + "FIRECRAWL_API_KEY": "fc-dc828ca1c1af4897adcb3f3c42ff01d9" + }, + "autoApprove": [ + "firecrawl_search", + "firecrawl_scrape", + "firecrawl_map", + "firecrawl_crawl", + "firecrawl_check_crawl_status", + "firecrawl_deep_research", + "firecrawl_generate_llmstxt" + ] + }, + "context7-mcp": { + "command": "npx", + "args": [ + "-y", + "@smithery/cli@latest", + "run", + "@upstash/context7-mcp", + "--key", + "fe556de3-a658-4330-a3e7-563cf6a91972" + ], + "autoApprove": [ + "resolve-library-id", + "get-library-docs" + ] + }, + "smart-e2b": { + "command": "npx", + "args": [ + "-y", + "@smithery/cli@latest", + "run", + "@Leghis/smart-e2b", + "--key", + "fe556de3-a658-4330-a3e7-563cf6a91972", + "--profile", + "operational-bedbug-smw1eB" + ], + "autoApprove": [ + "executeJavaScript", + "executePython", + "uploadFile", + "listFiles", + "readFile" + ] + }, + "mem0-mcp": { + "command": "npx", + "args": [ + "-y", + "@smithery/cli@latest", + "run", + "@big-omega/mem0-mcp", + "--key", + "fe556de3-a658-4330-a3e7-563cf6a91972", + "--profile", + "operational-bedbug-smw1eB" + ] + } + } +} \ No newline at end of file diff --git a/metagames-script.md b/metagames-script.md new file mode 100644 index 0000000..da868a2 --- /dev/null +++ b/metagames-script.md @@ -0,0 +1,124 @@ +## Metagames + +### Intro + +Are you tired of Cursor turning your codebase into a can of hot dog water? Does the phrase "you're absolutely right" give you Vietnam flashbacks even though you were born after 9/11? After working with Claude Code, does p(doom) feel like an expression of hope? + +Well, put down that emotional support copy of "That Alien Message," I've got a good one for you today. Today we're going to learn about using metagames to turn open-ended problems into closed-loop processes, so Claude can tell you it sees the issue now a little less often. I'm glassBead, and this is Design Patterns in MCP. Let's get it. + + +### What are metagames? + +What are metagames? In short, metagames are processes that help AI agents execute complex, open-ended tasks like debugging and feature implementations. They help agents reduce the complexity of these problem spaces. + +I wrote the first metagame about three months ago after trying and failing many, many times to prevent Claude Code from rabbit-holing during the debugging process. Whenever Claude Code would make a change to the code that resulted in TypeScript errors, it would almost always get lost trying to fix the type errors it created instead of stepping back and trying something else. Until finally, I came up with a workflow I called Ulysses Protocol that solved the issue. Let's walk through it together to illustrate what I'm talking about. + + +### Ulysses Protocol walkthrough + +Consider a scenario where we're about to begin a debugging process for some error. Let's call the first position, the one before we've done any work, State Step 0. + + +State Step 0 + + - Make a plan for State Step 1 and State Step 2 + - Set an expectation for each State Step's outcomes + - if State Step 1 goes how we expect, the codebase state we would expect is...[] + - if State Step 1 does not go how we expect, and we move to Step 2, the codebase state we would expect is...[] + + +State Step 1 + + - Put SS1 plan into action --> + - Evaluate our outcome + - if State Step 1 outcome == expectation --> SS1 = SS0 + - if State Step 1 outcome != expectation --> SS2 + + +State Step 2 + + - Put SS2 plan into action --> + - Evaluate our outcome + - if SS2 outcome == expectation --> SS2 = SS0 + - if SS2 outcome != expectation --> PAUSE -> ORIGINAL SS0 + + +PAUSE + + - CONSIDERATION (reasoning about why our outcomes did not match expectation) + - theorize about why previous turn of 2 steps was not successful + - add an entry to state documenting the 2 steps that did not work + - make a new plan for State Step 1 and State Step 2 + - Set an expectation for each State Step's outcomes + - if State Step 1 goes how we expect, the codebase state we would expect is...[] + - if State Step 1 does not go how we expect, and we move to Step 2, the codebase state we would expect is...[] + + +CHECKPOINTS + + - are spots in the stepwise Ulysses workflow that human user/agent infer are good places to come back to if failure happens later in the workflow. + - example: after a full subtask is completed, after a stubborn bug is overcome, etc. + - these are stored in JSON state object + - agent/user can come back to these points at any time if a PAUSE is reached + +If Claude Code or Roo Code hold to this pattern, they will almost always eventually arrive at a non-failure outcome. This is because there is a finite number of possible causes for a given error in a codebase. The number of things that could be going wrong is limited. Unless the agent experiences an unrelated error at runtime, the agent *will* avoid the usual failure modes and end up at an outcome that is not failure. It will either succeed, or it will figure out that the information it needs isn't in the codebase. + + +### Anatomy of a Metagame + +Now that we've walked through a metagame, let's briefly look at the template that describes how to put a new one together. I won't spend too much time here since you can access this yourself on GitHub through the link in the description, but every metagame proceeds this way: + + - Phase 0: Initialize + - Phase 1: Discovery/Analysis + - Phase 2: Strategy/Planning + - Phase 3: Execution Loop + - Phase 4: Validation + Reporting + +There are one or more "gates" between each of the phases. You can think of these gates as the "definitions of done" for each metagame phase. + +### Metagames in Action + +Alright, we're done reviewing metagames: let's see them in action. We'll need a task to apply them to, and this project will do as well as any. In this project, I have a few MCP servers: this is the first set of sequentialthinking forks i made this past winter, and they later formed the basis for my Clear Thought server. + +[link in description: plug bit] + +(Proton) +I have an email here from Smithery that says these servers need to migrate to SHTTP by September 7th. Streamable HTTP was not a supported protocol when I made these servers in Feburary, but here in September it's become the standard, so I need to update the servers to use sHTTP transport. This is a great use for a metagame called refactoring-game. We'll be able to see everything we've talked about today in action. I also already have a spec here in the specs/ folder describing what we're going to implement. + +I think that many MCP servers would benefit from serving metagames, but metagames don't require the agent using them to support MCP at all. Because they are usually best expressed as simple descriptive markdown versus deterministic code, we can provide metagames to Claude Code as slash commands, or as workflows in Cursor, Warp, etc. + +----------------------------- +#### Arguments + +- `codebase_path` (required): Path to the codebase to refactor +- `ship_deadline` (optional): ISO 8601 deadline (default: 4 hours from now) +- `budget` (optional): Energy units for refactoring (default: 100) +- `max_iterations` (optional): Maximum refactoring rounds (default: 5) +- `confidence_threshold` (optional): Quality threshold 0-1 (default: 0.8) +- `comments` (optional): developer comments on the task +``` +------------------- + + +I'm going to use Claude Code. At .claude/commands/games/refactoring-game.md, we have our metagame. We're going to pass arguments for codebase_path, confidence_threshold which we will set to 0.97, and some developer comments that contain our spec so the agent knows what to do. Then we're going to sit back, relax, and watch the agent play the game. + +we'll run... + +```bash +claude --mcp-config cc_mcp_config.json +``` + +then, because I'm on Claude Code, I'm going to use a slash to pull up all of my slash commands. If I type in "games:ref", I'll get my refactoring game. Ignore the other two, sorry. So I'll have some quotes and include a reference to the server we're refactoring first, then setting confidence threshold to 0.97, and finally I will tell Claude: + +```bash +/games:refactoring-game " @src/analogical-reasoning/ " confidence_threshold=0.97 "the spec for what you'll be implementing is located at @specs/mcp-http-migration.md. I want to make a clarification about, and addition to, your toolkit. Starting with clarity, you are equipped with three retrieval MCP servers right now: Exa, Firecrawl, and context7. Their purposes are as follows. Use context7 when you need technical documentation (the Smithery docs, for instance). Use Firecrawl when you know a specific URL that you want to visit. Use Exa in all other cases where you would be performing retrieval. As for the addition, you have E2B configured via MCP, so you can use sandbox environments to test Python and JS/TS code before writing it into our project code." +``` + + +### Metagames MCP server + +This has been a brief overview of metagames, why they're useful, and when to use them. Before we wrap up, I've released a Metagames MCP server on Smithery that serves these games to any MCP client application. At the time of filming this video, I haven't included any notebooks yet, which are key for making the games that steal directly from operations research work for us. That'll be where we pick up in the next Design Patterns in MCP video. + +Thanks for watching: the Metagames MCP server code is linked in the description. If you liked the video, or you think you can get some use from metagames later down the line, hit the like and subscribe buttons, and follow me on X at @glassBeadDeux. + +Thanks everyone! See you next time. \ No newline at end of file diff --git a/package.json b/package.json index c1059e5..77d86ab 100644 --- a/package.json +++ b/package.json @@ -9,35 +9,14 @@ "type": "git", "url": "https://github.com/waldzellai/model-enhancement-servers.git" }, - "workspaces": [ - "src/*" - ], "files": [], - "scripts": { - "build": "npm run build --workspaces", - "watch": "npm run watch --workspaces", - "publish-all": "npm publish --workspaces --access public", - "link-all": "npm link --workspaces" - }, + "scripts": {}, "dependencies": { "@modelcontextprotocol/sdk": "^1.10.2", - "chalk": "^5.3.0", - "ioredis": "^5.4.1", - "uuid": "^9.0.1", - "yargs": "^17.7.2", - "@waldzellai/analogical-reasoning": "*", - "@waldzellai/collaborative-reasoning": "*", - "@waldzellai/decision-framework": "*", - "@waldzellai/metacognitive-monitoring": "*", - "@waldzellai/scientific-method": "*", - "@waldzellai/structured-argumentation": "*", - "@waldzellai/visual-reasoning": "*" + "chalk": "^5.3.0" }, "devDependencies": { "@types/node": "^22", - "@types/uuid": "^9.0.8", - "@types/yargs": "^17.0.32", - "shx": "^0.3.4", "typescript": "^5.3.3" } } \ No newline at end of file diff --git a/specs/mcp-http-migration.md b/specs/mcp-http-migration.md new file mode 100644 index 0000000..766bb55 --- /dev/null +++ b/specs/mcp-http-migration.md @@ -0,0 +1,164 @@ +# MCP Server HTTP Transport Migration Plan + +## Executive Summary + +This migration plan follows the Smithery Migration Guide for converting MCP servers from STDIO transport to HTTP transport using the TypeScript with Smithery CLI approach (recommended path). + +## Current State + +7 MCP servers currently using STDIO transport: +- analogical-reasoning +- collaborative-reasoning +- decision-framework +- metacognitive-monitoring +- scientific-method +- structured-argumentation +- visual-reasoning + +## Migration Approach: TypeScript with Smithery CLI + +### Why This Approach +- **RECOMMENDED** by Smithery Migration Guide +- Simplest migration path with built-in development tools +- Automatic containerization and deployment +- Minimal configuration required +- GitHub auto-deploy integration + +### Prerequisites +- Node.js 18+ installed +- GitHub repository for deployment +- Existing TypeScript MCP servers with STDIO transport + +## Required Changes Per Server + +### 1. Transform Main Entry Point + +**Current Structure** (e.g., `src/analogical-reasoning/index.ts`): +```typescript +const server = new Server(...); +const transport = new StdioServerTransport(); +await server.connect(transport); +``` + +**New Structure** - Export createServer function: +```typescript +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; + +export default function createServer({ config }) { + const server = new McpServer({ + name: "server-name", + version: "0.1.0", + }); + + // Register tools here + server.registerTool(...); + + return server.server; +} +``` + +### 2. Update package.json + +Add Smithery CLI scripts and module field: +```json +{ + "module": "./src/index.ts", + "scripts": { + "build": "npx @smithery/cli build", + "dev": "npx @smithery/cli dev" + } +} +``` + +### 3. Update smithery.yaml + +Replace entire file with TypeScript runtime: +```yaml +runtime: "typescript" +``` + +## Project Structure After Migration + +``` +my-mcp-server/ +├── src/ +│ └── index.ts # Exports createServer function +├── package.json # Updated with Smithery CLI config +├── smithery.yaml # runtime: typescript +├── tsconfig.json +└── README.md +``` + +## Migration Steps + +### Phase 1: Infrastructure Setup +- [ ] Install Smithery CLI dependencies +- [ ] Create migration template based on Smithery tools +- [ ] Set up test environment + +### Phase 2: Server Migrations + +For each server: +1. Use `mcp__smithery-ai-migration-guide-mcp__create_migration_template` to generate template +2. Refactor existing tool handlers to fit new structure +3. Update package.json with required scripts +4. Generate new smithery.yaml with `mcp__smithery-ai-migration-guide-mcp__generate_smithery_yaml` +5. Validate with `mcp__smithery-ai-migration-guide-mcp__validate_package_json` +6. Test locally with `npm run dev` (interactive playground) + +### Phase 3: Deployment +1. Push changes to GitHub repository +2. Wait for auto-deploy or manually trigger from Smithery dashboard +3. Verify deployment status +4. Test deployed endpoints + +## Key Differences from STDIO + +1. **No Dockerfile needed** - Smithery CLI handles containerization +2. **Session-based configuration** - Config passed to createServer +3. **HTTP transport** - Automatic handling by Smithery +4. **Interactive dev server** - Built-in testing playground + +## Testing Strategy + +### Local Testing +- Use `npm run dev` for interactive testing +- Smithery CLI provides automatic playground + +### Integration Testing +- Test with actual MCP clients +- Verify tool registration and execution +- Validate configuration schema + +## Important Notes + +From Smithery Migration Guide: +- The 'module' field in package.json MUST point to the file that exports createServer +- Include lock files (yarn.lock/pnpm-lock.yaml) if using yarn/pnpm +- No backward compatibility needed unless supporting legacy STDIO clients +- Configuration is session-based, not environment-based + +## Validation Tools Available + +The Smithery Migration Guide MCP server provides: +- `get_migration_overview` - Overview and requirements +- `create_migration_template` - Generate server code template +- `generate_smithery_yaml` - Create configuration file +- `validate_package_json` - Ensure correct setup +- `validate_smithery_yaml` - Validate configuration + +## Success Criteria + +1. All servers successfully export createServer function +2. Local testing passes with `npm run dev` +3. Successful deployment to Smithery +4. Clients can connect via HTTP transport +5. All tools function correctly + +## Next Steps + +1. Start with pilot server (e.g., analogical-reasoning) +2. Use Smithery Migration Guide tools to generate templates +3. Test locally with Smithery CLI dev server +4. Deploy to GitHub and verify auto-deployment +5. Iterate based on learnings from pilot \ No newline at end of file diff --git a/src/analogical-reasoning/.smithery/index.cjs b/src/analogical-reasoning/.smithery/index.cjs new file mode 100644 index 0000000..5207f91 --- /dev/null +++ b/src/analogical-reasoning/.smithery/index.cjs @@ -0,0 +1,84223 @@ +"use strict"; +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// node_modules/zod/v3/helpers/util.js +var util, objectUtil, ZodParsedType, getParsedType; +var init_util = __esm({ + "node_modules/zod/v3/helpers/util.js"() { + (function(util3) { + util3.assertEqual = (_) => { + }; + function assertIs(_arg) { + } + util3.assertIs = assertIs; + function assertNever(_x) { + throw new Error(); + } + util3.assertNever = assertNever; + util3.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util3.getValidEnumValues = (obj) => { + const validKeys = util3.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number"); + const filtered = {}; + for (const k of validKeys) { + filtered[k] = obj[k]; + } + return util3.objectValues(filtered); + }; + util3.objectValues = (obj) => { + return util3.objectKeys(obj).map(function(e) { + return obj[e]; + }); + }; + util3.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => { + const keys = []; + for (const key in object) { + if (Object.prototype.hasOwnProperty.call(object, key)) { + keys.push(key); + } + } + return keys; + }; + util3.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return void 0; + }; + util3.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val; + function joinValues(array, separator = " | ") { + return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator); + } + util3.joinValues = joinValues; + util3.jsonStringifyReplacer = (_, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; + })(util || (util = {})); + (function(objectUtil3) { + objectUtil3.mergeShapes = (first, second) => { + return { + ...first, + ...second + // second overwrites first + }; + }; + })(objectUtil || (objectUtil = {})); + ZodParsedType = util.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" + ]); + getParsedType = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return ZodParsedType.undefined; + case "string": + return ZodParsedType.string; + case "number": + return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number; + case "boolean": + return ZodParsedType.boolean; + case "function": + return ZodParsedType.function; + case "bigint": + return ZodParsedType.bigint; + case "symbol": + return ZodParsedType.symbol; + case "object": + if (Array.isArray(data)) { + return ZodParsedType.array; + } + if (data === null) { + return ZodParsedType.null; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return ZodParsedType.promise; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return ZodParsedType.map; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return ZodParsedType.set; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return ZodParsedType.date; + } + return ZodParsedType.object; + default: + return ZodParsedType.unknown; + } + }; + } +}); + +// node_modules/zod/v3/ZodError.js +var ZodIssueCode, quotelessJson, ZodError; +var init_ZodError = __esm({ + "node_modules/zod/v3/ZodError.js"() { + init_util(); + ZodIssueCode = util.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite" + ]); + quotelessJson = (obj) => { + const json = JSON.stringify(obj, null, 2); + return json.replace(/"([^"]+)":/g, "$1:"); + }; + ZodError = class _ZodError2 extends Error { + get errors() { + return this.issues; + } + constructor(issues) { + super(); + this.issues = []; + this.addIssue = (sub) => { + this.issues = [...this.issues, sub]; + }; + this.addIssues = (subs = []) => { + this.issues = [...this.issues, ...subs]; + }; + const actualProto = new.target.prototype; + if (Object.setPrototypeOf) { + Object.setPrototypeOf(this, actualProto); + } else { + this.__proto__ = actualProto; + } + this.name = "ZodError"; + this.issues = issues; + } + format(_mapper) { + const mapper = _mapper || function(issue) { + return issue.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error) => { + for (const issue of error.issues) { + if (issue.code === "invalid_union") { + issue.unionErrors.map(processError); + } else if (issue.code === "invalid_return_type") { + processError(issue.returnTypeError); + } else if (issue.code === "invalid_arguments") { + processError(issue.argumentsError); + } else if (issue.path.length === 0) { + fieldErrors._errors.push(mapper(issue)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < issue.path.length) { + const el = issue.path[i]; + const terminal = i === issue.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(this); + return fieldErrors; + } + static assert(value) { + if (!(value instanceof _ZodError2)) { + throw new Error(`Not a ZodError: ${value}`); + } + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(mapper = (issue) => issue.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of this.issues) { + if (sub.path.length > 0) { + const firstEl = sub.path[0]; + fieldErrors[firstEl] = fieldErrors[firstEl] || []; + fieldErrors[firstEl].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; + } + get formErrors() { + return this.flatten(); + } + }; + ZodError.create = (issues) => { + const error = new ZodError(issues); + return error; + }; + } +}); + +// node_modules/zod/v3/locales/en.js +var errorMap, en_default; +var init_en = __esm({ + "node_modules/zod/v3/locales/en.js"() { + init_ZodError(); + init_util(); + errorMap = (issue, _ctx) => { + let message; + switch (issue.code) { + case ZodIssueCode.invalid_type: + if (issue.received === ZodParsedType.undefined) { + message = "Required"; + } else { + message = `Expected ${issue.expected}, received ${issue.received}`; + } + break; + case ZodIssueCode.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`; + break; + case ZodIssueCode.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`; + break; + case ZodIssueCode.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`; + break; + case ZodIssueCode.invalid_enum_value: + message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`; + break; + case ZodIssueCode.invalid_arguments: + message = `Invalid function arguments`; + break; + case ZodIssueCode.invalid_return_type: + message = `Invalid function return type`; + break; + case ZodIssueCode.invalid_date: + message = `Invalid date`; + break; + case ZodIssueCode.invalid_string: + if (typeof issue.validation === "object") { + if ("includes" in issue.validation) { + message = `Invalid input: must include "${issue.validation.includes}"`; + if (typeof issue.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`; + } + } else if ("startsWith" in issue.validation) { + message = `Invalid input: must start with "${issue.validation.startsWith}"`; + } else if ("endsWith" in issue.validation) { + message = `Invalid input: must end with "${issue.validation.endsWith}"`; + } else { + util.assertNever(issue.validation); + } + } else if (issue.validation !== "regex") { + message = `Invalid ${issue.validation}`; + } else { + message = "Invalid"; + } + break; + case ZodIssueCode.too_small: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`; + else if (issue.type === "bigint") + message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.too_big: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "bigint") + message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode.custom: + message = `Invalid input`; + break; + case ZodIssueCode.invalid_intersection_types: + message = `Intersection results could not be merged`; + break; + case ZodIssueCode.not_multiple_of: + message = `Number must be a multiple of ${issue.multipleOf}`; + break; + case ZodIssueCode.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util.assertNever(issue); + } + return { message }; + }; + en_default = errorMap; + } +}); + +// node_modules/zod/v3/errors.js +function setErrorMap(map) { + overrideErrorMap = map; +} +function getErrorMap() { + return overrideErrorMap; +} +var overrideErrorMap; +var init_errors = __esm({ + "node_modules/zod/v3/errors.js"() { + init_en(); + overrideErrorMap = en_default; + } +}); + +// node_modules/zod/v3/helpers/parseUtil.js +function addIssueToContext(ctx, issueData) { + const overrideMap = getErrorMap(); + const issue = makeIssue({ + issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + // contextual error map is first priority + ctx.schemaErrorMap, + // then schema-bound map if available + overrideMap, + // then global override map + overrideMap === en_default ? void 0 : en_default + // then global default map + ].filter((x) => !!x) + }); + ctx.common.issues.push(issue); +} +var makeIssue, EMPTY_PATH, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync; +var init_parseUtil = __esm({ + "node_modules/zod/v3/helpers/parseUtil.js"() { + init_errors(); + init_en(); + makeIssue = (params) => { + const { data, path, errorMaps, issueData } = params; + const fullPath = [...path, ...issueData.path || []]; + const fullIssue = { + ...issueData, + path: fullPath + }; + if (issueData.message !== void 0) { + return { + ...issueData, + path: fullPath, + message: issueData.message + }; + } + let errorMessage = ""; + const maps = errorMaps.filter((m) => !!m).slice().reverse(); + for (const map of maps) { + errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message; + } + return { + ...issueData, + path: fullPath, + message: errorMessage + }; + }; + EMPTY_PATH = []; + ParseStatus = class _ParseStatus2 { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") + this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") + this.value = "aborted"; + } + static mergeArray(status, results) { + const arrayValue = []; + for (const s of results) { + if (s.status === "aborted") + return INVALID; + if (s.status === "dirty") + status.dirty(); + arrayValue.push(s.value); + } + return { status: status.value, value: arrayValue }; + } + static async mergeObjectAsync(status, pairs) { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value + }); + } + return _ParseStatus2.mergeObjectSync(status, syncPairs); + } + static mergeObjectSync(status, pairs) { + const finalObject = {}; + for (const pair of pairs) { + const { key, value } = pair; + if (key.status === "aborted") + return INVALID; + if (value.status === "aborted") + return INVALID; + if (key.status === "dirty") + status.dirty(); + if (value.status === "dirty") + status.dirty(); + if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) { + finalObject[key.value] = value.value; + } + } + return { status: status.value, value: finalObject }; + } + }; + INVALID = Object.freeze({ + status: "aborted" + }); + DIRTY = (value) => ({ status: "dirty", value }); + OK = (value) => ({ status: "valid", value }); + isAborted = (x) => x.status === "aborted"; + isDirty = (x) => x.status === "dirty"; + isValid = (x) => x.status === "valid"; + isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise; + } +}); + +// node_modules/zod/v3/helpers/typeAliases.js +var init_typeAliases = __esm({ + "node_modules/zod/v3/helpers/typeAliases.js"() { + } +}); + +// node_modules/zod/v3/helpers/errorUtil.js +var errorUtil; +var init_errorUtil = __esm({ + "node_modules/zod/v3/helpers/errorUtil.js"() { + (function(errorUtil3) { + errorUtil3.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil3.toString = (message) => typeof message === "string" ? message : message?.message; + })(errorUtil || (errorUtil = {})); + } +}); + +// node_modules/zod/v3/types.js +function processCreateParams(params) { + if (!params) + return {}; + const { errorMap: errorMap3, invalid_type_error, required_error, description } = params; + if (errorMap3 && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap3) + return { errorMap: errorMap3, description }; + const customMap = (iss, ctx) => { + const { message } = params; + if (iss.code === "invalid_enum_value") { + return { message: message ?? ctx.defaultError }; + } + if (typeof ctx.data === "undefined") { + return { message: message ?? required_error ?? ctx.defaultError }; + } + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + return { message: message ?? invalid_type_error ?? ctx.defaultError }; + }; + return { errorMap: customMap, description }; +} +function timeRegexSource(args) { + let secondsRegexSource = `[0-5]\\d`; + if (args.precision) { + secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`; + } else if (args.precision == null) { + secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`; + } + const secondsQuantifier = args.precision ? "+" : "?"; + return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`; +} +function timeRegex(args) { + return new RegExp(`^${timeRegexSource(args)}$`); +} +function datetimeRegex(args) { + let regex = `${dateRegexSource}T${timeRegexSource(args)}`; + const opts = []; + opts.push(args.local ? `Z?` : `Z`); + if (args.offset) + opts.push(`([+-]\\d{2}:?\\d{2})`); + regex = `${regex}(${opts.join("|")})`; + return new RegExp(`^${regex}$`); +} +function isValidIP(ip, version) { + if ((version === "v4" || !version) && ipv4Regex.test(ip)) { + return true; + } + if ((version === "v6" || !version) && ipv6Regex.test(ip)) { + return true; + } + return false; +} +function isValidJWT(jwt, alg) { + if (!jwtRegex.test(jwt)) + return false; + try { + const [header] = jwt.split("."); + if (!header) + return false; + const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "="); + const decoded = JSON.parse(atob(base64)); + if (typeof decoded !== "object" || decoded === null) + return false; + if ("typ" in decoded && decoded?.typ !== "JWT") + return false; + if (!decoded.alg) + return false; + if (alg && decoded.alg !== alg) + return false; + return true; + } catch { + return false; + } +} +function isValidCidr(ip, version) { + if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) { + return true; + } + if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) { + return true; + } + return false; +} +function floatSafeRemainder(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepDecCount = (step.toString().split(".")[1] || "").length; + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = Number.parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / 10 ** decCount; +} +function deepPartialify(schema) { + if (schema instanceof ZodObject) { + const newShape = {}; + for (const key in schema.shape) { + const fieldSchema = schema.shape[key]; + newShape[key] = ZodOptional.create(deepPartialify(fieldSchema)); + } + return new ZodObject({ + ...schema._def, + shape: () => newShape + }); + } else if (schema instanceof ZodArray) { + return new ZodArray({ + ...schema._def, + type: deepPartialify(schema.element) + }); + } else if (schema instanceof ZodOptional) { + return ZodOptional.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodNullable) { + return ZodNullable.create(deepPartialify(schema.unwrap())); + } else if (schema instanceof ZodTuple) { + return ZodTuple.create(schema.items.map((item) => deepPartialify(item))); + } else { + return schema; + } +} +function mergeValues(a, b) { + const aType = getParsedType(a); + const bType = getParsedType(b); + if (a === b) { + return { valid: true, data: a }; + } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) { + const bKeys = util.objectKeys(b); + const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { valid: false }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) { + if (a.length !== b.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { valid: false }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) { + return { valid: true, data: a }; + } else { + return { valid: false }; + } +} +function createZodEnum(values, params) { + return new ZodEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodEnum, + ...processCreateParams(params) + }); +} +function cleanParams(params, data) { + const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params; + const p2 = typeof p === "string" ? { message: p } : p; + return p2; +} +function custom(check, _params = {}, fatal) { + if (check) + return ZodAny.create().superRefine((data, ctx) => { + const r = check(data); + if (r instanceof Promise) { + return r.then((r2) => { + if (!r2) { + const params = cleanParams(_params, data); + const _fatal = params.fatal ?? fatal ?? true; + ctx.addIssue({ code: "custom", ...params, fatal: _fatal }); + } + }); + } + if (!r) { + const params = cleanParams(_params, data); + const _fatal = params.fatal ?? fatal ?? true; + ctx.addIssue({ code: "custom", ...params, fatal: _fatal }); + } + return; + }); + return ZodAny.create(); +} +var ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, ZodReadonly, late, ZodFirstPartyTypeKind, instanceOfType, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType, ostring, onumber, oboolean, coerce, NEVER; +var init_types = __esm({ + "node_modules/zod/v3/types.js"() { + init_ZodError(); + init_errors(); + init_errorUtil(); + init_parseUtil(); + init_util(); + ParseInputLazyPath = class { + constructor(parent, value, path, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (Array.isArray(this._key)) { + this._cachedPath.push(...this._path, ...this._key); + } else { + this._cachedPath.push(...this._path, this._key); + } + } + return this._cachedPath; + } + }; + handleResult = (ctx, result) => { + if (isValid(result)) { + return { success: true, data: result.value }; + } else { + if (!ctx.common.issues.length) { + throw new Error("Validation failed but no issues detected."); + } + return { + success: false, + get error() { + if (this._error) + return this._error; + const error = new ZodError(ctx.common.issues); + this._error = error; + return this._error; + } + }; + } + }; + ZodType = class { + get description() { + return this._def.description; + } + _getType(input) { + return getParsedType(input.data); + } + _getOrReturnCtx(input, ctx) { + return ctx || { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + }; + } + _processInputParams(input) { + return { + status: new ParseStatus(), + ctx: { + common: input.parent.common, + data: input.data, + parsedType: getParsedType(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + } + }; + } + _parseSync(input) { + const result = this._parse(input); + if (isAsync(result)) { + throw new Error("Synchronous parse encountered promise."); + } + return result; + } + _parseAsync(input) { + const result = this._parse(input); + return Promise.resolve(result); + } + parse(data, params) { + const result = this.safeParse(data, params); + if (result.success) + return result.data; + throw result.error; + } + safeParse(data, params) { + const ctx = { + common: { + issues: [], + async: params?.async ?? false, + contextualErrorMap: params?.errorMap + }, + path: params?.path || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + const result = this._parseSync({ data, path: ctx.path, parent: ctx }); + return handleResult(ctx, result); + } + "~validate"(data) { + const ctx = { + common: { + issues: [], + async: !!this["~standard"].async + }, + path: [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + if (!this["~standard"].async) { + try { + const result = this._parseSync({ data, path: [], parent: ctx }); + return isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }; + } catch (err2) { + if (err2?.message?.toLowerCase()?.includes("encountered")) { + this["~standard"].async = true; + } + ctx.common = { + issues: [], + async: true + }; + } + } + return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }); + } + async parseAsync(data, params) { + const result = await this.safeParseAsync(data, params); + if (result.success) + return result.data; + throw result.error; + } + async safeParseAsync(data, params) { + const ctx = { + common: { + issues: [], + contextualErrorMap: params?.errorMap, + async: true + }, + path: params?.path || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType(data) + }; + const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx }); + const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult)); + return handleResult(ctx, result); + } + refine(check, message) { + const getIssueProperties = (val) => { + if (typeof message === "string" || typeof message === "undefined") { + return { message }; + } else if (typeof message === "function") { + return message(val); + } else { + return message; + } + }; + return this._refinement((val, ctx) => { + const result = check(val); + const setError = () => ctx.addIssue({ + code: ZodIssueCode.custom, + ...getIssueProperties(val) + }); + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then((data) => { + if (!data) { + setError(); + return false; + } else { + return true; + } + }); + } + if (!result) { + setError(); + return false; + } else { + return true; + } + }); + } + refinement(check, refinementData) { + return this._refinement((val, ctx) => { + if (!check(val)) { + ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData); + return false; + } else { + return true; + } + }); + } + _refinement(refinement) { + return new ZodEffects({ + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "refinement", refinement } + }); + } + superRefine(refinement) { + return this._refinement(refinement); + } + constructor(def) { + this.spa = this.safeParseAsync; + this._def = def; + this.parse = this.parse.bind(this); + this.safeParse = this.safeParse.bind(this); + this.parseAsync = this.parseAsync.bind(this); + this.safeParseAsync = this.safeParseAsync.bind(this); + this.spa = this.spa.bind(this); + this.refine = this.refine.bind(this); + this.refinement = this.refinement.bind(this); + this.superRefine = this.superRefine.bind(this); + this.optional = this.optional.bind(this); + this.nullable = this.nullable.bind(this); + this.nullish = this.nullish.bind(this); + this.array = this.array.bind(this); + this.promise = this.promise.bind(this); + this.or = this.or.bind(this); + this.and = this.and.bind(this); + this.transform = this.transform.bind(this); + this.brand = this.brand.bind(this); + this.default = this.default.bind(this); + this.catch = this.catch.bind(this); + this.describe = this.describe.bind(this); + this.pipe = this.pipe.bind(this); + this.readonly = this.readonly.bind(this); + this.isNullable = this.isNullable.bind(this); + this.isOptional = this.isOptional.bind(this); + this["~standard"] = { + version: 1, + vendor: "zod", + validate: (data) => this["~validate"](data) + }; + } + optional() { + return ZodOptional.create(this, this._def); + } + nullable() { + return ZodNullable.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray.create(this); + } + promise() { + return ZodPromise.create(this, this._def); + } + or(option) { + return ZodUnion.create([this, option], this._def); + } + and(incoming) { + return ZodIntersection.create(this, incoming, this._def); + } + transform(transform) { + return new ZodEffects({ + ...processCreateParams(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect: { type: "transform", transform } + }); + } + default(def) { + const defaultValueFunc = typeof def === "function" ? def : () => def; + return new ZodDefault({ + ...processCreateParams(this._def), + innerType: this, + defaultValue: defaultValueFunc, + typeName: ZodFirstPartyTypeKind.ZodDefault + }); + } + brand() { + return new ZodBranded({ + typeName: ZodFirstPartyTypeKind.ZodBranded, + type: this, + ...processCreateParams(this._def) + }); + } + catch(def) { + const catchValueFunc = typeof def === "function" ? def : () => def; + return new ZodCatch({ + ...processCreateParams(this._def), + innerType: this, + catchValue: catchValueFunc, + typeName: ZodFirstPartyTypeKind.ZodCatch + }); + } + describe(description) { + const This = this.constructor; + return new This({ + ...this._def, + description + }); + } + pipe(target) { + return ZodPipeline.create(this, target); + } + readonly() { + return ZodReadonly.create(this); + } + isOptional() { + return this.safeParse(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } + }; + cuidRegex = /^c[^\s-]{8,}$/i; + cuid2Regex = /^[0-9a-z]+$/; + ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i; + uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i; + nanoidRegex = /^[a-z0-9_-]{21}$/i; + jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/; + durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/; + emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; + _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; + ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; + ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/; + ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/; + ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; + base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; + base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/; + dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`; + dateRegex = new RegExp(`^${dateRegexSource}$`); + ZodString = class _ZodString2 extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.string) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.string, + received: ctx2.parsedType + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.length < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.length > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "length") { + const tooBig = input.data.length > check.value; + const tooSmall = input.data.length < check.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } else if (tooSmall) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } + status.dirty(); + } + } else if (check.kind === "email") { + if (!emailRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "email", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "emoji") { + if (!emojiRegex) { + emojiRegex = new RegExp(_emojiRegex, "u"); + } + if (!emojiRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "emoji", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "uuid") { + if (!uuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "uuid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "nanoid") { + if (!nanoidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "nanoid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid") { + if (!cuidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid2") { + if (!cuid2Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cuid2", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ulid") { + if (!ulidRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ulid", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "url") { + try { + new URL(input.data); + } catch { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "url", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "regex") { + check.regex.lastIndex = 0; + const testResult = check.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "regex", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "trim") { + input.data = input.data.trim(); + } else if (check.kind === "includes") { + if (!input.data.includes(check.value, check.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { includes: check.value, position: check.position }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } else if (check.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } else if (check.kind === "startsWith") { + if (!input.data.startsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { startsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "endsWith") { + if (!input.data.endsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: { endsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "datetime") { + const regex = datetimeRegex(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "datetime", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "date") { + const regex = dateRegex; + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "date", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "time") { + const regex = timeRegex(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_string, + validation: "time", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "duration") { + if (!durationRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "duration", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ip") { + if (!isValidIP(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "ip", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "jwt") { + if (!isValidJWT(input.data, check.alg)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "jwt", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cidr") { + if (!isValidCidr(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "cidr", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "base64") { + if (!base64Regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "base64url") { + if (!base64urlRegex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + validation: "base64url", + code: ZodIssueCode.invalid_string, + message: check.message + }); + status.dirty(); + } + } else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + _regex(regex, validation, message) { + return this.refinement((data) => regex.test(data), { + validation, + code: ZodIssueCode.invalid_string, + ...errorUtil.errToObj(message) + }); + } + _addCheck(check) { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + email(message) { + return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) }); + } + url(message) { + return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) }); + } + emoji(message) { + return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) }); + } + uuid(message) { + return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) }); + } + nanoid(message) { + return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) }); + } + cuid(message) { + return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) }); + } + cuid2(message) { + return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) }); + } + ulid(message) { + return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) }); + } + base64(message) { + return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) }); + } + base64url(message) { + return this._addCheck({ + kind: "base64url", + ...errorUtil.errToObj(message) + }); + } + jwt(options) { + return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) }); + } + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) }); + } + cidr(options) { + return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) }); + } + datetime(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "datetime", + precision: null, + offset: false, + local: false, + message: options + }); + } + return this._addCheck({ + kind: "datetime", + precision: typeof options?.precision === "undefined" ? null : options?.precision, + offset: options?.offset ?? false, + local: options?.local ?? false, + ...errorUtil.errToObj(options?.message) + }); + } + date(message) { + return this._addCheck({ kind: "date", message }); + } + time(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "time", + precision: null, + message: options + }); + } + return this._addCheck({ + kind: "time", + precision: typeof options?.precision === "undefined" ? null : options?.precision, + ...errorUtil.errToObj(options?.message) + }); + } + duration(message) { + return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) }); + } + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex, + ...errorUtil.errToObj(message) + }); + } + includes(value, options) { + return this._addCheck({ + kind: "includes", + value, + position: options?.position, + ...errorUtil.errToObj(options?.message) + }); + } + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value, + ...errorUtil.errToObj(message) + }); + } + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + value, + ...errorUtil.errToObj(message) + }); + } + min(minLength, message) { + return this._addCheck({ + kind: "min", + value: minLength, + ...errorUtil.errToObj(message) + }); + } + max(maxLength, message) { + return this._addCheck({ + kind: "max", + value: maxLength, + ...errorUtil.errToObj(message) + }); + } + length(len, message) { + return this._addCheck({ + kind: "length", + value: len, + ...errorUtil.errToObj(message) + }); + } + /** + * Equivalent to `.min(1)` + */ + nonempty(message) { + return this.min(1, errorUtil.errToObj(message)); + } + trim() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new _ZodString2({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }] + }); + } + get isDatetime() { + return !!this._def.checks.find((ch) => ch.kind === "datetime"); + } + get isDate() { + return !!this._def.checks.find((ch) => ch.kind === "date"); + } + get isTime() { + return !!this._def.checks.find((ch) => ch.kind === "time"); + } + get isDuration() { + return !!this._def.checks.find((ch) => ch.kind === "duration"); + } + get isEmail() { + return !!this._def.checks.find((ch) => ch.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((ch) => ch.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((ch) => ch.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((ch) => ch.kind === "uuid"); + } + get isNANOID() { + return !!this._def.checks.find((ch) => ch.kind === "nanoid"); + } + get isCUID() { + return !!this._def.checks.find((ch) => ch.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((ch) => ch.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((ch) => ch.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((ch) => ch.kind === "ip"); + } + get isCIDR() { + return !!this._def.checks.find((ch) => ch.kind === "cidr"); + } + get isBase64() { + return !!this._def.checks.find((ch) => ch.kind === "base64"); + } + get isBase64url() { + return !!this._def.checks.find((ch) => ch.kind === "base64url"); + } + get minLength() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxLength() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + }; + ZodString.create = (params) => { + return new ZodString({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodString, + coerce: params?.coerce ?? false, + ...processCreateParams(params) + }); + }; + ZodNumber = class _ZodNumber2 extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + this.step = this.multipleOf; + } + _parse(input) { + if (this._def.coerce) { + input.data = Number(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.number) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.number, + received: ctx2.parsedType + }); + return INVALID; + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "int") { + if (!util.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: "integer", + received: "float", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (floatSafeRemainder(input.data, check.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_finite, + message: check.message + }); + status.dirty(); + } + } else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodNumber2({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) + } + ] + }); + } + _addCheck(check) { + return new _ZodNumber2({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + int(message) { + return this._addCheck({ + kind: "int", + message: errorUtil.toString(message) + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + finite(message) { + return this._addCheck({ + kind: "finite", + message: errorUtil.toString(message) + }); + } + safe(message) { + return this._addCheck({ + kind: "min", + inclusive: true, + value: Number.MIN_SAFE_INTEGER, + message: errorUtil.toString(message) + })._addCheck({ + kind: "max", + inclusive: true, + value: Number.MAX_SAFE_INTEGER, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + get isInt() { + return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value)); + } + get isFinite() { + let max = null; + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") { + return true; + } else if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } else if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return Number.isFinite(min) && Number.isFinite(max); + } + }; + ZodNumber.create = (params) => { + return new ZodNumber({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodNumber, + coerce: params?.coerce || false, + ...processCreateParams(params) + }); + }; + ZodBigInt = class _ZodBigInt2 extends ZodType { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + try { + input.data = BigInt(input.data); + } catch { + return this._getInvalidInput(input); + } + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.bigint) { + return this._getInvalidInput(input); + } + let ctx = void 0; + const status = new ParseStatus(); + for (const check of this._def.checks) { + if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + type: "bigint", + minimum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + type: "bigint", + maximum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (input.data % check.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else { + util.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + _getInvalidInput(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.bigint, + received: ctx.parsedType + }); + return INVALID; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodBigInt2({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil.toString(message) + } + ] + }); + } + _addCheck(check) { + return new _ZodBigInt2({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: false, + message: errorUtil.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: true, + message: errorUtil.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + }; + ZodBigInt.create = (params) => { + return new ZodBigInt({ + checks: [], + typeName: ZodFirstPartyTypeKind.ZodBigInt, + coerce: params?.coerce ?? false, + ...processCreateParams(params) + }); + }; + ZodBoolean = class extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.boolean) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.boolean, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } + }; + ZodBoolean.create = (params) => { + return new ZodBoolean({ + typeName: ZodFirstPartyTypeKind.ZodBoolean, + coerce: params?.coerce || false, + ...processCreateParams(params) + }); + }; + ZodDate = class _ZodDate2 extends ZodType { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.date) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.date, + received: ctx2.parsedType + }); + return INVALID; + } + if (Number.isNaN(input.data.getTime())) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_date + }); + return INVALID; + } + const status = new ParseStatus(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.getTime() < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + message: check.message, + inclusive: true, + exact: false, + minimum: check.value, + type: "date" + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.getTime() > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + message: check.message, + inclusive: true, + exact: false, + maximum: check.value, + type: "date" + }); + status.dirty(); + } + } else { + util.assertNever(check); + } + } + return { + status: status.value, + value: new Date(input.data.getTime()) + }; + } + _addCheck(check) { + return new _ZodDate2({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + min(minDate, message) { + return this._addCheck({ + kind: "min", + value: minDate.getTime(), + message: errorUtil.toString(message) + }); + } + max(maxDate, message) { + return this._addCheck({ + kind: "max", + value: maxDate.getTime(), + message: errorUtil.toString(message) + }); + } + get minDate() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min != null ? new Date(min) : null; + } + get maxDate() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max != null ? new Date(max) : null; + } + }; + ZodDate.create = (params) => { + return new ZodDate({ + checks: [], + coerce: params?.coerce || false, + typeName: ZodFirstPartyTypeKind.ZodDate, + ...processCreateParams(params) + }); + }; + ZodSymbol = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.symbol) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.symbol, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } + }; + ZodSymbol.create = (params) => { + return new ZodSymbol({ + typeName: ZodFirstPartyTypeKind.ZodSymbol, + ...processCreateParams(params) + }); + }; + ZodUndefined = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.undefined, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } + }; + ZodUndefined.create = (params) => { + return new ZodUndefined({ + typeName: ZodFirstPartyTypeKind.ZodUndefined, + ...processCreateParams(params) + }); + }; + ZodNull = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.null) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.null, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } + }; + ZodNull.create = (params) => { + return new ZodNull({ + typeName: ZodFirstPartyTypeKind.ZodNull, + ...processCreateParams(params) + }); + }; + ZodAny = class extends ZodType { + constructor() { + super(...arguments); + this._any = true; + } + _parse(input) { + return OK(input.data); + } + }; + ZodAny.create = (params) => { + return new ZodAny({ + typeName: ZodFirstPartyTypeKind.ZodAny, + ...processCreateParams(params) + }); + }; + ZodUnknown = class extends ZodType { + constructor() { + super(...arguments); + this._unknown = true; + } + _parse(input) { + return OK(input.data); + } + }; + ZodUnknown.create = (params) => { + return new ZodUnknown({ + typeName: ZodFirstPartyTypeKind.ZodUnknown, + ...processCreateParams(params) + }); + }; + ZodNever = class extends ZodType { + _parse(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.never, + received: ctx.parsedType + }); + return INVALID; + } + }; + ZodNever.create = (params) => { + return new ZodNever({ + typeName: ZodFirstPartyTypeKind.ZodNever, + ...processCreateParams(params) + }); + }; + ZodVoid = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.void, + received: ctx.parsedType + }); + return INVALID; + } + return OK(input.data); + } + }; + ZodVoid.create = (params) => { + return new ZodVoid({ + typeName: ZodFirstPartyTypeKind.ZodVoid, + ...processCreateParams(params) + }); + }; + ZodArray = class _ZodArray2 extends ZodType { + _parse(input) { + const { ctx, status } = this._processInputParams(input); + const def = this._def; + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID; + } + if (def.exactLength !== null) { + const tooBig = ctx.data.length > def.exactLength.value; + const tooSmall = ctx.data.length < def.exactLength.value; + if (tooBig || tooSmall) { + addIssueToContext(ctx, { + code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small, + minimum: tooSmall ? def.exactLength.value : void 0, + maximum: tooBig ? def.exactLength.value : void 0, + type: "array", + inclusive: true, + exact: true, + message: def.exactLength.message + }); + status.dirty(); + } + } + if (def.minLength !== null) { + if (ctx.data.length < def.minLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.minLength.message + }); + status.dirty(); + } + } + if (def.maxLength !== null) { + if (ctx.data.length > def.maxLength.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.maxLength.message + }); + status.dirty(); + } + } + if (ctx.common.async) { + return Promise.all([...ctx.data].map((item, i) => { + return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + })).then((result2) => { + return ParseStatus.mergeArray(status, result2); + }); + } + const result = [...ctx.data].map((item, i) => { + return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i)); + }); + return ParseStatus.mergeArray(status, result); + } + get element() { + return this._def.type; + } + min(minLength, message) { + return new _ZodArray2({ + ...this._def, + minLength: { value: minLength, message: errorUtil.toString(message) } + }); + } + max(maxLength, message) { + return new _ZodArray2({ + ...this._def, + maxLength: { value: maxLength, message: errorUtil.toString(message) } + }); + } + length(len, message) { + return new _ZodArray2({ + ...this._def, + exactLength: { value: len, message: errorUtil.toString(message) } + }); + } + nonempty(message) { + return this.min(1, message); + } + }; + ZodArray.create = (schema, params) => { + return new ZodArray({ + type: schema, + minLength: null, + maxLength: null, + exactLength: null, + typeName: ZodFirstPartyTypeKind.ZodArray, + ...processCreateParams(params) + }); + }; + ZodObject = class _ZodObject2 extends ZodType { + constructor() { + super(...arguments); + this._cached = null; + this.nonstrict = this.passthrough; + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util.objectKeys(shape); + this._cached = { shape, keys }; + return this._cached; + } + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.object) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext(ctx2, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx2.parsedType + }); + return INVALID; + } + const { status, ctx } = this._processInputParams(input); + const { shape, keys: shapeKeys } = this._getCached(); + const extraKeys = []; + if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) { + for (const key in ctx.data) { + if (!shapeKeys.includes(key)) { + extraKeys.push(key); + } + } + } + const pairs = []; + for (const key of shapeKeys) { + const keyValidator = shape[key]; + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (this._def.catchall instanceof ZodNever) { + const unknownKeys = this._def.unknownKeys; + if (unknownKeys === "passthrough") { + for (const key of extraKeys) { + pairs.push({ + key: { status: "valid", value: key }, + value: { status: "valid", value: ctx.data[key] } + }); + } + } else if (unknownKeys === "strict") { + if (extraKeys.length > 0) { + addIssueToContext(ctx, { + code: ZodIssueCode.unrecognized_keys, + keys: extraKeys + }); + status.dirty(); + } + } else if (unknownKeys === "strip") { + } else { + throw new Error(`Internal ZodObject error: invalid unknownKeys value.`); + } + } else { + const catchall = this._def.catchall; + for (const key of extraKeys) { + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: catchall._parse( + new ParseInputLazyPath(ctx, value, ctx.path, key) + //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: key in ctx.data + }); + } + } + if (ctx.common.async) { + return Promise.resolve().then(async () => { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value, + alwaysSet: pair.alwaysSet + }); + } + return syncPairs; + }).then((syncPairs) => { + return ParseStatus.mergeObjectSync(status, syncPairs); + }); + } else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get shape() { + return this._def.shape(); + } + strict(message) { + errorUtil.errToObj; + return new _ZodObject2({ + ...this._def, + unknownKeys: "strict", + ...message !== void 0 ? { + errorMap: (issue, ctx) => { + const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError; + if (issue.code === "unrecognized_keys") + return { + message: errorUtil.errToObj(message).message ?? defaultError + }; + return { + message: defaultError + }; + } + } : {} + }); + } + strip() { + return new _ZodObject2({ + ...this._def, + unknownKeys: "strip" + }); + } + passthrough() { + return new _ZodObject2({ + ...this._def, + unknownKeys: "passthrough" + }); + } + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(augmentation) { + return new _ZodObject2({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...augmentation + }) + }); + } + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(merging) { + const merged = new _ZodObject2({ + unknownKeys: merging._def.unknownKeys, + catchall: merging._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...merging._def.shape() + }), + typeName: ZodFirstPartyTypeKind.ZodObject + }); + return merged; + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(key, schema) { + return this.augment({ [key]: schema }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(index) { + return new _ZodObject2({ + ...this._def, + catchall: index + }); + } + pick(mask) { + const shape = {}; + for (const key of util.objectKeys(mask)) { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject2({ + ...this._def, + shape: () => shape + }); + } + omit(mask) { + const shape = {}; + for (const key of util.objectKeys(this.shape)) { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + } + return new _ZodObject2({ + ...this._def, + shape: () => shape + }); + } + /** + * @deprecated + */ + deepPartial() { + return deepPartialify(this); + } + partial(mask) { + const newShape = {}; + for (const key of util.objectKeys(this.shape)) { + const fieldSchema = this.shape[key]; + if (mask && !mask[key]) { + newShape[key] = fieldSchema; + } else { + newShape[key] = fieldSchema.optional(); + } + } + return new _ZodObject2({ + ...this._def, + shape: () => newShape + }); + } + required(mask) { + const newShape = {}; + for (const key of util.objectKeys(this.shape)) { + if (mask && !mask[key]) { + newShape[key] = this.shape[key]; + } else { + const fieldSchema = this.shape[key]; + let newField = fieldSchema; + while (newField instanceof ZodOptional) { + newField = newField._def.innerType; + } + newShape[key] = newField; + } + } + return new _ZodObject2({ + ...this._def, + shape: () => newShape + }); + } + keyof() { + return createZodEnum(util.objectKeys(this.shape)); + } + }; + ZodObject.create = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + ZodObject.strictCreate = (shape, params) => { + return new ZodObject({ + shape: () => shape, + unknownKeys: "strict", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + ZodObject.lazycreate = (shape, params) => { + return new ZodObject({ + shape, + unknownKeys: "strip", + catchall: ZodNever.create(), + typeName: ZodFirstPartyTypeKind.ZodObject, + ...processCreateParams(params) + }); + }; + ZodUnion = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID; + } + if (ctx.common.async) { + return Promise.all(options.map(async (option) => { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + return { + result: await option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }), + ctx: childCtx + }; + })).then(handleResults); + } else { + let dirty = void 0; + const issues = []; + for (const option of options) { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + const result = option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }); + if (result.status === "valid") { + return result; + } else if (result.status === "dirty" && !dirty) { + dirty = { result, ctx: childCtx }; + } + if (childCtx.common.issues.length) { + issues.push(childCtx.common.issues); + } + } + if (dirty) { + ctx.common.issues.push(...dirty.ctx.common.issues); + return dirty.result; + } + const unionErrors = issues.map((issues2) => new ZodError(issues2)); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union, + unionErrors + }); + return INVALID; + } + } + get options() { + return this._def.options; + } + }; + ZodUnion.create = (types, params) => { + return new ZodUnion({ + options: types, + typeName: ZodFirstPartyTypeKind.ZodUnion, + ...processCreateParams(params) + }); + }; + getDiscriminator = (type) => { + if (type instanceof ZodLazy) { + return getDiscriminator(type.schema); + } else if (type instanceof ZodEffects) { + return getDiscriminator(type.innerType()); + } else if (type instanceof ZodLiteral) { + return [type.value]; + } else if (type instanceof ZodEnum) { + return type.options; + } else if (type instanceof ZodNativeEnum) { + return util.objectValues(type.enum); + } else if (type instanceof ZodDefault) { + return getDiscriminator(type._def.innerType); + } else if (type instanceof ZodUndefined) { + return [void 0]; + } else if (type instanceof ZodNull) { + return [null]; + } else if (type instanceof ZodOptional) { + return [void 0, ...getDiscriminator(type.unwrap())]; + } else if (type instanceof ZodNullable) { + return [null, ...getDiscriminator(type.unwrap())]; + } else if (type instanceof ZodBranded) { + return getDiscriminator(type.unwrap()); + } else if (type instanceof ZodReadonly) { + return getDiscriminator(type.unwrap()); + } else if (type instanceof ZodCatch) { + return getDiscriminator(type._def.innerType); + } else { + return []; + } + }; + ZodDiscriminatedUnion = class _ZodDiscriminatedUnion2 extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID; + } + const discriminator = this.discriminator; + const discriminatorValue = ctx.data[discriminator]; + const option = this.optionsMap.get(discriminatorValue); + if (!option) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [discriminator] + }); + return INVALID; + } + if (ctx.common.async) { + return option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } else { + return option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(discriminator, options, params) { + const optionsMap = /* @__PURE__ */ new Map(); + for (const type of options) { + const discriminatorValues = getDiscriminator(type.shape[discriminator]); + if (!discriminatorValues.length) { + throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`); + } + for (const value of discriminatorValues) { + if (optionsMap.has(value)) { + throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`); + } + optionsMap.set(value, type); + } + } + return new _ZodDiscriminatedUnion2({ + typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion, + discriminator, + options, + optionsMap, + ...processCreateParams(params) + }); + } + }; + ZodIntersection = class extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const handleParsed = (parsedLeft, parsedRight) => { + if (isAborted(parsedLeft) || isAborted(parsedRight)) { + return INVALID; + } + const merged = mergeValues(parsedLeft.value, parsedRight.value); + if (!merged.valid) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_intersection_types + }); + return INVALID; + } + if (isDirty(parsedLeft) || isDirty(parsedRight)) { + status.dirty(); + } + return { status: status.value, value: merged.data }; + }; + if (ctx.common.async) { + return Promise.all([ + this._def.left._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), + this._def.right._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }) + ]).then(([left, right]) => handleParsed(left, right)); + } else { + return handleParsed(this._def.left._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), this._def.right._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + })); + } + } + }; + ZodIntersection.create = (left, right, params) => { + return new ZodIntersection({ + left, + right, + typeName: ZodFirstPartyTypeKind.ZodIntersection, + ...processCreateParams(params) + }); + }; + ZodTuple = class _ZodTuple2 extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.array) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.array, + received: ctx.parsedType + }); + return INVALID; + } + if (ctx.data.length < this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + return INVALID; + } + const rest = this._def.rest; + if (!rest && ctx.data.length > this._def.items.length) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + status.dirty(); + } + const items = [...ctx.data].map((item, itemIndex) => { + const schema = this._def.items[itemIndex] || this._def.rest; + if (!schema) + return null; + return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex)); + }).filter((x) => !!x); + if (ctx.common.async) { + return Promise.all(items).then((results) => { + return ParseStatus.mergeArray(status, results); + }); + } else { + return ParseStatus.mergeArray(status, items); + } + } + get items() { + return this._def.items; + } + rest(rest) { + return new _ZodTuple2({ + ...this._def, + rest + }); + } + }; + ZodTuple.create = (schemas, params) => { + if (!Array.isArray(schemas)) { + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + } + return new ZodTuple({ + items: schemas, + typeName: ZodFirstPartyTypeKind.ZodTuple, + rest: null, + ...processCreateParams(params) + }); + }; + ZodRecord = class _ZodRecord2 extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.object) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.object, + received: ctx.parsedType + }); + return INVALID; + } + const pairs = []; + const keyType = this._def.keyType; + const valueType = this._def.valueType; + for (const key in ctx.data) { + pairs.push({ + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)), + value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (ctx.common.async) { + return ParseStatus.mergeObjectAsync(status, pairs); + } else { + return ParseStatus.mergeObjectSync(status, pairs); + } + } + get element() { + return this._def.valueType; + } + static create(first, second, third) { + if (second instanceof ZodType) { + return new _ZodRecord2({ + keyType: first, + valueType: second, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(third) + }); + } + return new _ZodRecord2({ + keyType: ZodString.create(), + valueType: first, + typeName: ZodFirstPartyTypeKind.ZodRecord, + ...processCreateParams(second) + }); + } + }; + ZodMap = class extends ZodType { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.map) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.map, + received: ctx.parsedType + }); + return INVALID; + } + const keyType = this._def.keyType; + const valueType = this._def.valueType; + const pairs = [...ctx.data.entries()].map(([key, value], index) => { + return { + key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])), + value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])) + }; + }); + if (ctx.common.async) { + const finalMap = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + }); + } else { + const finalMap = /* @__PURE__ */ new Map(); + for (const pair of pairs) { + const key = pair.key; + const value = pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + } + } + }; + ZodMap.create = (keyType, valueType, params) => { + return new ZodMap({ + valueType, + keyType, + typeName: ZodFirstPartyTypeKind.ZodMap, + ...processCreateParams(params) + }); + }; + ZodSet = class _ZodSet2 extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.set) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.set, + received: ctx.parsedType + }); + return INVALID; + } + const def = this._def; + if (def.minSize !== null) { + if (ctx.data.size < def.minSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_small, + minimum: def.minSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.minSize.message + }); + status.dirty(); + } + } + if (def.maxSize !== null) { + if (ctx.data.size > def.maxSize.value) { + addIssueToContext(ctx, { + code: ZodIssueCode.too_big, + maximum: def.maxSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.maxSize.message + }); + status.dirty(); + } + } + const valueType = this._def.valueType; + function finalizeSet(elements2) { + const parsedSet = /* @__PURE__ */ new Set(); + for (const element of elements2) { + if (element.status === "aborted") + return INVALID; + if (element.status === "dirty") + status.dirty(); + parsedSet.add(element.value); + } + return { status: status.value, value: parsedSet }; + } + const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i))); + if (ctx.common.async) { + return Promise.all(elements).then((elements2) => finalizeSet(elements2)); + } else { + return finalizeSet(elements); + } + } + min(minSize, message) { + return new _ZodSet2({ + ...this._def, + minSize: { value: minSize, message: errorUtil.toString(message) } + }); + } + max(maxSize, message) { + return new _ZodSet2({ + ...this._def, + maxSize: { value: maxSize, message: errorUtil.toString(message) } + }); + } + size(size, message) { + return this.min(size, message).max(size, message); + } + nonempty(message) { + return this.min(1, message); + } + }; + ZodSet.create = (valueType, params) => { + return new ZodSet({ + valueType, + minSize: null, + maxSize: null, + typeName: ZodFirstPartyTypeKind.ZodSet, + ...processCreateParams(params) + }); + }; + ZodFunction = class _ZodFunction2 extends ZodType { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.function) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.function, + received: ctx.parsedType + }); + return INVALID; + } + function makeArgsIssue(args, error) { + return makeIssue({ + data: args, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_arguments, + argumentsError: error + } + }); + } + function makeReturnsIssue(returns, error) { + return makeIssue({ + data: returns, + path: ctx.path, + errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x), + issueData: { + code: ZodIssueCode.invalid_return_type, + returnTypeError: error + } + }); + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise) { + const me = this; + return OK(async function(...args) { + const error = new ZodError([]); + const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => { + error.addIssue(makeArgsIssue(args, e)); + throw error; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => { + error.addIssue(makeReturnsIssue(result, e)); + throw error; + }); + return parsedReturns; + }); + } else { + const me = this; + return OK(function(...args) { + const parsedArgs = me._def.args.safeParse(args, params); + if (!parsedArgs.success) { + throw new ZodError([makeArgsIssue(args, parsedArgs.error)]); + } + const result = Reflect.apply(fn, this, parsedArgs.data); + const parsedReturns = me._def.returns.safeParse(result, params); + if (!parsedReturns.success) { + throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]); + } + return parsedReturns.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...items) { + return new _ZodFunction2({ + ...this._def, + args: ZodTuple.create(items).rest(ZodUnknown.create()) + }); + } + returns(returnType) { + return new _ZodFunction2({ + ...this._def, + returns: returnType + }); + } + implement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + strictImplement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + static create(args, returns, params) { + return new _ZodFunction2({ + args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()), + returns: returns || ZodUnknown.create(), + typeName: ZodFirstPartyTypeKind.ZodFunction, + ...processCreateParams(params) + }); + } + }; + ZodLazy = class extends ZodType { + get schema() { + return this._def.getter(); + } + _parse(input) { + const { ctx } = this._processInputParams(input); + const lazySchema = this._def.getter(); + return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx }); + } + }; + ZodLazy.create = (getter, params) => { + return new ZodLazy({ + getter, + typeName: ZodFirstPartyTypeKind.ZodLazy, + ...processCreateParams(params) + }); + }; + ZodLiteral = class extends ZodType { + _parse(input) { + if (input.data !== this._def.value) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_literal, + expected: this._def.value + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } + get value() { + return this._def.value; + } + }; + ZodLiteral.create = (value, params) => { + return new ZodLiteral({ + value, + typeName: ZodFirstPartyTypeKind.ZodLiteral, + ...processCreateParams(params) + }); + }; + ZodEnum = class _ZodEnum2 extends ZodType { + _parse(input) { + if (typeof input.data !== "string") { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID; + } + if (!this._cache) { + this._cache = new Set(this._def.values); + } + if (!this._cache.has(input.data)) { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID; + } + return OK(input.data); + } + get options() { + return this._def.values; + } + get enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Values() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + extract(values, newDef = this._def) { + return _ZodEnum2.create(values, { + ...this._def, + ...newDef + }); + } + exclude(values, newDef = this._def) { + return _ZodEnum2.create(this.options.filter((opt) => !values.includes(opt)), { + ...this._def, + ...newDef + }); + } + }; + ZodEnum.create = createZodEnum; + ZodNativeEnum = class extends ZodType { + _parse(input) { + const nativeEnumValues = util.getValidEnumValues(this._def.values); + const ctx = this._getOrReturnCtx(input); + if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + expected: util.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode.invalid_type + }); + return INVALID; + } + if (!this._cache) { + this._cache = new Set(util.getValidEnumValues(this._def.values)); + } + if (!this._cache.has(input.data)) { + const expectedValues = util.objectValues(nativeEnumValues); + addIssueToContext(ctx, { + received: ctx.data, + code: ZodIssueCode.invalid_enum_value, + options: expectedValues + }); + return INVALID; + } + return OK(input.data); + } + get enum() { + return this._def.values; + } + }; + ZodNativeEnum.create = (values, params) => { + return new ZodNativeEnum({ + values, + typeName: ZodFirstPartyTypeKind.ZodNativeEnum, + ...processCreateParams(params) + }); + }; + ZodPromise = class extends ZodType { + unwrap() { + return this._def.type; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) { + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.promise, + received: ctx.parsedType + }); + return INVALID; + } + const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data); + return OK(promisified.then((data) => { + return this._def.type.parseAsync(data, { + path: ctx.path, + errorMap: ctx.common.contextualErrorMap + }); + })); + } + }; + ZodPromise.create = (schema, params) => { + return new ZodPromise({ + type: schema, + typeName: ZodFirstPartyTypeKind.ZodPromise, + ...processCreateParams(params) + }); + }; + ZodEffects = class extends ZodType { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const effect = this._def.effect || null; + const checkCtx = { + addIssue: (arg) => { + addIssueToContext(ctx, arg); + if (arg.fatal) { + status.abort(); + } else { + status.dirty(); + } + }, + get path() { + return ctx.path; + } + }; + checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx); + if (effect.type === "preprocess") { + const processed = effect.transform(ctx.data, checkCtx); + if (ctx.common.async) { + return Promise.resolve(processed).then(async (processed2) => { + if (status.value === "aborted") + return INVALID; + const result = await this._def.schema._parseAsync({ + data: processed2, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + }); + } else { + if (status.value === "aborted") + return INVALID; + const result = this._def.schema._parseSync({ + data: processed, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID; + if (result.status === "dirty") + return DIRTY(result.value); + if (status.value === "dirty") + return DIRTY(result.value); + return result; + } + } + if (effect.type === "refinement") { + const executeRefinement = (acc) => { + const result = effect.refinement(acc, checkCtx); + if (ctx.common.async) { + return Promise.resolve(result); + } + if (result instanceof Promise) { + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + } + return acc; + }; + if (ctx.common.async === false) { + const inner = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + executeRefinement(inner.value); + return { status: status.value, value: inner.value }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => { + if (inner.status === "aborted") + return INVALID; + if (inner.status === "dirty") + status.dirty(); + return executeRefinement(inner.value).then(() => { + return { status: status.value, value: inner.value }; + }); + }); + } + } + if (effect.type === "transform") { + if (ctx.common.async === false) { + const base = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (!isValid(base)) + return INVALID; + const result = effect.transform(base.value, checkCtx); + if (result instanceof Promise) { + throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`); + } + return { status: status.value, value: result }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => { + if (!isValid(base)) + return INVALID; + return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ + status: status.value, + value: result + })); + }); + } + } + util.assertNever(effect); + } + }; + ZodEffects.create = (schema, effect, params) => { + return new ZodEffects({ + schema, + typeName: ZodFirstPartyTypeKind.ZodEffects, + effect, + ...processCreateParams(params) + }); + }; + ZodEffects.createWithPreprocess = (preprocess, schema, params) => { + return new ZodEffects({ + schema, + effect: { type: "preprocess", transform: preprocess }, + typeName: ZodFirstPartyTypeKind.ZodEffects, + ...processCreateParams(params) + }); + }; + ZodOptional = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.undefined) { + return OK(void 0); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } + }; + ZodOptional.create = (type, params) => { + return new ZodOptional({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodOptional, + ...processCreateParams(params) + }); + }; + ZodNullable = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType.null) { + return OK(null); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } + }; + ZodNullable.create = (type, params) => { + return new ZodNullable({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodNullable, + ...processCreateParams(params) + }); + }; + ZodDefault = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + let data = ctx.data; + if (ctx.parsedType === ZodParsedType.undefined) { + data = this._def.defaultValue(); + } + return this._def.innerType._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + removeDefault() { + return this._def.innerType; + } + }; + ZodDefault.create = (type, params) => { + return new ZodDefault({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodDefault, + defaultValue: typeof params.default === "function" ? params.default : () => params.default, + ...processCreateParams(params) + }); + }; + ZodCatch = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const newCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + } + }; + const result = this._def.innerType._parse({ + data: newCtx.data, + path: newCtx.path, + parent: { + ...newCtx + } + }); + if (isAsync(result)) { + return result.then((result2) => { + return { + status: "valid", + value: result2.status === "valid" ? result2.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + }); + } else { + return { + status: "valid", + value: result.status === "valid" ? result.value : this._def.catchValue({ + get error() { + return new ZodError(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + } + } + removeCatch() { + return this._def.innerType; + } + }; + ZodCatch.create = (type, params) => { + return new ZodCatch({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodCatch, + catchValue: typeof params.catch === "function" ? params.catch : () => params.catch, + ...processCreateParams(params) + }); + }; + ZodNaN = class extends ZodType { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType.nan) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext(ctx, { + code: ZodIssueCode.invalid_type, + expected: ZodParsedType.nan, + received: ctx.parsedType + }); + return INVALID; + } + return { status: "valid", value: input.data }; + } + }; + ZodNaN.create = (params) => { + return new ZodNaN({ + typeName: ZodFirstPartyTypeKind.ZodNaN, + ...processCreateParams(params) + }); + }; + BRAND = Symbol("zod_brand"); + ZodBranded = class extends ZodType { + _parse(input) { + const { ctx } = this._processInputParams(input); + const data = ctx.data; + return this._def.type._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + unwrap() { + return this._def.type; + } + }; + ZodPipeline = class _ZodPipeline2 extends ZodType { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.common.async) { + const handleAsync = async () => { + const inResult = await this._def.in._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return DIRTY(inResult.value); + } else { + return this._def.out._parseAsync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + }; + return handleAsync(); + } else { + const inResult = this._def.in._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID; + if (inResult.status === "dirty") { + status.dirty(); + return { + status: "dirty", + value: inResult.value + }; + } else { + return this._def.out._parseSync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + } + } + static create(a, b) { + return new _ZodPipeline2({ + in: a, + out: b, + typeName: ZodFirstPartyTypeKind.ZodPipeline + }); + } + }; + ZodReadonly = class extends ZodType { + _parse(input) { + const result = this._def.innerType._parse(input); + const freeze = (data) => { + if (isValid(data)) { + data.value = Object.freeze(data.value); + } + return data; + }; + return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result); + } + unwrap() { + return this._def.innerType; + } + }; + ZodReadonly.create = (type, params) => { + return new ZodReadonly({ + innerType: type, + typeName: ZodFirstPartyTypeKind.ZodReadonly, + ...processCreateParams(params) + }); + }; + late = { + object: ZodObject.lazycreate + }; + (function(ZodFirstPartyTypeKind3) { + ZodFirstPartyTypeKind3["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind3["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind3["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind3["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind3["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind3["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind3["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind3["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind3["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind3["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind3["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind3["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind3["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind3["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind3["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind3["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind3["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind3["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind3["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind3["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind3["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind3["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind3["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind3["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind3["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind3["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind3["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind3["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind3["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind3["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind3["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind3["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind3["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind3["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind3["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind3["ZodReadonly"] = "ZodReadonly"; + })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {})); + instanceOfType = (cls, params = { + message: `Input not instance of ${cls.name}` + }) => custom((data) => data instanceof cls, params); + stringType = ZodString.create; + numberType = ZodNumber.create; + nanType = ZodNaN.create; + bigIntType = ZodBigInt.create; + booleanType = ZodBoolean.create; + dateType = ZodDate.create; + symbolType = ZodSymbol.create; + undefinedType = ZodUndefined.create; + nullType = ZodNull.create; + anyType = ZodAny.create; + unknownType = ZodUnknown.create; + neverType = ZodNever.create; + voidType = ZodVoid.create; + arrayType = ZodArray.create; + objectType = ZodObject.create; + strictObjectType = ZodObject.strictCreate; + unionType = ZodUnion.create; + discriminatedUnionType = ZodDiscriminatedUnion.create; + intersectionType = ZodIntersection.create; + tupleType = ZodTuple.create; + recordType = ZodRecord.create; + mapType = ZodMap.create; + setType = ZodSet.create; + functionType = ZodFunction.create; + lazyType = ZodLazy.create; + literalType = ZodLiteral.create; + enumType = ZodEnum.create; + nativeEnumType = ZodNativeEnum.create; + promiseType = ZodPromise.create; + effectsType = ZodEffects.create; + optionalType = ZodOptional.create; + nullableType = ZodNullable.create; + preprocessType = ZodEffects.createWithPreprocess; + pipelineType = ZodPipeline.create; + ostring = () => stringType().optional(); + onumber = () => numberType().optional(); + oboolean = () => booleanType().optional(); + coerce = { + string: ((arg) => ZodString.create({ ...arg, coerce: true })), + number: ((arg) => ZodNumber.create({ ...arg, coerce: true })), + boolean: ((arg) => ZodBoolean.create({ + ...arg, + coerce: true + })), + bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })), + date: ((arg) => ZodDate.create({ ...arg, coerce: true })) + }; + NEVER = INVALID; + } +}); + +// node_modules/zod/v3/external.js +var external_exports = {}; +__export(external_exports, { + BRAND: () => BRAND, + DIRTY: () => DIRTY, + EMPTY_PATH: () => EMPTY_PATH, + INVALID: () => INVALID, + NEVER: () => NEVER, + OK: () => OK, + ParseStatus: () => ParseStatus, + Schema: () => ZodType, + ZodAny: () => ZodAny, + ZodArray: () => ZodArray, + ZodBigInt: () => ZodBigInt, + ZodBoolean: () => ZodBoolean, + ZodBranded: () => ZodBranded, + ZodCatch: () => ZodCatch, + ZodDate: () => ZodDate, + ZodDefault: () => ZodDefault, + ZodDiscriminatedUnion: () => ZodDiscriminatedUnion, + ZodEffects: () => ZodEffects, + ZodEnum: () => ZodEnum, + ZodError: () => ZodError, + ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind, + ZodFunction: () => ZodFunction, + ZodIntersection: () => ZodIntersection, + ZodIssueCode: () => ZodIssueCode, + ZodLazy: () => ZodLazy, + ZodLiteral: () => ZodLiteral, + ZodMap: () => ZodMap, + ZodNaN: () => ZodNaN, + ZodNativeEnum: () => ZodNativeEnum, + ZodNever: () => ZodNever, + ZodNull: () => ZodNull, + ZodNullable: () => ZodNullable, + ZodNumber: () => ZodNumber, + ZodObject: () => ZodObject, + ZodOptional: () => ZodOptional, + ZodParsedType: () => ZodParsedType, + ZodPipeline: () => ZodPipeline, + ZodPromise: () => ZodPromise, + ZodReadonly: () => ZodReadonly, + ZodRecord: () => ZodRecord, + ZodSchema: () => ZodType, + ZodSet: () => ZodSet, + ZodString: () => ZodString, + ZodSymbol: () => ZodSymbol, + ZodTransformer: () => ZodEffects, + ZodTuple: () => ZodTuple, + ZodType: () => ZodType, + ZodUndefined: () => ZodUndefined, + ZodUnion: () => ZodUnion, + ZodUnknown: () => ZodUnknown, + ZodVoid: () => ZodVoid, + addIssueToContext: () => addIssueToContext, + any: () => anyType, + array: () => arrayType, + bigint: () => bigIntType, + boolean: () => booleanType, + coerce: () => coerce, + custom: () => custom, + date: () => dateType, + datetimeRegex: () => datetimeRegex, + defaultErrorMap: () => en_default, + discriminatedUnion: () => discriminatedUnionType, + effect: () => effectsType, + enum: () => enumType, + function: () => functionType, + getErrorMap: () => getErrorMap, + getParsedType: () => getParsedType, + instanceof: () => instanceOfType, + intersection: () => intersectionType, + isAborted: () => isAborted, + isAsync: () => isAsync, + isDirty: () => isDirty, + isValid: () => isValid, + late: () => late, + lazy: () => lazyType, + literal: () => literalType, + makeIssue: () => makeIssue, + map: () => mapType, + nan: () => nanType, + nativeEnum: () => nativeEnumType, + never: () => neverType, + null: () => nullType, + nullable: () => nullableType, + number: () => numberType, + object: () => objectType, + objectUtil: () => objectUtil, + oboolean: () => oboolean, + onumber: () => onumber, + optional: () => optionalType, + ostring: () => ostring, + pipeline: () => pipelineType, + preprocess: () => preprocessType, + promise: () => promiseType, + quotelessJson: () => quotelessJson, + record: () => recordType, + set: () => setType, + setErrorMap: () => setErrorMap, + strictObject: () => strictObjectType, + string: () => stringType, + symbol: () => symbolType, + transformer: () => effectsType, + tuple: () => tupleType, + undefined: () => undefinedType, + union: () => unionType, + unknown: () => unknownType, + util: () => util, + void: () => voidType +}); +var init_external = __esm({ + "node_modules/zod/v3/external.js"() { + init_errors(); + init_parseUtil(); + init_typeAliases(); + init_util(); + init_types(); + init_ZodError(); + } +}); + +// node_modules/zod/index.js +var init_zod = __esm({ + "node_modules/zod/index.js"() { + init_external(); + init_external(); + } +}); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js +var LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, JSONRPC_VERSION, ProgressTokenSchema, CursorSchema, RequestMetaSchema, BaseRequestParamsSchema, RequestSchema, BaseNotificationParamsSchema, NotificationSchema, ResultSchema, RequestIdSchema, JSONRPCRequestSchema, isJSONRPCRequest, JSONRPCNotificationSchema, isJSONRPCNotification, JSONRPCResponseSchema, isJSONRPCResponse, ErrorCode, JSONRPCErrorSchema, isJSONRPCError, JSONRPCMessageSchema, EmptyResultSchema, CancelledNotificationSchema, BaseMetadataSchema, ImplementationSchema, ClientCapabilitiesSchema, InitializeRequestSchema, ServerCapabilitiesSchema, InitializeResultSchema, InitializedNotificationSchema, PingRequestSchema, ProgressSchema, ProgressNotificationSchema, PaginatedRequestSchema, PaginatedResultSchema, ResourceContentsSchema, TextResourceContentsSchema, Base64Schema, BlobResourceContentsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestSchema, TextContentSchema, ImageContentSchema, AudioContentSchema, EmbeddedResourceSchema, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolSchema, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, LoggingLevelSchema, SetLevelRequestSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, SamplingMessageSchema, CreateMessageRequestSchema, CreateMessageResultSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError; +var init_types2 = __esm({ + "node_modules/@modelcontextprotocol/sdk/dist/esm/types.js"() { + init_zod(); + LATEST_PROTOCOL_VERSION = "2025-06-18"; + SUPPORTED_PROTOCOL_VERSIONS = [ + LATEST_PROTOCOL_VERSION, + "2025-03-26", + "2024-11-05", + "2024-10-07" + ]; + JSONRPC_VERSION = "2.0"; + ProgressTokenSchema = external_exports.union([external_exports.string(), external_exports.number().int()]); + CursorSchema = external_exports.string(); + RequestMetaSchema = external_exports.object({ + /** + * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications. + */ + progressToken: external_exports.optional(ProgressTokenSchema) + }).passthrough(); + BaseRequestParamsSchema = external_exports.object({ + _meta: external_exports.optional(RequestMetaSchema) + }).passthrough(); + RequestSchema = external_exports.object({ + method: external_exports.string(), + params: external_exports.optional(BaseRequestParamsSchema) + }); + BaseNotificationParamsSchema = external_exports.object({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + NotificationSchema = external_exports.object({ + method: external_exports.string(), + params: external_exports.optional(BaseNotificationParamsSchema) + }); + ResultSchema = external_exports.object({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + RequestIdSchema = external_exports.union([external_exports.string(), external_exports.number().int()]); + JSONRPCRequestSchema = external_exports.object({ + jsonrpc: external_exports.literal(JSONRPC_VERSION), + id: RequestIdSchema + }).merge(RequestSchema).strict(); + isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success; + JSONRPCNotificationSchema = external_exports.object({ + jsonrpc: external_exports.literal(JSONRPC_VERSION) + }).merge(NotificationSchema).strict(); + isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success; + JSONRPCResponseSchema = external_exports.object({ + jsonrpc: external_exports.literal(JSONRPC_VERSION), + id: RequestIdSchema, + result: ResultSchema + }).strict(); + isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success; + (function(ErrorCode3) { + ErrorCode3[ErrorCode3["ConnectionClosed"] = -32e3] = "ConnectionClosed"; + ErrorCode3[ErrorCode3["RequestTimeout"] = -32001] = "RequestTimeout"; + ErrorCode3[ErrorCode3["ParseError"] = -32700] = "ParseError"; + ErrorCode3[ErrorCode3["InvalidRequest"] = -32600] = "InvalidRequest"; + ErrorCode3[ErrorCode3["MethodNotFound"] = -32601] = "MethodNotFound"; + ErrorCode3[ErrorCode3["InvalidParams"] = -32602] = "InvalidParams"; + ErrorCode3[ErrorCode3["InternalError"] = -32603] = "InternalError"; + })(ErrorCode || (ErrorCode = {})); + JSONRPCErrorSchema = external_exports.object({ + jsonrpc: external_exports.literal(JSONRPC_VERSION), + id: RequestIdSchema, + error: external_exports.object({ + /** + * The error type that occurred. + */ + code: external_exports.number().int(), + /** + * A short description of the error. The message SHOULD be limited to a concise single sentence. + */ + message: external_exports.string(), + /** + * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.). + */ + data: external_exports.optional(external_exports.unknown()) + }) + }).strict(); + isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success; + JSONRPCMessageSchema = external_exports.union([ + JSONRPCRequestSchema, + JSONRPCNotificationSchema, + JSONRPCResponseSchema, + JSONRPCErrorSchema + ]); + EmptyResultSchema = ResultSchema.strict(); + CancelledNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/cancelled"), + params: BaseNotificationParamsSchema.extend({ + /** + * The ID of the request to cancel. + * + * This MUST correspond to the ID of a request previously issued in the same direction. + */ + requestId: RequestIdSchema, + /** + * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user. + */ + reason: external_exports.string().optional() + }) + }); + BaseMetadataSchema = external_exports.object({ + /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */ + name: external_exports.string(), + /** + * Intended for UI and end-user contexts — optimized to be human-readable and easily understood, + * even by those unfamiliar with domain-specific terminology. + * + * If not provided, the name should be used for display (except for Tool, + * where `annotations.title` should be given precedence over using `name`, + * if present). + */ + title: external_exports.optional(external_exports.string()) + }).passthrough(); + ImplementationSchema = BaseMetadataSchema.extend({ + version: external_exports.string() + }); + ClientCapabilitiesSchema = external_exports.object({ + /** + * Experimental, non-standard capabilities that the client supports. + */ + experimental: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the client supports sampling from an LLM. + */ + sampling: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the client supports eliciting user input. + */ + elicitation: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the client supports listing roots. + */ + roots: external_exports.optional(external_exports.object({ + /** + * Whether the client supports issuing notifications for changes to the roots list. + */ + listChanged: external_exports.optional(external_exports.boolean()) + }).passthrough()) + }).passthrough(); + InitializeRequestSchema = RequestSchema.extend({ + method: external_exports.literal("initialize"), + params: BaseRequestParamsSchema.extend({ + /** + * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well. + */ + protocolVersion: external_exports.string(), + capabilities: ClientCapabilitiesSchema, + clientInfo: ImplementationSchema + }) + }); + ServerCapabilitiesSchema = external_exports.object({ + /** + * Experimental, non-standard capabilities that the server supports. + */ + experimental: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the server supports sending log messages to the client. + */ + logging: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the server supports sending completions to the client. + */ + completions: external_exports.optional(external_exports.object({}).passthrough()), + /** + * Present if the server offers any prompt templates. + */ + prompts: external_exports.optional(external_exports.object({ + /** + * Whether this server supports issuing notifications for changes to the prompt list. + */ + listChanged: external_exports.optional(external_exports.boolean()) + }).passthrough()), + /** + * Present if the server offers any resources to read. + */ + resources: external_exports.optional(external_exports.object({ + /** + * Whether this server supports clients subscribing to resource updates. + */ + subscribe: external_exports.optional(external_exports.boolean()), + /** + * Whether this server supports issuing notifications for changes to the resource list. + */ + listChanged: external_exports.optional(external_exports.boolean()) + }).passthrough()), + /** + * Present if the server offers any tools to call. + */ + tools: external_exports.optional(external_exports.object({ + /** + * Whether this server supports issuing notifications for changes to the tool list. + */ + listChanged: external_exports.optional(external_exports.boolean()) + }).passthrough()) + }).passthrough(); + InitializeResultSchema = ResultSchema.extend({ + /** + * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect. + */ + protocolVersion: external_exports.string(), + capabilities: ServerCapabilitiesSchema, + serverInfo: ImplementationSchema, + /** + * Instructions describing how to use the server and its features. + * + * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt. + */ + instructions: external_exports.optional(external_exports.string()) + }); + InitializedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/initialized") + }); + PingRequestSchema = RequestSchema.extend({ + method: external_exports.literal("ping") + }); + ProgressSchema = external_exports.object({ + /** + * The progress thus far. This should increase every time progress is made, even if the total is unknown. + */ + progress: external_exports.number(), + /** + * Total number of items to process (or total progress required), if known. + */ + total: external_exports.optional(external_exports.number()), + /** + * An optional message describing the current progress. + */ + message: external_exports.optional(external_exports.string()) + }).passthrough(); + ProgressNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/progress"), + params: BaseNotificationParamsSchema.merge(ProgressSchema).extend({ + /** + * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding. + */ + progressToken: ProgressTokenSchema + }) + }); + PaginatedRequestSchema = RequestSchema.extend({ + params: BaseRequestParamsSchema.extend({ + /** + * An opaque token representing the current pagination position. + * If provided, the server should return results starting after this cursor. + */ + cursor: external_exports.optional(CursorSchema) + }).optional() + }); + PaginatedResultSchema = ResultSchema.extend({ + /** + * An opaque token representing the pagination position after the last returned result. + * If present, there may be more results available. + */ + nextCursor: external_exports.optional(CursorSchema) + }); + ResourceContentsSchema = external_exports.object({ + /** + * The URI of this resource. + */ + uri: external_exports.string(), + /** + * The MIME type of this resource, if known. + */ + mimeType: external_exports.optional(external_exports.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + TextResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * The text of the item. This must only be set if the item can actually be represented as text (not binary data). + */ + text: external_exports.string() + }); + Base64Schema = external_exports.string().refine((val) => { + try { + atob(val); + return true; + } catch (_a) { + return false; + } + }, { message: "Invalid Base64 string" }); + BlobResourceContentsSchema = ResourceContentsSchema.extend({ + /** + * A base64-encoded string representing the binary data of the item. + */ + blob: Base64Schema + }); + ResourceSchema = BaseMetadataSchema.extend({ + /** + * The URI of this resource. + */ + uri: external_exports.string(), + /** + * A description of what this resource represents. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: external_exports.optional(external_exports.string()), + /** + * The MIME type of this resource, if known. + */ + mimeType: external_exports.optional(external_exports.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }); + ResourceTemplateSchema = BaseMetadataSchema.extend({ + /** + * A URI template (according to RFC 6570) that can be used to construct resource URIs. + */ + uriTemplate: external_exports.string(), + /** + * A description of what this template is for. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: external_exports.optional(external_exports.string()), + /** + * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type. + */ + mimeType: external_exports.optional(external_exports.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }); + ListResourcesRequestSchema = PaginatedRequestSchema.extend({ + method: external_exports.literal("resources/list") + }); + ListResourcesResultSchema = PaginatedResultSchema.extend({ + resources: external_exports.array(ResourceSchema) + }); + ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({ + method: external_exports.literal("resources/templates/list") + }); + ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({ + resourceTemplates: external_exports.array(ResourceTemplateSchema) + }); + ReadResourceRequestSchema = RequestSchema.extend({ + method: external_exports.literal("resources/read"), + params: BaseRequestParamsSchema.extend({ + /** + * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it. + */ + uri: external_exports.string() + }) + }); + ReadResourceResultSchema = ResultSchema.extend({ + contents: external_exports.array(external_exports.union([TextResourceContentsSchema, BlobResourceContentsSchema])) + }); + ResourceListChangedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/resources/list_changed") + }); + SubscribeRequestSchema = RequestSchema.extend({ + method: external_exports.literal("resources/subscribe"), + params: BaseRequestParamsSchema.extend({ + /** + * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it. + */ + uri: external_exports.string() + }) + }); + UnsubscribeRequestSchema = RequestSchema.extend({ + method: external_exports.literal("resources/unsubscribe"), + params: BaseRequestParamsSchema.extend({ + /** + * The URI of the resource to unsubscribe from. + */ + uri: external_exports.string() + }) + }); + ResourceUpdatedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/resources/updated"), + params: BaseNotificationParamsSchema.extend({ + /** + * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to. + */ + uri: external_exports.string() + }) + }); + PromptArgumentSchema = external_exports.object({ + /** + * The name of the argument. + */ + name: external_exports.string(), + /** + * A human-readable description of the argument. + */ + description: external_exports.optional(external_exports.string()), + /** + * Whether this argument must be provided. + */ + required: external_exports.optional(external_exports.boolean()) + }).passthrough(); + PromptSchema = BaseMetadataSchema.extend({ + /** + * An optional description of what this prompt provides + */ + description: external_exports.optional(external_exports.string()), + /** + * A list of arguments to use for templating the prompt. + */ + arguments: external_exports.optional(external_exports.array(PromptArgumentSchema)), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }); + ListPromptsRequestSchema = PaginatedRequestSchema.extend({ + method: external_exports.literal("prompts/list") + }); + ListPromptsResultSchema = PaginatedResultSchema.extend({ + prompts: external_exports.array(PromptSchema) + }); + GetPromptRequestSchema = RequestSchema.extend({ + method: external_exports.literal("prompts/get"), + params: BaseRequestParamsSchema.extend({ + /** + * The name of the prompt or prompt template. + */ + name: external_exports.string(), + /** + * Arguments to use for templating the prompt. + */ + arguments: external_exports.optional(external_exports.record(external_exports.string())) + }) + }); + TextContentSchema = external_exports.object({ + type: external_exports.literal("text"), + /** + * The text content of the message. + */ + text: external_exports.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + ImageContentSchema = external_exports.object({ + type: external_exports.literal("image"), + /** + * The base64-encoded image data. + */ + data: Base64Schema, + /** + * The MIME type of the image. Different providers may support different image types. + */ + mimeType: external_exports.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + AudioContentSchema = external_exports.object({ + type: external_exports.literal("audio"), + /** + * The base64-encoded audio data. + */ + data: Base64Schema, + /** + * The MIME type of the audio. Different providers may support different audio types. + */ + mimeType: external_exports.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + EmbeddedResourceSchema = external_exports.object({ + type: external_exports.literal("resource"), + resource: external_exports.union([TextResourceContentsSchema, BlobResourceContentsSchema]), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + ResourceLinkSchema = ResourceSchema.extend({ + type: external_exports.literal("resource_link") + }); + ContentBlockSchema = external_exports.union([ + TextContentSchema, + ImageContentSchema, + AudioContentSchema, + ResourceLinkSchema, + EmbeddedResourceSchema + ]); + PromptMessageSchema = external_exports.object({ + role: external_exports.enum(["user", "assistant"]), + content: ContentBlockSchema + }).passthrough(); + GetPromptResultSchema = ResultSchema.extend({ + /** + * An optional description for the prompt. + */ + description: external_exports.optional(external_exports.string()), + messages: external_exports.array(PromptMessageSchema) + }); + PromptListChangedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/prompts/list_changed") + }); + ToolAnnotationsSchema = external_exports.object({ + /** + * A human-readable title for the tool. + */ + title: external_exports.optional(external_exports.string()), + /** + * If true, the tool does not modify its environment. + * + * Default: false + */ + readOnlyHint: external_exports.optional(external_exports.boolean()), + /** + * If true, the tool may perform destructive updates to its environment. + * If false, the tool performs only additive updates. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: true + */ + destructiveHint: external_exports.optional(external_exports.boolean()), + /** + * If true, calling the tool repeatedly with the same arguments + * will have no additional effect on the its environment. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: false + */ + idempotentHint: external_exports.optional(external_exports.boolean()), + /** + * If true, this tool may interact with an "open world" of external + * entities. If false, the tool's domain of interaction is closed. + * For example, the world of a web search tool is open, whereas that + * of a memory tool is not. + * + * Default: true + */ + openWorldHint: external_exports.optional(external_exports.boolean()) + }).passthrough(); + ToolSchema = BaseMetadataSchema.extend({ + /** + * A human-readable description of the tool. + */ + description: external_exports.optional(external_exports.string()), + /** + * A JSON Schema object defining the expected parameters for the tool. + */ + inputSchema: external_exports.object({ + type: external_exports.literal("object"), + properties: external_exports.optional(external_exports.object({}).passthrough()), + required: external_exports.optional(external_exports.array(external_exports.string())) + }).passthrough(), + /** + * An optional JSON Schema object defining the structure of the tool's output returned in + * the structuredContent field of a CallToolResult. + */ + outputSchema: external_exports.optional(external_exports.object({ + type: external_exports.literal("object"), + properties: external_exports.optional(external_exports.object({}).passthrough()), + required: external_exports.optional(external_exports.array(external_exports.string())) + }).passthrough()), + /** + * Optional additional tool information. + */ + annotations: external_exports.optional(ToolAnnotationsSchema), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }); + ListToolsRequestSchema = PaginatedRequestSchema.extend({ + method: external_exports.literal("tools/list") + }); + ListToolsResultSchema = PaginatedResultSchema.extend({ + tools: external_exports.array(ToolSchema) + }); + CallToolResultSchema = ResultSchema.extend({ + /** + * A list of content objects that represent the result of the tool call. + * + * If the Tool does not define an outputSchema, this field MUST be present in the result. + * For backwards compatibility, this field is always present, but it may be empty. + */ + content: external_exports.array(ContentBlockSchema).default([]), + /** + * An object containing structured tool output. + * + * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema. + */ + structuredContent: external_exports.object({}).passthrough().optional(), + /** + * Whether the tool call ended in an error. + * + * If not set, this is assumed to be false (the call was successful). + * + * Any errors that originate from the tool SHOULD be reported inside the result + * object, with `isError` set to true, _not_ as an MCP protocol-level error + * response. Otherwise, the LLM would not be able to see that an error occurred + * and self-correct. + * + * However, any errors in _finding_ the tool, an error indicating that the + * server does not support tool calls, or any other exceptional conditions, + * should be reported as an MCP error response. + */ + isError: external_exports.optional(external_exports.boolean()) + }); + CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({ + toolResult: external_exports.unknown() + })); + CallToolRequestSchema = RequestSchema.extend({ + method: external_exports.literal("tools/call"), + params: BaseRequestParamsSchema.extend({ + name: external_exports.string(), + arguments: external_exports.optional(external_exports.record(external_exports.unknown())) + }) + }); + ToolListChangedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/tools/list_changed") + }); + LoggingLevelSchema = external_exports.enum([ + "debug", + "info", + "notice", + "warning", + "error", + "critical", + "alert", + "emergency" + ]); + SetLevelRequestSchema = RequestSchema.extend({ + method: external_exports.literal("logging/setLevel"), + params: BaseRequestParamsSchema.extend({ + /** + * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message. + */ + level: LoggingLevelSchema + }) + }); + LoggingMessageNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/message"), + params: BaseNotificationParamsSchema.extend({ + /** + * The severity of this log message. + */ + level: LoggingLevelSchema, + /** + * An optional name of the logger issuing this message. + */ + logger: external_exports.optional(external_exports.string()), + /** + * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here. + */ + data: external_exports.unknown() + }) + }); + ModelHintSchema = external_exports.object({ + /** + * A hint for a model name. + */ + name: external_exports.string().optional() + }).passthrough(); + ModelPreferencesSchema = external_exports.object({ + /** + * Optional hints to use for model selection. + */ + hints: external_exports.optional(external_exports.array(ModelHintSchema)), + /** + * How much to prioritize cost when selecting a model. + */ + costPriority: external_exports.optional(external_exports.number().min(0).max(1)), + /** + * How much to prioritize sampling speed (latency) when selecting a model. + */ + speedPriority: external_exports.optional(external_exports.number().min(0).max(1)), + /** + * How much to prioritize intelligence and capabilities when selecting a model. + */ + intelligencePriority: external_exports.optional(external_exports.number().min(0).max(1)) + }).passthrough(); + SamplingMessageSchema = external_exports.object({ + role: external_exports.enum(["user", "assistant"]), + content: external_exports.union([TextContentSchema, ImageContentSchema, AudioContentSchema]) + }).passthrough(); + CreateMessageRequestSchema = RequestSchema.extend({ + method: external_exports.literal("sampling/createMessage"), + params: BaseRequestParamsSchema.extend({ + messages: external_exports.array(SamplingMessageSchema), + /** + * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt. + */ + systemPrompt: external_exports.optional(external_exports.string()), + /** + * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request. + */ + includeContext: external_exports.optional(external_exports.enum(["none", "thisServer", "allServers"])), + temperature: external_exports.optional(external_exports.number()), + /** + * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested. + */ + maxTokens: external_exports.number().int(), + stopSequences: external_exports.optional(external_exports.array(external_exports.string())), + /** + * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific. + */ + metadata: external_exports.optional(external_exports.object({}).passthrough()), + /** + * The server's preferences for which model to select. + */ + modelPreferences: external_exports.optional(ModelPreferencesSchema) + }) + }); + CreateMessageResultSchema = ResultSchema.extend({ + /** + * The name of the model that generated the message. + */ + model: external_exports.string(), + /** + * The reason why sampling stopped. + */ + stopReason: external_exports.optional(external_exports.enum(["endTurn", "stopSequence", "maxTokens"]).or(external_exports.string())), + role: external_exports.enum(["user", "assistant"]), + content: external_exports.discriminatedUnion("type", [ + TextContentSchema, + ImageContentSchema, + AudioContentSchema + ]) + }); + BooleanSchemaSchema = external_exports.object({ + type: external_exports.literal("boolean"), + title: external_exports.optional(external_exports.string()), + description: external_exports.optional(external_exports.string()), + default: external_exports.optional(external_exports.boolean()) + }).passthrough(); + StringSchemaSchema = external_exports.object({ + type: external_exports.literal("string"), + title: external_exports.optional(external_exports.string()), + description: external_exports.optional(external_exports.string()), + minLength: external_exports.optional(external_exports.number()), + maxLength: external_exports.optional(external_exports.number()), + format: external_exports.optional(external_exports.enum(["email", "uri", "date", "date-time"])) + }).passthrough(); + NumberSchemaSchema = external_exports.object({ + type: external_exports.enum(["number", "integer"]), + title: external_exports.optional(external_exports.string()), + description: external_exports.optional(external_exports.string()), + minimum: external_exports.optional(external_exports.number()), + maximum: external_exports.optional(external_exports.number()) + }).passthrough(); + EnumSchemaSchema = external_exports.object({ + type: external_exports.literal("string"), + title: external_exports.optional(external_exports.string()), + description: external_exports.optional(external_exports.string()), + enum: external_exports.array(external_exports.string()), + enumNames: external_exports.optional(external_exports.array(external_exports.string())) + }).passthrough(); + PrimitiveSchemaDefinitionSchema = external_exports.union([ + BooleanSchemaSchema, + StringSchemaSchema, + NumberSchemaSchema, + EnumSchemaSchema + ]); + ElicitRequestSchema = RequestSchema.extend({ + method: external_exports.literal("elicitation/create"), + params: BaseRequestParamsSchema.extend({ + /** + * The message to present to the user. + */ + message: external_exports.string(), + /** + * The schema for the requested user input. + */ + requestedSchema: external_exports.object({ + type: external_exports.literal("object"), + properties: external_exports.record(external_exports.string(), PrimitiveSchemaDefinitionSchema), + required: external_exports.optional(external_exports.array(external_exports.string())) + }).passthrough() + }) + }); + ElicitResultSchema = ResultSchema.extend({ + /** + * The user's response action. + */ + action: external_exports.enum(["accept", "decline", "cancel"]), + /** + * The collected user input content (only present if action is "accept"). + */ + content: external_exports.optional(external_exports.record(external_exports.string(), external_exports.unknown())) + }); + ResourceTemplateReferenceSchema = external_exports.object({ + type: external_exports.literal("ref/resource"), + /** + * The URI or URI template of the resource. + */ + uri: external_exports.string() + }).passthrough(); + PromptReferenceSchema = external_exports.object({ + type: external_exports.literal("ref/prompt"), + /** + * The name of the prompt or prompt template + */ + name: external_exports.string() + }).passthrough(); + CompleteRequestSchema = RequestSchema.extend({ + method: external_exports.literal("completion/complete"), + params: BaseRequestParamsSchema.extend({ + ref: external_exports.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]), + /** + * The argument's information + */ + argument: external_exports.object({ + /** + * The name of the argument + */ + name: external_exports.string(), + /** + * The value of the argument to use for completion matching. + */ + value: external_exports.string() + }).passthrough(), + context: external_exports.optional(external_exports.object({ + /** + * Previously-resolved variables in a URI template or prompt. + */ + arguments: external_exports.optional(external_exports.record(external_exports.string(), external_exports.string())) + })) + }) + }); + CompleteResultSchema = ResultSchema.extend({ + completion: external_exports.object({ + /** + * An array of completion values. Must not exceed 100 items. + */ + values: external_exports.array(external_exports.string()).max(100), + /** + * The total number of completion options available. This can exceed the number of values actually sent in the response. + */ + total: external_exports.optional(external_exports.number().int()), + /** + * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown. + */ + hasMore: external_exports.optional(external_exports.boolean()) + }).passthrough() + }); + RootSchema = external_exports.object({ + /** + * The URI identifying the root. This *must* start with file:// for now. + */ + uri: external_exports.string().startsWith("file://"), + /** + * An optional name for the root. + */ + name: external_exports.optional(external_exports.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: external_exports.optional(external_exports.object({}).passthrough()) + }).passthrough(); + ListRootsRequestSchema = RequestSchema.extend({ + method: external_exports.literal("roots/list") + }); + ListRootsResultSchema = ResultSchema.extend({ + roots: external_exports.array(RootSchema) + }); + RootsListChangedNotificationSchema = NotificationSchema.extend({ + method: external_exports.literal("notifications/roots/list_changed") + }); + ClientRequestSchema = external_exports.union([ + PingRequestSchema, + InitializeRequestSchema, + CompleteRequestSchema, + SetLevelRequestSchema, + GetPromptRequestSchema, + ListPromptsRequestSchema, + ListResourcesRequestSchema, + ListResourceTemplatesRequestSchema, + ReadResourceRequestSchema, + SubscribeRequestSchema, + UnsubscribeRequestSchema, + CallToolRequestSchema, + ListToolsRequestSchema + ]); + ClientNotificationSchema = external_exports.union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + InitializedNotificationSchema, + RootsListChangedNotificationSchema + ]); + ClientResultSchema = external_exports.union([ + EmptyResultSchema, + CreateMessageResultSchema, + ElicitResultSchema, + ListRootsResultSchema + ]); + ServerRequestSchema = external_exports.union([ + PingRequestSchema, + CreateMessageRequestSchema, + ElicitRequestSchema, + ListRootsRequestSchema + ]); + ServerNotificationSchema = external_exports.union([ + CancelledNotificationSchema, + ProgressNotificationSchema, + LoggingMessageNotificationSchema, + ResourceUpdatedNotificationSchema, + ResourceListChangedNotificationSchema, + ToolListChangedNotificationSchema, + PromptListChangedNotificationSchema + ]); + ServerResultSchema = external_exports.union([ + EmptyResultSchema, + InitializeResultSchema, + CompleteResultSchema, + GetPromptResultSchema, + ListPromptsResultSchema, + ListResourcesResultSchema, + ListResourceTemplatesResultSchema, + ReadResourceResultSchema, + CallToolResultSchema, + ListToolsResultSchema + ]); + McpError = class extends Error { + constructor(code, message, data) { + super(`MCP error ${code}: ${message}`); + this.code = code; + this.data = data; + this.name = "McpError"; + } + }; + } +}); + +// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js +function mergeCapabilities(base, additional) { + return Object.entries(additional).reduce((acc, [key, value]) => { + if (value && typeof value === "object") { + acc[key] = acc[key] ? { ...acc[key], ...value } : value; + } else { + acc[key] = value; + } + return acc; + }, { ...base }); +} +var DEFAULT_REQUEST_TIMEOUT_MSEC, Protocol; +var init_protocol = __esm({ + "node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js"() { + init_types2(); + DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4; + Protocol = class { + constructor(_options) { + this._options = _options; + this._requestMessageId = 0; + this._requestHandlers = /* @__PURE__ */ new Map(); + this._requestHandlerAbortControllers = /* @__PURE__ */ new Map(); + this._notificationHandlers = /* @__PURE__ */ new Map(); + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers = /* @__PURE__ */ new Map(); + this._timeoutInfo = /* @__PURE__ */ new Map(); + this._pendingDebouncedNotifications = /* @__PURE__ */ new Set(); + this.setNotificationHandler(CancelledNotificationSchema, (notification) => { + const controller = this._requestHandlerAbortControllers.get(notification.params.requestId); + controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason); + }); + this.setNotificationHandler(ProgressNotificationSchema, (notification) => { + this._onprogress(notification); + }); + this.setRequestHandler( + PingRequestSchema, + // Automatic pong by default. + (_request) => ({}) + ); + } + _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) { + this._timeoutInfo.set(messageId, { + timeoutId: setTimeout(onTimeout, timeout), + startTime: Date.now(), + timeout, + maxTotalTimeout, + resetTimeoutOnProgress, + onTimeout + }); + } + _resetTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (!info) + return false; + const totalElapsed = Date.now() - info.startTime; + if (info.maxTotalTimeout && totalElapsed >= info.maxTotalTimeout) { + this._timeoutInfo.delete(messageId); + throw new McpError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", { maxTotalTimeout: info.maxTotalTimeout, totalElapsed }); + } + clearTimeout(info.timeoutId); + info.timeoutId = setTimeout(info.onTimeout, info.timeout); + return true; + } + _cleanupTimeout(messageId) { + const info = this._timeoutInfo.get(messageId); + if (info) { + clearTimeout(info.timeoutId); + this._timeoutInfo.delete(messageId); + } + } + /** + * Attaches to the given transport, starts it, and starts listening for messages. + * + * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward. + */ + async connect(transport) { + var _a, _b, _c; + this._transport = transport; + const _onclose = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose; + this._transport.onclose = () => { + _onclose === null || _onclose === void 0 ? void 0 : _onclose(); + this._onclose(); + }; + const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror; + this._transport.onerror = (error) => { + _onerror === null || _onerror === void 0 ? void 0 : _onerror(error); + this._onerror(error); + }; + const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage; + this._transport.onmessage = (message, extra) => { + _onmessage === null || _onmessage === void 0 ? void 0 : _onmessage(message, extra); + if (isJSONRPCResponse(message) || isJSONRPCError(message)) { + this._onresponse(message); + } else if (isJSONRPCRequest(message)) { + this._onrequest(message, extra); + } else if (isJSONRPCNotification(message)) { + this._onnotification(message); + } else { + this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`)); + } + }; + await this._transport.start(); + } + _onclose() { + var _a; + const responseHandlers = this._responseHandlers; + this._responseHandlers = /* @__PURE__ */ new Map(); + this._progressHandlers.clear(); + this._pendingDebouncedNotifications.clear(); + this._transport = void 0; + (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this); + const error = new McpError(ErrorCode.ConnectionClosed, "Connection closed"); + for (const handler of responseHandlers.values()) { + handler(error); + } + } + _onerror(error) { + var _a; + (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error); + } + _onnotification(notification) { + var _a; + const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler; + if (handler === void 0) { + return; + } + Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`))); + } + _onrequest(request, extra) { + var _a, _b; + const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler; + const capturedTransport = this._transport; + if (handler === void 0) { + capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({ + jsonrpc: "2.0", + id: request.id, + error: { + code: ErrorCode.MethodNotFound, + message: "Method not found" + } + }).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`))); + return; + } + const abortController = new AbortController(); + this._requestHandlerAbortControllers.set(request.id, abortController); + const fullExtra = { + signal: abortController.signal, + sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId, + _meta: (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta, + sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }), + sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }), + authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo, + requestId: request.id, + requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo + }; + Promise.resolve().then(() => handler(request, fullExtra)).then((result) => { + if (abortController.signal.aborted) { + return; + } + return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({ + result, + jsonrpc: "2.0", + id: request.id + }); + }, (error) => { + var _a2; + if (abortController.signal.aborted) { + return; + } + return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({ + jsonrpc: "2.0", + id: request.id, + error: { + code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError, + message: (_a2 = error.message) !== null && _a2 !== void 0 ? _a2 : "Internal error" + } + }); + }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => { + this._requestHandlerAbortControllers.delete(request.id); + }); + } + _onprogress(notification) { + const { progressToken, ...params } = notification.params; + const messageId = Number(progressToken); + const handler = this._progressHandlers.get(messageId); + if (!handler) { + this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`)); + return; + } + const responseHandler = this._responseHandlers.get(messageId); + const timeoutInfo = this._timeoutInfo.get(messageId); + if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) { + try { + this._resetTimeout(messageId); + } catch (error) { + responseHandler(error); + return; + } + } + handler(params); + } + _onresponse(response) { + const messageId = Number(response.id); + const handler = this._responseHandlers.get(messageId); + if (handler === void 0) { + this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`)); + return; + } + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + if (isJSONRPCResponse(response)) { + handler(response); + } else { + const error = new McpError(response.error.code, response.error.message, response.error.data); + handler(error); + } + } + get transport() { + return this._transport; + } + /** + * Closes the connection. + */ + async close() { + var _a; + await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close()); + } + /** + * Sends a request and wait for a response. + * + * Do not use this method to emit notifications! Use notification() instead. + */ + request(request, resultSchema, options) { + const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {}; + return new Promise((resolve, reject) => { + var _a, _b, _c, _d, _e, _f; + if (!this._transport) { + reject(new Error("Not connected")); + return; + } + if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) { + this.assertCapabilityForMethod(request.method); + } + (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted(); + const messageId = this._requestMessageId++; + const jsonrpcRequest = { + ...request, + jsonrpc: "2.0", + id: messageId + }; + if (options === null || options === void 0 ? void 0 : options.onprogress) { + this._progressHandlers.set(messageId, options.onprogress); + jsonrpcRequest.params = { + ...request.params, + _meta: { + ...((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {}, + progressToken: messageId + } + }; + } + const cancel = (reason) => { + var _a2; + this._responseHandlers.delete(messageId); + this._progressHandlers.delete(messageId); + this._cleanupTimeout(messageId); + (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({ + jsonrpc: "2.0", + method: "notifications/cancelled", + params: { + requestId: messageId, + reason: String(reason) + } + }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`))); + reject(reason); + }; + this._responseHandlers.set(messageId, (response) => { + var _a2; + if ((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted) { + return; + } + if (response instanceof Error) { + return reject(response); + } + try { + const result = resultSchema.parse(response.result); + resolve(result); + } catch (error) { + reject(error); + } + }); + (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener("abort", () => { + var _a2; + cancel((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.reason); + }); + const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC; + const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", { timeout })); + this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false); + this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => { + this._cleanupTimeout(messageId); + reject(error); + }); + }); + } + /** + * Emits a notification, which is a one-way message that does not expect a response. + */ + async notification(notification, options) { + var _a, _b; + if (!this._transport) { + throw new Error("Not connected"); + } + this.assertNotificationCapability(notification.method); + const debouncedMethods = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.debouncedNotificationMethods) !== null && _b !== void 0 ? _b : []; + const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId); + if (canDebounce) { + if (this._pendingDebouncedNotifications.has(notification.method)) { + return; + } + this._pendingDebouncedNotifications.add(notification.method); + Promise.resolve().then(() => { + var _a2; + this._pendingDebouncedNotifications.delete(notification.method); + if (!this._transport) { + return; + } + const jsonrpcNotification2 = { + ...notification, + jsonrpc: "2.0" + }; + (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send(jsonrpcNotification2, options).catch((error) => this._onerror(error)); + }); + return; + } + const jsonrpcNotification = { + ...notification, + jsonrpc: "2.0" + }; + await this._transport.send(jsonrpcNotification, options); + } + /** + * Registers a handler to invoke when this protocol object receives a request with the given method. + * + * Note that this will replace any previous request handler for the same method. + */ + setRequestHandler(requestSchema, handler) { + const method = requestSchema.shape.method.value; + this.assertRequestHandlerCapability(method); + this._requestHandlers.set(method, (request, extra) => { + return Promise.resolve(handler(requestSchema.parse(request), extra)); + }); + } + /** + * Removes the request handler for the given method. + */ + removeRequestHandler(method) { + this._requestHandlers.delete(method); + } + /** + * Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed. + */ + assertCanSetRequestHandler(method) { + if (this._requestHandlers.has(method)) { + throw new Error(`A request handler for ${method} already exists, which would be overridden`); + } + } + /** + * Registers a handler to invoke when this protocol object receives a notification with the given method. + * + * Note that this will replace any previous notification handler for the same method. + */ + setNotificationHandler(notificationSchema, handler) { + this._notificationHandlers.set(notificationSchema.shape.method.value, (notification) => Promise.resolve(handler(notificationSchema.parse(notification)))); + } + /** + * Removes the notification handler for the given method. + */ + removeNotificationHandler(method) { + this._notificationHandlers.delete(method); + } + }; + } +}); + +// node_modules/uri-js/dist/es5/uri.all.js +var require_uri_all = __commonJS({ + "node_modules/uri-js/dist/es5/uri.all.js"(exports2, module2) { + (function(global2, factory) { + typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.URI = global2.URI || {}); + })(exports2, (function(exports3) { + "use strict"; + function merge() { + for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) { + sets[_key] = arguments[_key]; + } + if (sets.length > 1) { + sets[0] = sets[0].slice(0, -1); + var xl = sets.length - 1; + for (var x = 1; x < xl; ++x) { + sets[x] = sets[x].slice(1, -1); + } + sets[xl] = sets[xl].slice(1); + return sets.join(""); + } else { + return sets[0]; + } + } + function subexp(str) { + return "(?:" + str + ")"; + } + function typeOf(o) { + return o === void 0 ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase(); + } + function toUpperCase(str) { + return str.toUpperCase(); + } + function toArray(obj) { + return obj !== void 0 && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : []; + } + function assign(target, source) { + var obj = target; + if (source) { + for (var key in source) { + obj[key] = source[key]; + } + } + return obj; + } + function buildExps(isIRI2) { + var ALPHA$$ = "[A-Za-z]", CR$ = "[\\x0D]", DIGIT$$ = "[0-9]", DQUOTE$$ = "[\\x22]", HEXDIG$$2 = merge(DIGIT$$, "[A-Fa-f]"), LF$$ = "[\\x0A]", SP$$ = "[\\x20]", PCT_ENCODED$2 = subexp(subexp("%[EFef]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%" + HEXDIG$$2 + HEXDIG$$2)), GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$), UCSCHAR$$ = isIRI2 ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", IPRIVATE$$ = isIRI2 ? "[\\uE000-\\uF8FF]" : "[]", UNRESERVED$$2 = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$), SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*"), USERINFO$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]")) + "*"), DEC_OCTET$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("[1-9]" + DIGIT$$) + "|" + DIGIT$$), DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$), IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$), H16$ = subexp(HEXDIG$$2 + "{1,4}"), LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$), IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$), IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$), IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"), IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")), ZONEID$ = subexp(subexp(UNRESERVED$$2 + "|" + PCT_ENCODED$2) + "+"), IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + "\\%25" + ZONEID$), IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + ZONEID$), IPVFUTURE$ = subexp("[vV]" + HEXDIG$$2 + "+\\." + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]") + "+"), IP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRZ_RELAXED$ + "|" + IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"), REG_NAME$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$)) + "*"), HOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "(?!" + REG_NAME$ + ")|" + REG_NAME$), PORT$ = subexp(DIGIT$$ + "*"), AUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"), PCHAR$ = subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@]")), SEGMENT$ = subexp(PCHAR$ + "*"), SEGMENT_NZ$ = subexp(PCHAR$ + "+"), SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\@]")) + "+"), PATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"), PATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"), PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$), PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$), PATH_EMPTY$ = "(?!" + PCHAR$ + ")", PATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), QUERY$ = subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*"), FRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"), HIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), RELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$), RELATIVE$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), URI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE$), ABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"), GENERIC_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", RELATIVE_REF$ = "^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", ABSOLUTE_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$", SAMEDOC_REF$ = "^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", AUTHORITY_REF$ = "^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$"; + return { + NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"), + NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"), + NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"), + NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"), + NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"), + NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"), + NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"), + ESCAPE: new RegExp(merge("[^]", UNRESERVED$$2, SUB_DELIMS$$), "g"), + UNRESERVED: new RegExp(UNRESERVED$$2, "g"), + OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$2, RESERVED$$), "g"), + PCT_ENCODED: new RegExp(PCT_ENCODED$2, "g"), + IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"), + IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$") + //RFC 6874, with relaxed parsing rules + }; + } + var URI_PROTOCOL = buildExps(false); + var IRI_PROTOCOL = buildExps(true); + var slicedToArray = /* @__PURE__ */ (function() { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = void 0; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) break; + } + } catch (err2) { + _d = true; + _e = err2; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } + return _arr; + } + return function(arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + })(); + var toConsumableArray = function(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } else { + return Array.from(arr); + } + }; + 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-\x7E]/; + 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$1(type) { + throw new RangeError(errors[type]); + } + function map(array, fn) { + var result = []; + var length = array.length; + while (length--) { + result[length] = fn(array[length]); + } + return result; + } + function mapDomain(string, fn) { + var parts = string.split("@"); + var result = ""; + if (parts.length > 1) { + result = parts[0] + "@"; + string = parts[1]; + } + string = string.replace(regexSeparators, "."); + var labels = string.split("."); + var encoded = map(labels, fn).join("."); + return result + encoded; + } + function ucs2decode(string) { + var output = []; + var counter = 0; + var length = string.length; + while (counter < length) { + var value = string.charCodeAt(counter++); + if (value >= 55296 && value <= 56319 && counter < length) { + var 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 = function ucs2encode2(array) { + return String.fromCodePoint.apply(String, toConsumableArray(array)); + }; + var basicToDigit = function basicToDigit2(codePoint) { + if (codePoint - 48 < 10) { + return codePoint - 22; + } + if (codePoint - 65 < 26) { + return codePoint - 65; + } + if (codePoint - 97 < 26) { + return codePoint - 97; + } + return base; + }; + var digitToBasic = function digitToBasic2(digit, flag) { + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + }; + var adapt = function adapt2(delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for ( + ; + /* no initialization */ + delta > baseMinusTMin * tMax >> 1; + k += base + ) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + }; + var decode = function decode2(input) { + var output = []; + var inputLength = input.length; + var i = 0; + var n = initialN; + var bias = initialBias; + var basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + for (var j = 0; j < basic; ++j) { + if (input.charCodeAt(j) >= 128) { + error$1("not-basic"); + } + output.push(input.charCodeAt(j)); + } + for (var index = basic > 0 ? basic + 1 : 0; index < inputLength; ) { + var oldi = i; + for ( + var w = 1, k = base; + ; + /* no condition */ + k += base + ) { + if (index >= inputLength) { + error$1("invalid-input"); + } + var digit = basicToDigit(input.charCodeAt(index++)); + if (digit >= base || digit > floor((maxInt - i) / w)) { + error$1("overflow"); + } + i += digit * w; + var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (digit < t) { + break; + } + var baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error$1("overflow"); + } + w *= baseMinusT; + } + var out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + if (floor(i / out) > maxInt - n) { + error$1("overflow"); + } + n += floor(i / out); + i %= out; + output.splice(i++, 0, n); + } + return String.fromCodePoint.apply(String, output); + }; + var encode = function encode2(input) { + var output = []; + input = ucs2decode(input); + var inputLength = input.length; + var n = initialN; + var delta = 0; + var bias = initialBias; + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = void 0; + try { + for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var _currentValue2 = _step.value; + if (_currentValue2 < 128) { + output.push(stringFromCharCode(_currentValue2)); + } + } + } catch (err2) { + _didIteratorError = true; + _iteratorError = err2; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + var basicLength = output.length; + var handledCPCount = basicLength; + if (basicLength) { + output.push(delimiter); + } + while (handledCPCount < inputLength) { + var m = maxInt; + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = void 0; + try { + for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var currentValue = _step2.value; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + } catch (err2) { + _didIteratorError2 = true; + _iteratorError2 = err2; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + var handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error$1("overflow"); + } + delta += (m - n) * handledCPCountPlusOne; + n = m; + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = void 0; + try { + for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var _currentValue = _step3.value; + if (_currentValue < n && ++delta > maxInt) { + error$1("overflow"); + } + if (_currentValue == n) { + var q = delta; + for ( + var k = base; + ; + /* no condition */ + k += base + ) { + var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (q < t) { + break; + } + var qMinusT = q - t; + var 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; + } + } + } catch (err2) { + _didIteratorError3 = true; + _iteratorError3 = err2; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + ++delta; + ++n; + } + return output.join(""); + }; + var toUnicode = function toUnicode2(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string; + }); + }; + var toASCII = function toASCII2(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.1.0", + /** + * 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 + }; + var SCHEMES = {}; + function pctEncChar(chr) { + var c = chr.charCodeAt(0); + var e = void 0; + if (c < 16) e = "%0" + c.toString(16).toUpperCase(); + else if (c < 128) e = "%" + c.toString(16).toUpperCase(); + else if (c < 2048) e = "%" + (c >> 6 | 192).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase(); + else e = "%" + (c >> 12 | 224).toString(16).toUpperCase() + "%" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase(); + return e; + } + function pctDecChars(str) { + var newStr = ""; + var i = 0; + var il = str.length; + while (i < il) { + var c = parseInt(str.substr(i + 1, 2), 16); + if (c < 128) { + newStr += String.fromCharCode(c); + i += 3; + } else if (c >= 194 && c < 224) { + if (il - i >= 6) { + var c2 = parseInt(str.substr(i + 4, 2), 16); + newStr += String.fromCharCode((c & 31) << 6 | c2 & 63); + } else { + newStr += str.substr(i, 6); + } + i += 6; + } else if (c >= 224) { + if (il - i >= 9) { + var _c = parseInt(str.substr(i + 4, 2), 16); + var c3 = parseInt(str.substr(i + 7, 2), 16); + newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63); + } else { + newStr += str.substr(i, 9); + } + i += 9; + } else { + newStr += str.substr(i, 3); + i += 3; + } + } + return newStr; + } + function _normalizeComponentEncoding(components, protocol) { + function decodeUnreserved2(str) { + var decStr = pctDecChars(str); + return !decStr.match(protocol.UNRESERVED) ? str : decStr; + } + if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_SCHEME, ""); + if (components.userinfo !== void 0) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); + if (components.host !== void 0) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); + if (components.path !== void 0) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); + if (components.query !== void 0) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); + if (components.fragment !== void 0) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase); + return components; + } + function _stripLeadingZeros(str) { + return str.replace(/^0*(.*)/, "$1") || "0"; + } + function _normalizeIPv4(host, protocol) { + var matches = host.match(protocol.IPV4ADDRESS) || []; + var _matches = slicedToArray(matches, 2), address = _matches[1]; + if (address) { + return address.split(".").map(_stripLeadingZeros).join("."); + } else { + return host; + } + } + function _normalizeIPv6(host, protocol) { + var matches = host.match(protocol.IPV6ADDRESS) || []; + var _matches2 = slicedToArray(matches, 3), address = _matches2[1], zone = _matches2[2]; + if (address) { + var _address$toLowerCase$ = address.toLowerCase().split("::").reverse(), _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2), last = _address$toLowerCase$2[0], first = _address$toLowerCase$2[1]; + var firstFields = first ? first.split(":").map(_stripLeadingZeros) : []; + var lastFields = last.split(":").map(_stripLeadingZeros); + var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]); + var fieldCount = isLastFieldIPv4Address ? 7 : 8; + var lastFieldsStart = lastFields.length - fieldCount; + var fields = Array(fieldCount); + for (var x = 0; x < fieldCount; ++x) { + fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || ""; + } + if (isLastFieldIPv4Address) { + fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol); + } + var allZeroFields = fields.reduce(function(acc, field, index) { + if (!field || field === "0") { + var lastLongest = acc[acc.length - 1]; + if (lastLongest && lastLongest.index + lastLongest.length === index) { + lastLongest.length++; + } else { + acc.push({ index, length: 1 }); + } + } + return acc; + }, []); + var longestZeroFields = allZeroFields.sort(function(a, b) { + return b.length - a.length; + })[0]; + var newHost = void 0; + if (longestZeroFields && longestZeroFields.length > 1) { + var newFirst = fields.slice(0, longestZeroFields.index); + var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length); + newHost = newFirst.join(":") + "::" + newLast.join(":"); + } else { + newHost = fields.join(":"); + } + if (zone) { + newHost += "%" + zone; + } + return newHost; + } else { + return host; + } + } + var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i; + var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === void 0; + function parse(uriString) { + var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + var components = {}; + var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL; + if (options.reference === "suffix") uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString; + var matches = uriString.match(URI_PARSE); + if (matches) { + if (NO_MATCH_IS_UNDEFINED) { + components.scheme = matches[1]; + components.userinfo = matches[3]; + components.host = matches[4]; + components.port = parseInt(matches[5], 10); + components.path = matches[6] || ""; + components.query = matches[7]; + components.fragment = matches[8]; + if (isNaN(components.port)) { + components.port = matches[5]; + } + } else { + components.scheme = matches[1] || void 0; + components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : void 0; + components.host = uriString.indexOf("//") !== -1 ? matches[4] : void 0; + components.port = parseInt(matches[5], 10); + components.path = matches[6] || ""; + components.query = uriString.indexOf("?") !== -1 ? matches[7] : void 0; + components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : void 0; + if (isNaN(components.port)) { + components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : void 0; + } + } + if (components.host) { + components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol); + } + if (components.scheme === void 0 && components.userinfo === void 0 && components.host === void 0 && components.port === void 0 && !components.path && components.query === void 0) { + components.reference = "same-document"; + } else if (components.scheme === void 0) { + components.reference = "relative"; + } else if (components.fragment === void 0) { + components.reference = "absolute"; + } else { + components.reference = "uri"; + } + if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) { + components.error = components.error || "URI is not a " + options.reference + " reference."; + } + var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()]; + if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) { + if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) { + try { + components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()); + } catch (e) { + components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e; + } + } + _normalizeComponentEncoding(components, URI_PROTOCOL); + } else { + _normalizeComponentEncoding(components, protocol); + } + if (schemeHandler && schemeHandler.parse) { + schemeHandler.parse(components, options); + } + } else { + components.error = components.error || "URI can not be parsed."; + } + return components; + } + function _recomposeAuthority(components, options) { + var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL; + var uriTokens = []; + if (components.userinfo !== void 0) { + uriTokens.push(components.userinfo); + uriTokens.push("@"); + } + if (components.host !== void 0) { + uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function(_, $1, $2) { + return "[" + $1 + ($2 ? "%25" + $2 : "") + "]"; + })); + } + if (typeof components.port === "number" || typeof components.port === "string") { + uriTokens.push(":"); + uriTokens.push(String(components.port)); + } + return uriTokens.length ? uriTokens.join("") : void 0; + } + var RDS1 = /^\.\.?\//; + var RDS2 = /^\/\.(\/|$)/; + var RDS3 = /^\/\.\.(\/|$)/; + var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/; + function removeDotSegments(input) { + var output = []; + while (input.length) { + if (input.match(RDS1)) { + input = input.replace(RDS1, ""); + } else if (input.match(RDS2)) { + input = input.replace(RDS2, "/"); + } else if (input.match(RDS3)) { + input = input.replace(RDS3, "/"); + output.pop(); + } else if (input === "." || input === "..") { + input = ""; + } else { + var im = input.match(RDS5); + if (im) { + var s = im[0]; + input = input.slice(s.length); + output.push(s); + } else { + throw new Error("Unexpected dot segment condition"); + } + } + } + return output.join(""); + } + function serialize(components) { + var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}; + var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL; + var uriTokens = []; + var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()]; + if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options); + if (components.host) { + if (protocol.IPV6ADDRESS.test(components.host)) { + } else if (options.domainHost || schemeHandler && schemeHandler.domainHost) { + try { + components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host); + } catch (e) { + components.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e; + } + } + } + _normalizeComponentEncoding(components, protocol); + if (options.reference !== "suffix" && components.scheme) { + uriTokens.push(components.scheme); + uriTokens.push(":"); + } + var authority = _recomposeAuthority(components, options); + if (authority !== void 0) { + if (options.reference !== "suffix") { + uriTokens.push("//"); + } + uriTokens.push(authority); + if (components.path && components.path.charAt(0) !== "/") { + uriTokens.push("/"); + } + } + if (components.path !== void 0) { + var s = components.path; + if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { + s = removeDotSegments(s); + } + if (authority === void 0) { + s = s.replace(/^\/\//, "/%2F"); + } + uriTokens.push(s); + } + if (components.query !== void 0) { + uriTokens.push("?"); + uriTokens.push(components.query); + } + if (components.fragment !== void 0) { + uriTokens.push("#"); + uriTokens.push(components.fragment); + } + return uriTokens.join(""); + } + function resolveComponents(base2, relative) { + var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}; + var skipNormalization = arguments[3]; + var target = {}; + if (!skipNormalization) { + base2 = parse(serialize(base2, options), options); + relative = parse(serialize(relative, options), options); + } + options = options || {}; + if (!options.tolerant && relative.scheme) { + target.scheme = relative.scheme; + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) { + target.userinfo = relative.userinfo; + target.host = relative.host; + target.port = relative.port; + target.path = removeDotSegments(relative.path || ""); + target.query = relative.query; + } else { + if (!relative.path) { + target.path = base2.path; + if (relative.query !== void 0) { + target.query = relative.query; + } else { + target.query = base2.query; + } + } else { + if (relative.path.charAt(0) === "/") { + target.path = removeDotSegments(relative.path); + } else { + if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) { + target.path = "/" + relative.path; + } else if (!base2.path) { + target.path = relative.path; + } else { + target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative.path; + } + target.path = removeDotSegments(target.path); + } + target.query = relative.query; + } + target.userinfo = base2.userinfo; + target.host = base2.host; + target.port = base2.port; + } + target.scheme = base2.scheme; + } + target.fragment = relative.fragment; + return target; + } + function resolve(baseURI, relativeURI, options) { + var schemelessOptions = assign({ scheme: "null" }, options); + return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions); + } + function normalize(uri, options) { + if (typeof uri === "string") { + uri = serialize(parse(uri, options), options); + } else if (typeOf(uri) === "object") { + uri = parse(serialize(uri, options), options); + } + return uri; + } + function equal(uriA, uriB, options) { + if (typeof uriA === "string") { + uriA = serialize(parse(uriA, options), options); + } else if (typeOf(uriA) === "object") { + uriA = serialize(uriA, options); + } + if (typeof uriB === "string") { + uriB = serialize(parse(uriB, options), options); + } else if (typeOf(uriB) === "object") { + uriB = serialize(uriB, options); + } + return uriA === uriB; + } + function escapeComponent(str, options) { + return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar); + } + function unescapeComponent(str, options) { + return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars); + } + var handler = { + scheme: "http", + domainHost: true, + parse: function parse2(components, options) { + if (!components.host) { + components.error = components.error || "HTTP URIs must have a host."; + } + return components; + }, + serialize: function serialize2(components, options) { + var secure = String(components.scheme).toLowerCase() === "https"; + if (components.port === (secure ? 443 : 80) || components.port === "") { + components.port = void 0; + } + if (!components.path) { + components.path = "/"; + } + return components; + } + }; + var handler$1 = { + scheme: "https", + domainHost: handler.domainHost, + parse: handler.parse, + serialize: handler.serialize + }; + function isSecure(wsComponents) { + return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss"; + } + var handler$2 = { + scheme: "ws", + domainHost: true, + parse: function parse2(components, options) { + var wsComponents = components; + wsComponents.secure = isSecure(wsComponents); + wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : ""); + wsComponents.path = void 0; + wsComponents.query = void 0; + return wsComponents; + }, + serialize: function serialize2(wsComponents, options) { + if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") { + wsComponents.port = void 0; + } + if (typeof wsComponents.secure === "boolean") { + wsComponents.scheme = wsComponents.secure ? "wss" : "ws"; + wsComponents.secure = void 0; + } + if (wsComponents.resourceName) { + var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1]; + wsComponents.path = path && path !== "/" ? path : void 0; + wsComponents.query = query; + wsComponents.resourceName = void 0; + } + wsComponents.fragment = void 0; + return wsComponents; + } + }; + var handler$3 = { + scheme: "wss", + domainHost: handler$2.domainHost, + parse: handler$2.parse, + serialize: handler$2.serialize + }; + var O = {}; + var isIRI = true; + var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~" + (isIRI ? "\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" : "") + "]"; + var HEXDIG$$ = "[0-9A-Fa-f]"; + var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)); + var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]"; + var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]"; + var VCHAR$$ = merge(QTEXT$$, '[\\"\\\\]'); + var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]"; + var UNRESERVED = new RegExp(UNRESERVED$$, "g"); + var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g"); + var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g"); + var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g"); + var NOT_HFVALUE = NOT_HFNAME; + function decodeUnreserved(str) { + var decStr = pctDecChars(str); + return !decStr.match(UNRESERVED) ? str : decStr; + } + var handler$4 = { + scheme: "mailto", + parse: function parse$$1(components, options) { + var mailtoComponents = components; + var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : []; + mailtoComponents.path = void 0; + if (mailtoComponents.query) { + var unknownHeaders = false; + var headers = {}; + var hfields = mailtoComponents.query.split("&"); + for (var x = 0, xl = hfields.length; x < xl; ++x) { + var hfield = hfields[x].split("="); + switch (hfield[0]) { + case "to": + var toAddrs = hfield[1].split(","); + for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) { + to.push(toAddrs[_x]); + } + break; + case "subject": + mailtoComponents.subject = unescapeComponent(hfield[1], options); + break; + case "body": + mailtoComponents.body = unescapeComponent(hfield[1], options); + break; + default: + unknownHeaders = true; + headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options); + break; + } + } + if (unknownHeaders) mailtoComponents.headers = headers; + } + mailtoComponents.query = void 0; + for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) { + var addr = to[_x2].split("@"); + addr[0] = unescapeComponent(addr[0]); + if (!options.unicodeSupport) { + try { + addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase()); + } catch (e) { + mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e; + } + } else { + addr[1] = unescapeComponent(addr[1], options).toLowerCase(); + } + to[_x2] = addr.join("@"); + } + return mailtoComponents; + }, + serialize: function serialize$$1(mailtoComponents, options) { + var components = mailtoComponents; + var to = toArray(mailtoComponents.to); + if (to) { + for (var x = 0, xl = to.length; x < xl; ++x) { + var toAddr = String(to[x]); + var atIdx = toAddr.lastIndexOf("@"); + var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar); + var domain = toAddr.slice(atIdx + 1); + try { + domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain); + } catch (e) { + components.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e; + } + to[x] = localPart + "@" + domain; + } + components.path = to.join(","); + } + var headers = mailtoComponents.headers = mailtoComponents.headers || {}; + if (mailtoComponents.subject) headers["subject"] = mailtoComponents.subject; + if (mailtoComponents.body) headers["body"] = mailtoComponents.body; + var fields = []; + for (var name in headers) { + if (headers[name] !== O[name]) { + fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + "=" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar)); + } + } + if (fields.length) { + components.query = fields.join("&"); + } + return components; + } + }; + var URN_PARSE = /^([^\:]+)\:(.*)/; + var handler$5 = { + scheme: "urn", + parse: function parse$$1(components, options) { + var matches = components.path && components.path.match(URN_PARSE); + var urnComponents = components; + if (matches) { + var scheme = options.scheme || urnComponents.scheme || "urn"; + var nid = matches[1].toLowerCase(); + var nss = matches[2]; + var urnScheme = scheme + ":" + (options.nid || nid); + var schemeHandler = SCHEMES[urnScheme]; + urnComponents.nid = nid; + urnComponents.nss = nss; + urnComponents.path = void 0; + if (schemeHandler) { + urnComponents = schemeHandler.parse(urnComponents, options); + } + } else { + urnComponents.error = urnComponents.error || "URN can not be parsed."; + } + return urnComponents; + }, + serialize: function serialize$$1(urnComponents, options) { + var scheme = options.scheme || urnComponents.scheme || "urn"; + var nid = urnComponents.nid; + var urnScheme = scheme + ":" + (options.nid || nid); + var schemeHandler = SCHEMES[urnScheme]; + if (schemeHandler) { + urnComponents = schemeHandler.serialize(urnComponents, options); + } + var uriComponents = urnComponents; + var nss = urnComponents.nss; + uriComponents.path = (nid || options.nid) + ":" + nss; + return uriComponents; + } + }; + var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/; + var handler$6 = { + scheme: "urn:uuid", + parse: function parse2(urnComponents, options) { + var uuidComponents = urnComponents; + uuidComponents.uuid = uuidComponents.nss; + uuidComponents.nss = void 0; + if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) { + uuidComponents.error = uuidComponents.error || "UUID is not valid."; + } + return uuidComponents; + }, + serialize: function serialize2(uuidComponents, options) { + var urnComponents = uuidComponents; + urnComponents.nss = (uuidComponents.uuid || "").toLowerCase(); + return urnComponents; + } + }; + SCHEMES[handler.scheme] = handler; + SCHEMES[handler$1.scheme] = handler$1; + SCHEMES[handler$2.scheme] = handler$2; + SCHEMES[handler$3.scheme] = handler$3; + SCHEMES[handler$4.scheme] = handler$4; + SCHEMES[handler$5.scheme] = handler$5; + SCHEMES[handler$6.scheme] = handler$6; + exports3.SCHEMES = SCHEMES; + exports3.pctEncChar = pctEncChar; + exports3.pctDecChars = pctDecChars; + exports3.parse = parse; + exports3.removeDotSegments = removeDotSegments; + exports3.serialize = serialize; + exports3.resolveComponents = resolveComponents; + exports3.resolve = resolve; + exports3.normalize = normalize; + exports3.equal = equal; + exports3.escapeComponent = escapeComponent; + exports3.unescapeComponent = unescapeComponent; + Object.defineProperty(exports3, "__esModule", { value: true }); + })); + } +}); + +// node_modules/fast-deep-equal/index.js +var require_fast_deep_equal = __commonJS({ + "node_modules/fast-deep-equal/index.js"(exports2, module2) { + "use strict"; + module2.exports = function equal(a, b) { + if (a === b) return true; + if (a && b && typeof a == "object" && typeof b == "object") { + if (a.constructor !== b.constructor) return false; + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0; ) + if (!equal(a[i], b[i])) return false; + return true; + } + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + for (i = length; i-- !== 0; ) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + for (i = length; i-- !== 0; ) { + var key = keys[i]; + if (!equal(a[key], b[key])) return false; + } + return true; + } + return a !== a && b !== b; + }; + } +}); + +// node_modules/ajv/lib/compile/ucs2length.js +var require_ucs2length = __commonJS({ + "node_modules/ajv/lib/compile/ucs2length.js"(exports2, module2) { + "use strict"; + module2.exports = function ucs2length(str) { + var length = 0, len = str.length, pos = 0, value; + while (pos < len) { + length++; + value = str.charCodeAt(pos++); + if (value >= 55296 && value <= 56319 && pos < len) { + value = str.charCodeAt(pos); + if ((value & 64512) == 56320) pos++; + } + } + return length; + }; + } +}); + +// node_modules/ajv/lib/compile/util.js +var require_util = __commonJS({ + "node_modules/ajv/lib/compile/util.js"(exports2, module2) { + "use strict"; + module2.exports = { + copy, + checkDataType, + checkDataTypes, + coerceToTypes, + toHash, + getProperty, + escapeQuotes, + equal: require_fast_deep_equal(), + ucs2length: require_ucs2length(), + varOccurences, + varReplace, + schemaHasRules, + schemaHasRulesExcept, + schemaUnknownRules, + toQuotedString, + getPathExpr, + getPath, + getData, + unescapeFragment, + unescapeJsonPointer, + escapeFragment, + escapeJsonPointer + }; + function copy(o, to) { + to = to || {}; + for (var key in o) to[key] = o[key]; + return to; + } + function checkDataType(dataType, data, strictNumbers, negate) { + var EQUAL = negate ? " !== " : " === ", AND = negate ? " || " : " && ", OK3 = negate ? "!" : "", NOT = negate ? "" : "!"; + switch (dataType) { + case "null": + return data + EQUAL + "null"; + case "array": + return OK3 + "Array.isArray(" + data + ")"; + case "object": + return "(" + OK3 + data + AND + "typeof " + data + EQUAL + '"object"' + AND + NOT + "Array.isArray(" + data + "))"; + case "integer": + return "(typeof " + data + EQUAL + '"number"' + AND + NOT + "(" + data + " % 1)" + AND + data + EQUAL + data + (strictNumbers ? AND + OK3 + "isFinite(" + data + ")" : "") + ")"; + case "number": + return "(typeof " + data + EQUAL + '"' + dataType + '"' + (strictNumbers ? AND + OK3 + "isFinite(" + data + ")" : "") + ")"; + default: + return "typeof " + data + EQUAL + '"' + dataType + '"'; + } + } + function checkDataTypes(dataTypes, data, strictNumbers) { + switch (dataTypes.length) { + case 1: + return checkDataType(dataTypes[0], data, strictNumbers, true); + default: + var code = ""; + var types = toHash(dataTypes); + if (types.array && types.object) { + code = types.null ? "(" : "(!" + data + " || "; + code += "typeof " + data + ' !== "object")'; + delete types.null; + delete types.array; + delete types.object; + } + if (types.number) delete types.integer; + for (var t in types) + code += (code ? " && " : "") + checkDataType(t, data, strictNumbers, true); + return code; + } + } + var COERCE_TO_TYPES = toHash(["string", "number", "integer", "boolean", "null"]); + function coerceToTypes(optionCoerceTypes, dataTypes) { + if (Array.isArray(dataTypes)) { + var types = []; + for (var i = 0; i < dataTypes.length; i++) { + var t = dataTypes[i]; + if (COERCE_TO_TYPES[t]) types[types.length] = t; + else if (optionCoerceTypes === "array" && t === "array") types[types.length] = t; + } + if (types.length) return types; + } else if (COERCE_TO_TYPES[dataTypes]) { + return [dataTypes]; + } else if (optionCoerceTypes === "array" && dataTypes === "array") { + return ["array"]; + } + } + function toHash(arr) { + var hash = {}; + for (var i = 0; i < arr.length; i++) hash[arr[i]] = true; + return hash; + } + var IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i; + var SINGLE_QUOTE = /'|\\/g; + function getProperty(key) { + return typeof key == "number" ? "[" + key + "]" : IDENTIFIER.test(key) ? "." + key : "['" + escapeQuotes(key) + "']"; + } + function escapeQuotes(str) { + return str.replace(SINGLE_QUOTE, "\\$&").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\f/g, "\\f").replace(/\t/g, "\\t"); + } + function varOccurences(str, dataVar) { + dataVar += "[^0-9]"; + var matches = str.match(new RegExp(dataVar, "g")); + return matches ? matches.length : 0; + } + function varReplace(str, dataVar, expr) { + dataVar += "([^0-9])"; + expr = expr.replace(/\$/g, "$$$$"); + return str.replace(new RegExp(dataVar, "g"), expr + "$1"); + } + function schemaHasRules(schema, rules) { + if (typeof schema == "boolean") return !schema; + for (var key in schema) if (rules[key]) return true; + } + function schemaHasRulesExcept(schema, rules, exceptKeyword) { + if (typeof schema == "boolean") return !schema && exceptKeyword != "not"; + for (var key in schema) if (key != exceptKeyword && rules[key]) return true; + } + function schemaUnknownRules(schema, rules) { + if (typeof schema == "boolean") return; + for (var key in schema) if (!rules[key]) return key; + } + function toQuotedString(str) { + return "'" + escapeQuotes(str) + "'"; + } + function getPathExpr(currentPath, expr, jsonPointers, isNumber) { + var path = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'"; + return joinPaths(currentPath, path); + } + function getPath(currentPath, prop, jsonPointers) { + var path = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop)); + return joinPaths(currentPath, path); + } + var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/; + var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/; + function getData($data, lvl, paths) { + var up, jsonPointer, data, matches; + if ($data === "") return "rootData"; + if ($data[0] == "/") { + if (!JSON_POINTER.test($data)) throw new Error("Invalid JSON-pointer: " + $data); + jsonPointer = $data; + data = "rootData"; + } else { + matches = $data.match(RELATIVE_JSON_POINTER); + if (!matches) throw new Error("Invalid JSON-pointer: " + $data); + up = +matches[1]; + jsonPointer = matches[2]; + if (jsonPointer == "#") { + if (up >= lvl) throw new Error("Cannot access property/index " + up + " levels up, current level is " + lvl); + return paths[lvl - up]; + } + if (up > lvl) throw new Error("Cannot access data " + up + " levels up, current level is " + lvl); + data = "data" + (lvl - up || ""); + if (!jsonPointer) return data; + } + var expr = data; + var segments = jsonPointer.split("/"); + for (var i = 0; i < segments.length; i++) { + var segment = segments[i]; + if (segment) { + data += getProperty(unescapeJsonPointer(segment)); + expr += " && " + data; + } + } + return expr; + } + function joinPaths(a, b) { + if (a == '""') return b; + return (a + " + " + b).replace(/([^\\])' \+ '/g, "$1"); + } + function unescapeFragment(str) { + return unescapeJsonPointer(decodeURIComponent(str)); + } + function escapeFragment(str) { + return encodeURIComponent(escapeJsonPointer(str)); + } + function escapeJsonPointer(str) { + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + function unescapeJsonPointer(str) { + return str.replace(/~1/g, "/").replace(/~0/g, "~"); + } + } +}); + +// node_modules/ajv/lib/compile/schema_obj.js +var require_schema_obj = __commonJS({ + "node_modules/ajv/lib/compile/schema_obj.js"(exports2, module2) { + "use strict"; + var util3 = require_util(); + module2.exports = SchemaObject; + function SchemaObject(obj) { + util3.copy(obj, this); + } + } +}); + +// node_modules/json-schema-traverse/index.js +var require_json_schema_traverse = __commonJS({ + "node_modules/json-schema-traverse/index.js"(exports2, module2) { + "use strict"; + var traverse = module2.exports = function(schema, opts, cb) { + if (typeof opts == "function") { + cb = opts; + opts = {}; + } + cb = opts.cb || cb; + var pre = typeof cb == "function" ? cb : cb.pre || function() { + }; + var post = cb.post || function() { + }; + _traverse(opts, pre, post, schema, "", schema); + }; + traverse.keywords = { + additionalItems: true, + items: true, + contains: true, + additionalProperties: true, + propertyNames: true, + not: true + }; + traverse.arrayKeywords = { + items: true, + allOf: true, + anyOf: true, + oneOf: true + }; + traverse.propsKeywords = { + definitions: true, + properties: true, + patternProperties: true, + dependencies: true + }; + traverse.skipKeywords = { + default: true, + enum: true, + const: true, + required: true, + maximum: true, + minimum: true, + exclusiveMaximum: true, + exclusiveMinimum: true, + multipleOf: true, + maxLength: true, + minLength: true, + pattern: true, + format: true, + maxItems: true, + minItems: true, + uniqueItems: true, + maxProperties: true, + minProperties: true + }; + function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { + if (schema && typeof schema == "object" && !Array.isArray(schema)) { + pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + for (var key in schema) { + var sch = schema[key]; + if (Array.isArray(sch)) { + if (key in traverse.arrayKeywords) { + for (var i = 0; i < sch.length; i++) + _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i); + } + } else if (key in traverse.propsKeywords) { + if (sch && typeof sch == "object") { + for (var prop in sch) + _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop); + } + } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) { + _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema); + } + } + post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex); + } + } + function escapeJsonPtr(str) { + return str.replace(/~/g, "~0").replace(/\//g, "~1"); + } + } +}); + +// node_modules/ajv/lib/compile/resolve.js +var require_resolve = __commonJS({ + "node_modules/ajv/lib/compile/resolve.js"(exports2, module2) { + "use strict"; + var URI = require_uri_all(); + var equal = require_fast_deep_equal(); + var util3 = require_util(); + var SchemaObject = require_schema_obj(); + var traverse = require_json_schema_traverse(); + module2.exports = resolve; + resolve.normalizeId = normalizeId; + resolve.fullPath = getFullPath; + resolve.url = resolveUrl; + resolve.ids = resolveIds; + resolve.inlineRef = inlineRef; + resolve.schema = resolveSchema; + function resolve(compile, root, ref) { + var refVal = this._refs[ref]; + if (typeof refVal == "string") { + if (this._refs[refVal]) refVal = this._refs[refVal]; + else return resolve.call(this, compile, root, refVal); + } + refVal = refVal || this._schemas[ref]; + if (refVal instanceof SchemaObject) { + return inlineRef(refVal.schema, this._opts.inlineRefs) ? refVal.schema : refVal.validate || this._compile(refVal); + } + var res = resolveSchema.call(this, root, ref); + var schema, v, baseId; + if (res) { + schema = res.schema; + root = res.root; + baseId = res.baseId; + } + if (schema instanceof SchemaObject) { + v = schema.validate || compile.call(this, schema.schema, root, void 0, baseId); + } else if (schema !== void 0) { + v = inlineRef(schema, this._opts.inlineRefs) ? schema : compile.call(this, schema, root, void 0, baseId); + } + return v; + } + function resolveSchema(root, ref) { + var p = URI.parse(ref), refPath = _getFullPath(p), baseId = getFullPath(this._getId(root.schema)); + if (Object.keys(root.schema).length === 0 || refPath !== baseId) { + var id = normalizeId(refPath); + var refVal = this._refs[id]; + if (typeof refVal == "string") { + return resolveRecursive.call(this, root, refVal, p); + } else if (refVal instanceof SchemaObject) { + if (!refVal.validate) this._compile(refVal); + root = refVal; + } else { + refVal = this._schemas[id]; + if (refVal instanceof SchemaObject) { + if (!refVal.validate) this._compile(refVal); + if (id == normalizeId(ref)) + return { schema: refVal, root, baseId }; + root = refVal; + } else { + return; + } + } + if (!root.schema) return; + baseId = getFullPath(this._getId(root.schema)); + } + return getJsonPointer.call(this, p, baseId, root.schema, root); + } + function resolveRecursive(root, ref, parsedRef) { + var res = resolveSchema.call(this, root, ref); + if (res) { + var schema = res.schema; + var baseId = res.baseId; + root = res.root; + var id = this._getId(schema); + if (id) baseId = resolveUrl(baseId, id); + return getJsonPointer.call(this, parsedRef, baseId, schema, root); + } + } + var PREVENT_SCOPE_CHANGE = util3.toHash(["properties", "patternProperties", "enum", "dependencies", "definitions"]); + function getJsonPointer(parsedRef, baseId, schema, root) { + parsedRef.fragment = parsedRef.fragment || ""; + if (parsedRef.fragment.slice(0, 1) != "/") return; + var parts = parsedRef.fragment.split("/"); + for (var i = 1; i < parts.length; i++) { + var part = parts[i]; + if (part) { + part = util3.unescapeFragment(part); + schema = schema[part]; + if (schema === void 0) break; + var id; + if (!PREVENT_SCOPE_CHANGE[part]) { + id = this._getId(schema); + if (id) baseId = resolveUrl(baseId, id); + if (schema.$ref) { + var $ref = resolveUrl(baseId, schema.$ref); + var res = resolveSchema.call(this, root, $ref); + if (res) { + schema = res.schema; + root = res.root; + baseId = res.baseId; + } + } + } + } + } + if (schema !== void 0 && schema !== root.schema) + return { schema, root, baseId }; + } + var SIMPLE_INLINED = util3.toHash([ + "type", + "format", + "pattern", + "maxLength", + "minLength", + "maxProperties", + "minProperties", + "maxItems", + "minItems", + "maximum", + "minimum", + "uniqueItems", + "multipleOf", + "required", + "enum" + ]); + function inlineRef(schema, limit) { + if (limit === false) return false; + if (limit === void 0 || limit === true) return checkNoRef(schema); + else if (limit) return countKeys(schema) <= limit; + } + function checkNoRef(schema) { + var item; + if (Array.isArray(schema)) { + for (var i = 0; i < schema.length; i++) { + item = schema[i]; + if (typeof item == "object" && !checkNoRef(item)) return false; + } + } else { + for (var key in schema) { + if (key == "$ref") return false; + item = schema[key]; + if (typeof item == "object" && !checkNoRef(item)) return false; + } + } + return true; + } + function countKeys(schema) { + var count = 0, item; + if (Array.isArray(schema)) { + for (var i = 0; i < schema.length; i++) { + item = schema[i]; + if (typeof item == "object") count += countKeys(item); + if (count == Infinity) return Infinity; + } + } else { + for (var key in schema) { + if (key == "$ref") return Infinity; + if (SIMPLE_INLINED[key]) { + count++; + } else { + item = schema[key]; + if (typeof item == "object") count += countKeys(item) + 1; + if (count == Infinity) return Infinity; + } + } + } + return count; + } + function getFullPath(id, normalize) { + if (normalize !== false) id = normalizeId(id); + var p = URI.parse(id); + return _getFullPath(p); + } + function _getFullPath(p) { + return URI.serialize(p).split("#")[0] + "#"; + } + var TRAILING_SLASH_HASH = /#\/?$/; + function normalizeId(id) { + return id ? id.replace(TRAILING_SLASH_HASH, "") : ""; + } + function resolveUrl(baseId, id) { + id = normalizeId(id); + return URI.resolve(baseId, id); + } + function resolveIds(schema) { + var schemaId = normalizeId(this._getId(schema)); + var baseIds = { "": schemaId }; + var fullPaths = { "": getFullPath(schemaId, false) }; + var localRefs = {}; + var self2 = this; + traverse(schema, { allKeys: true }, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) { + if (jsonPtr === "") return; + var id = self2._getId(sch); + var baseId = baseIds[parentJsonPtr]; + var fullPath = fullPaths[parentJsonPtr] + "/" + parentKeyword; + if (keyIndex !== void 0) + fullPath += "/" + (typeof keyIndex == "number" ? keyIndex : util3.escapeFragment(keyIndex)); + if (typeof id == "string") { + id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id); + var refVal = self2._refs[id]; + if (typeof refVal == "string") refVal = self2._refs[refVal]; + if (refVal && refVal.schema) { + if (!equal(sch, refVal.schema)) + throw new Error('id "' + id + '" resolves to more than one schema'); + } else if (id != normalizeId(fullPath)) { + if (id[0] == "#") { + if (localRefs[id] && !equal(sch, localRefs[id])) + throw new Error('id "' + id + '" resolves to more than one schema'); + localRefs[id] = sch; + } else { + self2._refs[id] = fullPath; + } + } + } + baseIds[jsonPtr] = baseId; + fullPaths[jsonPtr] = fullPath; + }); + return localRefs; + } + } +}); + +// node_modules/ajv/lib/compile/error_classes.js +var require_error_classes = __commonJS({ + "node_modules/ajv/lib/compile/error_classes.js"(exports2, module2) { + "use strict"; + var resolve = require_resolve(); + module2.exports = { + Validation: errorSubclass(ValidationError), + MissingRef: errorSubclass(MissingRefError) + }; + function ValidationError(errors) { + this.message = "validation failed"; + this.errors = errors; + this.ajv = this.validation = true; + } + MissingRefError.message = function(baseId, ref) { + return "can't resolve reference " + ref + " from id " + baseId; + }; + function MissingRefError(baseId, ref, message) { + this.message = message || MissingRefError.message(baseId, ref); + this.missingRef = resolve.url(baseId, ref); + this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef)); + } + function errorSubclass(Subclass) { + Subclass.prototype = Object.create(Error.prototype); + Subclass.prototype.constructor = Subclass; + return Subclass; + } + } +}); + +// node_modules/fast-json-stable-stringify/index.js +var require_fast_json_stable_stringify = __commonJS({ + "node_modules/fast-json-stable-stringify/index.js"(exports2, module2) { + "use strict"; + module2.exports = function(data, opts) { + if (!opts) opts = {}; + if (typeof opts === "function") opts = { cmp: opts }; + var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false; + var cmp = opts.cmp && /* @__PURE__ */ (function(f) { + return function(node) { + return function(a, b) { + var aobj = { key: a, value: node[a] }; + var bobj = { key: b, value: node[b] }; + return f(aobj, bobj); + }; + }; + })(opts.cmp); + var seen = []; + return (function stringify(node) { + if (node && node.toJSON && typeof node.toJSON === "function") { + node = node.toJSON(); + } + if (node === void 0) return; + if (typeof node == "number") return isFinite(node) ? "" + node : "null"; + if (typeof node !== "object") return JSON.stringify(node); + var i, out; + if (Array.isArray(node)) { + out = "["; + for (i = 0; i < node.length; i++) { + if (i) out += ","; + out += stringify(node[i]) || "null"; + } + return out + "]"; + } + if (node === null) return "null"; + if (seen.indexOf(node) !== -1) { + if (cycles) return JSON.stringify("__cycle__"); + throw new TypeError("Converting circular structure to JSON"); + } + var seenIndex = seen.push(node) - 1; + var keys = Object.keys(node).sort(cmp && cmp(node)); + out = ""; + for (i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = stringify(node[key]); + if (!value) continue; + if (out) out += ","; + out += JSON.stringify(key) + ":" + value; + } + seen.splice(seenIndex, 1); + return "{" + out + "}"; + })(data); + }; + } +}); + +// node_modules/ajv/lib/dotjs/validate.js +var require_validate = __commonJS({ + "node_modules/ajv/lib/dotjs/validate.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_validate(it, $keyword, $ruleType) { + var out = ""; + var $async = it.schema.$async === true, $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, "$ref"), $id = it.self._getId(it.schema); + if (it.opts.strictKeywords) { + var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords); + if ($unknownKwd) { + var $keywordsMsg = "unknown keyword: " + $unknownKwd; + if (it.opts.strictKeywords === "log") it.logger.warn($keywordsMsg); + else throw new Error($keywordsMsg); + } + } + if (it.isTop) { + out += " var validate = "; + if ($async) { + it.async = true; + out += "async "; + } + out += "function(data, dataPath, parentData, parentDataProperty, rootData) { 'use strict'; "; + if ($id && (it.opts.sourceCode || it.opts.processCode)) { + out += " " + ("/*# sourceURL=" + $id + " */") + " "; + } + } + if (typeof it.schema == "boolean" || !($refKeywords || it.schema.$ref)) { + var $keyword = "false schema"; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + if (it.schema === false) { + if (it.isTop) { + $breakOnError = true; + } else { + out += " var " + $valid + " = false; "; + } + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "false schema") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: 'boolean schema is false' "; + } + if (it.opts.verbose) { + out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + } else { + if (it.isTop) { + if ($async) { + out += " return data; "; + } else { + out += " validate.errors = null; return true; "; + } + } else { + out += " var " + $valid + " = true; "; + } + } + if (it.isTop) { + out += " }; return validate; "; + } + return out; + } + if (it.isTop) { + var $top = it.isTop, $lvl = it.level = 0, $dataLvl = it.dataLevel = 0, $data = "data"; + it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema)); + it.baseId = it.baseId || it.rootId; + delete it.isTop; + it.dataPathArr = [""]; + if (it.schema.default !== void 0 && it.opts.useDefaults && it.opts.strictDefaults) { + var $defaultMsg = "default is ignored in the schema root"; + if (it.opts.strictDefaults === "log") it.logger.warn($defaultMsg); + else throw new Error($defaultMsg); + } + out += " var vErrors = null; "; + out += " var errors = 0; "; + out += " if (rootData === undefined) rootData = data; "; + } else { + var $lvl = it.level, $dataLvl = it.dataLevel, $data = "data" + ($dataLvl || ""); + if ($id) it.baseId = it.resolve.url(it.baseId, $id); + if ($async && !it.async) throw new Error("async schema in sync schema"); + out += " var errs_" + $lvl + " = errors;"; + } + var $valid = "valid" + $lvl, $breakOnError = !it.opts.allErrors, $closingBraces1 = "", $closingBraces2 = ""; + var $errorKeyword; + var $typeSchema = it.schema.type, $typeIsArray = Array.isArray($typeSchema); + if ($typeSchema && it.opts.nullable && it.schema.nullable === true) { + if ($typeIsArray) { + if ($typeSchema.indexOf("null") == -1) $typeSchema = $typeSchema.concat("null"); + } else if ($typeSchema != "null") { + $typeSchema = [$typeSchema, "null"]; + $typeIsArray = true; + } + } + if ($typeIsArray && $typeSchema.length == 1) { + $typeSchema = $typeSchema[0]; + $typeIsArray = false; + } + if (it.schema.$ref && $refKeywords) { + if (it.opts.extendRefs == "fail") { + throw new Error('$ref: validation keywords used in schema at path "' + it.errSchemaPath + '" (see option extendRefs)'); + } else if (it.opts.extendRefs !== true) { + $refKeywords = false; + it.logger.warn('$ref: keywords ignored in schema at path "' + it.errSchemaPath + '"'); + } + } + if (it.schema.$comment && it.opts.$comment) { + out += " " + it.RULES.all.$comment.code(it, "$comment"); + } + if ($typeSchema) { + if (it.opts.coerceTypes) { + var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema); + } + var $rulesGroup = it.RULES.types[$typeSchema]; + if ($coerceToTypes || $typeIsArray || $rulesGroup === true || $rulesGroup && !$shouldUseGroup($rulesGroup)) { + var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type"; + var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type", $method = $typeIsArray ? "checkDataTypes" : "checkDataType"; + out += " if (" + it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true) + ") { "; + if ($coerceToTypes) { + var $dataType = "dataType" + $lvl, $coerced = "coerced" + $lvl; + out += " var " + $dataType + " = typeof " + $data + "; var " + $coerced + " = undefined; "; + if (it.opts.coerceTypes == "array") { + out += " if (" + $dataType + " == 'object' && Array.isArray(" + $data + ") && " + $data + ".length == 1) { " + $data + " = " + $data + "[0]; " + $dataType + " = typeof " + $data + "; if (" + it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers) + ") " + $coerced + " = " + $data + "; } "; + } + out += " if (" + $coerced + " !== undefined) ; "; + var arr1 = $coerceToTypes; + if (arr1) { + var $type, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $type = arr1[$i += 1]; + if ($type == "string") { + out += " else if (" + $dataType + " == 'number' || " + $dataType + " == 'boolean') " + $coerced + " = '' + " + $data + "; else if (" + $data + " === null) " + $coerced + " = ''; "; + } else if ($type == "number" || $type == "integer") { + out += " else if (" + $dataType + " == 'boolean' || " + $data + " === null || (" + $dataType + " == 'string' && " + $data + " && " + $data + " == +" + $data + " "; + if ($type == "integer") { + out += " && !(" + $data + " % 1)"; + } + out += ")) " + $coerced + " = +" + $data + "; "; + } else if ($type == "boolean") { + out += " else if (" + $data + " === 'false' || " + $data + " === 0 || " + $data + " === null) " + $coerced + " = false; else if (" + $data + " === 'true' || " + $data + " === 1) " + $coerced + " = true; "; + } else if ($type == "null") { + out += " else if (" + $data + " === '' || " + $data + " === 0 || " + $data + " === false) " + $coerced + " = null; "; + } else if (it.opts.coerceTypes == "array" && $type == "array") { + out += " else if (" + $dataType + " == 'string' || " + $dataType + " == 'number' || " + $dataType + " == 'boolean' || " + $data + " == null) " + $coerced + " = [" + $data + "]; "; + } + } + } + out += " else { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '"; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' } "; + if (it.opts.messages !== false) { + out += " , message: 'should be "; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } if (" + $coerced + " !== undefined) { "; + var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty"; + out += " " + $data + " = " + $coerced + "; "; + if (!$dataLvl) { + out += "if (" + $parentData + " !== undefined)"; + } + out += " " + $parentData + "[" + $parentDataProperty + "] = " + $coerced + "; } "; + } else { + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '"; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' } "; + if (it.opts.messages !== false) { + out += " , message: 'should be "; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + } + out += " } "; + } + } + if (it.schema.$ref && !$refKeywords) { + out += " " + it.RULES.all.$ref.code(it, "$ref") + " "; + if ($breakOnError) { + out += " } if (errors === "; + if ($top) { + out += "0"; + } else { + out += "errs_" + $lvl; + } + out += ") { "; + $closingBraces2 += "}"; + } + } else { + var arr2 = it.RULES; + if (arr2) { + var $rulesGroup, i2 = -1, l2 = arr2.length - 1; + while (i2 < l2) { + $rulesGroup = arr2[i2 += 1]; + if ($shouldUseGroup($rulesGroup)) { + if ($rulesGroup.type) { + out += " if (" + it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers) + ") { "; + } + if (it.opts.useDefaults) { + if ($rulesGroup.type == "object" && it.schema.properties) { + var $schema = it.schema.properties, $schemaKeys = Object.keys($schema); + var arr3 = $schemaKeys; + if (arr3) { + var $propertyKey, i3 = -1, l3 = arr3.length - 1; + while (i3 < l3) { + $propertyKey = arr3[i3 += 1]; + var $sch = $schema[$propertyKey]; + if ($sch.default !== void 0) { + var $passData = $data + it.util.getProperty($propertyKey); + if (it.compositeRule) { + if (it.opts.strictDefaults) { + var $defaultMsg = "default is ignored for: " + $passData; + if (it.opts.strictDefaults === "log") it.logger.warn($defaultMsg); + else throw new Error($defaultMsg); + } + } else { + out += " if (" + $passData + " === undefined "; + if (it.opts.useDefaults == "empty") { + out += " || " + $passData + " === null || " + $passData + " === '' "; + } + out += " ) " + $passData + " = "; + if (it.opts.useDefaults == "shared") { + out += " " + it.useDefault($sch.default) + " "; + } else { + out += " " + JSON.stringify($sch.default) + " "; + } + out += "; "; + } + } + } + } + } else if ($rulesGroup.type == "array" && Array.isArray(it.schema.items)) { + var arr4 = it.schema.items; + if (arr4) { + var $sch, $i = -1, l4 = arr4.length - 1; + while ($i < l4) { + $sch = arr4[$i += 1]; + if ($sch.default !== void 0) { + var $passData = $data + "[" + $i + "]"; + if (it.compositeRule) { + if (it.opts.strictDefaults) { + var $defaultMsg = "default is ignored for: " + $passData; + if (it.opts.strictDefaults === "log") it.logger.warn($defaultMsg); + else throw new Error($defaultMsg); + } + } else { + out += " if (" + $passData + " === undefined "; + if (it.opts.useDefaults == "empty") { + out += " || " + $passData + " === null || " + $passData + " === '' "; + } + out += " ) " + $passData + " = "; + if (it.opts.useDefaults == "shared") { + out += " " + it.useDefault($sch.default) + " "; + } else { + out += " " + JSON.stringify($sch.default) + " "; + } + out += "; "; + } + } + } + } + } + } + var arr5 = $rulesGroup.rules; + if (arr5) { + var $rule, i5 = -1, l5 = arr5.length - 1; + while (i5 < l5) { + $rule = arr5[i5 += 1]; + if ($shouldUseRule($rule)) { + var $code = $rule.code(it, $rule.keyword, $rulesGroup.type); + if ($code) { + out += " " + $code + " "; + if ($breakOnError) { + $closingBraces1 += "}"; + } + } + } + } + } + if ($breakOnError) { + out += " " + $closingBraces1 + " "; + $closingBraces1 = ""; + } + if ($rulesGroup.type) { + out += " } "; + if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) { + out += " else { "; + var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type"; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '"; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' } "; + if (it.opts.messages !== false) { + out += " , message: 'should be "; + if ($typeIsArray) { + out += "" + $typeSchema.join(","); + } else { + out += "" + $typeSchema; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } "; + } + } + if ($breakOnError) { + out += " if (errors === "; + if ($top) { + out += "0"; + } else { + out += "errs_" + $lvl; + } + out += ") { "; + $closingBraces2 += "}"; + } + } + } + } + } + if ($breakOnError) { + out += " " + $closingBraces2 + " "; + } + if ($top) { + if ($async) { + out += " if (errors === 0) return data; "; + out += " else throw new ValidationError(vErrors); "; + } else { + out += " validate.errors = vErrors; "; + out += " return errors === 0; "; + } + out += " }; return validate;"; + } else { + out += " var " + $valid + " = errors === errs_" + $lvl + ";"; + } + function $shouldUseGroup($rulesGroup2) { + var rules = $rulesGroup2.rules; + for (var i = 0; i < rules.length; i++) + if ($shouldUseRule(rules[i])) return true; + } + function $shouldUseRule($rule2) { + return it.schema[$rule2.keyword] !== void 0 || $rule2.implements && $ruleImplementsSomeKeyword($rule2); + } + function $ruleImplementsSomeKeyword($rule2) { + var impl = $rule2.implements; + for (var i = 0; i < impl.length; i++) + if (it.schema[impl[i]] !== void 0) return true; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/compile/index.js +var require_compile = __commonJS({ + "node_modules/ajv/lib/compile/index.js"(exports2, module2) { + "use strict"; + var resolve = require_resolve(); + var util3 = require_util(); + var errorClasses = require_error_classes(); + var stableStringify = require_fast_json_stable_stringify(); + var validateGenerator = require_validate(); + var ucs2length = util3.ucs2length; + var equal = require_fast_deep_equal(); + var ValidationError = errorClasses.Validation; + module2.exports = compile; + function compile(schema, root, localRefs, baseId) { + var self2 = this, opts = this._opts, refVal = [void 0], refs = {}, patterns = [], patternsHash = {}, defaults = [], defaultsHash = {}, customRules = []; + root = root || { schema, refVal, refs }; + var c = checkCompiling.call(this, schema, root, baseId); + var compilation = this._compilations[c.index]; + if (c.compiling) return compilation.callValidate = callValidate; + var formats = this._formats; + var RULES = this.RULES; + try { + var v = localCompile(schema, root, localRefs, baseId); + compilation.validate = v; + var cv = compilation.callValidate; + if (cv) { + cv.schema = v.schema; + cv.errors = null; + cv.refs = v.refs; + cv.refVal = v.refVal; + cv.root = v.root; + cv.$async = v.$async; + if (opts.sourceCode) cv.source = v.source; + } + return v; + } finally { + endCompiling.call(this, schema, root, baseId); + } + function callValidate() { + var validate = compilation.validate; + var result = validate.apply(this, arguments); + callValidate.errors = validate.errors; + return result; + } + function localCompile(_schema, _root, localRefs2, baseId2) { + var isRoot = !_root || _root && _root.schema == _schema; + if (_root.schema != root.schema) + return compile.call(self2, _schema, _root, localRefs2, baseId2); + var $async = _schema.$async === true; + var sourceCode = validateGenerator({ + isTop: true, + schema: _schema, + isRoot, + baseId: baseId2, + root: _root, + schemaPath: "", + errSchemaPath: "#", + errorPath: '""', + MissingRefError: errorClasses.MissingRef, + RULES, + validate: validateGenerator, + util: util3, + resolve, + resolveRef, + usePattern, + useDefault, + useCustomRule, + opts, + formats, + logger: self2.logger, + self: self2 + }); + sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) + vars(defaults, defaultCode) + vars(customRules, customRuleCode) + sourceCode; + if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema); + var validate; + try { + var makeValidate = new Function( + "self", + "RULES", + "formats", + "root", + "refVal", + "defaults", + "customRules", + "equal", + "ucs2length", + "ValidationError", + sourceCode + ); + validate = makeValidate( + self2, + RULES, + formats, + root, + refVal, + defaults, + customRules, + equal, + ucs2length, + ValidationError + ); + refVal[0] = validate; + } catch (e) { + self2.logger.error("Error compiling schema, function code:", sourceCode); + throw e; + } + validate.schema = _schema; + validate.errors = null; + validate.refs = refs; + validate.refVal = refVal; + validate.root = isRoot ? validate : _root; + if ($async) validate.$async = true; + if (opts.sourceCode === true) { + validate.source = { + code: sourceCode, + patterns, + defaults + }; + } + return validate; + } + function resolveRef(baseId2, ref, isRoot) { + ref = resolve.url(baseId2, ref); + var refIndex = refs[ref]; + var _refVal, refCode; + if (refIndex !== void 0) { + _refVal = refVal[refIndex]; + refCode = "refVal[" + refIndex + "]"; + return resolvedRef(_refVal, refCode); + } + if (!isRoot && root.refs) { + var rootRefId = root.refs[ref]; + if (rootRefId !== void 0) { + _refVal = root.refVal[rootRefId]; + refCode = addLocalRef(ref, _refVal); + return resolvedRef(_refVal, refCode); + } + } + refCode = addLocalRef(ref); + var v2 = resolve.call(self2, localCompile, root, ref); + if (v2 === void 0) { + var localSchema = localRefs && localRefs[ref]; + if (localSchema) { + v2 = resolve.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2); + } + } + if (v2 === void 0) { + removeLocalRef(ref); + } else { + replaceLocalRef(ref, v2); + return resolvedRef(v2, refCode); + } + } + function addLocalRef(ref, v2) { + var refId = refVal.length; + refVal[refId] = v2; + refs[ref] = refId; + return "refVal" + refId; + } + function removeLocalRef(ref) { + delete refs[ref]; + } + function replaceLocalRef(ref, v2) { + var refId = refs[ref]; + refVal[refId] = v2; + } + function resolvedRef(refVal2, code) { + return typeof refVal2 == "object" || typeof refVal2 == "boolean" ? { code, schema: refVal2, inline: true } : { code, $async: refVal2 && !!refVal2.$async }; + } + function usePattern(regexStr) { + var index = patternsHash[regexStr]; + if (index === void 0) { + index = patternsHash[regexStr] = patterns.length; + patterns[index] = regexStr; + } + return "pattern" + index; + } + function useDefault(value) { + switch (typeof value) { + case "boolean": + case "number": + return "" + value; + case "string": + return util3.toQuotedString(value); + case "object": + if (value === null) return "null"; + var valueStr = stableStringify(value); + var index = defaultsHash[valueStr]; + if (index === void 0) { + index = defaultsHash[valueStr] = defaults.length; + defaults[index] = value; + } + return "default" + index; + } + } + function useCustomRule(rule, schema2, parentSchema, it) { + if (self2._opts.validateSchema !== false) { + var deps = rule.definition.dependencies; + if (deps && !deps.every(function(keyword) { + return Object.prototype.hasOwnProperty.call(parentSchema, keyword); + })) + throw new Error("parent schema must have all required keywords: " + deps.join(",")); + var validateSchema = rule.definition.validateSchema; + if (validateSchema) { + var valid = validateSchema(schema2); + if (!valid) { + var message = "keyword schema is invalid: " + self2.errorsText(validateSchema.errors); + if (self2._opts.validateSchema == "log") self2.logger.error(message); + else throw new Error(message); + } + } + } + var compile2 = rule.definition.compile, inline = rule.definition.inline, macro = rule.definition.macro; + var validate; + if (compile2) { + validate = compile2.call(self2, schema2, parentSchema, it); + } else if (macro) { + validate = macro.call(self2, schema2, parentSchema, it); + if (opts.validateSchema !== false) self2.validateSchema(validate, true); + } else if (inline) { + validate = inline.call(self2, it, rule.keyword, schema2, parentSchema); + } else { + validate = rule.definition.validate; + if (!validate) return; + } + if (validate === void 0) + throw new Error('custom keyword "' + rule.keyword + '"failed to compile'); + var index = customRules.length; + customRules[index] = validate; + return { + code: "customRule" + index, + validate + }; + } + } + function checkCompiling(schema, root, baseId) { + var index = compIndex.call(this, schema, root, baseId); + if (index >= 0) return { index, compiling: true }; + index = this._compilations.length; + this._compilations[index] = { + schema, + root, + baseId + }; + return { index, compiling: false }; + } + function endCompiling(schema, root, baseId) { + var i = compIndex.call(this, schema, root, baseId); + if (i >= 0) this._compilations.splice(i, 1); + } + function compIndex(schema, root, baseId) { + for (var i = 0; i < this._compilations.length; i++) { + var c = this._compilations[i]; + if (c.schema == schema && c.root == root && c.baseId == baseId) return i; + } + return -1; + } + function patternCode(i, patterns) { + return "var pattern" + i + " = new RegExp(" + util3.toQuotedString(patterns[i]) + ");"; + } + function defaultCode(i) { + return "var default" + i + " = defaults[" + i + "];"; + } + function refValCode(i, refVal) { + return refVal[i] === void 0 ? "" : "var refVal" + i + " = refVal[" + i + "];"; + } + function customRuleCode(i) { + return "var customRule" + i + " = customRules[" + i + "];"; + } + function vars(arr, statement) { + if (!arr.length) return ""; + var code = ""; + for (var i = 0; i < arr.length; i++) + code += statement(i, arr); + return code; + } + } +}); + +// node_modules/ajv/lib/cache.js +var require_cache = __commonJS({ + "node_modules/ajv/lib/cache.js"(exports2, module2) { + "use strict"; + var Cache = module2.exports = function Cache2() { + this._cache = {}; + }; + Cache.prototype.put = function Cache_put(key, value) { + this._cache[key] = value; + }; + Cache.prototype.get = function Cache_get(key) { + return this._cache[key]; + }; + Cache.prototype.del = function Cache_del(key) { + delete this._cache[key]; + }; + Cache.prototype.clear = function Cache_clear() { + this._cache = {}; + }; + } +}); + +// node_modules/ajv/lib/compile/formats.js +var require_formats = __commonJS({ + "node_modules/ajv/lib/compile/formats.js"(exports2, module2) { + "use strict"; + var util3 = require_util(); + var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/; + var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i; + var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i; + var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; + var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i; + var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i; + var URL2 = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i; + var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i; + var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/; + var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i; + var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/; + module2.exports = formats; + function formats(mode) { + mode = mode == "full" ? "full" : "fast"; + return util3.copy(formats[mode]); + } + formats.fast = { + // date: http://tools.ietf.org/html/rfc3339#section-5.6 + date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/, + // date-time: http://tools.ietf.org/html/rfc3339#section-5.6 + time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, + "date-time": /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, + // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js + uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i, + "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i, + "uri-template": URITEMPLATE, + url: URL2, + // email (sources from jsen validator): + // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363 + // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation') + email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i, + hostname: HOSTNAME, + // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html + ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, + // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses + ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i, + regex, + // uuid: http://tools.ietf.org/html/rfc4122 + uuid: UUID, + // JSON-pointer: https://tools.ietf.org/html/rfc6901 + // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A + "json-pointer": JSON_POINTER, + "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT, + // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00 + "relative-json-pointer": RELATIVE_JSON_POINTER + }; + formats.full = { + date, + time, + "date-time": date_time, + uri, + "uri-reference": URIREF, + "uri-template": URITEMPLATE, + url: URL2, + email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i, + hostname: HOSTNAME, + ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/, + ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i, + regex, + uuid: UUID, + "json-pointer": JSON_POINTER, + "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT, + "relative-json-pointer": RELATIVE_JSON_POINTER + }; + function isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + function date(str) { + var matches = str.match(DATE); + if (!matches) return false; + var year = +matches[1]; + var month = +matches[2]; + var day = +matches[3]; + return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]); + } + function time(str, full) { + var matches = str.match(TIME); + if (!matches) return false; + var hour = matches[1]; + var minute = matches[2]; + var second = matches[3]; + var timeZone = matches[5]; + return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone); + } + var DATE_TIME_SEPARATOR = /t|\s/i; + function date_time(str) { + var dateTime = str.split(DATE_TIME_SEPARATOR); + return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true); + } + var NOT_URI_FRAGMENT = /\/|:/; + function uri(str) { + return NOT_URI_FRAGMENT.test(str) && URI.test(str); + } + var Z_ANCHOR = /[^\\]\\Z/; + function regex(str) { + if (Z_ANCHOR.test(str)) return false; + try { + new RegExp(str); + return true; + } catch (e) { + return false; + } + } + } +}); + +// node_modules/ajv/lib/dotjs/ref.js +var require_ref = __commonJS({ + "node_modules/ajv/lib/dotjs/ref.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_ref(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $async, $refCode; + if ($schema == "#" || $schema == "#/") { + if (it.isRoot) { + $async = it.async; + $refCode = "validate"; + } else { + $async = it.root.schema.$async === true; + $refCode = "root.refVal[0]"; + } + } else { + var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot); + if ($refVal === void 0) { + var $message = it.MissingRefError.message(it.baseId, $schema); + if (it.opts.missingRefs == "fail") { + it.logger.error($message); + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '$ref' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { ref: '" + it.util.escapeQuotes($schema) + "' } "; + if (it.opts.messages !== false) { + out += " , message: 'can\\'t resolve reference " + it.util.escapeQuotes($schema) + "' "; + } + if (it.opts.verbose) { + out += " , schema: " + it.util.toQuotedString($schema) + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + if ($breakOnError) { + out += " if (false) { "; + } + } else if (it.opts.missingRefs == "ignore") { + it.logger.warn($message); + if ($breakOnError) { + out += " if (true) { "; + } + } else { + throw new it.MissingRefError(it.baseId, $schema, $message); + } + } else if ($refVal.inline) { + var $it = it.util.copy(it); + $it.level++; + var $nextValid = "valid" + $it.level; + $it.schema = $refVal.schema; + $it.schemaPath = ""; + $it.errSchemaPath = $schema; + var $code = it.validate($it).replace(/validate\.schema/g, $refVal.code); + out += " " + $code + " "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + } + } else { + $async = $refVal.$async === true || it.async && $refVal.$async !== false; + $refCode = $refVal.code; + } + } + if ($refCode) { + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.opts.passContext) { + out += " " + $refCode + ".call(this, "; + } else { + out += " " + $refCode + "( "; + } + out += " " + $data + ", (dataPath || '')"; + if (it.errorPath != '""') { + out += " + " + it.errorPath; + } + var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty"; + out += " , " + $parentData + " , " + $parentDataProperty + ", rootData) "; + var __callValidate = out; + out = $$outStack.pop(); + if ($async) { + if (!it.async) throw new Error("async schema referenced by sync schema"); + if ($breakOnError) { + out += " var " + $valid + "; "; + } + out += " try { await " + __callValidate + "; "; + if ($breakOnError) { + out += " " + $valid + " = true; "; + } + out += " } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; "; + if ($breakOnError) { + out += " " + $valid + " = false; "; + } + out += " } "; + if ($breakOnError) { + out += " if (" + $valid + ") { "; + } + } else { + out += " if (!" + __callValidate + ") { if (vErrors === null) vErrors = " + $refCode + ".errors; else vErrors = vErrors.concat(" + $refCode + ".errors); errors = vErrors.length; } "; + if ($breakOnError) { + out += " else { "; + } + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/allOf.js +var require_allOf = __commonJS({ + "node_modules/ajv/lib/dotjs/allOf.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_allOf(it, $keyword, $ruleType) { + var out = " "; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $currentBaseId = $it.baseId, $allSchemasEmpty = true; + var arr1 = $schema; + if (arr1) { + var $sch, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $sch = arr1[$i += 1]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + $allSchemasEmpty = false; + $it.schema = $sch; + $it.schemaPath = $schemaPath + "[" + $i + "]"; + $it.errSchemaPath = $errSchemaPath + "/" + $i; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } + } + if ($breakOnError) { + if ($allSchemasEmpty) { + out += " if (true) { "; + } else { + out += " " + $closingBraces.slice(0, -1) + " "; + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/anyOf.js +var require_anyOf = __commonJS({ + "node_modules/ajv/lib/dotjs/anyOf.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_anyOf(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $noEmptySchema = $schema.every(function($sch2) { + return it.opts.strictKeywords ? typeof $sch2 == "object" && Object.keys($sch2).length > 0 || $sch2 === false : it.util.schemaHasRules($sch2, it.RULES.all); + }); + if ($noEmptySchema) { + var $currentBaseId = $it.baseId; + out += " var " + $errs + " = errors; var " + $valid + " = false; "; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + var arr1 = $schema; + if (arr1) { + var $sch, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $sch = arr1[$i += 1]; + $it.schema = $sch; + $it.schemaPath = $schemaPath + "[" + $i + "]"; + $it.errSchemaPath = $errSchemaPath + "/" + $i; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + out += " " + $valid + " = " + $valid + " || " + $nextValid + "; if (!" + $valid + ") { "; + $closingBraces += "}"; + } + } + it.compositeRule = $it.compositeRule = $wasComposite; + out += " " + $closingBraces + " if (!" + $valid + ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'anyOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: 'should match some schema in anyOf' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError(vErrors); "; + } else { + out += " validate.errors = vErrors; return false; "; + } + } + out += " } else { errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } "; + if (it.opts.allErrors) { + out += " } "; + } + } else { + if ($breakOnError) { + out += " if (true) { "; + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/comment.js +var require_comment = __commonJS({ + "node_modules/ajv/lib/dotjs/comment.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_comment(it, $keyword, $ruleType) { + var out = " "; + var $schema = it.schema[$keyword]; + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $comment = it.util.toQuotedString($schema); + if (it.opts.$comment === true) { + out += " console.log(" + $comment + ");"; + } else if (typeof it.opts.$comment == "function") { + out += " self._opts.$comment(" + $comment + ", " + it.util.toQuotedString($errSchemaPath) + ", validate.root.schema);"; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/const.js +var require_const = __commonJS({ + "node_modules/ajv/lib/dotjs/const.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_const(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (!$isData) { + out += " var schema" + $lvl + " = validate.schema" + $schemaPath + ";"; + } + out += "var " + $valid + " = equal(" + $data + ", schema" + $lvl + "); if (!" + $valid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'const' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { allowedValue: schema" + $lvl + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should be equal to constant' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " }"; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/contains.js +var require_contains = __commonJS({ + "node_modules/ajv/lib/dotjs/contains.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_contains(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it.baseId, $nonEmptySchema = it.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it.util.schemaHasRules($schema, it.RULES.all); + out += "var " + $errs + " = errors;var " + $valid + ";"; + if ($nonEmptySchema) { + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + $it.schema = $schema; + $it.schemaPath = $schemaPath; + $it.errSchemaPath = $errSchemaPath; + out += " var " + $nextValid + " = false; for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { "; + $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); + var $passData = $data + "[" + $idx + "]"; + $it.dataPathArr[$dataNxt] = $idx; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + out += " if (" + $nextValid + ") break; } "; + it.compositeRule = $it.compositeRule = $wasComposite; + out += " " + $closingBraces + " if (!" + $nextValid + ") {"; + } else { + out += " if (" + $data + ".length == 0) {"; + } + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'contains' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: 'should contain a valid item' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } else { "; + if ($nonEmptySchema) { + out += " errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } "; + } + if (it.opts.allErrors) { + out += " } "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/dependencies.js +var require_dependencies = __commonJS({ + "node_modules/ajv/lib/dotjs/dependencies.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_dependencies(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $schemaDeps = {}, $propertyDeps = {}, $ownProperties = it.opts.ownProperties; + for ($property in $schema) { + if ($property == "__proto__") continue; + var $sch = $schema[$property]; + var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps; + $deps[$property] = $sch; + } + out += "var " + $errs + " = errors;"; + var $currentErrorPath = it.errorPath; + out += "var missing" + $lvl + ";"; + for (var $property in $propertyDeps) { + $deps = $propertyDeps[$property]; + if ($deps.length) { + out += " if ( " + $data + it.util.getProperty($property) + " !== undefined "; + if ($ownProperties) { + out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($property) + "') "; + } + if ($breakOnError) { + out += " && ( "; + var arr1 = $deps; + if (arr1) { + var $propertyKey, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $propertyKey = arr1[$i += 1]; + if ($i) { + out += " || "; + } + var $prop = it.util.getProperty($propertyKey), $useData = $data + $prop; + out += " ( ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") && (missing" + $lvl + " = " + it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) + ") ) "; + } + } + out += ")) { "; + var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '"; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath; + } + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } "; + if (it.opts.messages !== false) { + out += " , message: 'should have "; + if ($deps.length == 1) { + out += "property " + it.util.escapeQuotes($deps[0]); + } else { + out += "properties " + it.util.escapeQuotes($deps.join(", ")); + } + out += " when property " + it.util.escapeQuotes($property) + " is present' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + } else { + out += " ) { "; + var arr2 = $deps; + if (arr2) { + var $propertyKey, i2 = -1, l2 = arr2.length - 1; + while (i2 < l2) { + $propertyKey = arr2[i2 += 1]; + var $prop = it.util.getProperty($propertyKey), $missingProperty = it.util.escapeQuotes($propertyKey), $useData = $data + $prop; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); + } + out += " if ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } "; + if (it.opts.messages !== false) { + out += " , message: 'should have "; + if ($deps.length == 1) { + out += "property " + it.util.escapeQuotes($deps[0]); + } else { + out += "properties " + it.util.escapeQuotes($deps.join(", ")); + } + out += " when property " + it.util.escapeQuotes($property) + " is present' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } "; + } + } + } + out += " } "; + if ($breakOnError) { + $closingBraces += "}"; + out += " else { "; + } + } + } + it.errorPath = $currentErrorPath; + var $currentBaseId = $it.baseId; + for (var $property in $schemaDeps) { + var $sch = $schemaDeps[$property]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + out += " " + $nextValid + " = true; if ( " + $data + it.util.getProperty($property) + " !== undefined "; + if ($ownProperties) { + out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($property) + "') "; + } + out += ") { "; + $it.schema = $sch; + $it.schemaPath = $schemaPath + it.util.getProperty($property); + $it.errSchemaPath = $errSchemaPath + "/" + it.util.escapeFragment($property); + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + out += " } "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } + if ($breakOnError) { + out += " " + $closingBraces + " if (" + $errs + " == errors) {"; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/enum.js +var require_enum = __commonJS({ + "node_modules/ajv/lib/dotjs/enum.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_enum(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + var $i = "i" + $lvl, $vSchema = "schema" + $lvl; + if (!$isData) { + out += " var " + $vSchema + " = validate.schema" + $schemaPath + ";"; + } + out += "var " + $valid + ";"; + if ($isData) { + out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {"; + } + out += "" + $valid + " = false;for (var " + $i + "=0; " + $i + "<" + $vSchema + ".length; " + $i + "++) if (equal(" + $data + ", " + $vSchema + "[" + $i + "])) { " + $valid + " = true; break; }"; + if ($isData) { + out += " } "; + } + out += " if (!" + $valid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'enum' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { allowedValues: schema" + $lvl + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should be equal to one of the allowed values' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " }"; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/format.js +var require_format = __commonJS({ + "node_modules/ajv/lib/dotjs/format.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_format(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + if (it.opts.format === false) { + if ($breakOnError) { + out += " if (true) { "; + } + return out; + } + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + var $unknownFormats = it.opts.unknownFormats, $allowUnknown = Array.isArray($unknownFormats); + if ($isData) { + var $format = "format" + $lvl, $isObject = "isObject" + $lvl, $formatType = "formatType" + $lvl; + out += " var " + $format + " = formats[" + $schemaValue + "]; var " + $isObject + " = typeof " + $format + " == 'object' && !(" + $format + " instanceof RegExp) && " + $format + ".validate; var " + $formatType + " = " + $isObject + " && " + $format + ".type || 'string'; if (" + $isObject + ") { "; + if (it.async) { + out += " var async" + $lvl + " = " + $format + ".async; "; + } + out += " " + $format + " = " + $format + ".validate; } if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || "; + } + out += " ("; + if ($unknownFormats != "ignore") { + out += " (" + $schemaValue + " && !" + $format + " "; + if ($allowUnknown) { + out += " && self._opts.unknownFormats.indexOf(" + $schemaValue + ") == -1 "; + } + out += ") || "; + } + out += " (" + $format + " && " + $formatType + " == '" + $ruleType + "' && !(typeof " + $format + " == 'function' ? "; + if (it.async) { + out += " (async" + $lvl + " ? await " + $format + "(" + $data + ") : " + $format + "(" + $data + ")) "; + } else { + out += " " + $format + "(" + $data + ") "; + } + out += " : " + $format + ".test(" + $data + "))))) {"; + } else { + var $format = it.formats[$schema]; + if (!$format) { + if ($unknownFormats == "ignore") { + it.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it.errSchemaPath + '"'); + if ($breakOnError) { + out += " if (true) { "; + } + return out; + } else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) { + if ($breakOnError) { + out += " if (true) { "; + } + return out; + } else { + throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it.errSchemaPath + '"'); + } + } + var $isObject = typeof $format == "object" && !($format instanceof RegExp) && $format.validate; + var $formatType = $isObject && $format.type || "string"; + if ($isObject) { + var $async = $format.async === true; + $format = $format.validate; + } + if ($formatType != $ruleType) { + if ($breakOnError) { + out += " if (true) { "; + } + return out; + } + if ($async) { + if (!it.async) throw new Error("async format in sync schema"); + var $formatRef = "formats" + it.util.getProperty($schema) + ".validate"; + out += " if (!(await " + $formatRef + "(" + $data + "))) { "; + } else { + out += " if (! "; + var $formatRef = "formats" + it.util.getProperty($schema); + if ($isObject) $formatRef += ".validate"; + if (typeof $format == "function") { + out += " " + $formatRef + "(" + $data + ") "; + } else { + out += " " + $formatRef + ".test(" + $data + ") "; + } + out += ") { "; + } + } + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'format' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { format: "; + if ($isData) { + out += "" + $schemaValue; + } else { + out += "" + it.util.toQuotedString($schema); + } + out += " } "; + if (it.opts.messages !== false) { + out += ` , message: 'should match format "`; + if ($isData) { + out += "' + " + $schemaValue + " + '"; + } else { + out += "" + it.util.escapeQuotes($schema); + } + out += `"' `; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + it.util.toQuotedString($schema); + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/if.js +var require_if = __commonJS({ + "node_modules/ajv/lib/dotjs/if.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_if(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + $it.level++; + var $nextValid = "valid" + $it.level; + var $thenSch = it.schema["then"], $elseSch = it.schema["else"], $thenPresent = $thenSch !== void 0 && (it.opts.strictKeywords ? typeof $thenSch == "object" && Object.keys($thenSch).length > 0 || $thenSch === false : it.util.schemaHasRules($thenSch, it.RULES.all)), $elsePresent = $elseSch !== void 0 && (it.opts.strictKeywords ? typeof $elseSch == "object" && Object.keys($elseSch).length > 0 || $elseSch === false : it.util.schemaHasRules($elseSch, it.RULES.all)), $currentBaseId = $it.baseId; + if ($thenPresent || $elsePresent) { + var $ifClause; + $it.createErrors = false; + $it.schema = $schema; + $it.schemaPath = $schemaPath; + $it.errSchemaPath = $errSchemaPath; + out += " var " + $errs + " = errors; var " + $valid + " = true; "; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + $it.createErrors = true; + out += " errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } "; + it.compositeRule = $it.compositeRule = $wasComposite; + if ($thenPresent) { + out += " if (" + $nextValid + ") { "; + $it.schema = it.schema["then"]; + $it.schemaPath = it.schemaPath + ".then"; + $it.errSchemaPath = it.errSchemaPath + "/then"; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + out += " " + $valid + " = " + $nextValid + "; "; + if ($thenPresent && $elsePresent) { + $ifClause = "ifClause" + $lvl; + out += " var " + $ifClause + " = 'then'; "; + } else { + $ifClause = "'then'"; + } + out += " } "; + if ($elsePresent) { + out += " else { "; + } + } else { + out += " if (!" + $nextValid + ") { "; + } + if ($elsePresent) { + $it.schema = it.schema["else"]; + $it.schemaPath = it.schemaPath + ".else"; + $it.errSchemaPath = it.errSchemaPath + "/else"; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + out += " " + $valid + " = " + $nextValid + "; "; + if ($thenPresent && $elsePresent) { + $ifClause = "ifClause" + $lvl; + out += " var " + $ifClause + " = 'else'; "; + } else { + $ifClause = "'else'"; + } + out += " } "; + } + out += " if (!" + $valid + ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'if' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { failingKeyword: " + $ifClause + " } "; + if (it.opts.messages !== false) { + out += ` , message: 'should match "' + ` + $ifClause + ` + '" schema' `; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError(vErrors); "; + } else { + out += " validate.errors = vErrors; return false; "; + } + } + out += " } "; + if ($breakOnError) { + out += " else { "; + } + } else { + if ($breakOnError) { + out += " if (true) { "; + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/items.js +var require_items = __commonJS({ + "node_modules/ajv/lib/dotjs/items.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_items(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it.baseId; + out += "var " + $errs + " = errors;var " + $valid + ";"; + if (Array.isArray($schema)) { + var $additionalItems = it.schema.additionalItems; + if ($additionalItems === false) { + out += " " + $valid + " = " + $data + ".length <= " + $schema.length + "; "; + var $currErrSchemaPath = $errSchemaPath; + $errSchemaPath = it.errSchemaPath + "/additionalItems"; + out += " if (!" + $valid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'additionalItems' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schema.length + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT have more than " + $schema.length + " items' "; + } + if (it.opts.verbose) { + out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } "; + $errSchemaPath = $currErrSchemaPath; + if ($breakOnError) { + $closingBraces += "}"; + out += " else { "; + } + } + var arr1 = $schema; + if (arr1) { + var $sch, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $sch = arr1[$i += 1]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + out += " " + $nextValid + " = true; if (" + $data + ".length > " + $i + ") { "; + var $passData = $data + "[" + $i + "]"; + $it.schema = $sch; + $it.schemaPath = $schemaPath + "[" + $i + "]"; + $it.errSchemaPath = $errSchemaPath + "/" + $i; + $it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true); + $it.dataPathArr[$dataNxt] = $i; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + out += " } "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } + } + if (typeof $additionalItems == "object" && (it.opts.strictKeywords ? typeof $additionalItems == "object" && Object.keys($additionalItems).length > 0 || $additionalItems === false : it.util.schemaHasRules($additionalItems, it.RULES.all))) { + $it.schema = $additionalItems; + $it.schemaPath = it.schemaPath + ".additionalItems"; + $it.errSchemaPath = it.errSchemaPath + "/additionalItems"; + out += " " + $nextValid + " = true; if (" + $data + ".length > " + $schema.length + ") { for (var " + $idx + " = " + $schema.length + "; " + $idx + " < " + $data + ".length; " + $idx + "++) { "; + $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); + var $passData = $data + "[" + $idx + "]"; + $it.dataPathArr[$dataNxt] = $idx; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + if ($breakOnError) { + out += " if (!" + $nextValid + ") break; "; + } + out += " } } "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } else if (it.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it.util.schemaHasRules($schema, it.RULES.all)) { + $it.schema = $schema; + $it.schemaPath = $schemaPath; + $it.errSchemaPath = $errSchemaPath; + out += " for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { "; + $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true); + var $passData = $data + "[" + $idx + "]"; + $it.dataPathArr[$dataNxt] = $idx; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + if ($breakOnError) { + out += " if (!" + $nextValid + ") break; "; + } + out += " }"; + } + if ($breakOnError) { + out += " " + $closingBraces + " if (" + $errs + " == errors) {"; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/_limit.js +var require_limit = __commonJS({ + "node_modules/ajv/lib/dotjs/_limit.js"(exports2, module2) { + "use strict"; + module2.exports = function generate__limit(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + var $isMax = $keyword == "maximum", $exclusiveKeyword = $isMax ? "exclusiveMaximum" : "exclusiveMinimum", $schemaExcl = it.schema[$exclusiveKeyword], $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data, $op = $isMax ? "<" : ">", $notOp = $isMax ? ">" : "<", $errorKeyword = void 0; + if (!($isData || typeof $schema == "number" || $schema === void 0)) { + throw new Error($keyword + " must be number"); + } + if (!($isDataExcl || $schemaExcl === void 0 || typeof $schemaExcl == "number" || typeof $schemaExcl == "boolean")) { + throw new Error($exclusiveKeyword + " must be number or boolean"); + } + if ($isDataExcl) { + var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr), $exclusive = "exclusive" + $lvl, $exclType = "exclType" + $lvl, $exclIsNumber = "exclIsNumber" + $lvl, $opExpr = "op" + $lvl, $opStr = "' + " + $opExpr + " + '"; + out += " var schemaExcl" + $lvl + " = " + $schemaValueExcl + "; "; + $schemaValueExcl = "schemaExcl" + $lvl; + out += " var " + $exclusive + "; var " + $exclType + " = typeof " + $schemaValueExcl + "; if (" + $exclType + " != 'boolean' && " + $exclType + " != 'undefined' && " + $exclType + " != 'number') { "; + var $errorKeyword = $exclusiveKeyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "_exclusiveLimit") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: '" + $exclusiveKeyword + " should be boolean' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } else if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + out += " " + $exclType + " == 'number' ? ( (" + $exclusive + " = " + $schemaValue + " === undefined || " + $schemaValueExcl + " " + $op + "= " + $schemaValue + ") ? " + $data + " " + $notOp + "= " + $schemaValueExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) : ( (" + $exclusive + " = " + $schemaValueExcl + " === true) ? " + $data + " " + $notOp + "= " + $schemaValue + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { var op" + $lvl + " = " + $exclusive + " ? '" + $op + "' : '" + $op + "='; "; + if ($schema === void 0) { + $errorKeyword = $exclusiveKeyword; + $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword; + $schemaValue = $schemaValueExcl; + $isData = $isDataExcl; + } + } else { + var $exclIsNumber = typeof $schemaExcl == "number", $opStr = $op; + if ($exclIsNumber && $isData) { + var $opExpr = "'" + $opStr + "'"; + out += " if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + out += " ( " + $schemaValue + " === undefined || " + $schemaExcl + " " + $op + "= " + $schemaValue + " ? " + $data + " " + $notOp + "= " + $schemaExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { "; + } else { + if ($exclIsNumber && $schema === void 0) { + $exclusive = true; + $errorKeyword = $exclusiveKeyword; + $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword; + $schemaValue = $schemaExcl; + $notOp += "="; + } else { + if ($exclIsNumber) $schemaValue = Math[$isMax ? "min" : "max"]($schemaExcl, $schema); + if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) { + $exclusive = true; + $errorKeyword = $exclusiveKeyword; + $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword; + $notOp += "="; + } else { + $exclusive = false; + $opStr += "="; + } + } + var $opExpr = "'" + $opStr + "'"; + out += " if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + out += " " + $data + " " + $notOp + " " + $schemaValue + " || " + $data + " !== " + $data + ") { "; + } + } + $errorKeyword = $errorKeyword || $keyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "_limit") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { comparison: " + $opExpr + ", limit: " + $schemaValue + ", exclusive: " + $exclusive + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should be " + $opStr + " "; + if ($isData) { + out += "' + " + $schemaValue; + } else { + out += "" + $schemaValue + "'"; + } + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/_limitItems.js +var require_limitItems = __commonJS({ + "node_modules/ajv/lib/dotjs/_limitItems.js"(exports2, module2) { + "use strict"; + module2.exports = function generate__limitItems(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (!($isData || typeof $schema == "number")) { + throw new Error($keyword + " must be number"); + } + var $op = $keyword == "maxItems" ? ">" : "<"; + out += "if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + out += " " + $data + ".length " + $op + " " + $schemaValue + ") { "; + var $errorKeyword = $keyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "_limitItems") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT have "; + if ($keyword == "maxItems") { + out += "more"; + } else { + out += "fewer"; + } + out += " than "; + if ($isData) { + out += "' + " + $schemaValue + " + '"; + } else { + out += "" + $schema; + } + out += " items' "; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += "} "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/_limitLength.js +var require_limitLength = __commonJS({ + "node_modules/ajv/lib/dotjs/_limitLength.js"(exports2, module2) { + "use strict"; + module2.exports = function generate__limitLength(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (!($isData || typeof $schema == "number")) { + throw new Error($keyword + " must be number"); + } + var $op = $keyword == "maxLength" ? ">" : "<"; + out += "if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + if (it.opts.unicode === false) { + out += " " + $data + ".length "; + } else { + out += " ucs2length(" + $data + ") "; + } + out += " " + $op + " " + $schemaValue + ") { "; + var $errorKeyword = $keyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "_limitLength") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT be "; + if ($keyword == "maxLength") { + out += "longer"; + } else { + out += "shorter"; + } + out += " than "; + if ($isData) { + out += "' + " + $schemaValue + " + '"; + } else { + out += "" + $schema; + } + out += " characters' "; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += "} "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/_limitProperties.js +var require_limitProperties = __commonJS({ + "node_modules/ajv/lib/dotjs/_limitProperties.js"(exports2, module2) { + "use strict"; + module2.exports = function generate__limitProperties(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (!($isData || typeof $schema == "number")) { + throw new Error($keyword + " must be number"); + } + var $op = $keyword == "maxProperties" ? ">" : "<"; + out += "if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || "; + } + out += " Object.keys(" + $data + ").length " + $op + " " + $schemaValue + ") { "; + var $errorKeyword = $keyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "_limitProperties") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT have "; + if ($keyword == "maxProperties") { + out += "more"; + } else { + out += "fewer"; + } + out += " than "; + if ($isData) { + out += "' + " + $schemaValue + " + '"; + } else { + out += "" + $schema; + } + out += " properties' "; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += "} "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/multipleOf.js +var require_multipleOf = __commonJS({ + "node_modules/ajv/lib/dotjs/multipleOf.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_multipleOf(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (!($isData || typeof $schema == "number")) { + throw new Error($keyword + " must be number"); + } + out += "var division" + $lvl + ";if ("; + if ($isData) { + out += " " + $schemaValue + " !== undefined && ( typeof " + $schemaValue + " != 'number' || "; + } + out += " (division" + $lvl + " = " + $data + " / " + $schemaValue + ", "; + if (it.opts.multipleOfPrecision) { + out += " Math.abs(Math.round(division" + $lvl + ") - division" + $lvl + ") > 1e-" + it.opts.multipleOfPrecision + " "; + } else { + out += " division" + $lvl + " !== parseInt(division" + $lvl + ") "; + } + out += " ) "; + if ($isData) { + out += " ) "; + } + out += " ) { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'multipleOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { multipleOf: " + $schemaValue + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should be multiple of "; + if ($isData) { + out += "' + " + $schemaValue; + } else { + out += "" + $schemaValue + "'"; + } + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += "} "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/not.js +var require_not = __commonJS({ + "node_modules/ajv/lib/dotjs/not.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_not(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + $it.level++; + var $nextValid = "valid" + $it.level; + if (it.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it.util.schemaHasRules($schema, it.RULES.all)) { + $it.schema = $schema; + $it.schemaPath = $schemaPath; + $it.errSchemaPath = $errSchemaPath; + out += " var " + $errs + " = errors; "; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + $it.createErrors = false; + var $allErrorsOption; + if ($it.opts.allErrors) { + $allErrorsOption = $it.opts.allErrors; + $it.opts.allErrors = false; + } + out += " " + it.validate($it) + " "; + $it.createErrors = true; + if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption; + it.compositeRule = $it.compositeRule = $wasComposite; + out += " if (" + $nextValid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT be valid' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } else { errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } "; + if (it.opts.allErrors) { + out += " } "; + } + } else { + out += " var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT be valid' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + if ($breakOnError) { + out += " if (false) { "; + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/oneOf.js +var require_oneOf = __commonJS({ + "node_modules/ajv/lib/dotjs/oneOf.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_oneOf(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $currentBaseId = $it.baseId, $prevValid = "prevValid" + $lvl, $passingSchemas = "passingSchemas" + $lvl; + out += "var " + $errs + " = errors , " + $prevValid + " = false , " + $valid + " = false , " + $passingSchemas + " = null; "; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + var arr1 = $schema; + if (arr1) { + var $sch, $i = -1, l1 = arr1.length - 1; + while ($i < l1) { + $sch = arr1[$i += 1]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + $it.schema = $sch; + $it.schemaPath = $schemaPath + "[" + $i + "]"; + $it.errSchemaPath = $errSchemaPath + "/" + $i; + out += " " + it.validate($it) + " "; + $it.baseId = $currentBaseId; + } else { + out += " var " + $nextValid + " = true; "; + } + if ($i) { + out += " if (" + $nextValid + " && " + $prevValid + ") { " + $valid + " = false; " + $passingSchemas + " = [" + $passingSchemas + ", " + $i + "]; } else { "; + $closingBraces += "}"; + } + out += " if (" + $nextValid + ") { " + $valid + " = " + $prevValid + " = true; " + $passingSchemas + " = " + $i + "; }"; + } + } + it.compositeRule = $it.compositeRule = $wasComposite; + out += "" + $closingBraces + "if (!" + $valid + ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'oneOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { passingSchemas: " + $passingSchemas + " } "; + if (it.opts.messages !== false) { + out += " , message: 'should match exactly one schema in oneOf' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError(vErrors); "; + } else { + out += " validate.errors = vErrors; return false; "; + } + } + out += "} else { errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; }"; + if (it.opts.allErrors) { + out += " } "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/pattern.js +var require_pattern = __commonJS({ + "node_modules/ajv/lib/dotjs/pattern.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_pattern(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + var $regexp = $isData ? "(new RegExp(" + $schemaValue + "))" : it.usePattern($schema); + out += "if ( "; + if ($isData) { + out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || "; + } + out += " !" + $regexp + ".test(" + $data + ") ) { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'pattern' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { pattern: "; + if ($isData) { + out += "" + $schemaValue; + } else { + out += "" + it.util.toQuotedString($schema); + } + out += " } "; + if (it.opts.messages !== false) { + out += ` , message: 'should match pattern "`; + if ($isData) { + out += "' + " + $schemaValue + " + '"; + } else { + out += "" + it.util.escapeQuotes($schema); + } + out += `"' `; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + it.util.toQuotedString($schema); + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += "} "; + if ($breakOnError) { + out += " else { "; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/properties.js +var require_properties = __commonJS({ + "node_modules/ajv/lib/dotjs/properties.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_properties(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + var $key = "key" + $lvl, $idx = "idx" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl; + var $schemaKeys = Object.keys($schema || {}).filter(notProto), $pProperties = it.schema.patternProperties || {}, $pPropertyKeys = Object.keys($pProperties).filter(notProto), $aProperties = it.schema.additionalProperties, $someProperties = $schemaKeys.length || $pPropertyKeys.length, $noAdditional = $aProperties === false, $additionalIsSchema = typeof $aProperties == "object" && Object.keys($aProperties).length, $removeAdditional = it.opts.removeAdditional, $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, $ownProperties = it.opts.ownProperties, $currentBaseId = it.baseId; + var $required = it.schema.required; + if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) { + var $requiredHash = it.util.toHash($required); + } + function notProto(p) { + return p !== "__proto__"; + } + out += "var " + $errs + " = errors;var " + $nextValid + " = true;"; + if ($ownProperties) { + out += " var " + $dataProperties + " = undefined;"; + } + if ($checkAdditional) { + if ($ownProperties) { + out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; "; + } else { + out += " for (var " + $key + " in " + $data + ") { "; + } + if ($someProperties) { + out += " var isAdditional" + $lvl + " = !(false "; + if ($schemaKeys.length) { + if ($schemaKeys.length > 8) { + out += " || validate.schema" + $schemaPath + ".hasOwnProperty(" + $key + ") "; + } else { + var arr1 = $schemaKeys; + if (arr1) { + var $propertyKey, i1 = -1, l1 = arr1.length - 1; + while (i1 < l1) { + $propertyKey = arr1[i1 += 1]; + out += " || " + $key + " == " + it.util.toQuotedString($propertyKey) + " "; + } + } + } + } + if ($pPropertyKeys.length) { + var arr2 = $pPropertyKeys; + if (arr2) { + var $pProperty, $i = -1, l2 = arr2.length - 1; + while ($i < l2) { + $pProperty = arr2[$i += 1]; + out += " || " + it.usePattern($pProperty) + ".test(" + $key + ") "; + } + } + } + out += " ); if (isAdditional" + $lvl + ") { "; + } + if ($removeAdditional == "all") { + out += " delete " + $data + "[" + $key + "]; "; + } else { + var $currentErrorPath = it.errorPath; + var $additionalProperty = "' + " + $key + " + '"; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); + } + if ($noAdditional) { + if ($removeAdditional) { + out += " delete " + $data + "[" + $key + "]; "; + } else { + out += " " + $nextValid + " = false; "; + var $currErrSchemaPath = $errSchemaPath; + $errSchemaPath = it.errSchemaPath + "/additionalProperties"; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'additionalProperties' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { additionalProperty: '" + $additionalProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is an invalid additional property"; + } else { + out += "should NOT have additional properties"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + $errSchemaPath = $currErrSchemaPath; + if ($breakOnError) { + out += " break; "; + } + } + } else if ($additionalIsSchema) { + if ($removeAdditional == "failing") { + out += " var " + $errs + " = errors; "; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + $it.schema = $aProperties; + $it.schemaPath = it.schemaPath + ".additionalProperties"; + $it.errSchemaPath = it.errSchemaPath + "/additionalProperties"; + $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); + var $passData = $data + "[" + $key + "]"; + $it.dataPathArr[$dataNxt] = $key; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + out += " if (!" + $nextValid + ") { errors = " + $errs + "; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete " + $data + "[" + $key + "]; } "; + it.compositeRule = $it.compositeRule = $wasComposite; + } else { + $it.schema = $aProperties; + $it.schemaPath = it.schemaPath + ".additionalProperties"; + $it.errSchemaPath = it.errSchemaPath + "/additionalProperties"; + $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); + var $passData = $data + "[" + $key + "]"; + $it.dataPathArr[$dataNxt] = $key; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + if ($breakOnError) { + out += " if (!" + $nextValid + ") break; "; + } + } + } + it.errorPath = $currentErrorPath; + } + if ($someProperties) { + out += " } "; + } + out += " } "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + var $useDefaults = it.opts.useDefaults && !it.compositeRule; + if ($schemaKeys.length) { + var arr3 = $schemaKeys; + if (arr3) { + var $propertyKey, i3 = -1, l3 = arr3.length - 1; + while (i3 < l3) { + $propertyKey = arr3[i3 += 1]; + var $sch = $schema[$propertyKey]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + var $prop = it.util.getProperty($propertyKey), $passData = $data + $prop, $hasDefault = $useDefaults && $sch.default !== void 0; + $it.schema = $sch; + $it.schemaPath = $schemaPath + $prop; + $it.errSchemaPath = $errSchemaPath + "/" + it.util.escapeFragment($propertyKey); + $it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers); + $it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey); + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + $code = it.util.varReplace($code, $nextData, $passData); + var $useData = $passData; + } else { + var $useData = $nextData; + out += " var " + $nextData + " = " + $passData + "; "; + } + if ($hasDefault) { + out += " " + $code + " "; + } else { + if ($requiredHash && $requiredHash[$propertyKey]) { + out += " if ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") { " + $nextValid + " = false; "; + var $currentErrorPath = it.errorPath, $currErrSchemaPath = $errSchemaPath, $missingProperty = it.util.escapeQuotes($propertyKey); + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); + } + $errSchemaPath = it.errSchemaPath + "/required"; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + $errSchemaPath = $currErrSchemaPath; + it.errorPath = $currentErrorPath; + out += " } else { "; + } else { + if ($breakOnError) { + out += " if ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") { " + $nextValid + " = true; } else { "; + } else { + out += " if (" + $useData + " !== undefined "; + if ($ownProperties) { + out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += " ) { "; + } + } + out += " " + $code + " } "; + } + } + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } + } + if ($pPropertyKeys.length) { + var arr4 = $pPropertyKeys; + if (arr4) { + var $pProperty, i4 = -1, l4 = arr4.length - 1; + while (i4 < l4) { + $pProperty = arr4[i4 += 1]; + var $sch = $pProperties[$pProperty]; + if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) { + $it.schema = $sch; + $it.schemaPath = it.schemaPath + ".patternProperties" + it.util.getProperty($pProperty); + $it.errSchemaPath = it.errSchemaPath + "/patternProperties/" + it.util.escapeFragment($pProperty); + if ($ownProperties) { + out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; "; + } else { + out += " for (var " + $key + " in " + $data + ") { "; + } + out += " if (" + it.usePattern($pProperty) + ".test(" + $key + ")) { "; + $it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers); + var $passData = $data + "[" + $key + "]"; + $it.dataPathArr[$dataNxt] = $key; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + if ($breakOnError) { + out += " if (!" + $nextValid + ") break; "; + } + out += " } "; + if ($breakOnError) { + out += " else " + $nextValid + " = true; "; + } + out += " } "; + if ($breakOnError) { + out += " if (" + $nextValid + ") { "; + $closingBraces += "}"; + } + } + } + } + } + if ($breakOnError) { + out += " " + $closingBraces + " if (" + $errs + " == errors) {"; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/propertyNames.js +var require_propertyNames = __commonJS({ + "node_modules/ajv/lib/dotjs/propertyNames.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_propertyNames(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $errs = "errs__" + $lvl; + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + out += "var " + $errs + " = errors;"; + if (it.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it.util.schemaHasRules($schema, it.RULES.all)) { + $it.schema = $schema; + $it.schemaPath = $schemaPath; + $it.errSchemaPath = $errSchemaPath; + var $key = "key" + $lvl, $idx = "idx" + $lvl, $i = "i" + $lvl, $invalidName = "' + " + $key + " + '", $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl, $ownProperties = it.opts.ownProperties, $currentBaseId = it.baseId; + if ($ownProperties) { + out += " var " + $dataProperties + " = undefined; "; + } + if ($ownProperties) { + out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; "; + } else { + out += " for (var " + $key + " in " + $data + ") { "; + } + out += " var startErrs" + $lvl + " = errors; "; + var $passData = $key; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + var $code = it.validate($it); + $it.baseId = $currentBaseId; + if (it.util.varOccurences($code, $nextData) < 2) { + out += " " + it.util.varReplace($code, $nextData, $passData) + " "; + } else { + out += " var " + $nextData + " = " + $passData + "; " + $code + " "; + } + it.compositeRule = $it.compositeRule = $wasComposite; + out += " if (!" + $nextValid + ") { for (var " + $i + "=startErrs" + $lvl + "; " + $i + " 0 || $propertySch === false : it.util.schemaHasRules($propertySch, it.RULES.all)))) { + $required[$required.length] = $property; + } + } + } + } else { + var $required = $schema; + } + } + if ($isData || $required.length) { + var $currentErrorPath = it.errorPath, $loopRequired = $isData || $required.length >= it.opts.loopRequired, $ownProperties = it.opts.ownProperties; + if ($breakOnError) { + out += " var missing" + $lvl + "; "; + if ($loopRequired) { + if (!$isData) { + out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; "; + } + var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '"; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); + } + out += " var " + $valid + " = true; "; + if ($isData) { + out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {"; + } + out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { " + $valid + " = " + $data + "[" + $vSchema + "[" + $i + "]] !== undefined "; + if ($ownProperties) { + out += " && Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) "; + } + out += "; if (!" + $valid + ") break; } "; + if ($isData) { + out += " } "; + } + out += " if (!" + $valid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } else { "; + } else { + out += " if ( "; + var arr2 = $required; + if (arr2) { + var $propertyKey, $i = -1, l2 = arr2.length - 1; + while ($i < l2) { + $propertyKey = arr2[$i += 1]; + if ($i) { + out += " || "; + } + var $prop = it.util.getProperty($propertyKey), $useData = $data + $prop; + out += " ( ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") && (missing" + $lvl + " = " + it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) + ") ) "; + } + } + out += ") { "; + var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '"; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath; + } + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } else { "; + } + } else { + if ($loopRequired) { + if (!$isData) { + out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; "; + } + var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '"; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers); + } + if ($isData) { + out += " if (" + $vSchema + " && !Array.isArray(" + $vSchema + ")) { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (" + $vSchema + " !== undefined) { "; + } + out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { if (" + $data + "[" + $vSchema + "[" + $i + "]] === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) "; + } + out += ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } "; + if ($isData) { + out += " } "; + } + } else { + var arr3 = $required; + if (arr3) { + var $propertyKey, i3 = -1, l3 = arr3.length - 1; + while (i3 < l3) { + $propertyKey = arr3[i3 += 1]; + var $prop = it.util.getProperty($propertyKey), $missingProperty = it.util.escapeQuotes($propertyKey), $useData = $data + $prop; + if (it.opts._errorDataPathProperty) { + it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers); + } + out += " if ( " + $useData + " === undefined "; + if ($ownProperties) { + out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') "; + } + out += ") { var err = "; + if (it.createErrors !== false) { + out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } "; + if (it.opts.messages !== false) { + out += " , message: '"; + if (it.opts._errorDataPathProperty) { + out += "is a required property"; + } else { + out += "should have required property \\'" + $missingProperty + "\\'"; + } + out += "' "; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } "; + } + } + } + } + it.errorPath = $currentErrorPath; + } else if ($breakOnError) { + out += " if (true) {"; + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/uniqueItems.js +var require_uniqueItems = __commonJS({ + "node_modules/ajv/lib/dotjs/uniqueItems.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_uniqueItems(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + if (($schema || $isData) && it.opts.uniqueItems !== false) { + if ($isData) { + out += " var " + $valid + "; if (" + $schemaValue + " === false || " + $schemaValue + " === undefined) " + $valid + " = true; else if (typeof " + $schemaValue + " != 'boolean') " + $valid + " = false; else { "; + } + out += " var i = " + $data + ".length , " + $valid + " = true , j; if (i > 1) { "; + var $itemType = it.schema.items && it.schema.items.type, $typeIsArray = Array.isArray($itemType); + if (!$itemType || $itemType == "object" || $itemType == "array" || $typeIsArray && ($itemType.indexOf("object") >= 0 || $itemType.indexOf("array") >= 0)) { + out += " outer: for (;i--;) { for (j = i; j--;) { if (equal(" + $data + "[i], " + $data + "[j])) { " + $valid + " = false; break outer; } } } "; + } else { + out += " var itemIndices = {}, item; for (;i--;) { var item = " + $data + "[i]; "; + var $method = "checkDataType" + ($typeIsArray ? "s" : ""); + out += " if (" + it.util[$method]($itemType, "item", it.opts.strictNumbers, true) + ") continue; "; + if ($typeIsArray) { + out += ` if (typeof item == 'string') item = '"' + item; `; + } + out += " if (typeof itemIndices[item] == 'number') { " + $valid + " = false; j = itemIndices[item]; break; } itemIndices[item] = i; } "; + } + out += " } "; + if ($isData) { + out += " } "; + } + out += " if (!" + $valid + ") { "; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: 'uniqueItems' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { i: i, j: j } "; + if (it.opts.messages !== false) { + out += " , message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)' "; + } + if (it.opts.verbose) { + out += " , schema: "; + if ($isData) { + out += "validate.schema" + $schemaPath; + } else { + out += "" + $schema; + } + out += " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + out += " } "; + if ($breakOnError) { + out += " else { "; + } + } else { + if ($breakOnError) { + out += " if (true) { "; + } + } + return out; + }; + } +}); + +// node_modules/ajv/lib/dotjs/index.js +var require_dotjs = __commonJS({ + "node_modules/ajv/lib/dotjs/index.js"(exports2, module2) { + "use strict"; + module2.exports = { + "$ref": require_ref(), + allOf: require_allOf(), + anyOf: require_anyOf(), + "$comment": require_comment(), + const: require_const(), + contains: require_contains(), + dependencies: require_dependencies(), + "enum": require_enum(), + format: require_format(), + "if": require_if(), + items: require_items(), + maximum: require_limit(), + minimum: require_limit(), + maxItems: require_limitItems(), + minItems: require_limitItems(), + maxLength: require_limitLength(), + minLength: require_limitLength(), + maxProperties: require_limitProperties(), + minProperties: require_limitProperties(), + multipleOf: require_multipleOf(), + not: require_not(), + oneOf: require_oneOf(), + pattern: require_pattern(), + properties: require_properties(), + propertyNames: require_propertyNames(), + required: require_required(), + uniqueItems: require_uniqueItems(), + validate: require_validate() + }; + } +}); + +// node_modules/ajv/lib/compile/rules.js +var require_rules = __commonJS({ + "node_modules/ajv/lib/compile/rules.js"(exports2, module2) { + "use strict"; + var ruleModules = require_dotjs(); + var toHash = require_util().toHash; + module2.exports = function rules() { + var RULES = [ + { + type: "number", + rules: [ + { "maximum": ["exclusiveMaximum"] }, + { "minimum": ["exclusiveMinimum"] }, + "multipleOf", + "format" + ] + }, + { + type: "string", + rules: ["maxLength", "minLength", "pattern", "format"] + }, + { + type: "array", + rules: ["maxItems", "minItems", "items", "contains", "uniqueItems"] + }, + { + type: "object", + rules: [ + "maxProperties", + "minProperties", + "required", + "dependencies", + "propertyNames", + { "properties": ["additionalProperties", "patternProperties"] } + ] + }, + { rules: ["$ref", "const", "enum", "not", "anyOf", "oneOf", "allOf", "if"] } + ]; + var ALL = ["type", "$comment"]; + var KEYWORDS = [ + "$schema", + "$id", + "id", + "$data", + "$async", + "title", + "description", + "default", + "definitions", + "examples", + "readOnly", + "writeOnly", + "contentMediaType", + "contentEncoding", + "additionalItems", + "then", + "else" + ]; + var TYPES = ["number", "integer", "string", "array", "object", "boolean", "null"]; + RULES.all = toHash(ALL); + RULES.types = toHash(TYPES); + RULES.forEach(function(group) { + group.rules = group.rules.map(function(keyword) { + var implKeywords; + if (typeof keyword == "object") { + var key = Object.keys(keyword)[0]; + implKeywords = keyword[key]; + keyword = key; + implKeywords.forEach(function(k) { + ALL.push(k); + RULES.all[k] = true; + }); + } + ALL.push(keyword); + var rule = RULES.all[keyword] = { + keyword, + code: ruleModules[keyword], + implements: implKeywords + }; + return rule; + }); + RULES.all.$comment = { + keyword: "$comment", + code: ruleModules.$comment + }; + if (group.type) RULES.types[group.type] = group; + }); + RULES.keywords = toHash(ALL.concat(KEYWORDS)); + RULES.custom = {}; + return RULES; + }; + } +}); + +// node_modules/ajv/lib/data.js +var require_data = __commonJS({ + "node_modules/ajv/lib/data.js"(exports2, module2) { + "use strict"; + var KEYWORDS = [ + "multipleOf", + "maximum", + "exclusiveMaximum", + "minimum", + "exclusiveMinimum", + "maxLength", + "minLength", + "pattern", + "additionalItems", + "maxItems", + "minItems", + "uniqueItems", + "maxProperties", + "minProperties", + "required", + "additionalProperties", + "enum", + "format", + "const" + ]; + module2.exports = function(metaSchema, keywordsJsonPointers) { + for (var i = 0; i < keywordsJsonPointers.length; i++) { + metaSchema = JSON.parse(JSON.stringify(metaSchema)); + var segments = keywordsJsonPointers[i].split("/"); + var keywords = metaSchema; + var j; + for (j = 1; j < segments.length; j++) + keywords = keywords[segments[j]]; + for (j = 0; j < KEYWORDS.length; j++) { + var key = KEYWORDS[j]; + var schema = keywords[key]; + if (schema) { + keywords[key] = { + anyOf: [ + schema, + { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" } + ] + }; + } + } + } + return metaSchema; + }; + } +}); + +// node_modules/ajv/lib/compile/async.js +var require_async = __commonJS({ + "node_modules/ajv/lib/compile/async.js"(exports2, module2) { + "use strict"; + var MissingRefError = require_error_classes().MissingRef; + module2.exports = compileAsync; + function compileAsync(schema, meta, callback) { + var self2 = this; + if (typeof this._opts.loadSchema != "function") + throw new Error("options.loadSchema should be a function"); + if (typeof meta == "function") { + callback = meta; + meta = void 0; + } + var p = loadMetaSchemaOf(schema).then(function() { + var schemaObj = self2._addSchema(schema, void 0, meta); + return schemaObj.validate || _compileAsync(schemaObj); + }); + if (callback) { + p.then( + function(v) { + callback(null, v); + }, + callback + ); + } + return p; + function loadMetaSchemaOf(sch) { + var $schema = sch.$schema; + return $schema && !self2.getSchema($schema) ? compileAsync.call(self2, { $ref: $schema }, true) : Promise.resolve(); + } + function _compileAsync(schemaObj) { + try { + return self2._compile(schemaObj); + } catch (e) { + if (e instanceof MissingRefError) return loadMissingSchema(e); + throw e; + } + function loadMissingSchema(e) { + var ref = e.missingSchema; + if (added(ref)) throw new Error("Schema " + ref + " is loaded but " + e.missingRef + " cannot be resolved"); + var schemaPromise = self2._loadingSchemas[ref]; + if (!schemaPromise) { + schemaPromise = self2._loadingSchemas[ref] = self2._opts.loadSchema(ref); + schemaPromise.then(removePromise, removePromise); + } + return schemaPromise.then(function(sch) { + if (!added(ref)) { + return loadMetaSchemaOf(sch).then(function() { + if (!added(ref)) self2.addSchema(sch, ref, void 0, meta); + }); + } + }).then(function() { + return _compileAsync(schemaObj); + }); + function removePromise() { + delete self2._loadingSchemas[ref]; + } + function added(ref2) { + return self2._refs[ref2] || self2._schemas[ref2]; + } + } + } + } + } +}); + +// node_modules/ajv/lib/dotjs/custom.js +var require_custom = __commonJS({ + "node_modules/ajv/lib/dotjs/custom.js"(exports2, module2) { + "use strict"; + module2.exports = function generate_custom(it, $keyword, $ruleType) { + var out = " "; + var $lvl = it.level; + var $dataLvl = it.dataLevel; + var $schema = it.schema[$keyword]; + var $schemaPath = it.schemaPath + it.util.getProperty($keyword); + var $errSchemaPath = it.errSchemaPath + "/" + $keyword; + var $breakOnError = !it.opts.allErrors; + var $errorKeyword; + var $data = "data" + ($dataLvl || ""); + var $valid = "valid" + $lvl; + var $errs = "errs__" + $lvl; + var $isData = it.opts.$data && $schema && $schema.$data, $schemaValue; + if ($isData) { + out += " var schema" + $lvl + " = " + it.util.getData($schema.$data, $dataLvl, it.dataPathArr) + "; "; + $schemaValue = "schema" + $lvl; + } else { + $schemaValue = $schema; + } + var $rule = this, $definition = "definition" + $lvl, $rDef = $rule.definition, $closingBraces = ""; + var $compile, $inline, $macro, $ruleValidate, $validateCode; + if ($isData && $rDef.$data) { + $validateCode = "keywordValidate" + $lvl; + var $validateSchema = $rDef.validateSchema; + out += " var " + $definition + " = RULES.custom['" + $keyword + "'].definition; var " + $validateCode + " = " + $definition + ".validate;"; + } else { + $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it); + if (!$ruleValidate) return; + $schemaValue = "validate.schema" + $schemaPath; + $validateCode = $ruleValidate.code; + $compile = $rDef.compile; + $inline = $rDef.inline; + $macro = $rDef.macro; + } + var $ruleErrs = $validateCode + ".errors", $i = "i" + $lvl, $ruleErr = "ruleErr" + $lvl, $asyncKeyword = $rDef.async; + if ($asyncKeyword && !it.async) throw new Error("async keyword in sync schema"); + if (!($inline || $macro)) { + out += "" + $ruleErrs + " = null;"; + } + out += "var " + $errs + " = errors;var " + $valid + ";"; + if ($isData && $rDef.$data) { + $closingBraces += "}"; + out += " if (" + $schemaValue + " === undefined) { " + $valid + " = true; } else { "; + if ($validateSchema) { + $closingBraces += "}"; + out += " " + $valid + " = " + $definition + ".validateSchema(" + $schemaValue + "); if (" + $valid + ") { "; + } + } + if ($inline) { + if ($rDef.statements) { + out += " " + $ruleValidate.validate + " "; + } else { + out += " " + $valid + " = " + $ruleValidate.validate + "; "; + } + } else if ($macro) { + var $it = it.util.copy(it); + var $closingBraces = ""; + $it.level++; + var $nextValid = "valid" + $it.level; + $it.schema = $ruleValidate.validate; + $it.schemaPath = ""; + var $wasComposite = it.compositeRule; + it.compositeRule = $it.compositeRule = true; + var $code = it.validate($it).replace(/validate\.schema/g, $validateCode); + it.compositeRule = $it.compositeRule = $wasComposite; + out += " " + $code; + } else { + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + out += " " + $validateCode + ".call( "; + if (it.opts.passContext) { + out += "this"; + } else { + out += "self"; + } + if ($compile || $rDef.schema === false) { + out += " , " + $data + " "; + } else { + out += " , " + $schemaValue + " , " + $data + " , validate.schema" + it.schemaPath + " "; + } + out += " , (dataPath || '')"; + if (it.errorPath != '""') { + out += " + " + it.errorPath; + } + var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty"; + out += " , " + $parentData + " , " + $parentDataProperty + " , rootData ) "; + var def_callRuleValidate = out; + out = $$outStack.pop(); + if ($rDef.errors === false) { + out += " " + $valid + " = "; + if ($asyncKeyword) { + out += "await "; + } + out += "" + def_callRuleValidate + "; "; + } else { + if ($asyncKeyword) { + $ruleErrs = "customErrors" + $lvl; + out += " var " + $ruleErrs + " = null; try { " + $valid + " = await " + def_callRuleValidate + "; } catch (e) { " + $valid + " = false; if (e instanceof ValidationError) " + $ruleErrs + " = e.errors; else throw e; } "; + } else { + out += " " + $ruleErrs + " = null; " + $valid + " = " + def_callRuleValidate + "; "; + } + } + } + if ($rDef.modifying) { + out += " if (" + $parentData + ") " + $data + " = " + $parentData + "[" + $parentDataProperty + "];"; + } + out += "" + $closingBraces; + if ($rDef.valid) { + if ($breakOnError) { + out += " if (true) { "; + } + } else { + out += " if ( "; + if ($rDef.valid === void 0) { + out += " !"; + if ($macro) { + out += "" + $nextValid; + } else { + out += "" + $valid; + } + } else { + out += " " + !$rDef.valid + " "; + } + out += ") { "; + $errorKeyword = $rule.keyword; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + var $$outStack = $$outStack || []; + $$outStack.push(out); + out = ""; + if (it.createErrors !== false) { + out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } "; + if (it.opts.messages !== false) { + out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `; + } + if (it.opts.verbose) { + out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " "; + } + out += " } "; + } else { + out += " {} "; + } + var __err = out; + out = $$outStack.pop(); + if (!it.compositeRule && $breakOnError) { + if (it.async) { + out += " throw new ValidationError([" + __err + "]); "; + } else { + out += " validate.errors = [" + __err + "]; return false; "; + } + } else { + out += " var err = " + __err + "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; "; + } + var def_customError = out; + out = $$outStack.pop(); + if ($inline) { + if ($rDef.errors) { + if ($rDef.errors != "full") { + out += " for (var " + $i + "=" + $errs + "; " + $i + " [level, index])); + this.isMessageIgnored = (level, sessionId) => { + const currentLevel = this._loggingLevels.get(sessionId); + return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false; + }; + this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {}; + this._instructions = options === null || options === void 0 ? void 0 : options.instructions; + this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request)); + this.setNotificationHandler(InitializedNotificationSchema, () => { + var _a2; + return (_a2 = this.oninitialized) === null || _a2 === void 0 ? void 0 : _a2.call(this); + }); + if (this._capabilities.logging) { + this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => { + var _a2; + const transportSessionId = extra.sessionId || ((_a2 = extra.requestInfo) === null || _a2 === void 0 ? void 0 : _a2.headers["mcp-session-id"]) || void 0; + const { level } = request.params; + const parseResult = LoggingLevelSchema.safeParse(level); + if (transportSessionId && parseResult.success) { + this._loggingLevels.set(transportSessionId, parseResult.data); + } + return {}; + }); + } + } + /** + * Registers new capabilities. This can only be called before connecting to a transport. + * + * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization). + */ + registerCapabilities(capabilities) { + if (this.transport) { + throw new Error("Cannot register capabilities after connecting to transport"); + } + this._capabilities = mergeCapabilities(this._capabilities, capabilities); + } + assertCapabilityForMethod(method) { + var _a, _b, _c; + switch (method) { + case "sampling/createMessage": + if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) { + throw new Error(`Client does not support sampling (required for ${method})`); + } + break; + case "elicitation/create": + if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation)) { + throw new Error(`Client does not support elicitation (required for ${method})`); + } + break; + case "roots/list": + if (!((_c = this._clientCapabilities) === null || _c === void 0 ? void 0 : _c.roots)) { + throw new Error(`Client does not support listing roots (required for ${method})`); + } + break; + case "ping": + break; + } + } + assertNotificationCapability(method) { + switch (method) { + case "notifications/message": + if (!this._capabilities.logging) { + throw new Error(`Server does not support logging (required for ${method})`); + } + break; + case "notifications/resources/updated": + case "notifications/resources/list_changed": + if (!this._capabilities.resources) { + throw new Error(`Server does not support notifying about resources (required for ${method})`); + } + break; + case "notifications/tools/list_changed": + if (!this._capabilities.tools) { + throw new Error(`Server does not support notifying of tool list changes (required for ${method})`); + } + break; + case "notifications/prompts/list_changed": + if (!this._capabilities.prompts) { + throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`); + } + break; + case "notifications/cancelled": + break; + case "notifications/progress": + break; + } + } + assertRequestHandlerCapability(method) { + switch (method) { + case "sampling/createMessage": + if (!this._capabilities.sampling) { + throw new Error(`Server does not support sampling (required for ${method})`); + } + break; + case "logging/setLevel": + if (!this._capabilities.logging) { + throw new Error(`Server does not support logging (required for ${method})`); + } + break; + case "prompts/get": + case "prompts/list": + if (!this._capabilities.prompts) { + throw new Error(`Server does not support prompts (required for ${method})`); + } + break; + case "resources/list": + case "resources/templates/list": + case "resources/read": + if (!this._capabilities.resources) { + throw new Error(`Server does not support resources (required for ${method})`); + } + break; + case "tools/call": + case "tools/list": + if (!this._capabilities.tools) { + throw new Error(`Server does not support tools (required for ${method})`); + } + break; + case "ping": + case "initialize": + break; + } + } + async _oninitialize(request) { + const requestedVersion = request.params.protocolVersion; + this._clientCapabilities = request.params.capabilities; + this._clientVersion = request.params.clientInfo; + const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION; + return { + protocolVersion, + capabilities: this.getCapabilities(), + serverInfo: this._serverInfo, + ...this._instructions && { instructions: this._instructions } + }; + } + /** + * After initialization has completed, this will be populated with the client's reported capabilities. + */ + getClientCapabilities() { + return this._clientCapabilities; + } + /** + * After initialization has completed, this will be populated with information about the client's name and version. + */ + getClientVersion() { + return this._clientVersion; + } + getCapabilities() { + return this._capabilities; + } + async ping() { + return this.request({ method: "ping" }, EmptyResultSchema); + } + async createMessage(params, options) { + return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options); + } + async elicitInput(params, options) { + const result = await this.request({ method: "elicitation/create", params }, ElicitResultSchema, options); + if (result.action === "accept" && result.content) { + try { + const ajv = new import_ajv.default(); + const validate = ajv.compile(params.requestedSchema); + const isValid3 = validate(result.content); + if (!isValid3) { + throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${ajv.errorsText(validate.errors)}`); + } + } catch (error) { + if (error instanceof McpError) { + throw error; + } + throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error}`); + } + } + return result; + } + async listRoots(params, options) { + return this.request({ method: "roots/list", params }, ListRootsResultSchema, options); + } + /** + * Sends a logging message to the client, if connected. + * Note: You only need to send the parameters object, not the entire JSON RPC message + * @see LoggingMessageNotification + * @param params + * @param sessionId optional for stateless and backward compatibility + */ + async sendLoggingMessage(params, sessionId) { + if (this._capabilities.logging) { + if (!sessionId || !this.isMessageIgnored(params.level, sessionId)) { + return this.notification({ method: "notifications/message", params }); + } + } + } + async sendResourceUpdated(params) { + return this.notification({ + method: "notifications/resources/updated", + params + }); + } + async sendResourceListChanged() { + return this.notification({ + method: "notifications/resources/list_changed" + }); + } + async sendToolListChanged() { + return this.notification({ method: "notifications/tools/list_changed" }); + } + async sendPromptListChanged() { + return this.notification({ method: "notifications/prompts/list_changed" }); + } + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/Options.js +var ignoreOverride, defaultOptions, getDefaultOptions; +var init_Options = __esm({ + "node_modules/zod-to-json-schema/dist/esm/Options.js"() { + ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use"); + defaultOptions = { + name: void 0, + $refStrategy: "root", + basePath: ["#"], + effectStrategy: "input", + pipeStrategy: "all", + dateStrategy: "format:date-time", + mapStrategy: "entries", + removeAdditionalStrategy: "passthrough", + allowedAdditionalProperties: true, + rejectedAdditionalProperties: false, + definitionPath: "definitions", + target: "jsonSchema7", + strictUnions: false, + definitions: {}, + errorMessages: false, + markdownDescription: false, + patternStrategy: "escape", + applyRegexFlags: false, + emailStrategy: "format:email", + base64Strategy: "contentEncoding:base64", + nameStrategy: "ref", + openAiAnyTypeName: "OpenAiAnyType" + }; + getDefaultOptions = (options) => typeof options === "string" ? { + ...defaultOptions, + name: options + } : { + ...defaultOptions, + ...options + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/Refs.js +var getRefs; +var init_Refs = __esm({ + "node_modules/zod-to-json-schema/dist/esm/Refs.js"() { + init_Options(); + getRefs = (options) => { + const _options = getDefaultOptions(options); + const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath; + return { + ..._options, + flags: { hasReferencedOpenAiAnyType: false }, + currentPath, + propertyPath: void 0, + seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [ + def._def, + { + def: def._def, + path: [..._options.basePath, _options.definitionPath, name], + // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now. + jsonSchema: void 0 + } + ])) + }; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/errorMessages.js +function addErrorMessage(res, key, errorMessage, refs) { + if (!refs?.errorMessages) + return; + if (errorMessage) { + res.errorMessage = { + ...res.errorMessage, + [key]: errorMessage + }; + } +} +function setResponseValueAndErrors(res, key, value, errorMessage, refs) { + res[key] = value; + addErrorMessage(res, key, errorMessage, refs); +} +var init_errorMessages = __esm({ + "node_modules/zod-to-json-schema/dist/esm/errorMessages.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/getRelativePath.js +var getRelativePath; +var init_getRelativePath = __esm({ + "node_modules/zod-to-json-schema/dist/esm/getRelativePath.js"() { + getRelativePath = (pathA, pathB) => { + let i = 0; + for (; i < pathA.length && i < pathB.length; i++) { + if (pathA[i] !== pathB[i]) + break; + } + return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/"); + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/any.js +function parseAnyDef(refs) { + if (refs.target !== "openAi") { + return {}; + } + const anyDefinitionPath = [ + ...refs.basePath, + refs.definitionPath, + refs.openAiAnyTypeName + ]; + refs.flags.hasReferencedOpenAiAnyType = true; + return { + $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/") + }; +} +var init_any = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/any.js"() { + init_getRelativePath(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/array.js +function parseArrayDef(def, refs) { + const res = { + type: "array" + }; + if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) { + res.items = parseDef(def.type._def, { + ...refs, + currentPath: [...refs.currentPath, "items"] + }); + } + if (def.minLength) { + setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs); + } + if (def.maxLength) { + setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs); + } + if (def.exactLength) { + setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs); + setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs); + } + return res; +} +var init_array = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/array.js"() { + init_zod(); + init_errorMessages(); + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js +function parseBigintDef(def, refs) { + const res = { + type: "integer", + format: "int64" + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } else { + setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } else { + setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} +var init_bigint = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js"() { + init_errorMessages(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js +function parseBooleanDef() { + return { + type: "boolean" + }; +} +var init_boolean = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/branded.js +function parseBrandedDef(_def, refs) { + return parseDef(_def.type._def, refs); +} +var init_branded = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/branded.js"() { + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/catch.js +var parseCatchDef; +var init_catch = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/catch.js"() { + init_parseDef(); + parseCatchDef = (def, refs) => { + return parseDef(def.innerType._def, refs); + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/date.js +function parseDateDef(def, refs, overrideDateStrategy) { + const strategy = overrideDateStrategy ?? refs.dateStrategy; + if (Array.isArray(strategy)) { + return { + anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)) + }; + } + switch (strategy) { + case "string": + case "format:date-time": + return { + type: "string", + format: "date-time" + }; + case "format:date": + return { + type: "string", + format: "date" + }; + case "integer": + return integerDateParser(def, refs); + } +} +var integerDateParser; +var init_date = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/date.js"() { + init_errorMessages(); + integerDateParser = (def, refs) => { + const res = { + type: "integer", + format: "unix-time" + }; + if (refs.target === "openApi3") { + return res; + } + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors( + res, + "minimum", + check.value, + // This is in milliseconds + check.message, + refs + ); + break; + case "max": + setResponseValueAndErrors( + res, + "maximum", + check.value, + // This is in milliseconds + check.message, + refs + ); + break; + } + } + return res; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/default.js +function parseDefaultDef(_def, refs) { + return { + ...parseDef(_def.innerType._def, refs), + default: _def.defaultValue() + }; +} +var init_default = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/default.js"() { + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/effects.js +function parseEffectsDef(_def, refs) { + return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs); +} +var init_effects = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/effects.js"() { + init_parseDef(); + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/enum.js +function parseEnumDef(def) { + return { + type: "string", + enum: Array.from(def.values) + }; +} +var init_enum = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/enum.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js +function parseIntersectionDef(def, refs) { + const allOf = [ + parseDef(def.left._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"] + }), + parseDef(def.right._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "1"] + }) + ].filter((x) => !!x); + let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0; + const mergedAllOf = []; + allOf.forEach((schema) => { + if (isJsonSchema7AllOfType(schema)) { + mergedAllOf.push(...schema.allOf); + if (schema.unevaluatedProperties === void 0) { + unevaluatedProperties = void 0; + } + } else { + let nestedSchema = schema; + if ("additionalProperties" in schema && schema.additionalProperties === false) { + const { additionalProperties, ...rest } = schema; + nestedSchema = rest; + } else { + unevaluatedProperties = void 0; + } + mergedAllOf.push(nestedSchema); + } + }); + return mergedAllOf.length ? { + allOf: mergedAllOf, + ...unevaluatedProperties + } : void 0; +} +var isJsonSchema7AllOfType; +var init_intersection = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js"() { + init_parseDef(); + isJsonSchema7AllOfType = (type) => { + if ("type" in type && type.type === "string") + return false; + return "allOf" in type; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/literal.js +function parseLiteralDef(def, refs) { + const parsedType = typeof def.value; + if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") { + return { + type: Array.isArray(def.value) ? "array" : "object" + }; + } + if (refs.target === "openApi3") { + return { + type: parsedType === "bigint" ? "integer" : parsedType, + enum: [def.value] + }; + } + return { + type: parsedType === "bigint" ? "integer" : parsedType, + const: def.value + }; +} +var init_literal = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/literal.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/string.js +function parseStringDef(def, refs) { + const res = { + type: "string" + }; + if (def.checks) { + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs); + break; + case "max": + setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs); + break; + case "email": + switch (refs.emailStrategy) { + case "format:email": + addFormat(res, "email", check.message, refs); + break; + case "format:idn-email": + addFormat(res, "idn-email", check.message, refs); + break; + case "pattern:zod": + addPattern(res, zodPatterns.email, check.message, refs); + break; + } + break; + case "url": + addFormat(res, "uri", check.message, refs); + break; + case "uuid": + addFormat(res, "uuid", check.message, refs); + break; + case "regex": + addPattern(res, check.regex, check.message, refs); + break; + case "cuid": + addPattern(res, zodPatterns.cuid, check.message, refs); + break; + case "cuid2": + addPattern(res, zodPatterns.cuid2, check.message, refs); + break; + case "startsWith": + addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs); + break; + case "endsWith": + addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs); + break; + case "datetime": + addFormat(res, "date-time", check.message, refs); + break; + case "date": + addFormat(res, "date", check.message, refs); + break; + case "time": + addFormat(res, "time", check.message, refs); + break; + case "duration": + addFormat(res, "duration", check.message, refs); + break; + case "length": + setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs); + setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs); + break; + case "includes": { + addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs); + break; + } + case "ip": { + if (check.version !== "v6") { + addFormat(res, "ipv4", check.message, refs); + } + if (check.version !== "v4") { + addFormat(res, "ipv6", check.message, refs); + } + break; + } + case "base64url": + addPattern(res, zodPatterns.base64url, check.message, refs); + break; + case "jwt": + addPattern(res, zodPatterns.jwt, check.message, refs); + break; + case "cidr": { + if (check.version !== "v6") { + addPattern(res, zodPatterns.ipv4Cidr, check.message, refs); + } + if (check.version !== "v4") { + addPattern(res, zodPatterns.ipv6Cidr, check.message, refs); + } + break; + } + case "emoji": + addPattern(res, zodPatterns.emoji(), check.message, refs); + break; + case "ulid": { + addPattern(res, zodPatterns.ulid, check.message, refs); + break; + } + case "base64": { + switch (refs.base64Strategy) { + case "format:binary": { + addFormat(res, "binary", check.message, refs); + break; + } + case "contentEncoding:base64": { + setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs); + break; + } + case "pattern:zod": { + addPattern(res, zodPatterns.base64, check.message, refs); + break; + } + } + break; + } + case "nanoid": { + addPattern(res, zodPatterns.nanoid, check.message, refs); + } + case "toLowerCase": + case "toUpperCase": + case "trim": + break; + default: + /* @__PURE__ */ ((_) => { + })(check); + } + } + } + return res; +} +function escapeLiteralCheckValue(literal, refs) { + return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal; +} +function escapeNonAlphaNumeric(source) { + let result = ""; + for (let i = 0; i < source.length; i++) { + if (!ALPHA_NUMERIC.has(source[i])) { + result += "\\"; + } + result += source[i]; + } + return result; +} +function addFormat(schema, value, message, refs) { + if (schema.format || schema.anyOf?.some((x) => x.format)) { + if (!schema.anyOf) { + schema.anyOf = []; + } + if (schema.format) { + schema.anyOf.push({ + format: schema.format, + ...schema.errorMessage && refs.errorMessages && { + errorMessage: { format: schema.errorMessage.format } + } + }); + delete schema.format; + if (schema.errorMessage) { + delete schema.errorMessage.format; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.anyOf.push({ + format: value, + ...message && refs.errorMessages && { errorMessage: { format: message } } + }); + } else { + setResponseValueAndErrors(schema, "format", value, message, refs); + } +} +function addPattern(schema, regex, message, refs) { + if (schema.pattern || schema.allOf?.some((x) => x.pattern)) { + if (!schema.allOf) { + schema.allOf = []; + } + if (schema.pattern) { + schema.allOf.push({ + pattern: schema.pattern, + ...schema.errorMessage && refs.errorMessages && { + errorMessage: { pattern: schema.errorMessage.pattern } + } + }); + delete schema.pattern; + if (schema.errorMessage) { + delete schema.errorMessage.pattern; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.allOf.push({ + pattern: stringifyRegExpWithFlags(regex, refs), + ...message && refs.errorMessages && { errorMessage: { pattern: message } } + }); + } else { + setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs); + } +} +function stringifyRegExpWithFlags(regex, refs) { + if (!refs.applyRegexFlags || !regex.flags) { + return regex.source; + } + const flags = { + i: regex.flags.includes("i"), + m: regex.flags.includes("m"), + s: regex.flags.includes("s") + // `.` matches newlines + }; + const source = flags.i ? regex.source.toLowerCase() : regex.source; + let pattern = ""; + let isEscaped = false; + let inCharGroup = false; + let inCharRange = false; + for (let i = 0; i < source.length; i++) { + if (isEscaped) { + pattern += source[i]; + isEscaped = false; + continue; + } + if (flags.i) { + if (inCharGroup) { + if (source[i].match(/[a-z]/)) { + if (inCharRange) { + pattern += source[i]; + pattern += `${source[i - 2]}-${source[i]}`.toUpperCase(); + inCharRange = false; + } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) { + pattern += source[i]; + inCharRange = true; + } else { + pattern += `${source[i]}${source[i].toUpperCase()}`; + } + continue; + } + } else if (source[i].match(/[a-z]/)) { + pattern += `[${source[i]}${source[i].toUpperCase()}]`; + continue; + } + } + if (flags.m) { + if (source[i] === "^") { + pattern += `(^|(?<=[\r +]))`; + continue; + } else if (source[i] === "$") { + pattern += `($|(?=[\r +]))`; + continue; + } + } + if (flags.s && source[i] === ".") { + pattern += inCharGroup ? `${source[i]}\r +` : `[${source[i]}\r +]`; + continue; + } + pattern += source[i]; + if (source[i] === "\\") { + isEscaped = true; + } else if (inCharGroup && source[i] === "]") { + inCharGroup = false; + } else if (!inCharGroup && source[i] === "[") { + inCharGroup = true; + } + } + try { + new RegExp(pattern); + } catch { + console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`); + return regex.source; + } + return pattern; +} +var emojiRegex2, zodPatterns, ALPHA_NUMERIC; +var init_string = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/string.js"() { + init_errorMessages(); + emojiRegex2 = void 0; + zodPatterns = { + /** + * `c` was changed to `[cC]` to replicate /i flag + */ + cuid: /^[cC][^\s-]{8,}$/, + cuid2: /^[0-9a-z]+$/, + ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/, + /** + * `a-z` was added to replicate /i flag + */ + email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/, + /** + * Constructed a valid Unicode RegExp + * + * Lazily instantiate since this type of regex isn't supported + * in all envs (e.g. React Native). + * + * See: + * https://github.com/colinhacks/zod/issues/2433 + * Fix in Zod: + * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b + */ + emoji: () => { + if (emojiRegex2 === void 0) { + emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u"); + } + return emojiRegex2; + }, + /** + * Unused + */ + uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/, + /** + * Unused + */ + ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, + ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/, + /** + * Unused + */ + ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, + ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, + base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, + base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, + nanoid: /^[a-zA-Z0-9_-]{21}$/, + jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/ + }; + ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/record.js +function parseRecordDef(def, refs) { + if (refs.target === "openAi") { + console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead."); + } + if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) { + return { + type: "object", + required: def.keyType._def.values, + properties: def.keyType._def.values.reduce((acc, key) => ({ + ...acc, + [key]: parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", key] + }) ?? parseAnyDef(refs) + }), {}), + additionalProperties: refs.rejectedAdditionalProperties + }; + } + const schema = { + type: "object", + additionalProperties: parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"] + }) ?? refs.allowedAdditionalProperties + }; + if (refs.target === "openApi3") { + return schema; + } + if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) { + const { type, ...keyType } = parseStringDef(def.keyType._def, refs); + return { + ...schema, + propertyNames: keyType + }; + } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) { + return { + ...schema, + propertyNames: { + enum: def.keyType._def.values + } + }; + } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) { + const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs); + return { + ...schema, + propertyNames: keyType + }; + } + return schema; +} +var init_record = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/record.js"() { + init_zod(); + init_parseDef(); + init_string(); + init_branded(); + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/map.js +function parseMapDef(def, refs) { + if (refs.mapStrategy === "record") { + return parseRecordDef(def, refs); + } + const keys = parseDef(def.keyType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "0"] + }) || parseAnyDef(refs); + const values = parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "1"] + }) || parseAnyDef(refs); + return { + type: "array", + maxItems: 125, + items: { + type: "array", + items: [keys, values], + minItems: 2, + maxItems: 2 + } + }; +} +var init_map = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/map.js"() { + init_parseDef(); + init_record(); + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js +function parseNativeEnumDef(def) { + const object = def.values; + const actualKeys = Object.keys(def.values).filter((key) => { + return typeof object[object[key]] !== "number"; + }); + const actualValues = actualKeys.map((key) => object[key]); + const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values))); + return { + type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"], + enum: actualValues + }; +} +var init_nativeEnum = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/never.js +function parseNeverDef(refs) { + return refs.target === "openAi" ? void 0 : { + not: parseAnyDef({ + ...refs, + currentPath: [...refs.currentPath, "not"] + }) + }; +} +var init_never = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/never.js"() { + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/null.js +function parseNullDef(refs) { + return refs.target === "openApi3" ? { + enum: ["null"], + nullable: true + } : { + type: "null" + }; +} +var init_null = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/null.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/union.js +function parseUnionDef(def, refs) { + if (refs.target === "openApi3") + return asAnyOf(def, refs); + const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options; + if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) { + const types = options.reduce((types2, x) => { + const type = primitiveMappings[x._def.typeName]; + return type && !types2.includes(type) ? [...types2, type] : types2; + }, []); + return { + type: types.length > 1 ? types : types[0] + }; + } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) { + const types = options.reduce((acc, x) => { + const type = typeof x._def.value; + switch (type) { + case "string": + case "number": + case "boolean": + return [...acc, type]; + case "bigint": + return [...acc, "integer"]; + case "object": + if (x._def.value === null) + return [...acc, "null"]; + case "symbol": + case "undefined": + case "function": + default: + return acc; + } + }, []); + if (types.length === options.length) { + const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i); + return { + type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0], + enum: options.reduce((acc, x) => { + return acc.includes(x._def.value) ? acc : [...acc, x._def.value]; + }, []) + }; + } + } else if (options.every((x) => x._def.typeName === "ZodEnum")) { + return { + type: "string", + enum: options.reduce((acc, x) => [ + ...acc, + ...x._def.values.filter((x2) => !acc.includes(x2)) + ], []) + }; + } + return asAnyOf(def, refs); +} +var primitiveMappings, asAnyOf; +var init_union = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/union.js"() { + init_parseDef(); + primitiveMappings = { + ZodString: "string", + ZodNumber: "number", + ZodBigInt: "integer", + ZodBoolean: "boolean", + ZodNull: "null" + }; + asAnyOf = (def, refs) => { + const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", `${i}`] + })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)); + return anyOf.length ? { anyOf } : void 0; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js +function parseNullableDef(def, refs) { + if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) { + if (refs.target === "openApi3") { + return { + type: primitiveMappings[def.innerType._def.typeName], + nullable: true + }; + } + return { + type: [ + primitiveMappings[def.innerType._def.typeName], + "null" + ] + }; + } + if (refs.target === "openApi3") { + const base2 = parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath] + }); + if (base2 && "$ref" in base2) + return { allOf: [base2], nullable: true }; + return base2 && { ...base2, nullable: true }; + } + const base = parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "0"] + }); + return base && { anyOf: [base, { type: "null" }] }; +} +var init_nullable = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js"() { + init_parseDef(); + init_union(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/number.js +function parseNumberDef(def, refs) { + const res = { + type: "number" + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "int": + res.type = "integer"; + addErrorMessage(res, "type", check.message, refs); + break; + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } else { + setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } else { + setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} +var init_number = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/number.js"() { + init_errorMessages(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/object.js +function parseObjectDef(def, refs) { + const forceOptionalIntoNullable = refs.target === "openAi"; + const result = { + type: "object", + properties: {} + }; + const required = []; + const shape = def.shape(); + for (const propName in shape) { + let propDef = shape[propName]; + if (propDef === void 0 || propDef._def === void 0) { + continue; + } + let propOptional = safeIsOptional(propDef); + if (propOptional && forceOptionalIntoNullable) { + if (propDef._def.typeName === "ZodOptional") { + propDef = propDef._def.innerType; + } + if (!propDef.isNullable()) { + propDef = propDef.nullable(); + } + propOptional = false; + } + const parsedDef = parseDef(propDef._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", propName], + propertyPath: [...refs.currentPath, "properties", propName] + }); + if (parsedDef === void 0) { + continue; + } + result.properties[propName] = parsedDef; + if (!propOptional) { + required.push(propName); + } + } + if (required.length) { + result.required = required; + } + const additionalProperties = decideAdditionalProperties(def, refs); + if (additionalProperties !== void 0) { + result.additionalProperties = additionalProperties; + } + return result; +} +function decideAdditionalProperties(def, refs) { + if (def.catchall._def.typeName !== "ZodNever") { + return parseDef(def.catchall._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"] + }); + } + switch (def.unknownKeys) { + case "passthrough": + return refs.allowedAdditionalProperties; + case "strict": + return refs.rejectedAdditionalProperties; + case "strip": + return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties; + } +} +function safeIsOptional(schema) { + try { + return schema.isOptional(); + } catch { + return true; + } +} +var init_object = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/object.js"() { + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/optional.js +var parseOptionalDef; +var init_optional = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/optional.js"() { + init_parseDef(); + init_any(); + parseOptionalDef = (def, refs) => { + if (refs.currentPath.toString() === refs.propertyPath?.toString()) { + return parseDef(def.innerType._def, refs); + } + const innerSchema = parseDef(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "1"] + }); + return innerSchema ? { + anyOf: [ + { + not: parseAnyDef(refs) + }, + innerSchema + ] + } : parseAnyDef(refs); + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js +var parsePipelineDef; +var init_pipeline = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js"() { + init_parseDef(); + parsePipelineDef = (def, refs) => { + if (refs.pipeStrategy === "input") { + return parseDef(def.in._def, refs); + } else if (refs.pipeStrategy === "output") { + return parseDef(def.out._def, refs); + } + const a = parseDef(def.in._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"] + }); + const b = parseDef(def.out._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"] + }); + return { + allOf: [a, b].filter((x) => x !== void 0) + }; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/promise.js +function parsePromiseDef(def, refs) { + return parseDef(def.type._def, refs); +} +var init_promise = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/promise.js"() { + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/set.js +function parseSetDef(def, refs) { + const items = parseDef(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items"] + }); + const schema = { + type: "array", + uniqueItems: true, + items + }; + if (def.minSize) { + setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs); + } + if (def.maxSize) { + setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs); + } + return schema; +} +var init_set = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/set.js"() { + init_errorMessages(); + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js +function parseTupleDef(def, refs) { + if (def.rest) { + return { + type: "array", + minItems: def.items.length, + items: def.items.map((x, i) => parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`] + })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []), + additionalItems: parseDef(def.rest._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalItems"] + }) + }; + } else { + return { + type: "array", + minItems: def.items.length, + maxItems: def.items.length, + items: def.items.map((x, i) => parseDef(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`] + })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []) + }; + } +} +var init_tuple = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js"() { + init_parseDef(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js +function parseUndefinedDef(refs) { + return { + not: parseAnyDef(refs) + }; +} +var init_undefined = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js"() { + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js +function parseUnknownDef(refs) { + return parseAnyDef(refs); +} +var init_unknown = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js"() { + init_any(); + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js +var parseReadonlyDef; +var init_readonly = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js"() { + init_parseDef(); + parseReadonlyDef = (def, refs) => { + return parseDef(def.innerType._def, refs); + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/selectParser.js +var selectParser; +var init_selectParser = __esm({ + "node_modules/zod-to-json-schema/dist/esm/selectParser.js"() { + init_zod(); + init_any(); + init_array(); + init_bigint(); + init_boolean(); + init_branded(); + init_catch(); + init_date(); + init_default(); + init_effects(); + init_enum(); + init_intersection(); + init_literal(); + init_map(); + init_nativeEnum(); + init_never(); + init_null(); + init_nullable(); + init_number(); + init_object(); + init_optional(); + init_pipeline(); + init_promise(); + init_record(); + init_set(); + init_string(); + init_tuple(); + init_undefined(); + init_union(); + init_unknown(); + init_readonly(); + selectParser = (def, typeName, refs) => { + switch (typeName) { + case ZodFirstPartyTypeKind.ZodString: + return parseStringDef(def, refs); + case ZodFirstPartyTypeKind.ZodNumber: + return parseNumberDef(def, refs); + case ZodFirstPartyTypeKind.ZodObject: + return parseObjectDef(def, refs); + case ZodFirstPartyTypeKind.ZodBigInt: + return parseBigintDef(def, refs); + case ZodFirstPartyTypeKind.ZodBoolean: + return parseBooleanDef(); + case ZodFirstPartyTypeKind.ZodDate: + return parseDateDef(def, refs); + case ZodFirstPartyTypeKind.ZodUndefined: + return parseUndefinedDef(refs); + case ZodFirstPartyTypeKind.ZodNull: + return parseNullDef(refs); + case ZodFirstPartyTypeKind.ZodArray: + return parseArrayDef(def, refs); + case ZodFirstPartyTypeKind.ZodUnion: + case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: + return parseUnionDef(def, refs); + case ZodFirstPartyTypeKind.ZodIntersection: + return parseIntersectionDef(def, refs); + case ZodFirstPartyTypeKind.ZodTuple: + return parseTupleDef(def, refs); + case ZodFirstPartyTypeKind.ZodRecord: + return parseRecordDef(def, refs); + case ZodFirstPartyTypeKind.ZodLiteral: + return parseLiteralDef(def, refs); + case ZodFirstPartyTypeKind.ZodEnum: + return parseEnumDef(def); + case ZodFirstPartyTypeKind.ZodNativeEnum: + return parseNativeEnumDef(def); + case ZodFirstPartyTypeKind.ZodNullable: + return parseNullableDef(def, refs); + case ZodFirstPartyTypeKind.ZodOptional: + return parseOptionalDef(def, refs); + case ZodFirstPartyTypeKind.ZodMap: + return parseMapDef(def, refs); + case ZodFirstPartyTypeKind.ZodSet: + return parseSetDef(def, refs); + case ZodFirstPartyTypeKind.ZodLazy: + return () => def.getter()._def; + case ZodFirstPartyTypeKind.ZodPromise: + return parsePromiseDef(def, refs); + case ZodFirstPartyTypeKind.ZodNaN: + case ZodFirstPartyTypeKind.ZodNever: + return parseNeverDef(refs); + case ZodFirstPartyTypeKind.ZodEffects: + return parseEffectsDef(def, refs); + case ZodFirstPartyTypeKind.ZodAny: + return parseAnyDef(refs); + case ZodFirstPartyTypeKind.ZodUnknown: + return parseUnknownDef(refs); + case ZodFirstPartyTypeKind.ZodDefault: + return parseDefaultDef(def, refs); + case ZodFirstPartyTypeKind.ZodBranded: + return parseBrandedDef(def, refs); + case ZodFirstPartyTypeKind.ZodReadonly: + return parseReadonlyDef(def, refs); + case ZodFirstPartyTypeKind.ZodCatch: + return parseCatchDef(def, refs); + case ZodFirstPartyTypeKind.ZodPipeline: + return parsePipelineDef(def, refs); + case ZodFirstPartyTypeKind.ZodFunction: + case ZodFirstPartyTypeKind.ZodVoid: + case ZodFirstPartyTypeKind.ZodSymbol: + return void 0; + default: + return /* @__PURE__ */ ((_) => void 0)(typeName); + } + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parseDef.js +function parseDef(def, refs, forceResolution = false) { + const seenItem = refs.seen.get(def); + if (refs.override) { + const overrideResult = refs.override?.(def, refs, seenItem, forceResolution); + if (overrideResult !== ignoreOverride) { + return overrideResult; + } + } + if (seenItem && !forceResolution) { + const seenSchema = get$ref(seenItem, refs); + if (seenSchema !== void 0) { + return seenSchema; + } + } + const newItem = { def, path: refs.currentPath, jsonSchema: void 0 }; + refs.seen.set(def, newItem); + const jsonSchemaOrGetter = selectParser(def, def.typeName, refs); + const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter; + if (jsonSchema) { + addMeta(def, refs, jsonSchema); + } + if (refs.postProcess) { + const postProcessResult = refs.postProcess(jsonSchema, def, refs); + newItem.jsonSchema = jsonSchema; + return postProcessResult; + } + newItem.jsonSchema = jsonSchema; + return jsonSchema; +} +var get$ref, addMeta; +var init_parseDef = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parseDef.js"() { + init_Options(); + init_selectParser(); + init_getRelativePath(); + init_any(); + get$ref = (item, refs) => { + switch (refs.$refStrategy) { + case "root": + return { $ref: item.path.join("/") }; + case "relative": + return { $ref: getRelativePath(refs.currentPath, item.path) }; + case "none": + case "seen": { + if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) { + console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`); + return parseAnyDef(refs); + } + return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0; + } + } + }; + addMeta = (def, refs, jsonSchema) => { + if (def.description) { + jsonSchema.description = def.description; + if (refs.markdownDescription) { + jsonSchema.markdownDescription = def.description; + } + } + return jsonSchema; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/parseTypes.js +var init_parseTypes = __esm({ + "node_modules/zod-to-json-schema/dist/esm/parseTypes.js"() { + } +}); + +// node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js +var zodToJsonSchema; +var init_zodToJsonSchema = __esm({ + "node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js"() { + init_parseDef(); + init_Refs(); + init_any(); + zodToJsonSchema = (schema, options) => { + const refs = getRefs(options); + let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({ + ...acc, + [name2]: parseDef(schema2._def, { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name2] + }, true) ?? parseAnyDef(refs) + }), {}) : void 0; + const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name; + const main = parseDef(schema._def, name === void 0 ? refs : { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name] + }, false) ?? parseAnyDef(refs); + const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0; + if (title !== void 0) { + main.title = title; + } + if (refs.flags.hasReferencedOpenAiAnyType) { + if (!definitions) { + definitions = {}; + } + if (!definitions[refs.openAiAnyTypeName]) { + definitions[refs.openAiAnyTypeName] = { + // Skipping "object" as no properties can be defined and additionalProperties must be "false" + type: ["string", "number", "integer", "boolean", "array", "null"], + items: { + $ref: refs.$refStrategy === "relative" ? "1" : [ + ...refs.basePath, + refs.definitionPath, + refs.openAiAnyTypeName + ].join("/") + } + }; + } + } + const combined = name === void 0 ? definitions ? { + ...main, + [refs.definitionPath]: definitions + } : main : { + $ref: [ + ...refs.$refStrategy === "relative" ? [] : refs.basePath, + refs.definitionPath, + name + ].join("/"), + [refs.definitionPath]: { + ...definitions, + [name]: main + } + }; + if (refs.target === "jsonSchema7") { + combined.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") { + combined.$schema = "https://json-schema.org/draft/2019-09/schema#"; + } + if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) { + console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property."); + } + return combined; + }; + } +}); + +// node_modules/zod-to-json-schema/dist/esm/index.js +var init_esm = __esm({ + "node_modules/zod-to-json-schema/dist/esm/index.js"() { + init_Options(); + init_Refs(); + init_errorMessages(); + init_getRelativePath(); + init_parseDef(); + init_parseTypes(); + init_any(); + init_array(); + init_bigint(); + init_boolean(); + init_branded(); + init_catch(); + init_date(); + init_default(); + init_effects(); + init_enum(); + init_intersection(); + init_literal(); + init_map(); + init_nativeEnum(); + init_never(); + init_null(); + init_nullable(); + init_number(); + init_object(); + init_optional(); + init_pipeline(); + init_promise(); + init_readonly(); + init_record(); + init_set(); + init_string(); + init_tuple(); + init_undefined(); + init_union(); + init_unknown(); + init_selectParser(); + init_zodToJsonSchema(); + init_zodToJsonSchema(); + } +}); + +// node_modules/chalk/source/vendor/ansi-styles/index.js +function assembleStyles() { + const codes = /* @__PURE__ */ new Map(); + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { + open: `\x1B[${style[0]}m`, + close: `\x1B[${style[1]}m` + }; + group[styleName] = styles[styleName]; + codes.set(style[0], style[1]); + } + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false + }); + } + Object.defineProperty(styles, "codes", { + value: codes, + enumerable: false + }); + styles.color.close = "\x1B[39m"; + styles.bgColor.close = "\x1B[49m"; + styles.color.ansi = wrapAnsi16(); + styles.color.ansi256 = wrapAnsi256(); + styles.color.ansi16m = wrapAnsi16m(); + styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET); + Object.defineProperties(styles, { + rgbToAnsi256: { + value(red, green, blue) { + if (red === green && green === blue) { + if (red < 8) { + return 16; + } + if (red > 248) { + return 231; + } + return Math.round((red - 8) / 247 * 24) + 232; + } + return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5); + }, + enumerable: false + }, + hexToRgb: { + value(hex) { + const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16)); + if (!matches) { + return [0, 0, 0]; + } + let [colorString] = matches; + if (colorString.length === 3) { + colorString = [...colorString].map((character) => character + character).join(""); + } + const integer = Number.parseInt(colorString, 16); + return [ + /* eslint-disable no-bitwise */ + integer >> 16 & 255, + integer >> 8 & 255, + integer & 255 + /* eslint-enable no-bitwise */ + ]; + }, + enumerable: false + }, + hexToAnsi256: { + value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)), + enumerable: false + }, + ansi256ToAnsi: { + value(code) { + if (code < 8) { + return 30 + code; + } + if (code < 16) { + return 90 + (code - 8); + } + let red; + let green; + let blue; + if (code >= 232) { + red = ((code - 232) * 10 + 8) / 255; + green = red; + blue = red; + } else { + code -= 16; + const remainder = code % 36; + red = Math.floor(code / 36) / 5; + green = Math.floor(remainder / 6) / 5; + blue = remainder % 6 / 5; + } + const value = Math.max(red, green, blue) * 2; + if (value === 0) { + return 30; + } + let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red)); + if (value === 2) { + result += 60; + } + return result; + }, + enumerable: false + }, + rgbToAnsi: { + value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), + enumerable: false + }, + hexToAnsi: { + value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), + enumerable: false + } + }); + return styles; +} +var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default; +var init_ansi_styles = __esm({ + "node_modules/chalk/source/vendor/ansi-styles/index.js"() { + ANSI_BACKGROUND_OFFSET = 10; + wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`; + wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`; + wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`; + styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + overline: [53, 55], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29] + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + // Bright color + blackBright: [90, 39], + gray: [90, 39], + // Alias of `blackBright` + grey: [90, 39], + // Alias of `blackBright` + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39] + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + // Bright color + bgBlackBright: [100, 49], + bgGray: [100, 49], + // Alias of `bgBlackBright` + bgGrey: [100, 49], + // Alias of `bgBlackBright` + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49] + } + }; + modifierNames = Object.keys(styles.modifier); + foregroundColorNames = Object.keys(styles.color); + backgroundColorNames = Object.keys(styles.bgColor); + colorNames = [...foregroundColorNames, ...backgroundColorNames]; + ansiStyles = assembleStyles(); + ansi_styles_default = ansiStyles; + } +}); + +// node_modules/chalk/source/vendor/supports-color/index.js +function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) { + const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--"; + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf("--"); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +} +function envForceColor() { + if ("FORCE_COLOR" in env) { + if (env.FORCE_COLOR === "true") { + return 1; + } + if (env.FORCE_COLOR === "false") { + return 0; + } + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} +function translateLevel(level) { + if (level === 0) { + return false; + } + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} +function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== void 0) { + flagForceColor = noFlagForceColor; + } + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + if (forceColor === 0) { + return 0; + } + if (sniffFlags) { + if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) { + return 3; + } + if (hasFlag("color=256")) { + return 2; + } + } + if ("TF_BUILD" in env && "AGENT_NAME" in env) { + return 1; + } + if (haveStream && !streamIsTTY && forceColor === void 0) { + return 0; + } + const min = forceColor || 0; + if (env.TERM === "dumb") { + return min; + } + if (import_node_process.default.platform === "win32") { + const osRelease = import_node_os.default.release().split("."); + if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + return 1; + } + if ("CI" in env) { + if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) { + return 3; + } + if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") { + return 1; + } + return min; + } + if ("TEAMCITY_VERSION" in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + if (env.COLORTERM === "truecolor") { + return 3; + } + if (env.TERM === "xterm-kitty") { + return 3; + } + if (env.TERM === "xterm-ghostty") { + return 3; + } + if (env.TERM === "wezterm") { + return 3; + } + if ("TERM_PROGRAM" in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10); + switch (env.TERM_PROGRAM) { + case "iTerm.app": { + return version >= 3 ? 3 : 2; + } + case "Apple_Terminal": { + return 2; + } + } + } + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + if ("COLORTERM" in env) { + return 1; + } + return min; +} +function createSupportsColor(stream, options = {}) { + const level = _supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options + }); + return translateLevel(level); +} +var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default; +var init_supports_color = __esm({ + "node_modules/chalk/source/vendor/supports-color/index.js"() { + import_node_process = __toESM(require("node:process"), 1); + import_node_os = __toESM(require("node:os"), 1); + import_node_tty = __toESM(require("node:tty"), 1); + ({ env } = import_node_process.default); + if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) { + flagForceColor = 0; + } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) { + flagForceColor = 1; + } + supportsColor = { + stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }), + stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) }) + }; + supports_color_default = supportsColor; + } +}); + +// node_modules/chalk/source/utilities.js +function stringReplaceAll(string, substring, replacer) { + let index = string.indexOf(substring); + if (index === -1) { + return string; + } + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ""; + do { + returnValue += string.slice(endIndex, index) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + returnValue += string.slice(endIndex); + return returnValue; +} +function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) { + let endIndex = 0; + let returnValue = ""; + do { + const gotCR = string[index - 1] === "\r"; + returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix; + endIndex = index + 1; + index = string.indexOf("\n", endIndex); + } while (index !== -1); + returnValue += string.slice(endIndex); + return returnValue; +} +var init_utilities = __esm({ + "node_modules/chalk/source/utilities.js"() { + } +}); + +// node_modules/chalk/source/index.js +function createChalk(options) { + return chalkFactory(options); +} +var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default; +var init_source = __esm({ + "node_modules/chalk/source/index.js"() { + init_ansi_styles(); + init_supports_color(); + init_utilities(); + ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default); + GENERATOR = Symbol("GENERATOR"); + STYLER = Symbol("STYLER"); + IS_EMPTY = Symbol("IS_EMPTY"); + levelMapping = [ + "ansi", + "ansi", + "ansi256", + "ansi16m" + ]; + styles2 = /* @__PURE__ */ Object.create(null); + applyOptions = (object, options = {}) => { + if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { + throw new Error("The `level` option should be an integer from 0 to 3"); + } + const colorLevel = stdoutColor ? stdoutColor.level : 0; + object.level = options.level === void 0 ? colorLevel : options.level; + }; + chalkFactory = (options) => { + const chalk2 = (...strings) => strings.join(" "); + applyOptions(chalk2, options); + Object.setPrototypeOf(chalk2, createChalk.prototype); + return chalk2; + }; + Object.setPrototypeOf(createChalk.prototype, Function.prototype); + for (const [styleName, style] of Object.entries(ansi_styles_default)) { + styles2[styleName] = { + get() { + const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, styleName, { value: builder }); + return builder; + } + }; + } + styles2.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, "visible", { value: builder }); + return builder; + } + }; + getModelAnsi = (model, level, type, ...arguments_) => { + if (model === "rgb") { + if (level === "ansi16m") { + return ansi_styles_default[type].ansi16m(...arguments_); + } + if (level === "ansi256") { + return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_)); + } + return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_)); + } + if (model === "hex") { + return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_)); + } + return ansi_styles_default[type][model](...arguments_); + }; + usedModels = ["rgb", "hex", "ansi256"]; + for (const model of usedModels) { + styles2[model] = { + get() { + const { level } = this; + return function(...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + } + }; + const bgModel = "bg" + model[0].toUpperCase() + model.slice(1); + styles2[bgModel] = { + get() { + const { level } = this; + return function(...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + } + }; + } + proto = Object.defineProperties(() => { + }, { + ...styles2, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + } + } + }); + createStyler = (open, close, parent) => { + let openAll; + let closeAll; + if (parent === void 0) { + openAll = open; + closeAll = close; + } else { + openAll = parent.openAll + open; + closeAll = close + parent.closeAll; + } + return { + open, + close, + openAll, + closeAll, + parent + }; + }; + createBuilder = (self2, _styler, _isEmpty) => { + const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" ")); + Object.setPrototypeOf(builder, proto); + builder[GENERATOR] = self2; + builder[STYLER] = _styler; + builder[IS_EMPTY] = _isEmpty; + return builder; + }; + applyStyle = (self2, string) => { + if (self2.level <= 0 || !string) { + return self2[IS_EMPTY] ? "" : string; + } + let styler = self2[STYLER]; + if (styler === void 0) { + return string; + } + const { openAll, closeAll } = styler; + if (string.includes("\x1B")) { + while (styler !== void 0) { + string = stringReplaceAll(string, styler.close, styler.open); + styler = styler.parent; + } + } + const lfIndex = string.indexOf("\n"); + if (lfIndex !== -1) { + string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); + } + return openAll + string + closeAll; + }; + Object.defineProperties(createChalk.prototype, styles2); + chalk = createChalk(); + chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 }); + source_default = chalk; + } +}); + +// index.ts +var index_exports = {}; +__export(index_exports, { + configSchema: () => configSchema, + default: () => createServer +}); +function isValidElementType(type) { + return typeof type === "string" && allowedElementTypes.includes(type); +} +function createServer({ + config +}) { + const server = new Server( + { + name: "analogical-reasoning-server", + version: "0.1.3" + }, + { + capabilities: { + tools: {} + } + } + ); + const analogicalReasoningServer = new AnalogicalReasoningServer(); + server.setRequestHandler(ListToolsRequestSchema, async () => ({ + tools: [ + { + name: "analogicalReasoning", + title: "Analogical Reasoning", + description: `A detailed tool for analogical thinking between source and target domains. +This tool helps models structure analogies systematically to improve understanding and reasoning. +It facilitates explicit mapping between domains, inference generation, and analogy evaluation. + +Use this tool to: +- Map concepts between familiar and unfamiliar domains +- Draw insights through structural alignment +- Generate predictions based on analogical transfer +- Solve problems by applying known solutions to new contexts`, + inputSchema: zodToJsonSchema(AnalogicalReasoningSchema) + } + ] + })); + server.setRequestHandler(CallToolRequestSchema, async (request) => { + const { name, arguments: toolArgs } = request.params; + if (name === "analogicalReasoning") { + const parsed = AnalogicalReasoningSchema.safeParse(toolArgs); + if (!parsed.success) { + throw new McpError( + ErrorCode.InvalidParams, + `Invalid arguments: ${parsed.error.message}` + ); + } + const result = await analogicalReasoningServer.processAnalogicalReasoning(parsed.data); + return result; + } + throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`); + }); + return server; +} +var configSchema, allowedElementTypes, AnalogicalReasoningServer, AnalogicalReasoningSchema; +var init_index = __esm({ + "index.ts"() { + "use strict"; + init_server(); + init_types2(); + init_zod(); + init_esm(); + init_source(); + configSchema = external_exports.object({}); + allowedElementTypes = ["entity", "attribute", "relation", "process"]; + AnalogicalReasoningServer = class { + analogyHistory = {}; + domainRegistry = {}; + nextElementId = 1; + validateAnalogicalReasoningData(input) { + const data = input; + if (!data.analogyId || typeof data.analogyId !== "string") { + throw new Error("Invalid analogyId: must be a string"); + } + if (!data.purpose || typeof data.purpose !== "string") { + throw new Error("Invalid purpose: must be a string"); + } + if (typeof data.confidence !== "number" || data.confidence < 0 || data.confidence > 1) { + throw new Error("Invalid confidence: must be a number between 0 and 1"); + } + if (typeof data.iteration !== "number" || data.iteration < 0) { + throw new Error("Invalid iteration: must be a non-negative number"); + } + if (typeof data.nextOperationNeeded !== "boolean") { + throw new Error("Invalid nextOperationNeeded: must be a boolean"); + } + const sourceDomain = data.sourceDomain; + const targetDomain = data.targetDomain; + if (!sourceDomain || typeof sourceDomain !== "object") { + throw new Error("Invalid sourceDomain: must be an object"); + } + if (!targetDomain || typeof targetDomain !== "object") { + throw new Error("Invalid targetDomain: must be an object"); + } + if (!sourceDomain.name || typeof sourceDomain.name !== "string") { + throw new Error("Invalid sourceDomain.name: must be a string"); + } + if (!targetDomain.name || typeof targetDomain.name !== "string") { + throw new Error("Invalid targetDomain.name: must be a string"); + } + if (!Array.isArray(sourceDomain.elements)) { + throw new Error("Invalid sourceDomain.elements: must be an array"); + } + if (!Array.isArray(targetDomain.elements)) { + throw new Error("Invalid targetDomain.elements: must be an array"); + } + const sourceElements = []; + for (const element of sourceDomain.elements) { + if (!element.id || typeof element.id !== "string") { + element.id = `elem-${this.nextElementId++}`; + } + if (!element.name || typeof element.name !== "string") { + throw new Error(`Invalid element name for element ${element.id}: must be a string`); + } + if (!element.type || typeof element.type !== "string") { + throw new Error(`Invalid element type for element ${element.id}: must be a string`); + } + if (!isValidElementType(element.type)) { + throw new Error(`Invalid element type for element ${element.id}: must be one of ${allowedElementTypes.join(", ")}`); + } + if (!element.description || typeof element.description !== "string") { + throw new Error(`Invalid element description for element ${element.id}: must be a string`); + } + sourceElements.push({ id: element.id, name: element.name, type: element.type, description: element.description }); + } + const targetElements = []; + for (const element of targetDomain.elements) { + if (!element.id || typeof element.id !== "string") { + element.id = `elem-${this.nextElementId++}`; + } + if (!element.name || typeof element.name !== "string") { + throw new Error(`Invalid element name for element ${element.id}: must be a string`); + } + if (!element.type || typeof element.type !== "string") { + throw new Error(`Invalid element type for element ${element.id}: must be a string`); + } + if (!isValidElementType(element.type)) { + throw new Error(`Invalid element type for element ${element.id}: must be one of ${allowedElementTypes.join(", ")}`); + } + if (!element.description || typeof element.description !== "string") { + throw new Error(`Invalid element description for element ${element.id}: must be a string`); + } + targetElements.push({ id: element.id, name: element.name, type: element.type, description: element.description }); + } + const mappings = []; + if (Array.isArray(data.mappings)) { + for (const mapping of data.mappings) { + if (!mapping.sourceElement || typeof mapping.sourceElement !== "string") { + throw new Error("Invalid mapping sourceElement: must be a string"); + } + if (!mapping.targetElement || typeof mapping.targetElement !== "string") { + throw new Error("Invalid mapping targetElement: must be a string"); + } + if (typeof mapping.mappingStrength !== "number" || mapping.mappingStrength < 0 || mapping.mappingStrength > 1) { + throw new Error("Invalid mappingStrength: must be a number between 0 and 1"); + } + if (!mapping.justification || typeof mapping.justification !== "string") { + throw new Error("Invalid mapping justification: must be a string"); + } + const limitations2 = []; + if (mapping.limitations && Array.isArray(mapping.limitations)) { + for (const limitation of mapping.limitations) { + if (typeof limitation === "string") { + limitations2.push(limitation); + } + } + } + const mappingData = { + sourceElement: mapping.sourceElement, + targetElement: mapping.targetElement, + mappingStrength: mapping.mappingStrength, + justification: mapping.justification + // limitations is added conditionally below + }; + if (limitations2.length > 0) { + mappingData.limitations = limitations2; + } + mappings.push(mappingData); + } + } + const strengths = []; + if (Array.isArray(data.strengths)) { + for (const strength of data.strengths) { + if (typeof strength === "string") { + strengths.push(strength); + } + } + } + const limitations = []; + if (Array.isArray(data.limitations)) { + for (const limitation of data.limitations) { + if (typeof limitation === "string") { + limitations.push(limitation); + } + } + } + const inferences = []; + if (Array.isArray(data.inferences)) { + for (const inference of data.inferences) { + if (!inference.statement || typeof inference.statement !== "string") { + throw new Error("Invalid inference statement: must be a string"); + } + if (typeof inference.confidence !== "number" || inference.confidence < 0 || inference.confidence > 1) { + throw new Error("Invalid inference confidence: must be a number between 0 and 1"); + } + if (!Array.isArray(inference.basedOnMappings)) { + throw new Error("Invalid inference basedOnMappings: must be an array of mapping IDs"); + } + const basedOnMappings = []; + for (const mappingId of inference.basedOnMappings) { + if (typeof mappingId === "string") { + basedOnMappings.push(mappingId); + } + } + inferences.push({ + statement: inference.statement, + confidence: inference.confidence, + basedOnMappings + }); + } + } + const suggestedOperations = []; + if (Array.isArray(data.suggestedOperations)) { + for (const operation of data.suggestedOperations) { + if (typeof operation === "string" && [ + "add-mapping", + "revise-mapping", + "draw-inference", + "evaluate-limitation", + "try-new-source" + ].includes(operation)) { + suggestedOperations.push(operation); + } + } + } + const validatedData = { + sourceDomain: { + name: sourceDomain.name, + elements: sourceElements + }, + targetDomain: { + name: targetDomain.name, + elements: targetElements + }, + mappings, + analogyId: data.analogyId, + purpose: data.purpose, + confidence: data.confidence, + iteration: data.iteration, + strengths, + limitations, + inferences, + nextOperationNeeded: data.nextOperationNeeded + // suggestedOperations is added conditionally below + }; + if (suggestedOperations.length > 0) { + validatedData.suggestedOperations = suggestedOperations; + } + return validatedData; + } + updateDomainRegistry(domain) { + this.domainRegistry[domain.name] = { + name: domain.name, + elements: [...domain.elements] + }; + } + updateAnalogicalReasoning(data) { + let historyEntry = this.analogyHistory[data.analogyId]; + if (!historyEntry) { + historyEntry = []; + this.analogyHistory[data.analogyId] = historyEntry; + } + historyEntry.push(data); + this.updateDomainRegistry(data.sourceDomain); + this.updateDomainRegistry(data.targetDomain); + } + visualizeMapping(data) { + const { sourceDomain, targetDomain, mappings } = data; + let output = ` +${source_default.bold(`ANALOGY: ${sourceDomain.name} \x94 ${targetDomain.name}`)} (ID: ${data.analogyId}) + +`; + output += `${source_default.cyan("Purpose:")} ${data.purpose} +`; + output += `${source_default.cyan("Confidence:")} ${(data.confidence * 100).toFixed(0)}% +`; + output += `${source_default.cyan("Iteration:")} ${data.iteration} + +`; + output += `${source_default.bold("STRUCTURAL MAPPINGS:")} + +`; + const mappingsBySourceType = /* @__PURE__ */ new Map(); + for (const mapping of mappings) { + const sourceElement = sourceDomain.elements.find((e) => e.id === mapping.sourceElement); + if (!sourceElement) continue; + if (!mappingsBySourceType.has(sourceElement.type)) { + mappingsBySourceType.set(sourceElement.type, []); + } + mappingsBySourceType.get(sourceElement.type)?.push(mapping); + } + for (const [type, typeMappings] of mappingsBySourceType.entries()) { + output += `${source_default.yellow(type.toUpperCase())} MAPPINGS: +`; + for (const mapping of typeMappings) { + const sourceElement = sourceDomain.elements.find((e) => e.id === mapping.sourceElement); + const targetElement = targetDomain.elements.find((e) => e.id === mapping.targetElement); + if (!sourceElement || !targetElement) continue; + let strengthIndicator; + if (mapping.mappingStrength >= 0.8) { + strengthIndicator = source_default.green("STRONG"); + } else if (mapping.mappingStrength >= 0.5) { + strengthIndicator = source_default.yellow("MODERATE"); + } else { + strengthIndicator = source_default.red("WEAK"); + } + output += ` ${source_default.bold(sourceElement.name)} ====[ ${strengthIndicator} ]===> ${source_default.bold(targetElement.name)} +`; + output += ` ${source_default.dim("Justification:")} ${mapping.justification} +`; + if (mapping.limitations && mapping.limitations.length > 0) { + output += ` ${source_default.dim("Limitations:")} ${mapping.limitations.join(", ")} +`; + } + output += "\n"; + } + } + const mappedSourceIds = new Set(mappings.map((m) => m.sourceElement)); + const mappedTargetIds = new Set(mappings.map((m) => m.targetElement)); + const unmappedSourceElements = sourceDomain.elements.filter((e) => !mappedSourceIds.has(e.id)); + const unmappedTargetElements = targetDomain.elements.filter((e) => !mappedTargetIds.has(e.id)); + if (unmappedSourceElements.length > 0) { + output += `${source_default.red("UNMAPPED SOURCE ELEMENTS:")} +`; + for (const element of unmappedSourceElements) { + output += ` - ${element.name} (${element.type}): ${element.description} +`; + } + output += "\n"; + } + if (unmappedTargetElements.length > 0) { + output += `${source_default.red("UNMAPPED TARGET ELEMENTS:")} +`; + for (const element of unmappedTargetElements) { + output += ` - ${element.name} (${element.type}): ${element.description} +`; + } + output += "\n"; + } + if (data.inferences.length > 0) { + output += `${source_default.bold("INFERENCES:")} +`; + for (const inference of data.inferences) { + const confidenceIndicator = inference.confidence >= 0.7 ? "" : "?"; + output += ` ${confidenceIndicator} ${inference.statement} +`; + output += ` ${source_default.dim(`Confidence: ${(inference.confidence * 100).toFixed(0)}%`)} +`; + output += "\n"; + } + } + if (data.strengths.length > 0) { + output += `${source_default.green("STRENGTHS:")} +`; + for (const strength of data.strengths) { + output += ` + ${strength} +`; + } + output += "\n"; + } + if (data.limitations.length > 0) { + output += `${source_default.red("LIMITATIONS:")} +`; + for (const limitation of data.limitations) { + output += ` - ${limitation} +`; + } + output += "\n"; + } + if (data.nextOperationNeeded) { + output += `${source_default.blue("SUGGESTED NEXT OPERATIONS:")} +`; + const operations = data.suggestedOperations || []; + if (operations.length > 0) { + for (const operation of operations) { + output += ` \x92 ${operation} +`; + } + } else { + output += ` \x92 Continue refining the analogy +`; + } + } + return output; + } + processAnalogicalReasoning(input) { + try { + const validatedInput = this.validateAnalogicalReasoningData(input); + this.updateAnalogicalReasoning(validatedInput); + const visualization = this.visualizeMapping(validatedInput); + console.error(visualization); + return { + content: [{ + type: "text", + text: JSON.stringify({ + analogyId: validatedInput.analogyId, + purpose: validatedInput.purpose, + iteration: validatedInput.iteration, + sourceDomain: validatedInput.sourceDomain.name, + targetDomain: validatedInput.targetDomain.name, + mappingCount: validatedInput.mappings.length, + inferenceCount: validatedInput.inferences.length, + nextOperationNeeded: validatedInput.nextOperationNeeded, + suggestedOperations: validatedInput.suggestedOperations + }, null, 2) + }] + }; + } catch (error) { + return { + content: [{ + type: "text", + text: JSON.stringify({ + error: error instanceof Error ? error.message : String(error), + status: "failed" + }, null, 2) + }], + isError: true + }; + } + } + }; + AnalogicalReasoningSchema = external_exports.object({ + sourceDomain: external_exports.object({ + name: external_exports.string(), + elements: external_exports.array(external_exports.object({ + id: external_exports.string().optional(), + name: external_exports.string(), + type: external_exports.enum(["entity", "attribute", "relation", "process"]), + description: external_exports.string() + })) + }), + targetDomain: external_exports.object({ + name: external_exports.string(), + elements: external_exports.array(external_exports.object({ + id: external_exports.string().optional(), + name: external_exports.string(), + type: external_exports.enum(["entity", "attribute", "relation", "process"]), + description: external_exports.string() + })) + }), + mappings: external_exports.array(external_exports.object({ + sourceElement: external_exports.string(), + targetElement: external_exports.string(), + mappingStrength: external_exports.number().min(0).max(1), + justification: external_exports.string(), + limitations: external_exports.array(external_exports.string()).optional() + })), + analogyId: external_exports.string(), + purpose: external_exports.enum(["explanation", "prediction", "problem-solving", "creative-generation"]), + confidence: external_exports.number().min(0).max(1), + iteration: external_exports.number().int().min(0), + strengths: external_exports.array(external_exports.string()), + limitations: external_exports.array(external_exports.string()), + inferences: external_exports.array(external_exports.object({ + statement: external_exports.string(), + confidence: external_exports.number().min(0).max(1), + basedOnMappings: external_exports.array(external_exports.string()) + })), + nextOperationNeeded: external_exports.boolean(), + suggestedOperations: external_exports.array( + external_exports.enum(["add-mapping", "revise-mapping", "draw-inference", "evaluate-limitation", "try-new-source"]) + ).optional() + }); + } +}); + +// bootstrap:virtual:bootstrap +var __create2 = Object.create; +var __defProp2 = Object.defineProperty; +var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor; +var __getOwnPropNames2 = Object.getOwnPropertyNames; +var __getProtoOf2 = Object.getPrototypeOf; +var __hasOwnProp2 = Object.prototype.hasOwnProperty; +var __commonJS2 = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps2 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames2(from)) + if (!__hasOwnProp2.call(to, key) && key !== except) + __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var require_bytes = __commonJS2({ + "node_modules/bytes/index.js"(exports2, module2) { + "use strict"; + module2.exports = bytes; + module2.exports.format = format; + module2.exports.parse = parse; + var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g; + var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/; + var map = { + b: 1, + kb: 1 << 10, + mb: 1 << 20, + gb: 1 << 30, + tb: Math.pow(1024, 4), + pb: Math.pow(1024, 5) + }; + var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i; + function bytes(value, options) { + if (typeof value === "string") { + return parse(value); + } + if (typeof value === "number") { + return format(value, options); + } + return null; + } + function format(value, options) { + if (!Number.isFinite(value)) { + return null; + } + var mag = Math.abs(value); + var thousandsSeparator = options && options.thousandsSeparator || ""; + var unitSeparator = options && options.unitSeparator || ""; + var decimalPlaces = options && options.decimalPlaces !== void 0 ? options.decimalPlaces : 2; + var fixedDecimals = Boolean(options && options.fixedDecimals); + var unit = options && options.unit || ""; + if (!unit || !map[unit.toLowerCase()]) { + if (mag >= map.pb) { + unit = "PB"; + } else if (mag >= map.tb) { + unit = "TB"; + } else if (mag >= map.gb) { + unit = "GB"; + } else if (mag >= map.mb) { + unit = "MB"; + } else if (mag >= map.kb) { + unit = "KB"; + } else { + unit = "B"; + } + } + var val = value / map[unit.toLowerCase()]; + var str = val.toFixed(decimalPlaces); + if (!fixedDecimals) { + str = str.replace(formatDecimalsRegExp, "$1"); + } + if (thousandsSeparator) { + str = str.split(".").map(function(s, i) { + return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s; + }).join("."); + } + return str + unitSeparator + unit; + } + function parse(val) { + if (typeof val === "number" && !isNaN(val)) { + return val; + } + if (typeof val !== "string") { + return null; + } + var results = parseRegExp.exec(val); + var floatValue; + var unit = "b"; + if (!results) { + floatValue = parseInt(val, 10); + unit = "b"; + } else { + floatValue = parseFloat(results[1]); + unit = results[4].toLowerCase(); + } + if (isNaN(floatValue)) { + return null; + } + return Math.floor(map[unit] * floatValue); + } + } +}); +var require_depd = __commonJS2({ + "node_modules/depd/index.js"(exports2, module2) { + var relative = require("path").relative; + module2.exports = depd; + var basePath = process.cwd(); + function containsNamespace(str, namespace) { + var vals = str.split(/[ ,]+/); + var ns = String(namespace).toLowerCase(); + for (var i = 0; i < vals.length; i++) { + var val = vals[i]; + if (val && (val === "*" || val.toLowerCase() === ns)) { + return true; + } + } + return false; + } + function convertDataDescriptorToAccessor(obj, prop, message) { + var descriptor = Object.getOwnPropertyDescriptor(obj, prop); + var value = descriptor.value; + descriptor.get = function getter() { + return value; + }; + if (descriptor.writable) { + descriptor.set = function setter(val) { + return value = val; + }; + } + delete descriptor.value; + delete descriptor.writable; + Object.defineProperty(obj, prop, descriptor); + return descriptor; + } + function createArgumentsString(arity) { + var str = ""; + for (var i = 0; i < arity; i++) { + str += ", arg" + i; + } + return str.substr(2); + } + function createStackString(stack) { + var str = this.name + ": " + this.namespace; + if (this.message) { + str += " deprecated " + this.message; + } + for (var i = 0; i < stack.length; i++) { + str += "\n at " + stack[i].toString(); + } + return str; + } + function depd(namespace) { + if (!namespace) { + throw new TypeError("argument namespace is required"); + } + var stack = getStack(); + var site = callSiteLocation(stack[1]); + var file = site[0]; + function deprecate(message) { + log.call(deprecate, message); + } + deprecate._file = file; + deprecate._ignored = isignored(namespace); + deprecate._namespace = namespace; + deprecate._traced = istraced(namespace); + deprecate._warned = /* @__PURE__ */ Object.create(null); + deprecate.function = wrapfunction; + deprecate.property = wrapproperty; + return deprecate; + } + function eehaslisteners(emitter, type) { + var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type); + return count > 0; + } + function isignored(namespace) { + if (process.noDeprecation) { + return true; + } + var str = process.env.NO_DEPRECATION || ""; + return containsNamespace(str, namespace); + } + function istraced(namespace) { + if (process.traceDeprecation) { + return true; + } + var str = process.env.TRACE_DEPRECATION || ""; + return containsNamespace(str, namespace); + } + function log(message, site) { + var haslisteners = eehaslisteners(process, "deprecation"); + if (!haslisteners && this._ignored) { + return; + } + var caller; + var callFile; + var callSite; + var depSite; + var i = 0; + var seen = false; + var stack = getStack(); + var file = this._file; + if (site) { + depSite = site; + callSite = callSiteLocation(stack[1]); + callSite.name = depSite.name; + file = callSite[0]; + } else { + i = 2; + depSite = callSiteLocation(stack[i]); + callSite = depSite; + } + for (; i < stack.length; i++) { + caller = callSiteLocation(stack[i]); + callFile = caller[0]; + if (callFile === file) { + seen = true; + } else if (callFile === this._file) { + file = this._file; + } else if (seen) { + break; + } + } + var key = caller ? depSite.join(":") + "__" + caller.join(":") : void 0; + if (key !== void 0 && key in this._warned) { + return; + } + this._warned[key] = true; + var msg = message; + if (!msg) { + msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite); + } + if (haslisteners) { + var err2 = DeprecationError(this._namespace, msg, stack.slice(i)); + process.emit("deprecation", err2); + return; + } + var format = process.stderr.isTTY ? formatColor : formatPlain; + var output = format.call(this, msg, caller, stack.slice(i)); + process.stderr.write(output + "\n", "utf8"); + } + function callSiteLocation(callSite) { + var file = callSite.getFileName() || ""; + var line = callSite.getLineNumber(); + var colm = callSite.getColumnNumber(); + if (callSite.isEval()) { + file = callSite.getEvalOrigin() + ", " + file; + } + var site = [file, line, colm]; + site.callSite = callSite; + site.name = callSite.getFunctionName(); + return site; + } + function defaultMessage(site) { + var callSite = site.callSite; + var funcName = site.name; + if (!funcName) { + funcName = ""; + } + var context = callSite.getThis(); + var typeName = context && callSite.getTypeName(); + if (typeName === "Object") { + typeName = void 0; + } + if (typeName === "Function") { + typeName = context.name || typeName; + } + return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName; + } + function formatPlain(msg, caller, stack) { + var timestamp = (/* @__PURE__ */ new Date()).toUTCString(); + var formatted = timestamp + " " + this._namespace + " deprecated " + msg; + if (this._traced) { + for (var i = 0; i < stack.length; i++) { + formatted += "\n at " + stack[i].toString(); + } + return formatted; + } + if (caller) { + formatted += " at " + formatLocation(caller); + } + return formatted; + } + function formatColor(msg, caller, stack) { + var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m \x1B[33;1mdeprecated\x1B[22;39m \x1B[0m" + msg + "\x1B[39m"; + if (this._traced) { + for (var i = 0; i < stack.length; i++) { + formatted += "\n \x1B[36mat " + stack[i].toString() + "\x1B[39m"; + } + return formatted; + } + if (caller) { + formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m"; + } + return formatted; + } + function formatLocation(callSite) { + return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2]; + } + function getStack() { + var limit = Error.stackTraceLimit; + var obj = {}; + var prep = Error.prepareStackTrace; + Error.prepareStackTrace = prepareObjectStackTrace; + Error.stackTraceLimit = Math.max(10, limit); + Error.captureStackTrace(obj); + var stack = obj.stack.slice(1); + Error.prepareStackTrace = prep; + Error.stackTraceLimit = limit; + return stack; + } + function prepareObjectStackTrace(obj, stack) { + return stack; + } + function wrapfunction(fn, message) { + if (typeof fn !== "function") { + throw new TypeError("argument fn must be a function"); + } + var args = createArgumentsString(fn.length); + var stack = getStack(); + var site = callSiteLocation(stack[1]); + site.name = fn.name; + var deprecatedfn = new Function( + "fn", + "log", + "deprecate", + "message", + "site", + '"use strict"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}" + )(fn, log, this, message, site); + return deprecatedfn; + } + function wrapproperty(obj, prop, message) { + if (!obj || typeof obj !== "object" && typeof obj !== "function") { + throw new TypeError("argument obj must be object"); + } + var descriptor = Object.getOwnPropertyDescriptor(obj, prop); + if (!descriptor) { + throw new TypeError("must call property on owner object"); + } + if (!descriptor.configurable) { + throw new TypeError("property must be configurable"); + } + var deprecate = this; + var stack = getStack(); + var site = callSiteLocation(stack[1]); + site.name = prop; + if ("value" in descriptor) { + descriptor = convertDataDescriptorToAccessor(obj, prop, message); + } + var get = descriptor.get; + var set = descriptor.set; + if (typeof get === "function") { + descriptor.get = function getter() { + log.call(deprecate, message, site); + return get.apply(this, arguments); + }; + } + if (typeof set === "function") { + descriptor.set = function setter() { + log.call(deprecate, message, site); + return set.apply(this, arguments); + }; + } + Object.defineProperty(obj, prop, descriptor); + } + function DeprecationError(namespace, message, stack) { + var error = new Error(); + var stackString; + Object.defineProperty(error, "constructor", { + value: DeprecationError + }); + Object.defineProperty(error, "message", { + configurable: true, + enumerable: false, + value: message, + writable: true + }); + Object.defineProperty(error, "name", { + enumerable: false, + configurable: true, + value: "DeprecationError", + writable: true + }); + Object.defineProperty(error, "namespace", { + configurable: true, + enumerable: false, + value: namespace, + writable: true + }); + Object.defineProperty(error, "stack", { + configurable: true, + enumerable: false, + get: function() { + if (stackString !== void 0) { + return stackString; + } + return stackString = createStackString.call(this, stack); + }, + set: function setter(val) { + stackString = val; + } + }); + return error; + } + } +}); +var require_setprototypeof = __commonJS2({ + "node_modules/setprototypeof/index.js"(exports2, module2) { + "use strict"; + module2.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties); + function setProtoOf(obj, proto2) { + obj.__proto__ = proto2; + return obj; + } + function mixinProperties(obj, proto2) { + for (var prop in proto2) { + if (!Object.prototype.hasOwnProperty.call(obj, prop)) { + obj[prop] = proto2[prop]; + } + } + return obj; + } + } +}); +var require_codes = __commonJS2({ + "node_modules/statuses/codes.json"(exports2, module2) { + module2.exports = { + "100": "Continue", + "101": "Switching Protocols", + "102": "Processing", + "103": "Early Hints", + "200": "OK", + "201": "Created", + "202": "Accepted", + "203": "Non-Authoritative Information", + "204": "No Content", + "205": "Reset Content", + "206": "Partial Content", + "207": "Multi-Status", + "208": "Already Reported", + "226": "IM Used", + "300": "Multiple Choices", + "301": "Moved Permanently", + "302": "Found", + "303": "See Other", + "304": "Not Modified", + "305": "Use Proxy", + "307": "Temporary Redirect", + "308": "Permanent Redirect", + "400": "Bad Request", + "401": "Unauthorized", + "402": "Payment Required", + "403": "Forbidden", + "404": "Not Found", + "405": "Method Not Allowed", + "406": "Not Acceptable", + "407": "Proxy Authentication Required", + "408": "Request Timeout", + "409": "Conflict", + "410": "Gone", + "411": "Length Required", + "412": "Precondition Failed", + "413": "Payload Too Large", + "414": "URI Too Long", + "415": "Unsupported Media Type", + "416": "Range Not Satisfiable", + "417": "Expectation Failed", + "418": "I'm a Teapot", + "421": "Misdirected Request", + "422": "Unprocessable Entity", + "423": "Locked", + "424": "Failed Dependency", + "425": "Too Early", + "426": "Upgrade Required", + "428": "Precondition Required", + "429": "Too Many Requests", + "431": "Request Header Fields Too Large", + "451": "Unavailable For Legal Reasons", + "500": "Internal Server Error", + "501": "Not Implemented", + "502": "Bad Gateway", + "503": "Service Unavailable", + "504": "Gateway Timeout", + "505": "HTTP Version Not Supported", + "506": "Variant Also Negotiates", + "507": "Insufficient Storage", + "508": "Loop Detected", + "509": "Bandwidth Limit Exceeded", + "510": "Not Extended", + "511": "Network Authentication Required" + }; + } +}); +var require_statuses = __commonJS2({ + "node_modules/statuses/index.js"(exports2, module2) { + "use strict"; + var codes = require_codes(); + module2.exports = status; + status.message = codes; + status.code = createMessageToStatusCodeMap(codes); + status.codes = createStatusCodeList(codes); + status.redirect = { + 300: true, + 301: true, + 302: true, + 303: true, + 305: true, + 307: true, + 308: true + }; + status.empty = { + 204: true, + 205: true, + 304: true + }; + status.retry = { + 502: true, + 503: true, + 504: true + }; + function createMessageToStatusCodeMap(codes2) { + var map = {}; + Object.keys(codes2).forEach(function forEachCode(code) { + var message = codes2[code]; + var status2 = Number(code); + map[message.toLowerCase()] = status2; + }); + return map; + } + function createStatusCodeList(codes2) { + return Object.keys(codes2).map(function mapCode(code) { + return Number(code); + }); + } + function getStatusCode(message) { + var msg = message.toLowerCase(); + if (!Object.prototype.hasOwnProperty.call(status.code, msg)) { + throw new Error('invalid status message: "' + message + '"'); + } + return status.code[msg]; + } + function getStatusMessage(code) { + if (!Object.prototype.hasOwnProperty.call(status.message, code)) { + throw new Error("invalid status code: " + code); + } + return status.message[code]; + } + function status(code) { + if (typeof code === "number") { + return getStatusMessage(code); + } + if (typeof code !== "string") { + throw new TypeError("code must be a number or string"); + } + var n = parseInt(code, 10); + if (!isNaN(n)) { + return getStatusMessage(n); + } + return getStatusCode(code); + } + } +}); +var require_inherits_browser = __commonJS2({ + "node_modules/inherits/inherits_browser.js"(exports2, module2) { + if (typeof Object.create === "function") { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + } + }; + } else { + module2.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor; + var TempCtor = function() { + }; + TempCtor.prototype = superCtor.prototype; + ctor.prototype = new TempCtor(); + ctor.prototype.constructor = ctor; + } + }; + } + } +}); +var require_inherits = __commonJS2({ + "node_modules/inherits/inherits.js"(exports2, module2) { + try { + util22 = require("util"); + if (typeof util22.inherits !== "function") throw ""; + module2.exports = util22.inherits; + } catch (e) { + module2.exports = require_inherits_browser(); + } + var util22; + } +}); +var require_toidentifier = __commonJS2({ + "node_modules/toidentifier/index.js"(exports2, module2) { + "use strict"; + module2.exports = toIdentifier; + function toIdentifier(str) { + return str.split(" ").map(function(token) { + return token.slice(0, 1).toUpperCase() + token.slice(1); + }).join("").replace(/[^ _0-9a-z]/gi, ""); + } + } +}); +var require_http_errors = __commonJS2({ + "node_modules/http-errors/index.js"(exports2, module2) { + "use strict"; + var deprecate = require_depd()("http-errors"); + var setPrototypeOf = require_setprototypeof(); + var statuses = require_statuses(); + var inherits = require_inherits(); + var toIdentifier = require_toidentifier(); + module2.exports = createError; + module2.exports.HttpError = createHttpErrorConstructor(); + module2.exports.isHttpError = createIsHttpErrorFunction(module2.exports.HttpError); + populateConstructorExports(module2.exports, statuses.codes, module2.exports.HttpError); + function codeClass(status) { + return Number(String(status).charAt(0) + "00"); + } + function createError() { + var err2; + var msg; + var status = 500; + var props = {}; + for (var i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + var type = typeof arg; + if (type === "object" && arg instanceof Error) { + err2 = arg; + status = err2.status || err2.statusCode || status; + } else if (type === "number" && i === 0) { + status = arg; + } else if (type === "string") { + msg = arg; + } else if (type === "object") { + props = arg; + } else { + throw new TypeError("argument #" + (i + 1) + " unsupported type " + type); + } + } + if (typeof status === "number" && (status < 400 || status >= 600)) { + deprecate("non-error status code; use only 4xx or 5xx status codes"); + } + if (typeof status !== "number" || !statuses.message[status] && (status < 400 || status >= 600)) { + status = 500; + } + var HttpError = createError[status] || createError[codeClass(status)]; + if (!err2) { + err2 = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]); + Error.captureStackTrace(err2, createError); + } + if (!HttpError || !(err2 instanceof HttpError) || err2.status !== status) { + err2.expose = status < 500; + err2.status = err2.statusCode = status; + } + for (var key in props) { + if (key !== "status" && key !== "statusCode") { + err2[key] = props[key]; + } + } + return err2; + } + function createHttpErrorConstructor() { + function HttpError() { + throw new TypeError("cannot construct abstract class"); + } + inherits(HttpError, Error); + return HttpError; + } + function createClientErrorConstructor(HttpError, name, code) { + var className = toClassName(name); + function ClientError(message) { + var msg = message != null ? message : statuses.message[code]; + var err2 = new Error(msg); + Error.captureStackTrace(err2, ClientError); + setPrototypeOf(err2, ClientError.prototype); + Object.defineProperty(err2, "message", { + enumerable: true, + configurable: true, + value: msg, + writable: true + }); + Object.defineProperty(err2, "name", { + enumerable: false, + configurable: true, + value: className, + writable: true + }); + return err2; + } + inherits(ClientError, HttpError); + nameFunc(ClientError, className); + ClientError.prototype.status = code; + ClientError.prototype.statusCode = code; + ClientError.prototype.expose = true; + return ClientError; + } + function createIsHttpErrorFunction(HttpError) { + return function isHttpError(val) { + if (!val || typeof val !== "object") { + return false; + } + if (val instanceof HttpError) { + return true; + } + return val instanceof Error && typeof val.expose === "boolean" && typeof val.statusCode === "number" && val.status === val.statusCode; + }; + } + function createServerErrorConstructor(HttpError, name, code) { + var className = toClassName(name); + function ServerError(message) { + var msg = message != null ? message : statuses.message[code]; + var err2 = new Error(msg); + Error.captureStackTrace(err2, ServerError); + setPrototypeOf(err2, ServerError.prototype); + Object.defineProperty(err2, "message", { + enumerable: true, + configurable: true, + value: msg, + writable: true + }); + Object.defineProperty(err2, "name", { + enumerable: false, + configurable: true, + value: className, + writable: true + }); + return err2; + } + inherits(ServerError, HttpError); + nameFunc(ServerError, className); + ServerError.prototype.status = code; + ServerError.prototype.statusCode = code; + ServerError.prototype.expose = false; + return ServerError; + } + function nameFunc(func, name) { + var desc = Object.getOwnPropertyDescriptor(func, "name"); + if (desc && desc.configurable) { + desc.value = name; + Object.defineProperty(func, "name", desc); + } + } + function populateConstructorExports(exports3, codes, HttpError) { + codes.forEach(function forEachCode(code) { + var CodeError; + var name = toIdentifier(statuses.message[code]); + switch (codeClass(code)) { + case 400: + CodeError = createClientErrorConstructor(HttpError, name, code); + break; + case 500: + CodeError = createServerErrorConstructor(HttpError, name, code); + break; + } + if (CodeError) { + exports3[code] = CodeError; + exports3[name] = CodeError; + } + }); + } + function toClassName(name) { + return name.substr(-5) !== "Error" ? name + "Error" : name; + } + } +}); +var require_safer = __commonJS2({ + "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; + } +}); +var require_bom_handling = __commonJS2({ + "node_modules/raw-body/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(); + }; + } +}); +var require_internal = __commonJS2({ + "node_modules/raw-body/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 === "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; + if (!StringDecoder.prototype.end) + StringDecoder.prototype.end = function() { + }; + 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), 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, contBytes = this.contBytes, accBytes = this.accBytes, 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; + }; + } +}); +var require_utf32 = __commonJS2({ + "node_modules/raw-body/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); + 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 = 55296 <= code && code < 56320; + var isLowSurrogate = 56320 <= code && 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[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24; + } else { + codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 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() { + this.overflow.length = 0; + }; + 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, invalidBE = 0; + var bmpCharsLE = 0, bmpCharsBE = 0; + outer_loop: + 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 outer_loop; + } + } + } + } + if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return "utf-32be"; + if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return "utf-32le"; + return defaultEncoding || "utf-32le"; + } + } +}); +var require_utf16 = __commonJS2({ + "node_modules/raw-body/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), i = 0, 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, asciiCharsBE = 0; + outer_loop: + 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 outer_loop; + } + } + } + } + if (asciiCharsBE > asciiCharsLE) return "utf-16be"; + if (asciiCharsBE < asciiCharsLE) return "utf-16le"; + return defaultEncoding || "utf-16le"; + } + } +}); +var require_utf7 = __commonJS2({ + "node_modules/raw-body/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 base64Regex22 = /[A-Za-z0-9\/+]/; + var base64Chars = []; + for (i = 0; i < 256; i++) + base64Chars[i] = base64Regex22.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 = "", lastI = 0, inBase64 = this.inBase64, 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, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer2.alloc(str.length * 5 + 10), bufIdx = 0; + for (var i2 = 0; i2 < str.length; i2++) { + var uChar = str.charCodeAt(i2); + if (32 <= uChar && 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), 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 = "", lastI = 0, inBase64 = this.inBase64, 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; + }; + } +}); +var require_sbcs_codec = __commonJS2({ + "node_modules/raw-body/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, 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() { + }; + } +}); +var require_sbcs_data = __commonJS2({ + "node_modules/raw-body/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", + "turkish": "iso88599", + "turkish8": "iso88599", + "thai": "iso885911", + "thai8": "iso885911", + "celtic": "iso885914", + "celtic8": "iso885914", + "isoceltic": "iso885914", + "tis6200": "tis620", + "tis62025291": "tis620", + "tis62025330": "tis620", + "10000": "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" + }; + } +}); +var require_sbcs_data_generated = __commonJS2({ + "node_modules/raw-body/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" + } + }; + } +}); +var require_dbcs_codec = __commonJS2({ + "node_modules/raw-body/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 (55296 <= code && code < 56320) { + var codeTrail = part.charCodeAt(l++); + if (56320 <= codeTrail && 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 (4080 < code && 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)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0; + while (true) { + if (nextChar === -1) { + if (i2 == str.length) break; + var uCode = str.charCodeAt(i2++); + } else { + var uCode = nextChar; + nextChar = -1; + } + if (55296 <= uCode && 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), 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), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, 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, 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; + } + } +}); +var require_shiftjis = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_eucjp = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_cp936 = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_gbk_added = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_gb18030_ranges = __commonJS2({ + "node_modules/raw-body/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] }; + } +}); +var require_cp949 = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_cp950 = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_big5_added = __commonJS2({ + "node_modules/raw-body/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"] + ]; + } +}); +var require_dbcs_data = __commonJS2({ + "node_modules/raw-body/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" + }; + } +}); +var require_encodings = __commonJS2({ + "node_modules/raw-body/node_modules/iconv-lite/encodings/index.js"(exports2, module2) { + "use strict"; + 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]; + for (enc in module2) + if (Object.prototype.hasOwnProperty.call(module2, enc)) + exports2[enc] = module2[enc]; + } + var module2; + var enc; + var i; + } +}); +var require_streams = __commonJS2({ + "node_modules/raw-body/node_modules/iconv-lite/lib/streams.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + module2.exports = function(stream_module) { + var Transform = stream_module.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 + }; + }; + } +}); +var require_lib = __commonJS2({ + "node_modules/raw-body/node_modules/iconv-lite/lib/index.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + var bomHandling = require_bom_handling(); + var iconv = module2.exports; + iconv.encodings = null; + iconv.defaultCharUnicode = "\uFFFD"; + iconv.defaultCharSingleByte = "?"; + iconv.encode = function encode(str, encoding, options) { + str = "" + (str || ""); + var encoder = iconv.getEncoder(encoding, options); + var res = encoder.write(str); + var trail = encoder.end(); + return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res; + }; + iconv.decode = function decode(buf, encoding, options) { + if (typeof buf === "string") { + if (!iconv.skipDecodeWarning) { + console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding"); + iconv.skipDecodeWarning = true; + } + buf = Buffer2.from("" + (buf || ""), "binary"); + } + var decoder = iconv.getDecoder(encoding, options); + var res = decoder.write(buf); + var trail = decoder.end(); + return trail ? res + trail : res; + }; + iconv.encodingExists = function encodingExists(enc) { + try { + iconv.getCodec(enc); + return true; + } catch (e) { + return false; + } + }; + iconv.toEncoding = iconv.encode; + iconv.fromEncoding = iconv.decode; + iconv._codecDataCache = {}; + iconv.getCodec = function getCodec(encoding) { + if (!iconv.encodings) + iconv.encodings = require_encodings(); + var enc = iconv._canonicalizeEncoding(encoding); + var codecOptions = {}; + while (true) { + var codec = iconv._codecDataCache[enc]; + if (codec) + return codec; + var codecDef = iconv.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, iconv); + iconv._codecDataCache[codecOptions.encodingName] = codec; + return codec; + default: + throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')"); + } + } + }; + iconv._canonicalizeEncoding = function(encoding) { + return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, ""); + }; + iconv.getEncoder = function getEncoder(encoding, options) { + var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec); + if (codec.bomAware && options && options.addBOM) + encoder = new bomHandling.PrependBOM(encoder, options); + return encoder; + }; + iconv.getDecoder = function getDecoder(encoding, options) { + var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec); + if (codec.bomAware && !(options && options.stripBOM === false)) + decoder = new bomHandling.StripBOM(decoder, options); + return decoder; + }; + iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) { + if (iconv.supportsStreams) + return; + var streams = require_streams()(stream_module2); + iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream; + iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream; + iconv.encodeStream = function encodeStream(encoding, options) { + return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options); + }; + iconv.decodeStream = function decodeStream(encoding, options) { + return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options); + }; + iconv.supportsStreams = true; + }; + var stream_module; + try { + stream_module = require("stream"); + } catch (e) { + } + if (stream_module && stream_module.Transform) { + iconv.enableStreamingAPI(stream_module); + } else { + iconv.encodeStream = iconv.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."); + } + } +}); +var require_unpipe = __commonJS2({ + "node_modules/unpipe/index.js"(exports2, module2) { + "use strict"; + module2.exports = unpipe; + function hasPipeDataListeners(stream) { + var listeners = stream.listeners("data"); + for (var i = 0; i < listeners.length; i++) { + if (listeners[i].name === "ondata") { + return true; + } + } + return false; + } + function unpipe(stream) { + if (!stream) { + throw new TypeError("argument stream is required"); + } + if (typeof stream.unpipe === "function") { + stream.unpipe(); + return; + } + if (!hasPipeDataListeners(stream)) { + return; + } + var listener; + var listeners = stream.listeners("close"); + for (var i = 0; i < listeners.length; i++) { + listener = listeners[i]; + if (listener.name !== "cleanup" && listener.name !== "onclose") { + continue; + } + listener.call(stream); + } + } + } +}); +var require_raw_body = __commonJS2({ + "node_modules/raw-body/index.js"(exports2, module2) { + "use strict"; + var asyncHooks = tryRequireAsyncHooks(); + var bytes = require_bytes(); + var createError = require_http_errors(); + var iconv = require_lib(); + var unpipe = require_unpipe(); + module2.exports = getRawBody2; + var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /; + function getDecoder(encoding) { + if (!encoding) return null; + try { + return iconv.getDecoder(encoding); + } catch (e) { + if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e; + throw createError(415, "specified encoding unsupported", { + encoding, + type: "encoding.unsupported" + }); + } + } + function getRawBody2(stream, options, callback) { + var done = callback; + var opts = options || {}; + if (stream === void 0) { + throw new TypeError("argument stream is required"); + } else if (typeof stream !== "object" || stream === null || typeof stream.on !== "function") { + throw new TypeError("argument stream must be a stream"); + } + if (options === true || typeof options === "string") { + opts = { + encoding: options + }; + } + if (typeof options === "function") { + done = options; + opts = {}; + } + if (done !== void 0 && typeof done !== "function") { + throw new TypeError("argument callback must be a function"); + } + if (!done && !global.Promise) { + throw new TypeError("argument callback is required"); + } + var encoding = opts.encoding !== true ? opts.encoding : "utf-8"; + var limit = bytes.parse(opts.limit); + var length = opts.length != null && !isNaN(opts.length) ? parseInt(opts.length, 10) : null; + if (done) { + return readStream(stream, encoding, length, limit, wrap(done)); + } + return new Promise(function executor(resolve, reject) { + readStream(stream, encoding, length, limit, function onRead(err2, buf) { + if (err2) return reject(err2); + resolve(buf); + }); + }); + } + function halt(stream) { + unpipe(stream); + if (typeof stream.pause === "function") { + stream.pause(); + } + } + function readStream(stream, encoding, length, limit, callback) { + var complete = false; + var sync = true; + if (limit !== null && length !== null && length > limit) { + return done(createError(413, "request entity too large", { + expected: length, + length, + limit, + type: "entity.too.large" + })); + } + var state = stream._readableState; + if (stream._decoder || state && (state.encoding || state.decoder)) { + return done(createError(500, "stream encoding should not be set", { + type: "stream.encoding.set" + })); + } + if (typeof stream.readable !== "undefined" && !stream.readable) { + return done(createError(500, "stream is not readable", { + type: "stream.not.readable" + })); + } + var received = 0; + var decoder; + try { + decoder = getDecoder(encoding); + } catch (err2) { + return done(err2); + } + var buffer = decoder ? "" : []; + stream.on("aborted", onAborted); + stream.on("close", cleanup); + stream.on("data", onData); + stream.on("end", onEnd); + stream.on("error", onEnd); + sync = false; + function done() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + complete = true; + if (sync) { + process.nextTick(invokeCallback); + } else { + invokeCallback(); + } + function invokeCallback() { + cleanup(); + if (args[0]) { + halt(stream); + } + callback.apply(null, args); + } + } + function onAborted() { + if (complete) return; + done(createError(400, "request aborted", { + code: "ECONNABORTED", + expected: length, + length, + received, + type: "request.aborted" + })); + } + function onData(chunk) { + if (complete) return; + received += chunk.length; + if (limit !== null && received > limit) { + done(createError(413, "request entity too large", { + limit, + received, + type: "entity.too.large" + })); + } else if (decoder) { + buffer += decoder.write(chunk); + } else { + buffer.push(chunk); + } + } + function onEnd(err2) { + if (complete) return; + if (err2) return done(err2); + if (length !== null && received !== length) { + done(createError(400, "request size did not match content length", { + expected: length, + length, + received, + type: "request.size.invalid" + })); + } else { + var string = decoder ? buffer + (decoder.end() || "") : Buffer.concat(buffer); + done(null, string); + } + } + function cleanup() { + buffer = null; + stream.removeListener("aborted", onAborted); + stream.removeListener("data", onData); + stream.removeListener("end", onEnd); + stream.removeListener("error", onEnd); + stream.removeListener("close", cleanup); + } + } + function tryRequireAsyncHooks() { + try { + return require("async_hooks"); + } catch (e) { + return {}; + } + } + function wrap(fn) { + var res; + if (asyncHooks.AsyncResource) { + res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn"); + } + if (!res || !res.runInAsyncScope) { + return fn; + } + return res.runInAsyncScope.bind(res, fn, null); + } + } +}); +var require_content_type = __commonJS2({ + "node_modules/content-type/index.js"(exports2) { + "use strict"; + var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g; + var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/; + var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/; + var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g; + var QUOTE_REGEXP = /([\\"])/g; + var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/; + exports2.format = format; + exports2.parse = parse; + function format(obj) { + if (!obj || typeof obj !== "object") { + throw new TypeError("argument obj is required"); + } + var parameters = obj.parameters; + var type = obj.type; + if (!type || !TYPE_REGEXP.test(type)) { + throw new TypeError("invalid type"); + } + var string = type; + if (parameters && typeof parameters === "object") { + var param; + var params = Object.keys(parameters).sort(); + for (var i = 0; i < params.length; i++) { + param = params[i]; + if (!TOKEN_REGEXP.test(param)) { + throw new TypeError("invalid parameter name"); + } + string += "; " + param + "=" + qstring(parameters[param]); + } + } + return string; + } + function parse(string) { + if (!string) { + throw new TypeError("argument string is required"); + } + var header = typeof string === "object" ? getcontenttype(string) : string; + if (typeof header !== "string") { + throw new TypeError("argument string is required to be a string"); + } + var index = header.indexOf(";"); + var type = index !== -1 ? header.slice(0, index).trim() : header.trim(); + if (!TYPE_REGEXP.test(type)) { + throw new TypeError("invalid media type"); + } + var obj = new ContentType(type.toLowerCase()); + if (index !== -1) { + var key; + var match; + var value; + PARAM_REGEXP.lastIndex = index; + while (match = PARAM_REGEXP.exec(header)) { + if (match.index !== index) { + throw new TypeError("invalid parameter format"); + } + index += match[0].length; + key = match[1].toLowerCase(); + value = match[2]; + if (value.charCodeAt(0) === 34) { + value = value.slice(1, -1); + if (value.indexOf("\\") !== -1) { + value = value.replace(QESC_REGEXP, "$1"); + } + } + obj.parameters[key] = value; + } + if (index !== header.length) { + throw new TypeError("invalid parameter format"); + } + } + return obj; + } + function getcontenttype(obj) { + var header; + if (typeof obj.getHeader === "function") { + header = obj.getHeader("content-type"); + } else if (typeof obj.headers === "object") { + header = obj.headers && obj.headers["content-type"]; + } + if (typeof header !== "string") { + throw new TypeError("content-type header is missing from object"); + } + return header; + } + function qstring(val) { + var str = String(val); + if (TOKEN_REGEXP.test(str)) { + return str; + } + if (str.length > 0 && !TEXT_REGEXP.test(str)) { + throw new TypeError("invalid parameter value"); + } + return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"'; + } + function ContentType(type) { + this.parameters = /* @__PURE__ */ Object.create(null); + this.type = type; + } + } +}); +var require_ms = __commonJS2({ + "node_modules/ms/index.js"(exports2, module2) { + var s = 1e3; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + module2.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === "string" && val.length > 0) { + return parse(val); + } else if (type === "number" && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) + ); + }; + function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || "ms").toLowerCase(); + switch (type) { + case "years": + case "year": + case "yrs": + case "yr": + case "y": + return n * y; + case "weeks": + case "week": + case "w": + return n * w; + case "days": + case "day": + case "d": + return n * d; + case "hours": + case "hour": + case "hrs": + case "hr": + case "h": + return n * h; + case "minutes": + case "minute": + case "mins": + case "min": + case "m": + return n * m; + case "seconds": + case "second": + case "secs": + case "sec": + case "s": + return n * s; + case "milliseconds": + case "millisecond": + case "msecs": + case "msec": + case "ms": + return n; + default: + return void 0; + } + } + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + "d"; + } + if (msAbs >= h) { + return Math.round(ms / h) + "h"; + } + if (msAbs >= m) { + return Math.round(ms / m) + "m"; + } + if (msAbs >= s) { + return Math.round(ms / s) + "s"; + } + return ms + "ms"; + } + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, "day"); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, "hour"); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, "minute"); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, "second"); + } + return ms + " ms"; + } + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + } + } +}); +var require_common = __commonJS2({ + "node_modules/debug/src/common.js"(exports2, module2) { + function setup(env2) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce22; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = require_ms(); + createDebug.destroy = destroy; + Object.keys(env2).forEach((key) => { + createDebug[key] = env2[key]; + }); + createDebug.names = []; + createDebug.skips = []; + createDebug.formatters = {}; + function selectColor(namespace) { + let hash = 0; + for (let i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; + } + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + function debug(...args) { + if (!debug.enabled) { + return; + } + const self2 = debug; + const curr = Number(/* @__PURE__ */ new Date()); + const ms = curr - (prevTime || curr); + self2.diff = ms; + self2.prev = prevTime; + self2.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== "string") { + args.unshift("%O"); + } + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + if (match === "%%") { + return "%"; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === "function") { + const val = args[index]; + match = formatter.call(self2, val); + args.splice(index, 1); + index--; + } + return match; + }); + createDebug.formatArgs.call(self2, args); + const logFn = self2.log || createDebug.log; + logFn.apply(self2, args); + } + debug.namespace = namespace; + debug.useColors = createDebug.useColors(); + debug.color = createDebug.selectColor(namespace); + debug.extend = extend; + debug.destroy = createDebug.destroy; + Object.defineProperty(debug, "enabled", { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: (v) => { + enableOverride = v; + } + }); + if (typeof createDebug.init === "function") { + createDebug.init(debug); + } + return debug; + } + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean); + for (const ns of split) { + if (ns[0] === "-") { + createDebug.skips.push(ns.slice(1)); + } else { + createDebug.names.push(ns); + } + } + } + function matchesTemplate(search, template) { + let searchIndex = 0; + let templateIndex = 0; + let starIndex = -1; + let matchIndex = 0; + while (searchIndex < search.length) { + if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) { + if (template[templateIndex] === "*") { + starIndex = templateIndex; + matchIndex = searchIndex; + templateIndex++; + } else { + searchIndex++; + templateIndex++; + } + } else if (starIndex !== -1) { + templateIndex = starIndex + 1; + matchIndex++; + searchIndex = matchIndex; + } else { + return false; + } + } + while (templateIndex < template.length && template[templateIndex] === "*") { + templateIndex++; + } + return templateIndex === template.length; + } + function disable() { + const namespaces = [ + ...createDebug.names, + ...createDebug.skips.map((namespace) => "-" + namespace) + ].join(","); + createDebug.enable(""); + return namespaces; + } + function enabled(name) { + for (const skip of createDebug.skips) { + if (matchesTemplate(name, skip)) { + return false; + } + } + for (const ns of createDebug.names) { + if (matchesTemplate(name, ns)) { + return true; + } + } + return false; + } + function coerce22(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + function destroy() { + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + createDebug.enable(createDebug.load()); + return createDebug; + } + module2.exports = setup; + } +}); +var require_browser = __commonJS2({ + "node_modules/debug/src/browser.js"(exports2, module2) { + exports2.formatArgs = formatArgs; + exports2.save = save; + exports2.load = load; + exports2.useColors = useColors; + exports2.storage = localstorage(); + exports2.destroy = /* @__PURE__ */ (() => { + let warned = false; + return () => { + if (!warned) { + warned = true; + console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."); + } + }; + })(); + exports2.colors = [ + "#0000CC", + "#0000FF", + "#0033CC", + "#0033FF", + "#0066CC", + "#0066FF", + "#0099CC", + "#0099FF", + "#00CC00", + "#00CC33", + "#00CC66", + "#00CC99", + "#00CCCC", + "#00CCFF", + "#3300CC", + "#3300FF", + "#3333CC", + "#3333FF", + "#3366CC", + "#3366FF", + "#3399CC", + "#3399FF", + "#33CC00", + "#33CC33", + "#33CC66", + "#33CC99", + "#33CCCC", + "#33CCFF", + "#6600CC", + "#6600FF", + "#6633CC", + "#6633FF", + "#66CC00", + "#66CC33", + "#9900CC", + "#9900FF", + "#9933CC", + "#9933FF", + "#99CC00", + "#99CC33", + "#CC0000", + "#CC0033", + "#CC0066", + "#CC0099", + "#CC00CC", + "#CC00FF", + "#CC3300", + "#CC3333", + "#CC3366", + "#CC3399", + "#CC33CC", + "#CC33FF", + "#CC6600", + "#CC6633", + "#CC9900", + "#CC9933", + "#CCCC00", + "#CCCC33", + "#FF0000", + "#FF0033", + "#FF0066", + "#FF0099", + "#FF00CC", + "#FF00FF", + "#FF3300", + "#FF3333", + "#FF3366", + "#FF3399", + "#FF33CC", + "#FF33FF", + "#FF6600", + "#FF6633", + "#FF9900", + "#FF9933", + "#FFCC00", + "#FFCC33" + ]; + function useColors() { + if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) { + return true; + } + if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + let m; + return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + function formatArgs(args) { + args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + const c = "color: " + this.color; + args.splice(1, 0, c, "color: inherit"); + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, (match) => { + if (match === "%%") { + return; + } + index++; + if (match === "%c") { + lastC = index; + } + }); + args.splice(lastC, 0, c); + } + exports2.log = console.debug || console.log || (() => { + }); + function save(namespaces) { + try { + if (namespaces) { + exports2.storage.setItem("debug", namespaces); + } else { + exports2.storage.removeItem("debug"); + } + } catch (error) { + } + } + function load() { + let r; + try { + r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG"); + } catch (error) { + } + if (!r && typeof process !== "undefined" && "env" in process) { + r = process.env.DEBUG; + } + return r; + } + function localstorage() { + try { + return localStorage; + } catch (error) { + } + } + module2.exports = require_common()(exports2); + var { formatters } = module2.exports; + formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (error) { + return "[UnexpectedJSONParseError]: " + error.message; + } + }; + } +}); +var require_has_flag = __commonJS2({ + "node_modules/has-flag/index.js"(exports2, module2) { + "use strict"; + module2.exports = (flag, argv = process.argv) => { + const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--"; + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf("--"); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); + }; + } +}); +var require_supports_color = __commonJS2({ + "node_modules/supports-color/index.js"(exports2, module2) { + "use strict"; + var os2 = require("os"); + var tty2 = require("tty"); + var hasFlag2 = require_has_flag(); + var { env: env2 } = process; + var forceColor; + if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) { + forceColor = 0; + } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) { + forceColor = 1; + } + if ("FORCE_COLOR" in env2) { + if (env2.FORCE_COLOR === "true") { + forceColor = 1; + } else if (env2.FORCE_COLOR === "false") { + forceColor = 0; + } else { + forceColor = env2.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env2.FORCE_COLOR, 10), 3); + } + } + function translateLevel2(level) { + if (level === 0) { + return false; + } + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; + } + function supportsColor2(haveStream, streamIsTTY) { + if (forceColor === 0) { + return 0; + } + if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) { + return 3; + } + if (hasFlag2("color=256")) { + return 2; + } + if (haveStream && !streamIsTTY && forceColor === void 0) { + return 0; + } + const min = forceColor || 0; + if (env2.TERM === "dumb") { + return min; + } + if (process.platform === "win32") { + const osRelease = os2.release().split("."); + if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + return 1; + } + if ("CI" in env2) { + if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") { + return 1; + } + return min; + } + if ("TEAMCITY_VERSION" in env2) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0; + } + if (env2.COLORTERM === "truecolor") { + return 3; + } + if ("TERM_PROGRAM" in env2) { + const version = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10); + switch (env2.TERM_PROGRAM) { + case "iTerm.app": + return version >= 3 ? 3 : 2; + case "Apple_Terminal": + return 2; + } + } + if (/-256(color)?$/i.test(env2.TERM)) { + return 2; + } + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) { + return 1; + } + if ("COLORTERM" in env2) { + return 1; + } + return min; + } + function getSupportLevel(stream) { + const level = supportsColor2(stream, stream && stream.isTTY); + return translateLevel2(level); + } + module2.exports = { + supportsColor: getSupportLevel, + stdout: translateLevel2(supportsColor2(true, tty2.isatty(1))), + stderr: translateLevel2(supportsColor2(true, tty2.isatty(2))) + }; + } +}); +var require_node = __commonJS2({ + "node_modules/debug/src/node.js"(exports2, module2) { + var tty2 = require("tty"); + var util22 = require("util"); + exports2.init = init; + exports2.log = log; + exports2.formatArgs = formatArgs; + exports2.save = save; + exports2.load = load; + exports2.useColors = useColors; + exports2.destroy = util22.deprecate( + () => { + }, + "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`." + ); + exports2.colors = [6, 2, 3, 4, 5, 1]; + try { + const supportsColor2 = require_supports_color(); + if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) { + exports2.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } + } catch (error) { + } + exports2.inspectOpts = Object.keys(process.env).filter((key) => { + return /^debug_/i.test(key); + }).reduce((obj, key) => { + const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_2, k) => { + return k.toUpperCase(); + }); + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === "null") { + val = null; + } else { + val = Number(val); + } + obj[prop] = val; + return obj; + }, {}); + function useColors() { + return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty2.isatty(process.stderr.fd); + } + function formatArgs(args) { + const { namespace: name, useColors: useColors2 } = this; + if (useColors2) { + const c = this.color; + const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c); + const prefix = ` ${colorCode};1m${name} \x1B[0m`; + args[0] = prefix + args[0].split("\n").join("\n" + prefix); + args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m"); + } else { + args[0] = getDate() + name + " " + args[0]; + } + } + function getDate() { + if (exports2.inspectOpts.hideDate) { + return ""; + } + return (/* @__PURE__ */ new Date()).toISOString() + " "; + } + function log(...args) { + return process.stderr.write(util22.formatWithOptions(exports2.inspectOpts, ...args) + "\n"); + } + function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + delete process.env.DEBUG; + } + } + function load() { + return process.env.DEBUG; + } + function init(debug) { + debug.inspectOpts = {}; + const keys = Object.keys(exports2.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]]; + } + } + module2.exports = require_common()(exports2); + var { formatters } = module2.exports; + formatters.o = function(v) { + this.inspectOpts.colors = this.useColors; + return util22.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" "); + }; + formatters.O = function(v) { + this.inspectOpts.colors = this.useColors; + return util22.inspect(v, this.inspectOpts); + }; + } +}); +var require_src = __commonJS2({ + "node_modules/debug/src/index.js"(exports2, module2) { + if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) { + module2.exports = require_browser(); + } else { + module2.exports = require_node(); + } + } +}); +var require_ee_first = __commonJS2({ + "node_modules/ee-first/index.js"(exports2, module2) { + "use strict"; + module2.exports = first; + function first(stuff, done) { + if (!Array.isArray(stuff)) + throw new TypeError("arg must be an array of [ee, events...] arrays"); + var cleanups = []; + for (var i = 0; i < stuff.length; i++) { + var arr = stuff[i]; + if (!Array.isArray(arr) || arr.length < 2) + throw new TypeError("each array member must be [ee, events...]"); + var ee = arr[0]; + for (var j = 1; j < arr.length; j++) { + var event = arr[j]; + var fn = listener(event, callback); + ee.on(event, fn); + cleanups.push({ + ee, + event, + fn + }); + } + } + function callback() { + cleanup(); + done.apply(null, arguments); + } + function cleanup() { + var x; + for (var i2 = 0; i2 < cleanups.length; i2++) { + x = cleanups[i2]; + x.ee.removeListener(x.event, x.fn); + } + } + function thunk(fn2) { + done = fn2; + } + thunk.cancel = cleanup; + return thunk; + } + function listener(event, done) { + return function onevent(arg1) { + var args = new Array(arguments.length); + var ee = this; + var err2 = event === "error" ? arg1 : null; + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + done(err2, ee, event, args); + }; + } + } +}); +var require_on_finished = __commonJS2({ + "node_modules/on-finished/index.js"(exports2, module2) { + "use strict"; + module2.exports = onFinished; + module2.exports.isFinished = isFinished; + var asyncHooks = tryRequireAsyncHooks(); + var first = require_ee_first(); + var defer = typeof setImmediate === "function" ? setImmediate : function(fn) { + process.nextTick(fn.bind.apply(fn, arguments)); + }; + function onFinished(msg, listener) { + if (isFinished(msg) !== false) { + defer(listener, null, msg); + return msg; + } + attachListener(msg, wrap(listener)); + return msg; + } + function isFinished(msg) { + var socket = msg.socket; + if (typeof msg.finished === "boolean") { + return Boolean(msg.finished || socket && !socket.writable); + } + if (typeof msg.complete === "boolean") { + return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable); + } + return void 0; + } + function attachFinishedListener(msg, callback) { + var eeMsg; + var eeSocket; + var finished = false; + function onFinish(error) { + eeMsg.cancel(); + eeSocket.cancel(); + finished = true; + callback(error); + } + eeMsg = eeSocket = first([[msg, "end", "finish"]], onFinish); + function onSocket(socket) { + msg.removeListener("socket", onSocket); + if (finished) return; + if (eeMsg !== eeSocket) return; + eeSocket = first([[socket, "error", "close"]], onFinish); + } + if (msg.socket) { + onSocket(msg.socket); + return; + } + msg.on("socket", onSocket); + if (msg.socket === void 0) { + patchAssignSocket(msg, onSocket); + } + } + function attachListener(msg, listener) { + var attached = msg.__onFinished; + if (!attached || !attached.queue) { + attached = msg.__onFinished = createListener(msg); + attachFinishedListener(msg, attached); + } + attached.queue.push(listener); + } + function createListener(msg) { + function listener(err2) { + if (msg.__onFinished === listener) msg.__onFinished = null; + if (!listener.queue) return; + var queue = listener.queue; + listener.queue = null; + for (var i = 0; i < queue.length; i++) { + queue[i](err2, msg); + } + } + listener.queue = []; + return listener; + } + function patchAssignSocket(res, callback) { + var assignSocket = res.assignSocket; + if (typeof assignSocket !== "function") return; + res.assignSocket = function _assignSocket(socket) { + assignSocket.call(this, socket); + callback(socket); + }; + } + function tryRequireAsyncHooks() { + try { + return require("async_hooks"); + } catch (e) { + return {}; + } + } + function wrap(fn) { + var res; + if (asyncHooks.AsyncResource) { + res = new asyncHooks.AsyncResource(fn.name || "bound-anonymous-fn"); + } + if (!res || !res.runInAsyncScope) { + return fn; + } + return res.runInAsyncScope.bind(res, fn, null); + } + } +}); +var require_bom_handling2 = __commonJS2({ + "node_modules/body-parser/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(); + }; + } +}); +var require_internal2 = __commonJS2({ + "node_modules/body-parser/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 === "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; + if (!StringDecoder.prototype.end) + StringDecoder.prototype.end = function() { + }; + 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), 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, contBytes = this.contBytes, accBytes = this.accBytes, 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; + }; + } +}); +var require_utf322 = __commonJS2({ + "node_modules/body-parser/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); + 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 = 55296 <= code && code < 56320; + var isLowSurrogate = 56320 <= code && 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[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24; + } else { + codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 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() { + this.overflow.length = 0; + }; + 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, invalidBE = 0; + var bmpCharsLE = 0, bmpCharsBE = 0; + outer_loop: + 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 outer_loop; + } + } + } + } + if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return "utf-32be"; + if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return "utf-32le"; + return defaultEncoding || "utf-32le"; + } + } +}); +var require_utf162 = __commonJS2({ + "node_modules/body-parser/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), i = 0, 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, asciiCharsBE = 0; + outer_loop: + 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 outer_loop; + } + } + } + } + if (asciiCharsBE > asciiCharsLE) return "utf-16be"; + if (asciiCharsBE < asciiCharsLE) return "utf-16le"; + return defaultEncoding || "utf-16le"; + } + } +}); +var require_utf72 = __commonJS2({ + "node_modules/body-parser/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 base64Regex22 = /[A-Za-z0-9\/+]/; + var base64Chars = []; + for (i = 0; i < 256; i++) + base64Chars[i] = base64Regex22.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 = "", lastI = 0, inBase64 = this.inBase64, 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, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer2.alloc(str.length * 5 + 10), bufIdx = 0; + for (var i2 = 0; i2 < str.length; i2++) { + var uChar = str.charCodeAt(i2); + if (32 <= uChar && 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), 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 = "", lastI = 0, inBase64 = this.inBase64, 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; + }; + } +}); +var require_sbcs_codec2 = __commonJS2({ + "node_modules/body-parser/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, 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() { + }; + } +}); +var require_sbcs_data2 = __commonJS2({ + "node_modules/body-parser/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", + "turkish": "iso88599", + "turkish8": "iso88599", + "thai": "iso885911", + "thai8": "iso885911", + "celtic": "iso885914", + "celtic8": "iso885914", + "isoceltic": "iso885914", + "tis6200": "tis620", + "tis62025291": "tis620", + "tis62025330": "tis620", + "10000": "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" + }; + } +}); +var require_sbcs_data_generated2 = __commonJS2({ + "node_modules/body-parser/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" + } + }; + } +}); +var require_dbcs_codec2 = __commonJS2({ + "node_modules/body-parser/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 (55296 <= code && code < 56320) { + var codeTrail = part.charCodeAt(l++); + if (56320 <= codeTrail && 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 (4080 < code && 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)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0; + while (true) { + if (nextChar === -1) { + if (i2 == str.length) break; + var uCode = str.charCodeAt(i2++); + } else { + var uCode = nextChar; + nextChar = -1; + } + if (55296 <= uCode && 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), 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), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, 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, 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; + } + } +}); +var require_shiftjis2 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_eucjp2 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_cp9362 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_gbk_added2 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_gb18030_ranges2 = __commonJS2({ + "node_modules/body-parser/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] }; + } +}); +var require_cp9492 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_cp9502 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_big5_added2 = __commonJS2({ + "node_modules/body-parser/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"] + ]; + } +}); +var require_dbcs_data2 = __commonJS2({ + "node_modules/body-parser/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_shiftjis2(); + }, + 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_eucjp2(); + }, + 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_cp9362(); + } + }, + // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other. + "gbk": { + type: "_dbcs", + table: function() { + return require_cp9362().concat(require_gbk_added2()); + } + }, + "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_cp9362().concat(require_gbk_added2()); + }, + gb18030: function() { + return require_gb18030_ranges2(); + }, + 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_cp9492(); + } + }, + "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_cp9502(); + } + }, + // 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_cp9502().concat(require_big5_added2()); + }, + 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" + }; + } +}); +var require_encodings2 = __commonJS2({ + "node_modules/body-parser/node_modules/iconv-lite/encodings/index.js"(exports2, module2) { + "use strict"; + var modules = [ + require_internal2(), + require_utf322(), + require_utf162(), + require_utf72(), + require_sbcs_codec2(), + require_sbcs_data2(), + require_sbcs_data_generated2(), + require_dbcs_codec2(), + require_dbcs_data2() + ]; + for (i = 0; i < modules.length; i++) { + module2 = modules[i]; + for (enc in module2) + if (Object.prototype.hasOwnProperty.call(module2, enc)) + exports2[enc] = module2[enc]; + } + var module2; + var enc; + var i; + } +}); +var require_streams2 = __commonJS2({ + "node_modules/body-parser/node_modules/iconv-lite/lib/streams.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + module2.exports = function(stream_module) { + var Transform = stream_module.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 + }; + }; + } +}); +var require_lib2 = __commonJS2({ + "node_modules/body-parser/node_modules/iconv-lite/lib/index.js"(exports2, module2) { + "use strict"; + var Buffer2 = require_safer().Buffer; + var bomHandling = require_bom_handling2(); + var iconv = module2.exports; + iconv.encodings = null; + iconv.defaultCharUnicode = "\uFFFD"; + iconv.defaultCharSingleByte = "?"; + iconv.encode = function encode(str, encoding, options) { + str = "" + (str || ""); + var encoder = iconv.getEncoder(encoding, options); + var res = encoder.write(str); + var trail = encoder.end(); + return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res; + }; + iconv.decode = function decode(buf, encoding, options) { + if (typeof buf === "string") { + if (!iconv.skipDecodeWarning) { + console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding"); + iconv.skipDecodeWarning = true; + } + buf = Buffer2.from("" + (buf || ""), "binary"); + } + var decoder = iconv.getDecoder(encoding, options); + var res = decoder.write(buf); + var trail = decoder.end(); + return trail ? res + trail : res; + }; + iconv.encodingExists = function encodingExists(enc) { + try { + iconv.getCodec(enc); + return true; + } catch (e) { + return false; + } + }; + iconv.toEncoding = iconv.encode; + iconv.fromEncoding = iconv.decode; + iconv._codecDataCache = {}; + iconv.getCodec = function getCodec(encoding) { + if (!iconv.encodings) + iconv.encodings = require_encodings2(); + var enc = iconv._canonicalizeEncoding(encoding); + var codecOptions = {}; + while (true) { + var codec = iconv._codecDataCache[enc]; + if (codec) + return codec; + var codecDef = iconv.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, iconv); + iconv._codecDataCache[codecOptions.encodingName] = codec; + return codec; + default: + throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')"); + } + } + }; + iconv._canonicalizeEncoding = function(encoding) { + return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, ""); + }; + iconv.getEncoder = function getEncoder(encoding, options) { + var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec); + if (codec.bomAware && options && options.addBOM) + encoder = new bomHandling.PrependBOM(encoder, options); + return encoder; + }; + iconv.getDecoder = function getDecoder(encoding, options) { + var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec); + if (codec.bomAware && !(options && options.stripBOM === false)) + decoder = new bomHandling.StripBOM(decoder, options); + return decoder; + }; + iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) { + if (iconv.supportsStreams) + return; + var streams = require_streams2()(stream_module2); + iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream; + iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream; + iconv.encodeStream = function encodeStream(encoding, options) { + return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options); + }; + iconv.decodeStream = function decodeStream(encoding, options) { + return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options); + }; + iconv.supportsStreams = true; + }; + var stream_module; + try { + stream_module = require("stream"); + } catch (e) { + } + if (stream_module && stream_module.Transform) { + iconv.enableStreamingAPI(stream_module); + } else { + iconv.encodeStream = iconv.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."); + } + } +}); +var require_read = __commonJS2({ + "node_modules/body-parser/lib/read.js"(exports2, module2) { + "use strict"; + var createError = require_http_errors(); + var getBody = require_raw_body(); + var iconv = require_lib2(); + var onFinished = require_on_finished(); + var zlib = require("node:zlib"); + module2.exports = read; + function read(req, res, next, parse, debug, options) { + var length; + var opts = options; + var stream; + var encoding = opts.encoding !== null ? opts.encoding : null; + var verify = opts.verify; + try { + stream = contentstream(req, debug, opts.inflate); + length = stream.length; + stream.length = void 0; + } catch (err2) { + return next(err2); + } + opts.length = length; + opts.encoding = verify ? null : encoding; + if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) { + return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', { + charset: encoding.toLowerCase(), + type: "charset.unsupported" + })); + } + debug("read body"); + getBody(stream, opts, function(error, body) { + if (error) { + var _error; + if (error.type === "encoding.unsupported") { + _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', { + charset: encoding.toLowerCase(), + type: "charset.unsupported" + }); + } else { + _error = createError(400, error); + } + if (stream !== req) { + req.unpipe(); + stream.destroy(); + } + dump(req, function onfinished() { + next(createError(400, _error)); + }); + return; + } + if (verify) { + try { + debug("verify body"); + verify(req, res, body, encoding); + } catch (err2) { + next(createError(403, err2, { + body, + type: err2.type || "entity.verify.failed" + })); + return; + } + } + var str = body; + try { + debug("parse body"); + str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body; + req.body = parse(str, encoding); + } catch (err2) { + next(createError(400, err2, { + body: str, + type: err2.type || "entity.parse.failed" + })); + return; + } + next(); + }); + } + function contentstream(req, debug, inflate) { + var encoding = (req.headers["content-encoding"] || "identity").toLowerCase(); + var length = req.headers["content-length"]; + debug('content-encoding "%s"', encoding); + if (inflate === false && encoding !== "identity") { + throw createError(415, "content encoding unsupported", { + encoding, + type: "encoding.unsupported" + }); + } + if (encoding === "identity") { + req.length = length; + return req; + } + var stream = createDecompressionStream(encoding, debug); + req.pipe(stream); + return stream; + } + function createDecompressionStream(encoding, debug) { + switch (encoding) { + case "deflate": + debug("inflate body"); + return zlib.createInflate(); + case "gzip": + debug("gunzip body"); + return zlib.createGunzip(); + case "br": + debug("brotli decompress body"); + return zlib.createBrotliDecompress(); + default: + throw createError(415, 'unsupported content encoding "' + encoding + '"', { + encoding, + type: "encoding.unsupported" + }); + } + } + function dump(req, callback) { + if (onFinished.isFinished(req)) { + callback(null); + } else { + onFinished(req, callback); + req.resume(); + } + } + } +}); +var require_db = __commonJS2({ + "node_modules/type-is/node_modules/mime-db/db.json"(exports2, module2) { + module2.exports = { + "application/1d-interleaved-parityfec": { + source: "iana" + }, + "application/3gpdash-qoe-report+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/3gpp-ims+xml": { + source: "iana", + compressible: true + }, + "application/3gpphal+json": { + source: "iana", + compressible: true + }, + "application/3gpphalforms+json": { + source: "iana", + compressible: true + }, + "application/a2l": { + source: "iana" + }, + "application/ace+cbor": { + source: "iana" + }, + "application/ace+json": { + source: "iana", + compressible: true + }, + "application/ace-groupcomm+cbor": { + source: "iana" + }, + "application/ace-trl+cbor": { + source: "iana" + }, + "application/activemessage": { + source: "iana" + }, + "application/activity+json": { + source: "iana", + compressible: true + }, + "application/aif+cbor": { + source: "iana" + }, + "application/aif+json": { + source: "iana", + compressible: true + }, + "application/alto-cdni+json": { + source: "iana", + compressible: true + }, + "application/alto-cdnifilter+json": { + source: "iana", + compressible: true + }, + "application/alto-costmap+json": { + source: "iana", + compressible: true + }, + "application/alto-costmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-directory+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcost+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcostparams+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointprop+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointpropparams+json": { + source: "iana", + compressible: true + }, + "application/alto-error+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmap+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-propmap+json": { + source: "iana", + compressible: true + }, + "application/alto-propmapparams+json": { + source: "iana", + compressible: true + }, + "application/alto-tips+json": { + source: "iana", + compressible: true + }, + "application/alto-tipsparams+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamcontrol+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamparams+json": { + source: "iana", + compressible: true + }, + "application/aml": { + source: "iana" + }, + "application/andrew-inset": { + source: "iana", + extensions: ["ez"] + }, + "application/appinstaller": { + compressible: false, + extensions: ["appinstaller"] + }, + "application/applefile": { + source: "iana" + }, + "application/applixware": { + source: "apache", + extensions: ["aw"] + }, + "application/appx": { + compressible: false, + extensions: ["appx"] + }, + "application/appxbundle": { + compressible: false, + extensions: ["appxbundle"] + }, + "application/at+jwt": { + source: "iana" + }, + "application/atf": { + source: "iana" + }, + "application/atfx": { + source: "iana" + }, + "application/atom+xml": { + source: "iana", + compressible: true, + extensions: ["atom"] + }, + "application/atomcat+xml": { + source: "iana", + compressible: true, + extensions: ["atomcat"] + }, + "application/atomdeleted+xml": { + source: "iana", + compressible: true, + extensions: ["atomdeleted"] + }, + "application/atomicmail": { + source: "iana" + }, + "application/atomsvc+xml": { + source: "iana", + compressible: true, + extensions: ["atomsvc"] + }, + "application/atsc-dwd+xml": { + source: "iana", + compressible: true, + extensions: ["dwd"] + }, + "application/atsc-dynamic-event-message": { + source: "iana" + }, + "application/atsc-held+xml": { + source: "iana", + compressible: true, + extensions: ["held"] + }, + "application/atsc-rdt+json": { + source: "iana", + compressible: true + }, + "application/atsc-rsat+xml": { + source: "iana", + compressible: true, + extensions: ["rsat"] + }, + "application/atxml": { + source: "iana" + }, + "application/auth-policy+xml": { + source: "iana", + compressible: true + }, + "application/automationml-aml+xml": { + source: "iana", + compressible: true, + extensions: ["aml"] + }, + "application/automationml-amlx+zip": { + source: "iana", + compressible: false, + extensions: ["amlx"] + }, + "application/bacnet-xdd+zip": { + source: "iana", + compressible: false + }, + "application/batch-smtp": { + source: "iana" + }, + "application/bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/beep+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/bufr": { + source: "iana" + }, + "application/c2pa": { + source: "iana" + }, + "application/calendar+json": { + source: "iana", + compressible: true + }, + "application/calendar+xml": { + source: "iana", + compressible: true, + extensions: ["xcs"] + }, + "application/call-completion": { + source: "iana" + }, + "application/cals-1840": { + source: "iana" + }, + "application/captive+json": { + source: "iana", + compressible: true + }, + "application/cbor": { + source: "iana" + }, + "application/cbor-seq": { + source: "iana" + }, + "application/cccex": { + source: "iana" + }, + "application/ccmp+xml": { + source: "iana", + compressible: true + }, + "application/ccxml+xml": { + source: "iana", + compressible: true, + extensions: ["ccxml"] + }, + "application/cda+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/cdfx+xml": { + source: "iana", + compressible: true, + extensions: ["cdfx"] + }, + "application/cdmi-capability": { + source: "iana", + extensions: ["cdmia"] + }, + "application/cdmi-container": { + source: "iana", + extensions: ["cdmic"] + }, + "application/cdmi-domain": { + source: "iana", + extensions: ["cdmid"] + }, + "application/cdmi-object": { + source: "iana", + extensions: ["cdmio"] + }, + "application/cdmi-queue": { + source: "iana", + extensions: ["cdmiq"] + }, + "application/cdni": { + source: "iana" + }, + "application/ce+cbor": { + source: "iana" + }, + "application/cea": { + source: "iana" + }, + "application/cea-2018+xml": { + source: "iana", + compressible: true + }, + "application/cellml+xml": { + source: "iana", + compressible: true + }, + "application/cfw": { + source: "iana" + }, + "application/cid-edhoc+cbor-seq": { + source: "iana" + }, + "application/city+json": { + source: "iana", + compressible: true + }, + "application/city+json-seq": { + source: "iana" + }, + "application/clr": { + source: "iana" + }, + "application/clue+xml": { + source: "iana", + compressible: true + }, + "application/clue_info+xml": { + source: "iana", + compressible: true + }, + "application/cms": { + source: "iana" + }, + "application/cnrp+xml": { + source: "iana", + compressible: true + }, + "application/coap-eap": { + source: "iana" + }, + "application/coap-group+json": { + source: "iana", + compressible: true + }, + "application/coap-payload": { + source: "iana" + }, + "application/commonground": { + source: "iana" + }, + "application/concise-problem-details+cbor": { + source: "iana" + }, + "application/conference-info+xml": { + source: "iana", + compressible: true + }, + "application/cose": { + source: "iana" + }, + "application/cose-key": { + source: "iana" + }, + "application/cose-key-set": { + source: "iana" + }, + "application/cose-x509": { + source: "iana" + }, + "application/cpl+xml": { + source: "iana", + compressible: true, + extensions: ["cpl"] + }, + "application/csrattrs": { + source: "iana" + }, + "application/csta+xml": { + source: "iana", + compressible: true + }, + "application/cstadata+xml": { + source: "iana", + compressible: true + }, + "application/csvm+json": { + source: "iana", + compressible: true + }, + "application/cu-seeme": { + source: "apache", + extensions: ["cu"] + }, + "application/cwl": { + source: "iana", + extensions: ["cwl"] + }, + "application/cwl+json": { + source: "iana", + compressible: true + }, + "application/cwl+yaml": { + source: "iana" + }, + "application/cwt": { + source: "iana" + }, + "application/cybercash": { + source: "iana" + }, + "application/dart": { + compressible: true + }, + "application/dash+xml": { + source: "iana", + compressible: true, + extensions: ["mpd"] + }, + "application/dash-patch+xml": { + source: "iana", + compressible: true, + extensions: ["mpp"] + }, + "application/dashdelta": { + source: "iana" + }, + "application/davmount+xml": { + source: "iana", + compressible: true, + extensions: ["davmount"] + }, + "application/dca-rft": { + source: "iana" + }, + "application/dcd": { + source: "iana" + }, + "application/dec-dx": { + source: "iana" + }, + "application/dialog-info+xml": { + source: "iana", + compressible: true + }, + "application/dicom": { + source: "iana", + extensions: ["dcm"] + }, + "application/dicom+json": { + source: "iana", + compressible: true + }, + "application/dicom+xml": { + source: "iana", + compressible: true + }, + "application/dii": { + source: "iana" + }, + "application/dit": { + source: "iana" + }, + "application/dns": { + source: "iana" + }, + "application/dns+json": { + source: "iana", + compressible: true + }, + "application/dns-message": { + source: "iana" + }, + "application/docbook+xml": { + source: "apache", + compressible: true, + extensions: ["dbk"] + }, + "application/dots+cbor": { + source: "iana" + }, + "application/dpop+jwt": { + source: "iana" + }, + "application/dskpp+xml": { + source: "iana", + compressible: true + }, + "application/dssc+der": { + source: "iana", + extensions: ["dssc"] + }, + "application/dssc+xml": { + source: "iana", + compressible: true, + extensions: ["xdssc"] + }, + "application/dvcs": { + source: "iana" + }, + "application/eat+cwt": { + source: "iana" + }, + "application/eat+jwt": { + source: "iana" + }, + "application/eat-bun+cbor": { + source: "iana" + }, + "application/eat-bun+json": { + source: "iana", + compressible: true + }, + "application/eat-ucs+cbor": { + source: "iana" + }, + "application/eat-ucs+json": { + source: "iana", + compressible: true + }, + "application/ecmascript": { + source: "apache", + compressible: true, + extensions: ["ecma"] + }, + "application/edhoc+cbor-seq": { + source: "iana" + }, + "application/edi-consent": { + source: "iana" + }, + "application/edi-x12": { + source: "iana", + compressible: false + }, + "application/edifact": { + source: "iana", + compressible: false + }, + "application/efi": { + source: "iana" + }, + "application/elm+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/elm+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.cap+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/emergencycalldata.comment+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.control+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.deviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.ecall.msd": { + source: "iana" + }, + "application/emergencycalldata.legacyesn+json": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.providerinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.serviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.subscriberinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.veds+xml": { + source: "iana", + compressible: true + }, + "application/emma+xml": { + source: "iana", + compressible: true, + extensions: ["emma"] + }, + "application/emotionml+xml": { + source: "iana", + compressible: true, + extensions: ["emotionml"] + }, + "application/encaprtp": { + source: "iana" + }, + "application/entity-statement+jwt": { + source: "iana" + }, + "application/epp+xml": { + source: "iana", + compressible: true + }, + "application/epub+zip": { + source: "iana", + compressible: false, + extensions: ["epub"] + }, + "application/eshop": { + source: "iana" + }, + "application/exi": { + source: "iana", + extensions: ["exi"] + }, + "application/expect-ct-report+json": { + source: "iana", + compressible: true + }, + "application/express": { + source: "iana", + extensions: ["exp"] + }, + "application/fastinfoset": { + source: "iana" + }, + "application/fastsoap": { + source: "iana" + }, + "application/fdf": { + source: "iana", + extensions: ["fdf"] + }, + "application/fdt+xml": { + source: "iana", + compressible: true, + extensions: ["fdt"] + }, + "application/fhir+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fhir+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fido.trusted-apps+json": { + compressible: true + }, + "application/fits": { + source: "iana" + }, + "application/flexfec": { + source: "iana" + }, + "application/font-sfnt": { + source: "iana" + }, + "application/font-tdpfr": { + source: "iana", + extensions: ["pfr"] + }, + "application/font-woff": { + source: "iana", + compressible: false + }, + "application/framework-attributes+xml": { + source: "iana", + compressible: true + }, + "application/geo+json": { + source: "iana", + compressible: true, + extensions: ["geojson"] + }, + "application/geo+json-seq": { + source: "iana" + }, + "application/geopackage+sqlite3": { + source: "iana" + }, + "application/geopose+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+xml": { + source: "iana", + compressible: true + }, + "application/gltf-buffer": { + source: "iana" + }, + "application/gml+xml": { + source: "iana", + compressible: true, + extensions: ["gml"] + }, + "application/gnap-binding-jws": { + source: "iana" + }, + "application/gnap-binding-jwsd": { + source: "iana" + }, + "application/gnap-binding-rotation-jws": { + source: "iana" + }, + "application/gnap-binding-rotation-jwsd": { + source: "iana" + }, + "application/gpx+xml": { + source: "apache", + compressible: true, + extensions: ["gpx"] + }, + "application/grib": { + source: "iana" + }, + "application/gxf": { + source: "apache", + extensions: ["gxf"] + }, + "application/gzip": { + source: "iana", + compressible: false, + extensions: ["gz"] + }, + "application/h224": { + source: "iana" + }, + "application/held+xml": { + source: "iana", + compressible: true + }, + "application/hjson": { + extensions: ["hjson"] + }, + "application/hl7v2+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/http": { + source: "iana" + }, + "application/hyperstudio": { + source: "iana", + extensions: ["stk"] + }, + "application/ibe-key-request+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pkg-reply+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pp-data": { + source: "iana" + }, + "application/iges": { + source: "iana" + }, + "application/im-iscomposing+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/index": { + source: "iana" + }, + "application/index.cmd": { + source: "iana" + }, + "application/index.obj": { + source: "iana" + }, + "application/index.response": { + source: "iana" + }, + "application/index.vnd": { + source: "iana" + }, + "application/inkml+xml": { + source: "iana", + compressible: true, + extensions: ["ink", "inkml"] + }, + "application/iotp": { + source: "iana" + }, + "application/ipfix": { + source: "iana", + extensions: ["ipfix"] + }, + "application/ipp": { + source: "iana" + }, + "application/isup": { + source: "iana" + }, + "application/its+xml": { + source: "iana", + compressible: true, + extensions: ["its"] + }, + "application/java-archive": { + source: "iana", + compressible: false, + extensions: ["jar", "war", "ear"] + }, + "application/java-serialized-object": { + source: "apache", + compressible: false, + extensions: ["ser"] + }, + "application/java-vm": { + source: "apache", + compressible: false, + extensions: ["class"] + }, + "application/javascript": { + source: "apache", + charset: "UTF-8", + compressible: true, + extensions: ["js"] + }, + "application/jf2feed+json": { + source: "iana", + compressible: true + }, + "application/jose": { + source: "iana" + }, + "application/jose+json": { + source: "iana", + compressible: true + }, + "application/jrd+json": { + source: "iana", + compressible: true + }, + "application/jscalendar+json": { + source: "iana", + compressible: true + }, + "application/jscontact+json": { + source: "iana", + compressible: true + }, + "application/json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["json", "map"] + }, + "application/json-patch+json": { + source: "iana", + compressible: true + }, + "application/json-seq": { + source: "iana" + }, + "application/json5": { + extensions: ["json5"] + }, + "application/jsonml+json": { + source: "apache", + compressible: true, + extensions: ["jsonml"] + }, + "application/jsonpath": { + source: "iana" + }, + "application/jwk+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+jwt": { + source: "iana" + }, + "application/jwt": { + source: "iana" + }, + "application/kpml-request+xml": { + source: "iana", + compressible: true + }, + "application/kpml-response+xml": { + source: "iana", + compressible: true + }, + "application/ld+json": { + source: "iana", + compressible: true, + extensions: ["jsonld"] + }, + "application/lgr+xml": { + source: "iana", + compressible: true, + extensions: ["lgr"] + }, + "application/link-format": { + source: "iana" + }, + "application/linkset": { + source: "iana" + }, + "application/linkset+json": { + source: "iana", + compressible: true + }, + "application/load-control+xml": { + source: "iana", + compressible: true + }, + "application/logout+jwt": { + source: "iana" + }, + "application/lost+xml": { + source: "iana", + compressible: true, + extensions: ["lostxml"] + }, + "application/lostsync+xml": { + source: "iana", + compressible: true + }, + "application/lpf+zip": { + source: "iana", + compressible: false + }, + "application/lxf": { + source: "iana" + }, + "application/mac-binhex40": { + source: "iana", + extensions: ["hqx"] + }, + "application/mac-compactpro": { + source: "apache", + extensions: ["cpt"] + }, + "application/macwriteii": { + source: "iana" + }, + "application/mads+xml": { + source: "iana", + compressible: true, + extensions: ["mads"] + }, + "application/manifest+json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["webmanifest"] + }, + "application/marc": { + source: "iana", + extensions: ["mrc"] + }, + "application/marcxml+xml": { + source: "iana", + compressible: true, + extensions: ["mrcx"] + }, + "application/mathematica": { + source: "iana", + extensions: ["ma", "nb", "mb"] + }, + "application/mathml+xml": { + source: "iana", + compressible: true, + extensions: ["mathml"] + }, + "application/mathml-content+xml": { + source: "iana", + compressible: true + }, + "application/mathml-presentation+xml": { + source: "iana", + compressible: true + }, + "application/mbms-associated-procedure-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-deregister+xml": { + source: "iana", + compressible: true + }, + "application/mbms-envelope+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-protection-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-reception-report+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-schedule+xml": { + source: "iana", + compressible: true + }, + "application/mbms-user-service-description+xml": { + source: "iana", + compressible: true + }, + "application/mbox": { + source: "iana", + extensions: ["mbox"] + }, + "application/media-policy-dataset+xml": { + source: "iana", + compressible: true, + extensions: ["mpf"] + }, + "application/media_control+xml": { + source: "iana", + compressible: true + }, + "application/mediaservercontrol+xml": { + source: "iana", + compressible: true, + extensions: ["mscml"] + }, + "application/merge-patch+json": { + source: "iana", + compressible: true + }, + "application/metalink+xml": { + source: "apache", + compressible: true, + extensions: ["metalink"] + }, + "application/metalink4+xml": { + source: "iana", + compressible: true, + extensions: ["meta4"] + }, + "application/mets+xml": { + source: "iana", + compressible: true, + extensions: ["mets"] + }, + "application/mf4": { + source: "iana" + }, + "application/mikey": { + source: "iana" + }, + "application/mipc": { + source: "iana" + }, + "application/missing-blocks+cbor-seq": { + source: "iana" + }, + "application/mmt-aei+xml": { + source: "iana", + compressible: true, + extensions: ["maei"] + }, + "application/mmt-usd+xml": { + source: "iana", + compressible: true, + extensions: ["musd"] + }, + "application/mods+xml": { + source: "iana", + compressible: true, + extensions: ["mods"] + }, + "application/moss-keys": { + source: "iana" + }, + "application/moss-signature": { + source: "iana" + }, + "application/mosskey-data": { + source: "iana" + }, + "application/mosskey-request": { + source: "iana" + }, + "application/mp21": { + source: "iana", + extensions: ["m21", "mp21"] + }, + "application/mp4": { + source: "iana", + extensions: ["mp4", "mpg4", "mp4s", "m4p"] + }, + "application/mpeg4-generic": { + source: "iana" + }, + "application/mpeg4-iod": { + source: "iana" + }, + "application/mpeg4-iod-xmt": { + source: "iana" + }, + "application/mrb-consumer+xml": { + source: "iana", + compressible: true + }, + "application/mrb-publish+xml": { + source: "iana", + compressible: true + }, + "application/msc-ivr+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msc-mixer+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msix": { + compressible: false, + extensions: ["msix"] + }, + "application/msixbundle": { + compressible: false, + extensions: ["msixbundle"] + }, + "application/msword": { + source: "iana", + compressible: false, + extensions: ["doc", "dot"] + }, + "application/mud+json": { + source: "iana", + compressible: true + }, + "application/multipart-core": { + source: "iana" + }, + "application/mxf": { + source: "iana", + extensions: ["mxf"] + }, + "application/n-quads": { + source: "iana", + extensions: ["nq"] + }, + "application/n-triples": { + source: "iana", + extensions: ["nt"] + }, + "application/nasdata": { + source: "iana" + }, + "application/news-checkgroups": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-groupinfo": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-transmission": { + source: "iana" + }, + "application/nlsml+xml": { + source: "iana", + compressible: true + }, + "application/node": { + source: "iana", + extensions: ["cjs"] + }, + "application/nss": { + source: "iana" + }, + "application/oauth-authz-req+jwt": { + source: "iana" + }, + "application/oblivious-dns-message": { + source: "iana" + }, + "application/ocsp-request": { + source: "iana" + }, + "application/ocsp-response": { + source: "iana" + }, + "application/octet-stream": { + source: "iana", + compressible: true, + extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] + }, + "application/oda": { + source: "iana", + extensions: ["oda"] + }, + "application/odm+xml": { + source: "iana", + compressible: true + }, + "application/odx": { + source: "iana" + }, + "application/oebps-package+xml": { + source: "iana", + compressible: true, + extensions: ["opf"] + }, + "application/ogg": { + source: "iana", + compressible: false, + extensions: ["ogx"] + }, + "application/ohttp-keys": { + source: "iana" + }, + "application/omdoc+xml": { + source: "apache", + compressible: true, + extensions: ["omdoc"] + }, + "application/onenote": { + source: "apache", + extensions: ["onetoc", "onetoc2", "onetmp", "onepkg", "one", "onea"] + }, + "application/opc-nodeset+xml": { + source: "iana", + compressible: true + }, + "application/oscore": { + source: "iana" + }, + "application/oxps": { + source: "iana", + extensions: ["oxps"] + }, + "application/p21": { + source: "iana" + }, + "application/p21+zip": { + source: "iana", + compressible: false + }, + "application/p2p-overlay+xml": { + source: "iana", + compressible: true, + extensions: ["relo"] + }, + "application/parityfec": { + source: "iana" + }, + "application/passport": { + source: "iana" + }, + "application/patch-ops-error+xml": { + source: "iana", + compressible: true, + extensions: ["xer"] + }, + "application/pdf": { + source: "iana", + compressible: false, + extensions: ["pdf"] + }, + "application/pdx": { + source: "iana" + }, + "application/pem-certificate-chain": { + source: "iana" + }, + "application/pgp-encrypted": { + source: "iana", + compressible: false, + extensions: ["pgp"] + }, + "application/pgp-keys": { + source: "iana", + extensions: ["asc"] + }, + "application/pgp-signature": { + source: "iana", + extensions: ["sig", "asc"] + }, + "application/pics-rules": { + source: "apache", + extensions: ["prf"] + }, + "application/pidf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pidf-diff+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pkcs10": { + source: "iana", + extensions: ["p10"] + }, + "application/pkcs12": { + source: "iana" + }, + "application/pkcs7-mime": { + source: "iana", + extensions: ["p7m", "p7c"] + }, + "application/pkcs7-signature": { + source: "iana", + extensions: ["p7s"] + }, + "application/pkcs8": { + source: "iana", + extensions: ["p8"] + }, + "application/pkcs8-encrypted": { + source: "iana" + }, + "application/pkix-attr-cert": { + source: "iana", + extensions: ["ac"] + }, + "application/pkix-cert": { + source: "iana", + extensions: ["cer"] + }, + "application/pkix-crl": { + source: "iana", + extensions: ["crl"] + }, + "application/pkix-pkipath": { + source: "iana", + extensions: ["pkipath"] + }, + "application/pkixcmp": { + source: "iana", + extensions: ["pki"] + }, + "application/pls+xml": { + source: "iana", + compressible: true, + extensions: ["pls"] + }, + "application/poc-settings+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/postscript": { + source: "iana", + compressible: true, + extensions: ["ai", "eps", "ps"] + }, + "application/ppsp-tracker+json": { + source: "iana", + compressible: true + }, + "application/private-token-issuer-directory": { + source: "iana" + }, + "application/private-token-request": { + source: "iana" + }, + "application/private-token-response": { + source: "iana" + }, + "application/problem+json": { + source: "iana", + compressible: true + }, + "application/problem+xml": { + source: "iana", + compressible: true + }, + "application/provenance+xml": { + source: "iana", + compressible: true, + extensions: ["provx"] + }, + "application/provided-claims+jwt": { + source: "iana" + }, + "application/prs.alvestrand.titrax-sheet": { + source: "iana" + }, + "application/prs.cww": { + source: "iana", + extensions: ["cww"] + }, + "application/prs.cyn": { + source: "iana", + charset: "7-BIT" + }, + "application/prs.hpub+zip": { + source: "iana", + compressible: false + }, + "application/prs.implied-document+xml": { + source: "iana", + compressible: true + }, + "application/prs.implied-executable": { + source: "iana" + }, + "application/prs.implied-object+json": { + source: "iana", + compressible: true + }, + "application/prs.implied-object+json-seq": { + source: "iana" + }, + "application/prs.implied-object+yaml": { + source: "iana" + }, + "application/prs.implied-structure": { + source: "iana" + }, + "application/prs.mayfile": { + source: "iana" + }, + "application/prs.nprend": { + source: "iana" + }, + "application/prs.plucker": { + source: "iana" + }, + "application/prs.rdf-xml-crypt": { + source: "iana" + }, + "application/prs.vcfbzip2": { + source: "iana" + }, + "application/prs.xsf+xml": { + source: "iana", + compressible: true, + extensions: ["xsf"] + }, + "application/pskc+xml": { + source: "iana", + compressible: true, + extensions: ["pskcxml"] + }, + "application/pvd+json": { + source: "iana", + compressible: true + }, + "application/qsig": { + source: "iana" + }, + "application/raml+yaml": { + compressible: true, + extensions: ["raml"] + }, + "application/raptorfec": { + source: "iana" + }, + "application/rdap+json": { + source: "iana", + compressible: true + }, + "application/rdf+xml": { + source: "iana", + compressible: true, + extensions: ["rdf", "owl"] + }, + "application/reginfo+xml": { + source: "iana", + compressible: true, + extensions: ["rif"] + }, + "application/relax-ng-compact-syntax": { + source: "iana", + extensions: ["rnc"] + }, + "application/remote-printing": { + source: "apache" + }, + "application/reputon+json": { + source: "iana", + compressible: true + }, + "application/resolve-response+jwt": { + source: "iana" + }, + "application/resource-lists+xml": { + source: "iana", + compressible: true, + extensions: ["rl"] + }, + "application/resource-lists-diff+xml": { + source: "iana", + compressible: true, + extensions: ["rld"] + }, + "application/rfc+xml": { + source: "iana", + compressible: true + }, + "application/riscos": { + source: "iana" + }, + "application/rlmi+xml": { + source: "iana", + compressible: true + }, + "application/rls-services+xml": { + source: "iana", + compressible: true, + extensions: ["rs"] + }, + "application/route-apd+xml": { + source: "iana", + compressible: true, + extensions: ["rapd"] + }, + "application/route-s-tsid+xml": { + source: "iana", + compressible: true, + extensions: ["sls"] + }, + "application/route-usd+xml": { + source: "iana", + compressible: true, + extensions: ["rusd"] + }, + "application/rpki-checklist": { + source: "iana" + }, + "application/rpki-ghostbusters": { + source: "iana", + extensions: ["gbr"] + }, + "application/rpki-manifest": { + source: "iana", + extensions: ["mft"] + }, + "application/rpki-publication": { + source: "iana" + }, + "application/rpki-roa": { + source: "iana", + extensions: ["roa"] + }, + "application/rpki-signed-tal": { + source: "iana" + }, + "application/rpki-updown": { + source: "iana" + }, + "application/rsd+xml": { + source: "apache", + compressible: true, + extensions: ["rsd"] + }, + "application/rss+xml": { + source: "apache", + compressible: true, + extensions: ["rss"] + }, + "application/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "application/rtploopback": { + source: "iana" + }, + "application/rtx": { + source: "iana" + }, + "application/samlassertion+xml": { + source: "iana", + compressible: true + }, + "application/samlmetadata+xml": { + source: "iana", + compressible: true + }, + "application/sarif+json": { + source: "iana", + compressible: true + }, + "application/sarif-external-properties+json": { + source: "iana", + compressible: true + }, + "application/sbe": { + source: "iana" + }, + "application/sbml+xml": { + source: "iana", + compressible: true, + extensions: ["sbml"] + }, + "application/scaip+xml": { + source: "iana", + compressible: true + }, + "application/scim+json": { + source: "iana", + compressible: true + }, + "application/scvp-cv-request": { + source: "iana", + extensions: ["scq"] + }, + "application/scvp-cv-response": { + source: "iana", + extensions: ["scs"] + }, + "application/scvp-vp-request": { + source: "iana", + extensions: ["spq"] + }, + "application/scvp-vp-response": { + source: "iana", + extensions: ["spp"] + }, + "application/sdp": { + source: "iana", + extensions: ["sdp"] + }, + "application/secevent+jwt": { + source: "iana" + }, + "application/senml+cbor": { + source: "iana" + }, + "application/senml+json": { + source: "iana", + compressible: true + }, + "application/senml+xml": { + source: "iana", + compressible: true, + extensions: ["senmlx"] + }, + "application/senml-etch+cbor": { + source: "iana" + }, + "application/senml-etch+json": { + source: "iana", + compressible: true + }, + "application/senml-exi": { + source: "iana" + }, + "application/sensml+cbor": { + source: "iana" + }, + "application/sensml+json": { + source: "iana", + compressible: true + }, + "application/sensml+xml": { + source: "iana", + compressible: true, + extensions: ["sensmlx"] + }, + "application/sensml-exi": { + source: "iana" + }, + "application/sep+xml": { + source: "iana", + compressible: true + }, + "application/sep-exi": { + source: "iana" + }, + "application/session-info": { + source: "iana" + }, + "application/set-payment": { + source: "iana" + }, + "application/set-payment-initiation": { + source: "iana", + extensions: ["setpay"] + }, + "application/set-registration": { + source: "iana" + }, + "application/set-registration-initiation": { + source: "iana", + extensions: ["setreg"] + }, + "application/sgml": { + source: "iana" + }, + "application/sgml-open-catalog": { + source: "iana" + }, + "application/shf+xml": { + source: "iana", + compressible: true, + extensions: ["shf"] + }, + "application/sieve": { + source: "iana", + extensions: ["siv", "sieve"] + }, + "application/simple-filter+xml": { + source: "iana", + compressible: true + }, + "application/simple-message-summary": { + source: "iana" + }, + "application/simplesymbolcontainer": { + source: "iana" + }, + "application/sipc": { + source: "iana" + }, + "application/slate": { + source: "iana" + }, + "application/smil": { + source: "apache" + }, + "application/smil+xml": { + source: "iana", + compressible: true, + extensions: ["smi", "smil"] + }, + "application/smpte336m": { + source: "iana" + }, + "application/soap+fastinfoset": { + source: "iana" + }, + "application/soap+xml": { + source: "iana", + compressible: true + }, + "application/sparql-query": { + source: "iana", + extensions: ["rq"] + }, + "application/sparql-results+xml": { + source: "iana", + compressible: true, + extensions: ["srx"] + }, + "application/spdx+json": { + source: "iana", + compressible: true + }, + "application/spirits-event+xml": { + source: "iana", + compressible: true + }, + "application/sql": { + source: "iana", + extensions: ["sql"] + }, + "application/srgs": { + source: "iana", + extensions: ["gram"] + }, + "application/srgs+xml": { + source: "iana", + compressible: true, + extensions: ["grxml"] + }, + "application/sru+xml": { + source: "iana", + compressible: true, + extensions: ["sru"] + }, + "application/ssdl+xml": { + source: "apache", + compressible: true, + extensions: ["ssdl"] + }, + "application/sslkeylogfile": { + source: "iana" + }, + "application/ssml+xml": { + source: "iana", + compressible: true, + extensions: ["ssml"] + }, + "application/st2110-41": { + source: "iana" + }, + "application/stix+json": { + source: "iana", + compressible: true + }, + "application/stratum": { + source: "iana" + }, + "application/swid+cbor": { + source: "iana" + }, + "application/swid+xml": { + source: "iana", + compressible: true, + extensions: ["swidtag"] + }, + "application/tamp-apex-update": { + source: "iana" + }, + "application/tamp-apex-update-confirm": { + source: "iana" + }, + "application/tamp-community-update": { + source: "iana" + }, + "application/tamp-community-update-confirm": { + source: "iana" + }, + "application/tamp-error": { + source: "iana" + }, + "application/tamp-sequence-adjust": { + source: "iana" + }, + "application/tamp-sequence-adjust-confirm": { + source: "iana" + }, + "application/tamp-status-query": { + source: "iana" + }, + "application/tamp-status-response": { + source: "iana" + }, + "application/tamp-update": { + source: "iana" + }, + "application/tamp-update-confirm": { + source: "iana" + }, + "application/tar": { + compressible: true + }, + "application/taxii+json": { + source: "iana", + compressible: true + }, + "application/td+json": { + source: "iana", + compressible: true + }, + "application/tei+xml": { + source: "iana", + compressible: true, + extensions: ["tei", "teicorpus"] + }, + "application/tetra_isi": { + source: "iana" + }, + "application/thraud+xml": { + source: "iana", + compressible: true, + extensions: ["tfi"] + }, + "application/timestamp-query": { + source: "iana" + }, + "application/timestamp-reply": { + source: "iana" + }, + "application/timestamped-data": { + source: "iana", + extensions: ["tsd"] + }, + "application/tlsrpt+gzip": { + source: "iana" + }, + "application/tlsrpt+json": { + source: "iana", + compressible: true + }, + "application/tm+json": { + source: "iana", + compressible: true + }, + "application/tnauthlist": { + source: "iana" + }, + "application/toc+cbor": { + source: "iana" + }, + "application/token-introspection+jwt": { + source: "iana" + }, + "application/toml": { + source: "iana", + compressible: true, + extensions: ["toml"] + }, + "application/trickle-ice-sdpfrag": { + source: "iana" + }, + "application/trig": { + source: "iana", + extensions: ["trig"] + }, + "application/trust-chain+json": { + source: "iana", + compressible: true + }, + "application/trust-mark+jwt": { + source: "iana" + }, + "application/trust-mark-delegation+jwt": { + source: "iana" + }, + "application/ttml+xml": { + source: "iana", + compressible: true, + extensions: ["ttml"] + }, + "application/tve-trigger": { + source: "iana" + }, + "application/tzif": { + source: "iana" + }, + "application/tzif-leap": { + source: "iana" + }, + "application/ubjson": { + compressible: false, + extensions: ["ubj"] + }, + "application/uccs+cbor": { + source: "iana" + }, + "application/ujcs+json": { + source: "iana", + compressible: true + }, + "application/ulpfec": { + source: "iana" + }, + "application/urc-grpsheet+xml": { + source: "iana", + compressible: true + }, + "application/urc-ressheet+xml": { + source: "iana", + compressible: true, + extensions: ["rsheet"] + }, + "application/urc-targetdesc+xml": { + source: "iana", + compressible: true, + extensions: ["td"] + }, + "application/urc-uisocketdesc+xml": { + source: "iana", + compressible: true + }, + "application/vc": { + source: "iana" + }, + "application/vc+cose": { + source: "iana" + }, + "application/vc+jwt": { + source: "iana" + }, + "application/vcard+json": { + source: "iana", + compressible: true + }, + "application/vcard+xml": { + source: "iana", + compressible: true + }, + "application/vemmi": { + source: "iana" + }, + "application/vividence.scriptfile": { + source: "apache" + }, + "application/vnd.1000minds.decision-model+xml": { + source: "iana", + compressible: true, + extensions: ["1km"] + }, + "application/vnd.1ob": { + source: "iana" + }, + "application/vnd.3gpp-prose+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3a+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ach+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ch+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc8+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-v2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gnas": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.access-transfer-events+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.bsf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.crs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.current-location-discovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gmop+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gtpc": { + source: "iana" + }, + "application/vnd.3gpp.interworking-data": { + source: "iana" + }, + "application/vnd.3gpp.lpp": { + source: "iana" + }, + "application/vnd.3gpp.mc-signalling-ear": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-payload": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-signalling": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-floor-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-signed+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-init-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-transmission-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mid-call+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ngap": { + source: "iana" + }, + "application/vnd.3gpp.pfcp": { + source: "iana" + }, + "application/vnd.3gpp.pic-bw-large": { + source: "iana", + extensions: ["plb"] + }, + "application/vnd.3gpp.pic-bw-small": { + source: "iana", + extensions: ["psb"] + }, + "application/vnd.3gpp.pic-bw-var": { + source: "iana", + extensions: ["pvb"] + }, + "application/vnd.3gpp.pinapp-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.s1ap": { + source: "iana" + }, + "application/vnd.3gpp.seal-group-doc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-network-qos-management-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-ue-config-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-unicast-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-user-profile-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.sms": { + source: "iana" + }, + "application/vnd.3gpp.sms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-ext+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.state-and-event-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ussd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.v2x": { + source: "iana" + }, + "application/vnd.3gpp.vae-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.bcmcsinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.sms": { + source: "iana" + }, + "application/vnd.3gpp2.tcap": { + source: "iana", + extensions: ["tcap"] + }, + "application/vnd.3lightssoftware.imagescal": { + source: "iana" + }, + "application/vnd.3m.post-it-notes": { + source: "iana", + extensions: ["pwn"] + }, + "application/vnd.accpac.simply.aso": { + source: "iana", + extensions: ["aso"] + }, + "application/vnd.accpac.simply.imp": { + source: "iana", + extensions: ["imp"] + }, + "application/vnd.acm.addressxfer+json": { + source: "iana", + compressible: true + }, + "application/vnd.acm.chatbot+json": { + source: "iana", + compressible: true + }, + "application/vnd.acucobol": { + source: "iana", + extensions: ["acu"] + }, + "application/vnd.acucorp": { + source: "iana", + extensions: ["atc", "acutc"] + }, + "application/vnd.adobe.air-application-installer-package+zip": { + source: "apache", + compressible: false, + extensions: ["air"] + }, + "application/vnd.adobe.flash.movie": { + source: "iana" + }, + "application/vnd.adobe.formscentral.fcdt": { + source: "iana", + extensions: ["fcdt"] + }, + "application/vnd.adobe.fxp": { + source: "iana", + extensions: ["fxp", "fxpl"] + }, + "application/vnd.adobe.partial-upload": { + source: "iana" + }, + "application/vnd.adobe.xdp+xml": { + source: "iana", + compressible: true, + extensions: ["xdp"] + }, + "application/vnd.adobe.xfdf": { + source: "apache", + extensions: ["xfdf"] + }, + "application/vnd.aether.imp": { + source: "iana" + }, + "application/vnd.afpc.afplinedata": { + source: "iana" + }, + "application/vnd.afpc.afplinedata-pagedef": { + source: "iana" + }, + "application/vnd.afpc.cmoca-cmresource": { + source: "iana" + }, + "application/vnd.afpc.foca-charset": { + source: "iana" + }, + "application/vnd.afpc.foca-codedfont": { + source: "iana" + }, + "application/vnd.afpc.foca-codepage": { + source: "iana" + }, + "application/vnd.afpc.modca": { + source: "iana" + }, + "application/vnd.afpc.modca-cmtable": { + source: "iana" + }, + "application/vnd.afpc.modca-formdef": { + source: "iana" + }, + "application/vnd.afpc.modca-mediummap": { + source: "iana" + }, + "application/vnd.afpc.modca-objectcontainer": { + source: "iana" + }, + "application/vnd.afpc.modca-overlay": { + source: "iana" + }, + "application/vnd.afpc.modca-pagesegment": { + source: "iana" + }, + "application/vnd.age": { + source: "iana", + extensions: ["age"] + }, + "application/vnd.ah-barcode": { + source: "apache" + }, + "application/vnd.ahead.space": { + source: "iana", + extensions: ["ahead"] + }, + "application/vnd.airzip.filesecure.azf": { + source: "iana", + extensions: ["azf"] + }, + "application/vnd.airzip.filesecure.azs": { + source: "iana", + extensions: ["azs"] + }, + "application/vnd.amadeus+json": { + source: "iana", + compressible: true + }, + "application/vnd.amazon.ebook": { + source: "apache", + extensions: ["azw"] + }, + "application/vnd.amazon.mobi8-ebook": { + source: "iana" + }, + "application/vnd.americandynamics.acc": { + source: "iana", + extensions: ["acc"] + }, + "application/vnd.amiga.ami": { + source: "iana", + extensions: ["ami"] + }, + "application/vnd.amundsen.maze+xml": { + source: "iana", + compressible: true + }, + "application/vnd.android.ota": { + source: "iana" + }, + "application/vnd.android.package-archive": { + source: "apache", + compressible: false, + extensions: ["apk"] + }, + "application/vnd.anki": { + source: "iana" + }, + "application/vnd.anser-web-certificate-issue-initiation": { + source: "iana", + extensions: ["cii"] + }, + "application/vnd.anser-web-funds-transfer-initiation": { + source: "apache", + extensions: ["fti"] + }, + "application/vnd.antix.game-component": { + source: "iana", + extensions: ["atx"] + }, + "application/vnd.apache.arrow.file": { + source: "iana" + }, + "application/vnd.apache.arrow.stream": { + source: "iana" + }, + "application/vnd.apache.parquet": { + source: "iana" + }, + "application/vnd.apache.thrift.binary": { + source: "iana" + }, + "application/vnd.apache.thrift.compact": { + source: "iana" + }, + "application/vnd.apache.thrift.json": { + source: "iana" + }, + "application/vnd.apexlang": { + source: "iana" + }, + "application/vnd.api+json": { + source: "iana", + compressible: true + }, + "application/vnd.aplextor.warrp+json": { + source: "iana", + compressible: true + }, + "application/vnd.apothekende.reservation+json": { + source: "iana", + compressible: true + }, + "application/vnd.apple.installer+xml": { + source: "iana", + compressible: true, + extensions: ["mpkg"] + }, + "application/vnd.apple.keynote": { + source: "iana", + extensions: ["key"] + }, + "application/vnd.apple.mpegurl": { + source: "iana", + extensions: ["m3u8"] + }, + "application/vnd.apple.numbers": { + source: "iana", + extensions: ["numbers"] + }, + "application/vnd.apple.pages": { + source: "iana", + extensions: ["pages"] + }, + "application/vnd.apple.pkpass": { + compressible: false, + extensions: ["pkpass"] + }, + "application/vnd.arastra.swi": { + source: "apache" + }, + "application/vnd.aristanetworks.swi": { + source: "iana", + extensions: ["swi"] + }, + "application/vnd.artisan+json": { + source: "iana", + compressible: true + }, + "application/vnd.artsquare": { + source: "iana" + }, + "application/vnd.astraea-software.iota": { + source: "iana", + extensions: ["iota"] + }, + "application/vnd.audiograph": { + source: "iana", + extensions: ["aep"] + }, + "application/vnd.autodesk.fbx": { + extensions: ["fbx"] + }, + "application/vnd.autopackage": { + source: "iana" + }, + "application/vnd.avalon+json": { + source: "iana", + compressible: true + }, + "application/vnd.avistar+xml": { + source: "iana", + compressible: true + }, + "application/vnd.balsamiq.bmml+xml": { + source: "iana", + compressible: true, + extensions: ["bmml"] + }, + "application/vnd.balsamiq.bmpr": { + source: "iana" + }, + "application/vnd.banana-accounting": { + source: "iana" + }, + "application/vnd.bbf.usp.error": { + source: "iana" + }, + "application/vnd.bbf.usp.msg": { + source: "iana" + }, + "application/vnd.bbf.usp.msg+json": { + source: "iana", + compressible: true + }, + "application/vnd.bekitzur-stech+json": { + source: "iana", + compressible: true + }, + "application/vnd.belightsoft.lhzd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.belightsoft.lhzl+zip": { + source: "iana", + compressible: false + }, + "application/vnd.bint.med-content": { + source: "iana" + }, + "application/vnd.biopax.rdf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.blink-idb-value-wrapper": { + source: "iana" + }, + "application/vnd.blueice.multipass": { + source: "iana", + extensions: ["mpm"] + }, + "application/vnd.bluetooth.ep.oob": { + source: "iana" + }, + "application/vnd.bluetooth.le.oob": { + source: "iana" + }, + "application/vnd.bmi": { + source: "iana", + extensions: ["bmi"] + }, + "application/vnd.bpf": { + source: "iana" + }, + "application/vnd.bpf3": { + source: "iana" + }, + "application/vnd.businessobjects": { + source: "iana", + extensions: ["rep"] + }, + "application/vnd.byu.uapi+json": { + source: "iana", + compressible: true + }, + "application/vnd.bzip3": { + source: "iana" + }, + "application/vnd.c3voc.schedule+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cab-jscript": { + source: "iana" + }, + "application/vnd.canon-cpdl": { + source: "iana" + }, + "application/vnd.canon-lips": { + source: "iana" + }, + "application/vnd.capasystems-pg+json": { + source: "iana", + compressible: true + }, + "application/vnd.cendio.thinlinc.clientconf": { + source: "iana" + }, + "application/vnd.century-systems.tcp_stream": { + source: "iana" + }, + "application/vnd.chemdraw+xml": { + source: "iana", + compressible: true, + extensions: ["cdxml"] + }, + "application/vnd.chess-pgn": { + source: "iana" + }, + "application/vnd.chipnuts.karaoke-mmd": { + source: "iana", + extensions: ["mmd"] + }, + "application/vnd.ciedi": { + source: "iana" + }, + "application/vnd.cinderella": { + source: "iana", + extensions: ["cdy"] + }, + "application/vnd.cirpack.isdn-ext": { + source: "iana" + }, + "application/vnd.citationstyles.style+xml": { + source: "iana", + compressible: true, + extensions: ["csl"] + }, + "application/vnd.claymore": { + source: "iana", + extensions: ["cla"] + }, + "application/vnd.cloanto.rp9": { + source: "iana", + extensions: ["rp9"] + }, + "application/vnd.clonk.c4group": { + source: "iana", + extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"] + }, + "application/vnd.cluetrust.cartomobile-config": { + source: "iana", + extensions: ["c11amc"] + }, + "application/vnd.cluetrust.cartomobile-config-pkg": { + source: "iana", + extensions: ["c11amz"] + }, + "application/vnd.cncf.helm.chart.content.v1.tar+gzip": { + source: "iana" + }, + "application/vnd.cncf.helm.chart.provenance.v1.prov": { + source: "iana" + }, + "application/vnd.cncf.helm.config.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.coffeescript": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet-template": { + source: "iana" + }, + "application/vnd.collection+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.doc+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.next+json": { + source: "iana", + compressible: true + }, + "application/vnd.comicbook+zip": { + source: "iana", + compressible: false + }, + "application/vnd.comicbook-rar": { + source: "iana" + }, + "application/vnd.commerce-battelle": { + source: "iana" + }, + "application/vnd.commonspace": { + source: "iana", + extensions: ["csp"] + }, + "application/vnd.contact.cmsg": { + source: "iana", + extensions: ["cdbcmsg"] + }, + "application/vnd.coreos.ignition+json": { + source: "iana", + compressible: true + }, + "application/vnd.cosmocaller": { + source: "iana", + extensions: ["cmc"] + }, + "application/vnd.crick.clicker": { + source: "iana", + extensions: ["clkx"] + }, + "application/vnd.crick.clicker.keyboard": { + source: "iana", + extensions: ["clkk"] + }, + "application/vnd.crick.clicker.palette": { + source: "iana", + extensions: ["clkp"] + }, + "application/vnd.crick.clicker.template": { + source: "iana", + extensions: ["clkt"] + }, + "application/vnd.crick.clicker.wordbank": { + source: "iana", + extensions: ["clkw"] + }, + "application/vnd.criticaltools.wbs+xml": { + source: "iana", + compressible: true, + extensions: ["wbs"] + }, + "application/vnd.cryptii.pipe+json": { + source: "iana", + compressible: true + }, + "application/vnd.crypto-shade-file": { + source: "iana" + }, + "application/vnd.cryptomator.encrypted": { + source: "iana" + }, + "application/vnd.cryptomator.vault": { + source: "iana" + }, + "application/vnd.ctc-posml": { + source: "iana", + extensions: ["pml"] + }, + "application/vnd.ctct.ws+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cups-pdf": { + source: "iana" + }, + "application/vnd.cups-postscript": { + source: "iana" + }, + "application/vnd.cups-ppd": { + source: "iana", + extensions: ["ppd"] + }, + "application/vnd.cups-raster": { + source: "iana" + }, + "application/vnd.cups-raw": { + source: "iana" + }, + "application/vnd.curl": { + source: "iana" + }, + "application/vnd.curl.car": { + source: "apache", + extensions: ["car"] + }, + "application/vnd.curl.pcurl": { + source: "apache", + extensions: ["pcurl"] + }, + "application/vnd.cyan.dean.root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cybank": { + source: "iana" + }, + "application/vnd.cyclonedx+json": { + source: "iana", + compressible: true + }, + "application/vnd.cyclonedx+xml": { + source: "iana", + compressible: true + }, + "application/vnd.d2l.coursepackage1p0+zip": { + source: "iana", + compressible: false + }, + "application/vnd.d3m-dataset": { + source: "iana" + }, + "application/vnd.d3m-problem": { + source: "iana" + }, + "application/vnd.dart": { + source: "iana", + compressible: true, + extensions: ["dart"] + }, + "application/vnd.data-vision.rdz": { + source: "iana", + extensions: ["rdz"] + }, + "application/vnd.datalog": { + source: "iana" + }, + "application/vnd.datapackage+json": { + source: "iana", + compressible: true + }, + "application/vnd.dataresource+json": { + source: "iana", + compressible: true + }, + "application/vnd.dbf": { + source: "iana", + extensions: ["dbf"] + }, + "application/vnd.dcmp+xml": { + source: "iana", + compressible: true, + extensions: ["dcmp"] + }, + "application/vnd.debian.binary-package": { + source: "iana" + }, + "application/vnd.dece.data": { + source: "iana", + extensions: ["uvf", "uvvf", "uvd", "uvvd"] + }, + "application/vnd.dece.ttml+xml": { + source: "iana", + compressible: true, + extensions: ["uvt", "uvvt"] + }, + "application/vnd.dece.unspecified": { + source: "iana", + extensions: ["uvx", "uvvx"] + }, + "application/vnd.dece.zip": { + source: "iana", + extensions: ["uvz", "uvvz"] + }, + "application/vnd.denovo.fcselayout-link": { + source: "iana", + extensions: ["fe_launch"] + }, + "application/vnd.desmume.movie": { + source: "iana" + }, + "application/vnd.dir-bi.plate-dl-nosuffix": { + source: "iana" + }, + "application/vnd.dm.delegation+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dna": { + source: "iana", + extensions: ["dna"] + }, + "application/vnd.document+json": { + source: "iana", + compressible: true + }, + "application/vnd.dolby.mlp": { + source: "apache", + extensions: ["mlp"] + }, + "application/vnd.dolby.mobile.1": { + source: "iana" + }, + "application/vnd.dolby.mobile.2": { + source: "iana" + }, + "application/vnd.doremir.scorecloud-binary-document": { + source: "iana" + }, + "application/vnd.dpgraph": { + source: "iana", + extensions: ["dpg"] + }, + "application/vnd.dreamfactory": { + source: "iana", + extensions: ["dfac"] + }, + "application/vnd.drive+json": { + source: "iana", + compressible: true + }, + "application/vnd.ds-keypoint": { + source: "apache", + extensions: ["kpxx"] + }, + "application/vnd.dtg.local": { + source: "iana" + }, + "application/vnd.dtg.local.flash": { + source: "iana" + }, + "application/vnd.dtg.local.html": { + source: "iana" + }, + "application/vnd.dvb.ait": { + source: "iana", + extensions: ["ait"] + }, + "application/vnd.dvb.dvbisl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.dvbj": { + source: "iana" + }, + "application/vnd.dvb.esgcontainer": { + source: "iana" + }, + "application/vnd.dvb.ipdcdftnotifaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess2": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgpdd": { + source: "iana" + }, + "application/vnd.dvb.ipdcroaming": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-base": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-enhancement": { + source: "iana" + }, + "application/vnd.dvb.notif-aggregate-root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-container+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-generic+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-msglist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-response+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-init+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.pfr": { + source: "iana" + }, + "application/vnd.dvb.service": { + source: "iana", + extensions: ["svc"] + }, + "application/vnd.dxr": { + source: "iana" + }, + "application/vnd.dynageo": { + source: "iana", + extensions: ["geo"] + }, + "application/vnd.dzr": { + source: "iana" + }, + "application/vnd.easykaraoke.cdgdownload": { + source: "iana" + }, + "application/vnd.ecdis-update": { + source: "iana" + }, + "application/vnd.ecip.rlp": { + source: "iana" + }, + "application/vnd.eclipse.ditto+json": { + source: "iana", + compressible: true + }, + "application/vnd.ecowin.chart": { + source: "iana", + extensions: ["mag"] + }, + "application/vnd.ecowin.filerequest": { + source: "iana" + }, + "application/vnd.ecowin.fileupdate": { + source: "iana" + }, + "application/vnd.ecowin.series": { + source: "iana" + }, + "application/vnd.ecowin.seriesrequest": { + source: "iana" + }, + "application/vnd.ecowin.seriesupdate": { + source: "iana" + }, + "application/vnd.efi.img": { + source: "iana" + }, + "application/vnd.efi.iso": { + source: "iana" + }, + "application/vnd.eln+zip": { + source: "iana", + compressible: false + }, + "application/vnd.emclient.accessrequest+xml": { + source: "iana", + compressible: true + }, + "application/vnd.enliven": { + source: "iana", + extensions: ["nml"] + }, + "application/vnd.enphase.envoy": { + source: "iana" + }, + "application/vnd.eprints.data+xml": { + source: "iana", + compressible: true + }, + "application/vnd.epson.esf": { + source: "iana", + extensions: ["esf"] + }, + "application/vnd.epson.msf": { + source: "iana", + extensions: ["msf"] + }, + "application/vnd.epson.quickanime": { + source: "iana", + extensions: ["qam"] + }, + "application/vnd.epson.salt": { + source: "iana", + extensions: ["slt"] + }, + "application/vnd.epson.ssf": { + source: "iana", + extensions: ["ssf"] + }, + "application/vnd.ericsson.quickcall": { + source: "iana" + }, + "application/vnd.erofs": { + source: "iana" + }, + "application/vnd.espass-espass+zip": { + source: "iana", + compressible: false + }, + "application/vnd.eszigno3+xml": { + source: "iana", + compressible: true, + extensions: ["es3", "et3"] + }, + "application/vnd.etsi.aoc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.asic-e+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.asic-s+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.cug+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvcommand+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-bc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-cod+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-npvr+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvservice+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsync+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mcid+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mheg5": { + source: "iana" + }, + "application/vnd.etsi.overload-control-policy-dataset+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.pstn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.sci+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.simservs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.timestamp-token": { + source: "iana" + }, + "application/vnd.etsi.tsl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.tsl.der": { + source: "iana" + }, + "application/vnd.eu.kasparian.car+json": { + source: "iana", + compressible: true + }, + "application/vnd.eudora.data": { + source: "iana" + }, + "application/vnd.evolv.ecig.profile": { + source: "iana" + }, + "application/vnd.evolv.ecig.settings": { + source: "iana" + }, + "application/vnd.evolv.ecig.theme": { + source: "iana" + }, + "application/vnd.exstream-empower+zip": { + source: "iana", + compressible: false + }, + "application/vnd.exstream-package": { + source: "iana" + }, + "application/vnd.ezpix-album": { + source: "iana", + extensions: ["ez2"] + }, + "application/vnd.ezpix-package": { + source: "iana", + extensions: ["ez3"] + }, + "application/vnd.f-secure.mobile": { + source: "iana" + }, + "application/vnd.familysearch.gedcom+zip": { + source: "iana", + compressible: false + }, + "application/vnd.fastcopy-disk-image": { + source: "iana" + }, + "application/vnd.fdf": { + source: "apache", + extensions: ["fdf"] + }, + "application/vnd.fdsn.mseed": { + source: "iana", + extensions: ["mseed"] + }, + "application/vnd.fdsn.seed": { + source: "iana", + extensions: ["seed", "dataless"] + }, + "application/vnd.fdsn.stationxml+xml": { + source: "iana", + charset: "XML-BASED", + compressible: true + }, + "application/vnd.ffsns": { + source: "iana" + }, + "application/vnd.ficlab.flb+zip": { + source: "iana", + compressible: false + }, + "application/vnd.filmit.zfc": { + source: "iana" + }, + "application/vnd.fints": { + source: "iana" + }, + "application/vnd.firemonkeys.cloudcell": { + source: "iana" + }, + "application/vnd.flographit": { + source: "iana", + extensions: ["gph"] + }, + "application/vnd.fluxtime.clip": { + source: "iana", + extensions: ["ftc"] + }, + "application/vnd.font-fontforge-sfd": { + source: "iana" + }, + "application/vnd.framemaker": { + source: "iana", + extensions: ["fm", "frame", "maker", "book"] + }, + "application/vnd.freelog.comic": { + source: "iana" + }, + "application/vnd.frogans.fnc": { + source: "apache", + extensions: ["fnc"] + }, + "application/vnd.frogans.ltf": { + source: "apache", + extensions: ["ltf"] + }, + "application/vnd.fsc.weblaunch": { + source: "iana", + extensions: ["fsc"] + }, + "application/vnd.fujifilm.fb.docuworks": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.binder": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.container": { + source: "iana" + }, + "application/vnd.fujifilm.fb.jfi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.fujitsu.oasys": { + source: "iana", + extensions: ["oas"] + }, + "application/vnd.fujitsu.oasys2": { + source: "iana", + extensions: ["oa2"] + }, + "application/vnd.fujitsu.oasys3": { + source: "iana", + extensions: ["oa3"] + }, + "application/vnd.fujitsu.oasysgp": { + source: "iana", + extensions: ["fg5"] + }, + "application/vnd.fujitsu.oasysprs": { + source: "iana", + extensions: ["bh2"] + }, + "application/vnd.fujixerox.art-ex": { + source: "iana" + }, + "application/vnd.fujixerox.art4": { + source: "iana" + }, + "application/vnd.fujixerox.ddd": { + source: "iana", + extensions: ["ddd"] + }, + "application/vnd.fujixerox.docuworks": { + source: "iana", + extensions: ["xdw"] + }, + "application/vnd.fujixerox.docuworks.binder": { + source: "iana", + extensions: ["xbd"] + }, + "application/vnd.fujixerox.docuworks.container": { + source: "iana" + }, + "application/vnd.fujixerox.hbpl": { + source: "iana" + }, + "application/vnd.fut-misnet": { + source: "iana" + }, + "application/vnd.futoin+cbor": { + source: "iana" + }, + "application/vnd.futoin+json": { + source: "iana", + compressible: true + }, + "application/vnd.fuzzysheet": { + source: "iana", + extensions: ["fzs"] + }, + "application/vnd.ga4gh.passport+jwt": { + source: "iana" + }, + "application/vnd.genomatix.tuxedo": { + source: "iana", + extensions: ["txd"] + }, + "application/vnd.genozip": { + source: "iana" + }, + "application/vnd.gentics.grd+json": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.catmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.ebuild": { + source: "iana" + }, + "application/vnd.gentoo.eclass": { + source: "iana" + }, + "application/vnd.gentoo.gpkg": { + source: "iana" + }, + "application/vnd.gentoo.manifest": { + source: "iana" + }, + "application/vnd.gentoo.pkgmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.xpak": { + source: "iana" + }, + "application/vnd.geo+json": { + source: "apache", + compressible: true + }, + "application/vnd.geocube+xml": { + source: "apache", + compressible: true + }, + "application/vnd.geogebra.file": { + source: "iana", + extensions: ["ggb"] + }, + "application/vnd.geogebra.pinboard": { + source: "iana" + }, + "application/vnd.geogebra.slides": { + source: "iana", + extensions: ["ggs"] + }, + "application/vnd.geogebra.tool": { + source: "iana", + extensions: ["ggt"] + }, + "application/vnd.geometry-explorer": { + source: "iana", + extensions: ["gex", "gre"] + }, + "application/vnd.geonext": { + source: "iana", + extensions: ["gxt"] + }, + "application/vnd.geoplan": { + source: "iana", + extensions: ["g2w"] + }, + "application/vnd.geospace": { + source: "iana", + extensions: ["g3w"] + }, + "application/vnd.gerber": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt-response": { + source: "iana" + }, + "application/vnd.gmx": { + source: "iana", + extensions: ["gmx"] + }, + "application/vnd.gnu.taler.exchange+json": { + source: "iana", + compressible: true + }, + "application/vnd.gnu.taler.merchant+json": { + source: "iana", + compressible: true + }, + "application/vnd.google-apps.audio": {}, + "application/vnd.google-apps.document": { + compressible: false, + extensions: ["gdoc"] + }, + "application/vnd.google-apps.drawing": { + compressible: false, + extensions: ["gdraw"] + }, + "application/vnd.google-apps.drive-sdk": { + compressible: false + }, + "application/vnd.google-apps.file": {}, + "application/vnd.google-apps.folder": { + compressible: false + }, + "application/vnd.google-apps.form": { + compressible: false, + extensions: ["gform"] + }, + "application/vnd.google-apps.fusiontable": {}, + "application/vnd.google-apps.jam": { + compressible: false, + extensions: ["gjam"] + }, + "application/vnd.google-apps.mail-layout": {}, + "application/vnd.google-apps.map": { + compressible: false, + extensions: ["gmap"] + }, + "application/vnd.google-apps.photo": {}, + "application/vnd.google-apps.presentation": { + compressible: false, + extensions: ["gslides"] + }, + "application/vnd.google-apps.script": { + compressible: false, + extensions: ["gscript"] + }, + "application/vnd.google-apps.shortcut": {}, + "application/vnd.google-apps.site": { + compressible: false, + extensions: ["gsite"] + }, + "application/vnd.google-apps.spreadsheet": { + compressible: false, + extensions: ["gsheet"] + }, + "application/vnd.google-apps.unknown": {}, + "application/vnd.google-apps.video": {}, + "application/vnd.google-earth.kml+xml": { + source: "iana", + compressible: true, + extensions: ["kml"] + }, + "application/vnd.google-earth.kmz": { + source: "iana", + compressible: false, + extensions: ["kmz"] + }, + "application/vnd.gov.sk.e-form+xml": { + source: "apache", + compressible: true + }, + "application/vnd.gov.sk.e-form+zip": { + source: "iana", + compressible: false + }, + "application/vnd.gov.sk.xmldatacontainer+xml": { + source: "iana", + compressible: true, + extensions: ["xdcf"] + }, + "application/vnd.gpxsee.map+xml": { + source: "iana", + compressible: true + }, + "application/vnd.grafeq": { + source: "iana", + extensions: ["gqf", "gqs"] + }, + "application/vnd.gridmp": { + source: "iana" + }, + "application/vnd.groove-account": { + source: "iana", + extensions: ["gac"] + }, + "application/vnd.groove-help": { + source: "iana", + extensions: ["ghf"] + }, + "application/vnd.groove-identity-message": { + source: "iana", + extensions: ["gim"] + }, + "application/vnd.groove-injector": { + source: "iana", + extensions: ["grv"] + }, + "application/vnd.groove-tool-message": { + source: "iana", + extensions: ["gtm"] + }, + "application/vnd.groove-tool-template": { + source: "iana", + extensions: ["tpl"] + }, + "application/vnd.groove-vcard": { + source: "iana", + extensions: ["vcg"] + }, + "application/vnd.hal+json": { + source: "iana", + compressible: true + }, + "application/vnd.hal+xml": { + source: "iana", + compressible: true, + extensions: ["hal"] + }, + "application/vnd.handheld-entertainment+xml": { + source: "iana", + compressible: true, + extensions: ["zmm"] + }, + "application/vnd.hbci": { + source: "iana", + extensions: ["hbci"] + }, + "application/vnd.hc+json": { + source: "iana", + compressible: true + }, + "application/vnd.hcl-bireports": { + source: "iana" + }, + "application/vnd.hdt": { + source: "iana" + }, + "application/vnd.heroku+json": { + source: "iana", + compressible: true + }, + "application/vnd.hhe.lesson-player": { + source: "iana", + extensions: ["les"] + }, + "application/vnd.hp-hpgl": { + source: "iana", + extensions: ["hpgl"] + }, + "application/vnd.hp-hpid": { + source: "iana", + extensions: ["hpid"] + }, + "application/vnd.hp-hps": { + source: "iana", + extensions: ["hps"] + }, + "application/vnd.hp-jlyt": { + source: "iana", + extensions: ["jlt"] + }, + "application/vnd.hp-pcl": { + source: "iana", + extensions: ["pcl"] + }, + "application/vnd.hp-pclxl": { + source: "iana", + extensions: ["pclxl"] + }, + "application/vnd.hsl": { + source: "iana" + }, + "application/vnd.httphone": { + source: "iana" + }, + "application/vnd.hydrostatix.sof-data": { + source: "iana", + extensions: ["sfd-hdstx"] + }, + "application/vnd.hyper+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyper-item+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyperdrive+json": { + source: "iana", + compressible: true + }, + "application/vnd.hzn-3d-crossword": { + source: "iana" + }, + "application/vnd.ibm.afplinedata": { + source: "apache" + }, + "application/vnd.ibm.electronic-media": { + source: "iana" + }, + "application/vnd.ibm.minipay": { + source: "iana", + extensions: ["mpy"] + }, + "application/vnd.ibm.modcap": { + source: "apache", + extensions: ["afp", "listafp", "list3820"] + }, + "application/vnd.ibm.rights-management": { + source: "iana", + extensions: ["irm"] + }, + "application/vnd.ibm.secure-container": { + source: "iana", + extensions: ["sc"] + }, + "application/vnd.iccprofile": { + source: "iana", + extensions: ["icc", "icm"] + }, + "application/vnd.ieee.1905": { + source: "iana" + }, + "application/vnd.igloader": { + source: "iana", + extensions: ["igl"] + }, + "application/vnd.imagemeter.folder+zip": { + source: "iana", + compressible: false + }, + "application/vnd.imagemeter.image+zip": { + source: "iana", + compressible: false + }, + "application/vnd.immervision-ivp": { + source: "iana", + extensions: ["ivp"] + }, + "application/vnd.immervision-ivu": { + source: "iana", + extensions: ["ivu"] + }, + "application/vnd.ims.imsccv1p1": { + source: "iana" + }, + "application/vnd.ims.imsccv1p2": { + source: "iana" + }, + "application/vnd.ims.imsccv1p3": { + source: "iana" + }, + "application/vnd.ims.lis.v2.result+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolconsumerprofile+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy.id+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings.simple+json": { + source: "iana", + compressible: true + }, + "application/vnd.informedcontrol.rms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.informix-visionary": { + source: "apache" + }, + "application/vnd.infotech.project": { + source: "iana" + }, + "application/vnd.infotech.project+xml": { + source: "iana", + compressible: true + }, + "application/vnd.innopath.wamp.notification": { + source: "iana" + }, + "application/vnd.insors.igm": { + source: "iana", + extensions: ["igm"] + }, + "application/vnd.intercon.formnet": { + source: "iana", + extensions: ["xpw", "xpx"] + }, + "application/vnd.intergeo": { + source: "iana", + extensions: ["i2g"] + }, + "application/vnd.intertrust.digibox": { + source: "iana" + }, + "application/vnd.intertrust.nncp": { + source: "iana" + }, + "application/vnd.intu.qbo": { + source: "iana", + extensions: ["qbo"] + }, + "application/vnd.intu.qfx": { + source: "iana", + extensions: ["qfx"] + }, + "application/vnd.ipfs.ipns-record": { + source: "iana" + }, + "application/vnd.ipld.car": { + source: "iana" + }, + "application/vnd.ipld.dag-cbor": { + source: "iana" + }, + "application/vnd.ipld.dag-json": { + source: "iana" + }, + "application/vnd.ipld.raw": { + source: "iana" + }, + "application/vnd.iptc.g2.catalogitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.conceptitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.knowledgeitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.packageitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.planningitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ipunplugged.rcprofile": { + source: "iana", + extensions: ["rcprofile"] + }, + "application/vnd.irepository.package+xml": { + source: "iana", + compressible: true, + extensions: ["irp"] + }, + "application/vnd.is-xpr": { + source: "iana", + extensions: ["xpr"] + }, + "application/vnd.isac.fcs": { + source: "iana", + extensions: ["fcs"] + }, + "application/vnd.iso11783-10+zip": { + source: "iana", + compressible: false + }, + "application/vnd.jam": { + source: "iana", + extensions: ["jam"] + }, + "application/vnd.japannet-directory-service": { + source: "iana" + }, + "application/vnd.japannet-jpnstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-payment-wakeup": { + source: "iana" + }, + "application/vnd.japannet-registration": { + source: "iana" + }, + "application/vnd.japannet-registration-wakeup": { + source: "iana" + }, + "application/vnd.japannet-setstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-verification": { + source: "iana" + }, + "application/vnd.japannet-verification-wakeup": { + source: "iana" + }, + "application/vnd.jcp.javame.midlet-rms": { + source: "iana", + extensions: ["rms"] + }, + "application/vnd.jisp": { + source: "iana", + extensions: ["jisp"] + }, + "application/vnd.joost.joda-archive": { + source: "iana", + extensions: ["joda"] + }, + "application/vnd.jsk.isdn-ngn": { + source: "iana" + }, + "application/vnd.kahootz": { + source: "iana", + extensions: ["ktz", "ktr"] + }, + "application/vnd.kde.karbon": { + source: "iana", + extensions: ["karbon"] + }, + "application/vnd.kde.kchart": { + source: "iana", + extensions: ["chrt"] + }, + "application/vnd.kde.kformula": { + source: "iana", + extensions: ["kfo"] + }, + "application/vnd.kde.kivio": { + source: "iana", + extensions: ["flw"] + }, + "application/vnd.kde.kontour": { + source: "iana", + extensions: ["kon"] + }, + "application/vnd.kde.kpresenter": { + source: "iana", + extensions: ["kpr", "kpt"] + }, + "application/vnd.kde.kspread": { + source: "iana", + extensions: ["ksp"] + }, + "application/vnd.kde.kword": { + source: "iana", + extensions: ["kwd", "kwt"] + }, + "application/vnd.kdl": { + source: "iana" + }, + "application/vnd.kenameaapp": { + source: "iana", + extensions: ["htke"] + }, + "application/vnd.keyman.kmp+zip": { + source: "iana", + compressible: false + }, + "application/vnd.keyman.kmx": { + source: "iana" + }, + "application/vnd.kidspiration": { + source: "iana", + extensions: ["kia"] + }, + "application/vnd.kinar": { + source: "iana", + extensions: ["kne", "knp"] + }, + "application/vnd.koan": { + source: "iana", + extensions: ["skp", "skd", "skt", "skm"] + }, + "application/vnd.kodak-descriptor": { + source: "iana", + extensions: ["sse"] + }, + "application/vnd.las": { + source: "iana" + }, + "application/vnd.las.las+json": { + source: "iana", + compressible: true + }, + "application/vnd.las.las+xml": { + source: "iana", + compressible: true, + extensions: ["lasxml"] + }, + "application/vnd.laszip": { + source: "iana" + }, + "application/vnd.ldev.productlicensing": { + source: "iana" + }, + "application/vnd.leap+json": { + source: "iana", + compressible: true + }, + "application/vnd.liberty-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.llamagraphics.life-balance.desktop": { + source: "iana", + extensions: ["lbd"] + }, + "application/vnd.llamagraphics.life-balance.exchange+xml": { + source: "iana", + compressible: true, + extensions: ["lbe"] + }, + "application/vnd.logipipe.circuit+zip": { + source: "iana", + compressible: false + }, + "application/vnd.loom": { + source: "iana" + }, + "application/vnd.lotus-1-2-3": { + source: "iana", + extensions: ["123"] + }, + "application/vnd.lotus-approach": { + source: "iana", + extensions: ["apr"] + }, + "application/vnd.lotus-freelance": { + source: "iana", + extensions: ["pre"] + }, + "application/vnd.lotus-notes": { + source: "iana", + extensions: ["nsf"] + }, + "application/vnd.lotus-organizer": { + source: "iana", + extensions: ["org"] + }, + "application/vnd.lotus-screencam": { + source: "iana", + extensions: ["scm"] + }, + "application/vnd.lotus-wordpro": { + source: "iana", + extensions: ["lwp"] + }, + "application/vnd.macports.portpkg": { + source: "iana", + extensions: ["portpkg"] + }, + "application/vnd.mapbox-vector-tile": { + source: "iana", + extensions: ["mvt"] + }, + "application/vnd.marlin.drm.actiontoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.conftoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.license+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.mdcf": { + source: "iana" + }, + "application/vnd.mason+json": { + source: "iana", + compressible: true + }, + "application/vnd.maxar.archive.3tz+zip": { + source: "iana", + compressible: false + }, + "application/vnd.maxmind.maxmind-db": { + source: "iana" + }, + "application/vnd.mcd": { + source: "iana", + extensions: ["mcd"] + }, + "application/vnd.mdl": { + source: "iana" + }, + "application/vnd.mdl-mbsdf": { + source: "iana" + }, + "application/vnd.medcalcdata": { + source: "iana", + extensions: ["mc1"] + }, + "application/vnd.mediastation.cdkey": { + source: "iana", + extensions: ["cdkey"] + }, + "application/vnd.medicalholodeck.recordxr": { + source: "iana" + }, + "application/vnd.meridian-slingshot": { + source: "iana" + }, + "application/vnd.mermaid": { + source: "iana" + }, + "application/vnd.mfer": { + source: "iana", + extensions: ["mwf"] + }, + "application/vnd.mfmp": { + source: "iana", + extensions: ["mfm"] + }, + "application/vnd.micro+json": { + source: "iana", + compressible: true + }, + "application/vnd.micrografx.flo": { + source: "iana", + extensions: ["flo"] + }, + "application/vnd.micrografx.igx": { + source: "iana", + extensions: ["igx"] + }, + "application/vnd.microsoft.portable-executable": { + source: "iana" + }, + "application/vnd.microsoft.windows.thumbnail-cache": { + source: "iana" + }, + "application/vnd.miele+json": { + source: "iana", + compressible: true + }, + "application/vnd.mif": { + source: "iana", + extensions: ["mif"] + }, + "application/vnd.minisoft-hp3000-save": { + source: "iana" + }, + "application/vnd.mitsubishi.misty-guard.trustweb": { + source: "iana" + }, + "application/vnd.mobius.daf": { + source: "iana", + extensions: ["daf"] + }, + "application/vnd.mobius.dis": { + source: "iana", + extensions: ["dis"] + }, + "application/vnd.mobius.mbk": { + source: "iana", + extensions: ["mbk"] + }, + "application/vnd.mobius.mqy": { + source: "iana", + extensions: ["mqy"] + }, + "application/vnd.mobius.msl": { + source: "iana", + extensions: ["msl"] + }, + "application/vnd.mobius.plc": { + source: "iana", + extensions: ["plc"] + }, + "application/vnd.mobius.txf": { + source: "iana", + extensions: ["txf"] + }, + "application/vnd.modl": { + source: "iana" + }, + "application/vnd.mophun.application": { + source: "iana", + extensions: ["mpn"] + }, + "application/vnd.mophun.certificate": { + source: "iana", + extensions: ["mpc"] + }, + "application/vnd.motorola.flexsuite": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.adsi": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.fis": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.gotap": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.kmr": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.ttc": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.wem": { + source: "iana" + }, + "application/vnd.motorola.iprm": { + source: "iana" + }, + "application/vnd.mozilla.xul+xml": { + source: "iana", + compressible: true, + extensions: ["xul"] + }, + "application/vnd.ms-3mfdocument": { + source: "iana" + }, + "application/vnd.ms-artgalry": { + source: "iana", + extensions: ["cil"] + }, + "application/vnd.ms-asf": { + source: "iana" + }, + "application/vnd.ms-cab-compressed": { + source: "iana", + extensions: ["cab"] + }, + "application/vnd.ms-color.iccprofile": { + source: "apache" + }, + "application/vnd.ms-excel": { + source: "iana", + compressible: false, + extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] + }, + "application/vnd.ms-excel.addin.macroenabled.12": { + source: "iana", + extensions: ["xlam"] + }, + "application/vnd.ms-excel.sheet.binary.macroenabled.12": { + source: "iana", + extensions: ["xlsb"] + }, + "application/vnd.ms-excel.sheet.macroenabled.12": { + source: "iana", + extensions: ["xlsm"] + }, + "application/vnd.ms-excel.template.macroenabled.12": { + source: "iana", + extensions: ["xltm"] + }, + "application/vnd.ms-fontobject": { + source: "iana", + compressible: true, + extensions: ["eot"] + }, + "application/vnd.ms-htmlhelp": { + source: "iana", + extensions: ["chm"] + }, + "application/vnd.ms-ims": { + source: "iana", + extensions: ["ims"] + }, + "application/vnd.ms-lrm": { + source: "iana", + extensions: ["lrm"] + }, + "application/vnd.ms-office.activex+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-officetheme": { + source: "iana", + extensions: ["thmx"] + }, + "application/vnd.ms-opentype": { + source: "apache", + compressible: true + }, + "application/vnd.ms-outlook": { + compressible: false, + extensions: ["msg"] + }, + "application/vnd.ms-package.obfuscated-opentype": { + source: "apache" + }, + "application/vnd.ms-pki.seccat": { + source: "apache", + extensions: ["cat"] + }, + "application/vnd.ms-pki.stl": { + source: "apache", + extensions: ["stl"] + }, + "application/vnd.ms-playready.initiator+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-powerpoint": { + source: "iana", + compressible: false, + extensions: ["ppt", "pps", "pot"] + }, + "application/vnd.ms-powerpoint.addin.macroenabled.12": { + source: "iana", + extensions: ["ppam"] + }, + "application/vnd.ms-powerpoint.presentation.macroenabled.12": { + source: "iana", + extensions: ["pptm"] + }, + "application/vnd.ms-powerpoint.slide.macroenabled.12": { + source: "iana", + extensions: ["sldm"] + }, + "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { + source: "iana", + extensions: ["ppsm"] + }, + "application/vnd.ms-powerpoint.template.macroenabled.12": { + source: "iana", + extensions: ["potm"] + }, + "application/vnd.ms-printdevicecapabilities+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-printing.printticket+xml": { + source: "apache", + compressible: true + }, + "application/vnd.ms-printschematicket+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-project": { + source: "iana", + extensions: ["mpp", "mpt"] + }, + "application/vnd.ms-tnef": { + source: "iana" + }, + "application/vnd.ms-visio.viewer": { + extensions: ["vdx"] + }, + "application/vnd.ms-windows.devicepairing": { + source: "iana" + }, + "application/vnd.ms-windows.nwprinting.oob": { + source: "iana" + }, + "application/vnd.ms-windows.printerpairing": { + source: "iana" + }, + "application/vnd.ms-windows.wsd.oob": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-resp": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-resp": { + source: "iana" + }, + "application/vnd.ms-word.document.macroenabled.12": { + source: "iana", + extensions: ["docm"] + }, + "application/vnd.ms-word.template.macroenabled.12": { + source: "iana", + extensions: ["dotm"] + }, + "application/vnd.ms-works": { + source: "iana", + extensions: ["wps", "wks", "wcm", "wdb"] + }, + "application/vnd.ms-wpl": { + source: "iana", + extensions: ["wpl"] + }, + "application/vnd.ms-xpsdocument": { + source: "iana", + compressible: false, + extensions: ["xps"] + }, + "application/vnd.msa-disk-image": { + source: "iana" + }, + "application/vnd.mseq": { + source: "iana", + extensions: ["mseq"] + }, + "application/vnd.msgpack": { + source: "iana" + }, + "application/vnd.msign": { + source: "iana" + }, + "application/vnd.multiad.creator": { + source: "iana" + }, + "application/vnd.multiad.creator.cif": { + source: "iana" + }, + "application/vnd.music-niff": { + source: "iana" + }, + "application/vnd.musician": { + source: "iana", + extensions: ["mus"] + }, + "application/vnd.muvee.style": { + source: "iana", + extensions: ["msty"] + }, + "application/vnd.mynfc": { + source: "iana", + extensions: ["taglet"] + }, + "application/vnd.nacamar.ybrid+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+cbor": { + source: "iana" + }, + "application/vnd.nato.bindingdataobject+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+xml": { + source: "iana", + compressible: true, + extensions: ["bdo"] + }, + "application/vnd.nato.openxmlformats-package.iepd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.ncd.control": { + source: "iana" + }, + "application/vnd.ncd.reference": { + source: "iana" + }, + "application/vnd.nearst.inv+json": { + source: "iana", + compressible: true + }, + "application/vnd.nebumind.line": { + source: "iana" + }, + "application/vnd.nervana": { + source: "iana" + }, + "application/vnd.netfpx": { + source: "iana" + }, + "application/vnd.neurolanguage.nlu": { + source: "iana", + extensions: ["nlu"] + }, + "application/vnd.nimn": { + source: "iana" + }, + "application/vnd.nintendo.nitro.rom": { + source: "iana" + }, + "application/vnd.nintendo.snes.rom": { + source: "iana" + }, + "application/vnd.nitf": { + source: "iana", + extensions: ["ntf", "nitf"] + }, + "application/vnd.noblenet-directory": { + source: "iana", + extensions: ["nnd"] + }, + "application/vnd.noblenet-sealer": { + source: "iana", + extensions: ["nns"] + }, + "application/vnd.noblenet-web": { + source: "iana", + extensions: ["nnw"] + }, + "application/vnd.nokia.catalogs": { + source: "iana" + }, + "application/vnd.nokia.conml+wbxml": { + source: "iana" + }, + "application/vnd.nokia.conml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.iptv.config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.isds-radio-presets": { + source: "iana" + }, + "application/vnd.nokia.landmark+wbxml": { + source: "iana" + }, + "application/vnd.nokia.landmark+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.landmarkcollection+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.n-gage.ac+xml": { + source: "iana", + compressible: true, + extensions: ["ac"] + }, + "application/vnd.nokia.n-gage.data": { + source: "iana", + extensions: ["ngdat"] + }, + "application/vnd.nokia.n-gage.symbian.install": { + source: "apache", + extensions: ["n-gage"] + }, + "application/vnd.nokia.ncd": { + source: "iana" + }, + "application/vnd.nokia.pcd+wbxml": { + source: "iana" + }, + "application/vnd.nokia.pcd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.radio-preset": { + source: "iana", + extensions: ["rpst"] + }, + "application/vnd.nokia.radio-presets": { + source: "iana", + extensions: ["rpss"] + }, + "application/vnd.novadigm.edm": { + source: "iana", + extensions: ["edm"] + }, + "application/vnd.novadigm.edx": { + source: "iana", + extensions: ["edx"] + }, + "application/vnd.novadigm.ext": { + source: "iana", + extensions: ["ext"] + }, + "application/vnd.ntt-local.content-share": { + source: "iana" + }, + "application/vnd.ntt-local.file-transfer": { + source: "iana" + }, + "application/vnd.ntt-local.ogw_remote-access": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_remote": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_tcp_stream": { + source: "iana" + }, + "application/vnd.oai.workflows": { + source: "iana" + }, + "application/vnd.oai.workflows+json": { + source: "iana", + compressible: true + }, + "application/vnd.oai.workflows+yaml": { + source: "iana" + }, + "application/vnd.oasis.opendocument.base": { + source: "iana" + }, + "application/vnd.oasis.opendocument.chart": { + source: "iana", + extensions: ["odc"] + }, + "application/vnd.oasis.opendocument.chart-template": { + source: "iana", + extensions: ["otc"] + }, + "application/vnd.oasis.opendocument.database": { + source: "apache", + extensions: ["odb"] + }, + "application/vnd.oasis.opendocument.formula": { + source: "iana", + extensions: ["odf"] + }, + "application/vnd.oasis.opendocument.formula-template": { + source: "iana", + extensions: ["odft"] + }, + "application/vnd.oasis.opendocument.graphics": { + source: "iana", + compressible: false, + extensions: ["odg"] + }, + "application/vnd.oasis.opendocument.graphics-template": { + source: "iana", + extensions: ["otg"] + }, + "application/vnd.oasis.opendocument.image": { + source: "iana", + extensions: ["odi"] + }, + "application/vnd.oasis.opendocument.image-template": { + source: "iana", + extensions: ["oti"] + }, + "application/vnd.oasis.opendocument.presentation": { + source: "iana", + compressible: false, + extensions: ["odp"] + }, + "application/vnd.oasis.opendocument.presentation-template": { + source: "iana", + extensions: ["otp"] + }, + "application/vnd.oasis.opendocument.spreadsheet": { + source: "iana", + compressible: false, + extensions: ["ods"] + }, + "application/vnd.oasis.opendocument.spreadsheet-template": { + source: "iana", + extensions: ["ots"] + }, + "application/vnd.oasis.opendocument.text": { + source: "iana", + compressible: false, + extensions: ["odt"] + }, + "application/vnd.oasis.opendocument.text-master": { + source: "iana", + extensions: ["odm"] + }, + "application/vnd.oasis.opendocument.text-master-template": { + source: "iana" + }, + "application/vnd.oasis.opendocument.text-template": { + source: "iana", + extensions: ["ott"] + }, + "application/vnd.oasis.opendocument.text-web": { + source: "iana", + extensions: ["oth"] + }, + "application/vnd.obn": { + source: "iana" + }, + "application/vnd.ocf+cbor": { + source: "iana" + }, + "application/vnd.oci.image.manifest.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.oftn.l10n+json": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessdownload+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessstreaming+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.cspg-hexbinary": { + source: "iana" + }, + "application/vnd.oipf.dae.svg+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.dae.xhtml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.mippvcontrolmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.pae.gem": { + source: "iana" + }, + "application/vnd.oipf.spdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.spdlist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.ueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.userprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.olpc-sugar": { + source: "iana", + extensions: ["xo"] + }, + "application/vnd.oma-scws-config": { + source: "iana" + }, + "application/vnd.oma-scws-http-request": { + source: "iana" + }, + "application/vnd.oma-scws-http-response": { + source: "iana" + }, + "application/vnd.oma.bcast.associated-procedure-parameter+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.drm-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.imd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.ltkm": { + source: "iana" + }, + "application/vnd.oma.bcast.notification+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.provisioningtrigger": { + source: "iana" + }, + "application/vnd.oma.bcast.sgboot": { + source: "iana" + }, + "application/vnd.oma.bcast.sgdd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sgdu": { + source: "iana" + }, + "application/vnd.oma.bcast.simple-symbol-container": { + source: "iana" + }, + "application/vnd.oma.bcast.smartcard-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.sprov+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.stkm": { + source: "iana" + }, + "application/vnd.oma.cab-address-book+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-feature-handler+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-pcc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-subs-invite+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-user-prefs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.dcd": { + source: "iana" + }, + "application/vnd.oma.dcdc": { + source: "iana" + }, + "application/vnd.oma.dd2+xml": { + source: "iana", + compressible: true, + extensions: ["dd2"] + }, + "application/vnd.oma.drm.risd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.group-usage-list+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+cbor": { + source: "iana" + }, + "application/vnd.oma.lwm2m+json": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+tlv": { + source: "iana" + }, + "application/vnd.oma.pal+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.detailed-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.final-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.groups+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.invocation-descriptor+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.optimized-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.push": { + source: "iana" + }, + "application/vnd.oma.scidm.messages+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.xcap-directory+xml": { + source: "iana", + compressible: true + }, + "application/vnd.omads-email+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-file+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-folder+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omaloc-supl-init": { + source: "iana" + }, + "application/vnd.onepager": { + source: "iana" + }, + "application/vnd.onepagertamp": { + source: "iana" + }, + "application/vnd.onepagertamx": { + source: "iana" + }, + "application/vnd.onepagertat": { + source: "iana" + }, + "application/vnd.onepagertatp": { + source: "iana" + }, + "application/vnd.onepagertatx": { + source: "iana" + }, + "application/vnd.onvif.metadata": { + source: "iana" + }, + "application/vnd.openblox.game+xml": { + source: "iana", + compressible: true, + extensions: ["obgx"] + }, + "application/vnd.openblox.game-binary": { + source: "iana" + }, + "application/vnd.openeye.oeb": { + source: "iana" + }, + "application/vnd.openofficeorg.extension": { + source: "apache", + extensions: ["oxt"] + }, + "application/vnd.openstreetmap.data+xml": { + source: "iana", + compressible: true, + extensions: ["osm"] + }, + "application/vnd.opentimestamps.ots": { + source: "iana" + }, + "application/vnd.openvpi.dspx+json": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.custom-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawing+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.extended-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation": { + source: "iana", + compressible: false, + extensions: ["pptx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide": { + source: "iana", + extensions: ["sldx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { + source: "iana", + extensions: ["ppsx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.template": { + source: "iana", + extensions: ["potx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { + source: "iana", + compressible: false, + extensions: ["xlsx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { + source: "iana", + extensions: ["xltx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.theme+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.themeoverride+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.vmldrawing": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { + source: "iana", + compressible: false, + extensions: ["docx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { + source: "iana", + extensions: ["dotx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.core-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.relationships+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oracle.resource+json": { + source: "iana", + compressible: true + }, + "application/vnd.orange.indata": { + source: "iana" + }, + "application/vnd.osa.netdeploy": { + source: "iana" + }, + "application/vnd.osgeo.mapguide.package": { + source: "iana", + extensions: ["mgp"] + }, + "application/vnd.osgi.bundle": { + source: "iana" + }, + "application/vnd.osgi.dp": { + source: "iana", + extensions: ["dp"] + }, + "application/vnd.osgi.subsystem": { + source: "iana", + extensions: ["esa"] + }, + "application/vnd.otps.ct-kip+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oxli.countgraph": { + source: "iana" + }, + "application/vnd.pagerduty+json": { + source: "iana", + compressible: true + }, + "application/vnd.palm": { + source: "iana", + extensions: ["pdb", "pqa", "oprc"] + }, + "application/vnd.panoply": { + source: "iana" + }, + "application/vnd.paos.xml": { + source: "iana" + }, + "application/vnd.patentdive": { + source: "iana" + }, + "application/vnd.patientecommsdoc": { + source: "iana" + }, + "application/vnd.pawaafile": { + source: "iana", + extensions: ["paw"] + }, + "application/vnd.pcos": { + source: "iana" + }, + "application/vnd.pg.format": { + source: "iana", + extensions: ["str"] + }, + "application/vnd.pg.osasli": { + source: "iana", + extensions: ["ei6"] + }, + "application/vnd.piaccess.application-licence": { + source: "iana" + }, + "application/vnd.picsel": { + source: "iana", + extensions: ["efif"] + }, + "application/vnd.pmi.widget": { + source: "iana", + extensions: ["wg"] + }, + "application/vnd.poc.group-advertisement+xml": { + source: "iana", + compressible: true + }, + "application/vnd.pocketlearn": { + source: "iana", + extensions: ["plf"] + }, + "application/vnd.powerbuilder6": { + source: "iana", + extensions: ["pbd"] + }, + "application/vnd.powerbuilder6-s": { + source: "iana" + }, + "application/vnd.powerbuilder7": { + source: "iana" + }, + "application/vnd.powerbuilder7-s": { + source: "iana" + }, + "application/vnd.powerbuilder75": { + source: "iana" + }, + "application/vnd.powerbuilder75-s": { + source: "iana" + }, + "application/vnd.preminet": { + source: "iana" + }, + "application/vnd.previewsystems.box": { + source: "iana", + extensions: ["box"] + }, + "application/vnd.procrate.brushset": { + extensions: ["brushset"] + }, + "application/vnd.procreate.brush": { + extensions: ["brush"] + }, + "application/vnd.procreate.dream": { + extensions: ["drm"] + }, + "application/vnd.proteus.magazine": { + source: "iana", + extensions: ["mgz"] + }, + "application/vnd.psfs": { + source: "iana" + }, + "application/vnd.pt.mundusmundi": { + source: "iana" + }, + "application/vnd.publishare-delta-tree": { + source: "iana", + extensions: ["qps"] + }, + "application/vnd.pvi.ptid1": { + source: "iana", + extensions: ["ptid"] + }, + "application/vnd.pwg-multiplexed": { + source: "iana" + }, + "application/vnd.pwg-xhtml-print+xml": { + source: "iana", + compressible: true, + extensions: ["xhtm"] + }, + "application/vnd.qualcomm.brew-app-res": { + source: "iana" + }, + "application/vnd.quarantainenet": { + source: "iana" + }, + "application/vnd.quark.quarkxpress": { + source: "iana", + extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] + }, + "application/vnd.quobject-quoxdocument": { + source: "iana" + }, + "application/vnd.radisys.moml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-stream+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-base+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-detect+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-group+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-speech+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-transform+xml": { + source: "iana", + compressible: true + }, + "application/vnd.rainstor.data": { + source: "iana" + }, + "application/vnd.rapid": { + source: "iana" + }, + "application/vnd.rar": { + source: "iana", + extensions: ["rar"] + }, + "application/vnd.realvnc.bed": { + source: "iana", + extensions: ["bed"] + }, + "application/vnd.recordare.musicxml": { + source: "iana", + extensions: ["mxl"] + }, + "application/vnd.recordare.musicxml+xml": { + source: "iana", + compressible: true, + extensions: ["musicxml"] + }, + "application/vnd.relpipe": { + source: "iana" + }, + "application/vnd.renlearn.rlprint": { + source: "iana" + }, + "application/vnd.resilient.logic": { + source: "iana" + }, + "application/vnd.restful+json": { + source: "iana", + compressible: true + }, + "application/vnd.rig.cryptonote": { + source: "iana", + extensions: ["cryptonote"] + }, + "application/vnd.rim.cod": { + source: "apache", + extensions: ["cod"] + }, + "application/vnd.rn-realmedia": { + source: "apache", + extensions: ["rm"] + }, + "application/vnd.rn-realmedia-vbr": { + source: "apache", + extensions: ["rmvb"] + }, + "application/vnd.route66.link66+xml": { + source: "iana", + compressible: true, + extensions: ["link66"] + }, + "application/vnd.rs-274x": { + source: "iana" + }, + "application/vnd.ruckus.download": { + source: "iana" + }, + "application/vnd.s3sms": { + source: "iana" + }, + "application/vnd.sailingtracker.track": { + source: "iana", + extensions: ["st"] + }, + "application/vnd.sar": { + source: "iana" + }, + "application/vnd.sbm.cid": { + source: "iana" + }, + "application/vnd.sbm.mid2": { + source: "iana" + }, + "application/vnd.scribus": { + source: "iana" + }, + "application/vnd.sealed.3df": { + source: "iana" + }, + "application/vnd.sealed.csf": { + source: "iana" + }, + "application/vnd.sealed.doc": { + source: "iana" + }, + "application/vnd.sealed.eml": { + source: "iana" + }, + "application/vnd.sealed.mht": { + source: "iana" + }, + "application/vnd.sealed.net": { + source: "iana" + }, + "application/vnd.sealed.ppt": { + source: "iana" + }, + "application/vnd.sealed.tiff": { + source: "iana" + }, + "application/vnd.sealed.xls": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.html": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.pdf": { + source: "iana" + }, + "application/vnd.seemail": { + source: "iana", + extensions: ["see"] + }, + "application/vnd.seis+json": { + source: "iana", + compressible: true + }, + "application/vnd.sema": { + source: "iana", + extensions: ["sema"] + }, + "application/vnd.semd": { + source: "iana", + extensions: ["semd"] + }, + "application/vnd.semf": { + source: "iana", + extensions: ["semf"] + }, + "application/vnd.shade-save-file": { + source: "iana" + }, + "application/vnd.shana.informed.formdata": { + source: "iana", + extensions: ["ifm"] + }, + "application/vnd.shana.informed.formtemplate": { + source: "iana", + extensions: ["itp"] + }, + "application/vnd.shana.informed.interchange": { + source: "iana", + extensions: ["iif"] + }, + "application/vnd.shana.informed.package": { + source: "iana", + extensions: ["ipk"] + }, + "application/vnd.shootproof+json": { + source: "iana", + compressible: true + }, + "application/vnd.shopkick+json": { + source: "iana", + compressible: true + }, + "application/vnd.shp": { + source: "iana" + }, + "application/vnd.shx": { + source: "iana" + }, + "application/vnd.sigrok.session": { + source: "iana" + }, + "application/vnd.simtech-mindmapper": { + source: "iana", + extensions: ["twd", "twds"] + }, + "application/vnd.siren+json": { + source: "iana", + compressible: true + }, + "application/vnd.sketchometry": { + source: "iana" + }, + "application/vnd.smaf": { + source: "iana", + extensions: ["mmf"] + }, + "application/vnd.smart.notebook": { + source: "iana" + }, + "application/vnd.smart.teacher": { + source: "iana", + extensions: ["teacher"] + }, + "application/vnd.smintio.portals.archive": { + source: "iana" + }, + "application/vnd.snesdev-page-table": { + source: "iana" + }, + "application/vnd.software602.filler.form+xml": { + source: "iana", + compressible: true, + extensions: ["fo"] + }, + "application/vnd.software602.filler.form-xml-zip": { + source: "iana" + }, + "application/vnd.solent.sdkm+xml": { + source: "iana", + compressible: true, + extensions: ["sdkm", "sdkd"] + }, + "application/vnd.spotfire.dxp": { + source: "iana", + extensions: ["dxp"] + }, + "application/vnd.spotfire.sfs": { + source: "iana", + extensions: ["sfs"] + }, + "application/vnd.sqlite3": { + source: "iana" + }, + "application/vnd.sss-cod": { + source: "iana" + }, + "application/vnd.sss-dtf": { + source: "iana" + }, + "application/vnd.sss-ntf": { + source: "iana" + }, + "application/vnd.stardivision.calc": { + source: "apache", + extensions: ["sdc"] + }, + "application/vnd.stardivision.draw": { + source: "apache", + extensions: ["sda"] + }, + "application/vnd.stardivision.impress": { + source: "apache", + extensions: ["sdd"] + }, + "application/vnd.stardivision.math": { + source: "apache", + extensions: ["smf"] + }, + "application/vnd.stardivision.writer": { + source: "apache", + extensions: ["sdw", "vor"] + }, + "application/vnd.stardivision.writer-global": { + source: "apache", + extensions: ["sgl"] + }, + "application/vnd.stepmania.package": { + source: "iana", + extensions: ["smzip"] + }, + "application/vnd.stepmania.stepchart": { + source: "iana", + extensions: ["sm"] + }, + "application/vnd.street-stream": { + source: "iana" + }, + "application/vnd.sun.wadl+xml": { + source: "iana", + compressible: true, + extensions: ["wadl"] + }, + "application/vnd.sun.xml.calc": { + source: "apache", + extensions: ["sxc"] + }, + "application/vnd.sun.xml.calc.template": { + source: "apache", + extensions: ["stc"] + }, + "application/vnd.sun.xml.draw": { + source: "apache", + extensions: ["sxd"] + }, + "application/vnd.sun.xml.draw.template": { + source: "apache", + extensions: ["std"] + }, + "application/vnd.sun.xml.impress": { + source: "apache", + extensions: ["sxi"] + }, + "application/vnd.sun.xml.impress.template": { + source: "apache", + extensions: ["sti"] + }, + "application/vnd.sun.xml.math": { + source: "apache", + extensions: ["sxm"] + }, + "application/vnd.sun.xml.writer": { + source: "apache", + extensions: ["sxw"] + }, + "application/vnd.sun.xml.writer.global": { + source: "apache", + extensions: ["sxg"] + }, + "application/vnd.sun.xml.writer.template": { + source: "apache", + extensions: ["stw"] + }, + "application/vnd.sus-calendar": { + source: "iana", + extensions: ["sus", "susp"] + }, + "application/vnd.svd": { + source: "iana", + extensions: ["svd"] + }, + "application/vnd.swiftview-ics": { + source: "iana" + }, + "application/vnd.sybyl.mol2": { + source: "iana" + }, + "application/vnd.sycle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.syft+json": { + source: "iana", + compressible: true + }, + "application/vnd.symbian.install": { + source: "apache", + extensions: ["sis", "sisx"] + }, + "application/vnd.syncml+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xsm"] + }, + "application/vnd.syncml.dm+wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["bdm"] + }, + "application/vnd.syncml.dm+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xdm"] + }, + "application/vnd.syncml.dm.notification": { + source: "iana" + }, + "application/vnd.syncml.dmddf+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmddf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["ddf"] + }, + "application/vnd.syncml.dmtnds+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmtnds+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.syncml.ds.notification": { + source: "iana" + }, + "application/vnd.tableschema+json": { + source: "iana", + compressible: true + }, + "application/vnd.tao.intent-module-archive": { + source: "iana", + extensions: ["tao"] + }, + "application/vnd.tcpdump.pcap": { + source: "iana", + extensions: ["pcap", "cap", "dmp"] + }, + "application/vnd.think-cell.ppttc+json": { + source: "iana", + compressible: true + }, + "application/vnd.tmd.mediaflex.api+xml": { + source: "iana", + compressible: true + }, + "application/vnd.tml": { + source: "iana" + }, + "application/vnd.tmobile-livetv": { + source: "iana", + extensions: ["tmo"] + }, + "application/vnd.tri.onesource": { + source: "iana" + }, + "application/vnd.trid.tpt": { + source: "iana", + extensions: ["tpt"] + }, + "application/vnd.triscape.mxs": { + source: "iana", + extensions: ["mxs"] + }, + "application/vnd.trueapp": { + source: "iana", + extensions: ["tra"] + }, + "application/vnd.truedoc": { + source: "iana" + }, + "application/vnd.ubisoft.webplayer": { + source: "iana" + }, + "application/vnd.ufdl": { + source: "iana", + extensions: ["ufd", "ufdl"] + }, + "application/vnd.uic.osdm+json": { + source: "iana", + compressible: true + }, + "application/vnd.uiq.theme": { + source: "iana", + extensions: ["utz"] + }, + "application/vnd.umajin": { + source: "iana", + extensions: ["umj"] + }, + "application/vnd.unity": { + source: "iana", + extensions: ["unityweb"] + }, + "application/vnd.uoml+xml": { + source: "iana", + compressible: true, + extensions: ["uoml", "uo"] + }, + "application/vnd.uplanet.alert": { + source: "iana" + }, + "application/vnd.uplanet.alert-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.cacheop": { + source: "iana" + }, + "application/vnd.uplanet.cacheop-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.channel": { + source: "iana" + }, + "application/vnd.uplanet.channel-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.list": { + source: "iana" + }, + "application/vnd.uplanet.list-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.listcmd": { + source: "iana" + }, + "application/vnd.uplanet.listcmd-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.signal": { + source: "iana" + }, + "application/vnd.uri-map": { + source: "iana" + }, + "application/vnd.valve.source.material": { + source: "iana" + }, + "application/vnd.vcx": { + source: "iana", + extensions: ["vcx"] + }, + "application/vnd.vd-study": { + source: "iana" + }, + "application/vnd.vectorworks": { + source: "iana" + }, + "application/vnd.vel+json": { + source: "iana", + compressible: true + }, + "application/vnd.veraison.tsm-report+cbor": { + source: "iana" + }, + "application/vnd.veraison.tsm-report+json": { + source: "iana", + compressible: true + }, + "application/vnd.verimatrix.vcas": { + source: "iana" + }, + "application/vnd.veritone.aion+json": { + source: "iana", + compressible: true + }, + "application/vnd.veryant.thin": { + source: "iana" + }, + "application/vnd.ves.encrypted": { + source: "iana" + }, + "application/vnd.vidsoft.vidconference": { + source: "iana" + }, + "application/vnd.visio": { + source: "iana", + extensions: ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"] + }, + "application/vnd.visionary": { + source: "iana", + extensions: ["vis"] + }, + "application/vnd.vividence.scriptfile": { + source: "iana" + }, + "application/vnd.vocalshaper.vsp4": { + source: "iana" + }, + "application/vnd.vsf": { + source: "iana", + extensions: ["vsf"] + }, + "application/vnd.wap.sic": { + source: "iana" + }, + "application/vnd.wap.slc": { + source: "iana" + }, + "application/vnd.wap.wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["wbxml"] + }, + "application/vnd.wap.wmlc": { + source: "iana", + extensions: ["wmlc"] + }, + "application/vnd.wap.wmlscriptc": { + source: "iana", + extensions: ["wmlsc"] + }, + "application/vnd.wasmflow.wafl": { + source: "iana" + }, + "application/vnd.webturbo": { + source: "iana", + extensions: ["wtb"] + }, + "application/vnd.wfa.dpp": { + source: "iana" + }, + "application/vnd.wfa.p2p": { + source: "iana" + }, + "application/vnd.wfa.wsc": { + source: "iana" + }, + "application/vnd.windows.devicepairing": { + source: "iana" + }, + "application/vnd.wmc": { + source: "iana" + }, + "application/vnd.wmf.bootstrap": { + source: "iana" + }, + "application/vnd.wolfram.mathematica": { + source: "iana" + }, + "application/vnd.wolfram.mathematica.package": { + source: "iana" + }, + "application/vnd.wolfram.player": { + source: "iana", + extensions: ["nbp"] + }, + "application/vnd.wordlift": { + source: "iana" + }, + "application/vnd.wordperfect": { + source: "iana", + extensions: ["wpd"] + }, + "application/vnd.wqd": { + source: "iana", + extensions: ["wqd"] + }, + "application/vnd.wrq-hp3000-labelled": { + source: "iana" + }, + "application/vnd.wt.stf": { + source: "iana", + extensions: ["stf"] + }, + "application/vnd.wv.csp+wbxml": { + source: "iana" + }, + "application/vnd.wv.csp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.wv.ssp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xacml+json": { + source: "iana", + compressible: true + }, + "application/vnd.xara": { + source: "iana", + extensions: ["xar"] + }, + "application/vnd.xarin.cpj": { + source: "iana" + }, + "application/vnd.xecrets-encrypted": { + source: "iana" + }, + "application/vnd.xfdl": { + source: "iana", + extensions: ["xfdl"] + }, + "application/vnd.xfdl.webform": { + source: "iana" + }, + "application/vnd.xmi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xmpie.cpkg": { + source: "iana" + }, + "application/vnd.xmpie.dpkg": { + source: "iana" + }, + "application/vnd.xmpie.plan": { + source: "iana" + }, + "application/vnd.xmpie.ppkg": { + source: "iana" + }, + "application/vnd.xmpie.xlim": { + source: "iana" + }, + "application/vnd.yamaha.hv-dic": { + source: "iana", + extensions: ["hvd"] + }, + "application/vnd.yamaha.hv-script": { + source: "iana", + extensions: ["hvs"] + }, + "application/vnd.yamaha.hv-voice": { + source: "iana", + extensions: ["hvp"] + }, + "application/vnd.yamaha.openscoreformat": { + source: "iana", + extensions: ["osf"] + }, + "application/vnd.yamaha.openscoreformat.osfpvg+xml": { + source: "iana", + compressible: true, + extensions: ["osfpvg"] + }, + "application/vnd.yamaha.remote-setup": { + source: "iana" + }, + "application/vnd.yamaha.smaf-audio": { + source: "iana", + extensions: ["saf"] + }, + "application/vnd.yamaha.smaf-phrase": { + source: "iana", + extensions: ["spf"] + }, + "application/vnd.yamaha.through-ngn": { + source: "iana" + }, + "application/vnd.yamaha.tunnel-udpencap": { + source: "iana" + }, + "application/vnd.yaoweme": { + source: "iana" + }, + "application/vnd.yellowriver-custom-menu": { + source: "iana", + extensions: ["cmp"] + }, + "application/vnd.zul": { + source: "iana", + extensions: ["zir", "zirz"] + }, + "application/vnd.zzazz.deck+xml": { + source: "iana", + compressible: true, + extensions: ["zaz"] + }, + "application/voicexml+xml": { + source: "iana", + compressible: true, + extensions: ["vxml"] + }, + "application/voucher-cms+json": { + source: "iana", + compressible: true + }, + "application/voucher-jws+json": { + source: "iana", + compressible: true + }, + "application/vp": { + source: "iana" + }, + "application/vp+cose": { + source: "iana" + }, + "application/vp+jwt": { + source: "iana" + }, + "application/vq-rtcpxr": { + source: "iana" + }, + "application/wasm": { + source: "iana", + compressible: true, + extensions: ["wasm"] + }, + "application/watcherinfo+xml": { + source: "iana", + compressible: true, + extensions: ["wif"] + }, + "application/webpush-options+json": { + source: "iana", + compressible: true + }, + "application/whoispp-query": { + source: "iana" + }, + "application/whoispp-response": { + source: "iana" + }, + "application/widget": { + source: "iana", + extensions: ["wgt"] + }, + "application/winhlp": { + source: "apache", + extensions: ["hlp"] + }, + "application/wita": { + source: "iana" + }, + "application/wordperfect5.1": { + source: "iana" + }, + "application/wsdl+xml": { + source: "iana", + compressible: true, + extensions: ["wsdl"] + }, + "application/wspolicy+xml": { + source: "iana", + compressible: true, + extensions: ["wspolicy"] + }, + "application/x-7z-compressed": { + source: "apache", + compressible: false, + extensions: ["7z"] + }, + "application/x-abiword": { + source: "apache", + extensions: ["abw"] + }, + "application/x-ace-compressed": { + source: "apache", + extensions: ["ace"] + }, + "application/x-amf": { + source: "apache" + }, + "application/x-apple-diskimage": { + source: "apache", + extensions: ["dmg"] + }, + "application/x-arj": { + compressible: false, + extensions: ["arj"] + }, + "application/x-authorware-bin": { + source: "apache", + extensions: ["aab", "x32", "u32", "vox"] + }, + "application/x-authorware-map": { + source: "apache", + extensions: ["aam"] + }, + "application/x-authorware-seg": { + source: "apache", + extensions: ["aas"] + }, + "application/x-bcpio": { + source: "apache", + extensions: ["bcpio"] + }, + "application/x-bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/x-bittorrent": { + source: "apache", + extensions: ["torrent"] + }, + "application/x-blender": { + extensions: ["blend"] + }, + "application/x-blorb": { + source: "apache", + extensions: ["blb", "blorb"] + }, + "application/x-bzip": { + source: "apache", + compressible: false, + extensions: ["bz"] + }, + "application/x-bzip2": { + source: "apache", + compressible: false, + extensions: ["bz2", "boz"] + }, + "application/x-cbr": { + source: "apache", + extensions: ["cbr", "cba", "cbt", "cbz", "cb7"] + }, + "application/x-cdlink": { + source: "apache", + extensions: ["vcd"] + }, + "application/x-cfs-compressed": { + source: "apache", + extensions: ["cfs"] + }, + "application/x-chat": { + source: "apache", + extensions: ["chat"] + }, + "application/x-chess-pgn": { + source: "apache", + extensions: ["pgn"] + }, + "application/x-chrome-extension": { + extensions: ["crx"] + }, + "application/x-cocoa": { + source: "nginx", + extensions: ["cco"] + }, + "application/x-compress": { + source: "apache" + }, + "application/x-compressed": { + extensions: ["rar"] + }, + "application/x-conference": { + source: "apache", + extensions: ["nsc"] + }, + "application/x-cpio": { + source: "apache", + extensions: ["cpio"] + }, + "application/x-csh": { + source: "apache", + extensions: ["csh"] + }, + "application/x-deb": { + compressible: false + }, + "application/x-debian-package": { + source: "apache", + extensions: ["deb", "udeb"] + }, + "application/x-dgc-compressed": { + source: "apache", + extensions: ["dgc"] + }, + "application/x-director": { + source: "apache", + extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] + }, + "application/x-doom": { + source: "apache", + extensions: ["wad"] + }, + "application/x-dtbncx+xml": { + source: "apache", + compressible: true, + extensions: ["ncx"] + }, + "application/x-dtbook+xml": { + source: "apache", + compressible: true, + extensions: ["dtb"] + }, + "application/x-dtbresource+xml": { + source: "apache", + compressible: true, + extensions: ["res"] + }, + "application/x-dvi": { + source: "apache", + compressible: false, + extensions: ["dvi"] + }, + "application/x-envoy": { + source: "apache", + extensions: ["evy"] + }, + "application/x-eva": { + source: "apache", + extensions: ["eva"] + }, + "application/x-font-bdf": { + source: "apache", + extensions: ["bdf"] + }, + "application/x-font-dos": { + source: "apache" + }, + "application/x-font-framemaker": { + source: "apache" + }, + "application/x-font-ghostscript": { + source: "apache", + extensions: ["gsf"] + }, + "application/x-font-libgrx": { + source: "apache" + }, + "application/x-font-linux-psf": { + source: "apache", + extensions: ["psf"] + }, + "application/x-font-pcf": { + source: "apache", + extensions: ["pcf"] + }, + "application/x-font-snf": { + source: "apache", + extensions: ["snf"] + }, + "application/x-font-speedo": { + source: "apache" + }, + "application/x-font-sunos-news": { + source: "apache" + }, + "application/x-font-type1": { + source: "apache", + extensions: ["pfa", "pfb", "pfm", "afm"] + }, + "application/x-font-vfont": { + source: "apache" + }, + "application/x-freearc": { + source: "apache", + extensions: ["arc"] + }, + "application/x-futuresplash": { + source: "apache", + extensions: ["spl"] + }, + "application/x-gca-compressed": { + source: "apache", + extensions: ["gca"] + }, + "application/x-glulx": { + source: "apache", + extensions: ["ulx"] + }, + "application/x-gnumeric": { + source: "apache", + extensions: ["gnumeric"] + }, + "application/x-gramps-xml": { + source: "apache", + extensions: ["gramps"] + }, + "application/x-gtar": { + source: "apache", + extensions: ["gtar"] + }, + "application/x-gzip": { + source: "apache" + }, + "application/x-hdf": { + source: "apache", + extensions: ["hdf"] + }, + "application/x-httpd-php": { + compressible: true, + extensions: ["php"] + }, + "application/x-install-instructions": { + source: "apache", + extensions: ["install"] + }, + "application/x-ipynb+json": { + compressible: true, + extensions: ["ipynb"] + }, + "application/x-iso9660-image": { + source: "apache", + extensions: ["iso"] + }, + "application/x-iwork-keynote-sffkey": { + extensions: ["key"] + }, + "application/x-iwork-numbers-sffnumbers": { + extensions: ["numbers"] + }, + "application/x-iwork-pages-sffpages": { + extensions: ["pages"] + }, + "application/x-java-archive-diff": { + source: "nginx", + extensions: ["jardiff"] + }, + "application/x-java-jnlp-file": { + source: "apache", + compressible: false, + extensions: ["jnlp"] + }, + "application/x-javascript": { + compressible: true + }, + "application/x-keepass2": { + extensions: ["kdbx"] + }, + "application/x-latex": { + source: "apache", + compressible: false, + extensions: ["latex"] + }, + "application/x-lua-bytecode": { + extensions: ["luac"] + }, + "application/x-lzh-compressed": { + source: "apache", + extensions: ["lzh", "lha"] + }, + "application/x-makeself": { + source: "nginx", + extensions: ["run"] + }, + "application/x-mie": { + source: "apache", + extensions: ["mie"] + }, + "application/x-mobipocket-ebook": { + source: "apache", + extensions: ["prc", "mobi"] + }, + "application/x-mpegurl": { + compressible: false + }, + "application/x-ms-application": { + source: "apache", + extensions: ["application"] + }, + "application/x-ms-shortcut": { + source: "apache", + extensions: ["lnk"] + }, + "application/x-ms-wmd": { + source: "apache", + extensions: ["wmd"] + }, + "application/x-ms-wmz": { + source: "apache", + extensions: ["wmz"] + }, + "application/x-ms-xbap": { + source: "apache", + extensions: ["xbap"] + }, + "application/x-msaccess": { + source: "apache", + extensions: ["mdb"] + }, + "application/x-msbinder": { + source: "apache", + extensions: ["obd"] + }, + "application/x-mscardfile": { + source: "apache", + extensions: ["crd"] + }, + "application/x-msclip": { + source: "apache", + extensions: ["clp"] + }, + "application/x-msdos-program": { + extensions: ["exe"] + }, + "application/x-msdownload": { + source: "apache", + extensions: ["exe", "dll", "com", "bat", "msi"] + }, + "application/x-msmediaview": { + source: "apache", + extensions: ["mvb", "m13", "m14"] + }, + "application/x-msmetafile": { + source: "apache", + extensions: ["wmf", "wmz", "emf", "emz"] + }, + "application/x-msmoney": { + source: "apache", + extensions: ["mny"] + }, + "application/x-mspublisher": { + source: "apache", + extensions: ["pub"] + }, + "application/x-msschedule": { + source: "apache", + extensions: ["scd"] + }, + "application/x-msterminal": { + source: "apache", + extensions: ["trm"] + }, + "application/x-mswrite": { + source: "apache", + extensions: ["wri"] + }, + "application/x-netcdf": { + source: "apache", + extensions: ["nc", "cdf"] + }, + "application/x-ns-proxy-autoconfig": { + compressible: true, + extensions: ["pac"] + }, + "application/x-nzb": { + source: "apache", + extensions: ["nzb"] + }, + "application/x-perl": { + source: "nginx", + extensions: ["pl", "pm"] + }, + "application/x-pilot": { + source: "nginx", + extensions: ["prc", "pdb"] + }, + "application/x-pkcs12": { + source: "apache", + compressible: false, + extensions: ["p12", "pfx"] + }, + "application/x-pkcs7-certificates": { + source: "apache", + extensions: ["p7b", "spc"] + }, + "application/x-pkcs7-certreqresp": { + source: "apache", + extensions: ["p7r"] + }, + "application/x-pki-message": { + source: "iana" + }, + "application/x-rar-compressed": { + source: "apache", + compressible: false, + extensions: ["rar"] + }, + "application/x-redhat-package-manager": { + source: "nginx", + extensions: ["rpm"] + }, + "application/x-research-info-systems": { + source: "apache", + extensions: ["ris"] + }, + "application/x-sea": { + source: "nginx", + extensions: ["sea"] + }, + "application/x-sh": { + source: "apache", + compressible: true, + extensions: ["sh"] + }, + "application/x-shar": { + source: "apache", + extensions: ["shar"] + }, + "application/x-shockwave-flash": { + source: "apache", + compressible: false, + extensions: ["swf"] + }, + "application/x-silverlight-app": { + source: "apache", + extensions: ["xap"] + }, + "application/x-sql": { + source: "apache", + extensions: ["sql"] + }, + "application/x-stuffit": { + source: "apache", + compressible: false, + extensions: ["sit"] + }, + "application/x-stuffitx": { + source: "apache", + extensions: ["sitx"] + }, + "application/x-subrip": { + source: "apache", + extensions: ["srt"] + }, + "application/x-sv4cpio": { + source: "apache", + extensions: ["sv4cpio"] + }, + "application/x-sv4crc": { + source: "apache", + extensions: ["sv4crc"] + }, + "application/x-t3vm-image": { + source: "apache", + extensions: ["t3"] + }, + "application/x-tads": { + source: "apache", + extensions: ["gam"] + }, + "application/x-tar": { + source: "apache", + compressible: true, + extensions: ["tar"] + }, + "application/x-tcl": { + source: "apache", + extensions: ["tcl", "tk"] + }, + "application/x-tex": { + source: "apache", + extensions: ["tex"] + }, + "application/x-tex-tfm": { + source: "apache", + extensions: ["tfm"] + }, + "application/x-texinfo": { + source: "apache", + extensions: ["texinfo", "texi"] + }, + "application/x-tgif": { + source: "apache", + extensions: ["obj"] + }, + "application/x-ustar": { + source: "apache", + extensions: ["ustar"] + }, + "application/x-virtualbox-hdd": { + compressible: true, + extensions: ["hdd"] + }, + "application/x-virtualbox-ova": { + compressible: true, + extensions: ["ova"] + }, + "application/x-virtualbox-ovf": { + compressible: true, + extensions: ["ovf"] + }, + "application/x-virtualbox-vbox": { + compressible: true, + extensions: ["vbox"] + }, + "application/x-virtualbox-vbox-extpack": { + compressible: false, + extensions: ["vbox-extpack"] + }, + "application/x-virtualbox-vdi": { + compressible: true, + extensions: ["vdi"] + }, + "application/x-virtualbox-vhd": { + compressible: true, + extensions: ["vhd"] + }, + "application/x-virtualbox-vmdk": { + compressible: true, + extensions: ["vmdk"] + }, + "application/x-wais-source": { + source: "apache", + extensions: ["src"] + }, + "application/x-web-app-manifest+json": { + compressible: true, + extensions: ["webapp"] + }, + "application/x-www-form-urlencoded": { + source: "iana", + compressible: true + }, + "application/x-x509-ca-cert": { + source: "iana", + extensions: ["der", "crt", "pem"] + }, + "application/x-x509-ca-ra-cert": { + source: "iana" + }, + "application/x-x509-next-ca-cert": { + source: "iana" + }, + "application/x-xfig": { + source: "apache", + extensions: ["fig"] + }, + "application/x-xliff+xml": { + source: "apache", + compressible: true, + extensions: ["xlf"] + }, + "application/x-xpinstall": { + source: "apache", + compressible: false, + extensions: ["xpi"] + }, + "application/x-xz": { + source: "apache", + extensions: ["xz"] + }, + "application/x-zip-compressed": { + extensions: ["zip"] + }, + "application/x-zmachine": { + source: "apache", + extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] + }, + "application/x400-bp": { + source: "iana" + }, + "application/xacml+xml": { + source: "iana", + compressible: true + }, + "application/xaml+xml": { + source: "apache", + compressible: true, + extensions: ["xaml"] + }, + "application/xcap-att+xml": { + source: "iana", + compressible: true, + extensions: ["xav"] + }, + "application/xcap-caps+xml": { + source: "iana", + compressible: true, + extensions: ["xca"] + }, + "application/xcap-diff+xml": { + source: "iana", + compressible: true, + extensions: ["xdf"] + }, + "application/xcap-el+xml": { + source: "iana", + compressible: true, + extensions: ["xel"] + }, + "application/xcap-error+xml": { + source: "iana", + compressible: true + }, + "application/xcap-ns+xml": { + source: "iana", + compressible: true, + extensions: ["xns"] + }, + "application/xcon-conference-info+xml": { + source: "iana", + compressible: true + }, + "application/xcon-conference-info-diff+xml": { + source: "iana", + compressible: true + }, + "application/xenc+xml": { + source: "iana", + compressible: true, + extensions: ["xenc"] + }, + "application/xfdf": { + source: "iana", + extensions: ["xfdf"] + }, + "application/xhtml+xml": { + source: "iana", + compressible: true, + extensions: ["xhtml", "xht"] + }, + "application/xhtml-voice+xml": { + source: "apache", + compressible: true + }, + "application/xliff+xml": { + source: "iana", + compressible: true, + extensions: ["xlf"] + }, + "application/xml": { + source: "iana", + compressible: true, + extensions: ["xml", "xsl", "xsd", "rng"] + }, + "application/xml-dtd": { + source: "iana", + compressible: true, + extensions: ["dtd"] + }, + "application/xml-external-parsed-entity": { + source: "iana" + }, + "application/xml-patch+xml": { + source: "iana", + compressible: true + }, + "application/xmpp+xml": { + source: "iana", + compressible: true + }, + "application/xop+xml": { + source: "iana", + compressible: true, + extensions: ["xop"] + }, + "application/xproc+xml": { + source: "apache", + compressible: true, + extensions: ["xpl"] + }, + "application/xslt+xml": { + source: "iana", + compressible: true, + extensions: ["xsl", "xslt"] + }, + "application/xspf+xml": { + source: "apache", + compressible: true, + extensions: ["xspf"] + }, + "application/xv+xml": { + source: "iana", + compressible: true, + extensions: ["mxml", "xhvml", "xvml", "xvm"] + }, + "application/yaml": { + source: "iana" + }, + "application/yang": { + source: "iana", + extensions: ["yang"] + }, + "application/yang-data+cbor": { + source: "iana" + }, + "application/yang-data+json": { + source: "iana", + compressible: true + }, + "application/yang-data+xml": { + source: "iana", + compressible: true + }, + "application/yang-patch+json": { + source: "iana", + compressible: true + }, + "application/yang-patch+xml": { + source: "iana", + compressible: true + }, + "application/yang-sid+json": { + source: "iana", + compressible: true + }, + "application/yin+xml": { + source: "iana", + compressible: true, + extensions: ["yin"] + }, + "application/zip": { + source: "iana", + compressible: false, + extensions: ["zip"] + }, + "application/zip+dotlottie": { + extensions: ["lottie"] + }, + "application/zlib": { + source: "iana" + }, + "application/zstd": { + source: "iana" + }, + "audio/1d-interleaved-parityfec": { + source: "iana" + }, + "audio/32kadpcm": { + source: "iana" + }, + "audio/3gpp": { + source: "iana", + compressible: false, + extensions: ["3gpp"] + }, + "audio/3gpp2": { + source: "iana" + }, + "audio/aac": { + source: "iana", + extensions: ["adts", "aac"] + }, + "audio/ac3": { + source: "iana" + }, + "audio/adpcm": { + source: "apache", + extensions: ["adp"] + }, + "audio/amr": { + source: "iana", + extensions: ["amr"] + }, + "audio/amr-wb": { + source: "iana" + }, + "audio/amr-wb+": { + source: "iana" + }, + "audio/aptx": { + source: "iana" + }, + "audio/asc": { + source: "iana" + }, + "audio/atrac-advanced-lossless": { + source: "iana" + }, + "audio/atrac-x": { + source: "iana" + }, + "audio/atrac3": { + source: "iana" + }, + "audio/basic": { + source: "iana", + compressible: false, + extensions: ["au", "snd"] + }, + "audio/bv16": { + source: "iana" + }, + "audio/bv32": { + source: "iana" + }, + "audio/clearmode": { + source: "iana" + }, + "audio/cn": { + source: "iana" + }, + "audio/dat12": { + source: "iana" + }, + "audio/dls": { + source: "iana" + }, + "audio/dsr-es201108": { + source: "iana" + }, + "audio/dsr-es202050": { + source: "iana" + }, + "audio/dsr-es202211": { + source: "iana" + }, + "audio/dsr-es202212": { + source: "iana" + }, + "audio/dv": { + source: "iana" + }, + "audio/dvi4": { + source: "iana" + }, + "audio/eac3": { + source: "iana" + }, + "audio/encaprtp": { + source: "iana" + }, + "audio/evrc": { + source: "iana" + }, + "audio/evrc-qcp": { + source: "iana" + }, + "audio/evrc0": { + source: "iana" + }, + "audio/evrc1": { + source: "iana" + }, + "audio/evrcb": { + source: "iana" + }, + "audio/evrcb0": { + source: "iana" + }, + "audio/evrcb1": { + source: "iana" + }, + "audio/evrcnw": { + source: "iana" + }, + "audio/evrcnw0": { + source: "iana" + }, + "audio/evrcnw1": { + source: "iana" + }, + "audio/evrcwb": { + source: "iana" + }, + "audio/evrcwb0": { + source: "iana" + }, + "audio/evrcwb1": { + source: "iana" + }, + "audio/evs": { + source: "iana" + }, + "audio/flac": { + source: "iana" + }, + "audio/flexfec": { + source: "iana" + }, + "audio/fwdred": { + source: "iana" + }, + "audio/g711-0": { + source: "iana" + }, + "audio/g719": { + source: "iana" + }, + "audio/g722": { + source: "iana" + }, + "audio/g7221": { + source: "iana" + }, + "audio/g723": { + source: "iana" + }, + "audio/g726-16": { + source: "iana" + }, + "audio/g726-24": { + source: "iana" + }, + "audio/g726-32": { + source: "iana" + }, + "audio/g726-40": { + source: "iana" + }, + "audio/g728": { + source: "iana" + }, + "audio/g729": { + source: "iana" + }, + "audio/g7291": { + source: "iana" + }, + "audio/g729d": { + source: "iana" + }, + "audio/g729e": { + source: "iana" + }, + "audio/gsm": { + source: "iana" + }, + "audio/gsm-efr": { + source: "iana" + }, + "audio/gsm-hr-08": { + source: "iana" + }, + "audio/ilbc": { + source: "iana" + }, + "audio/ip-mr_v2.5": { + source: "iana" + }, + "audio/isac": { + source: "apache" + }, + "audio/l16": { + source: "iana" + }, + "audio/l20": { + source: "iana" + }, + "audio/l24": { + source: "iana", + compressible: false + }, + "audio/l8": { + source: "iana" + }, + "audio/lpc": { + source: "iana" + }, + "audio/matroska": { + source: "iana" + }, + "audio/melp": { + source: "iana" + }, + "audio/melp1200": { + source: "iana" + }, + "audio/melp2400": { + source: "iana" + }, + "audio/melp600": { + source: "iana" + }, + "audio/mhas": { + source: "iana" + }, + "audio/midi": { + source: "apache", + extensions: ["mid", "midi", "kar", "rmi"] + }, + "audio/midi-clip": { + source: "iana" + }, + "audio/mobile-xmf": { + source: "iana", + extensions: ["mxmf"] + }, + "audio/mp3": { + compressible: false, + extensions: ["mp3"] + }, + "audio/mp4": { + source: "iana", + compressible: false, + extensions: ["m4a", "mp4a", "m4b"] + }, + "audio/mp4a-latm": { + source: "iana" + }, + "audio/mpa": { + source: "iana" + }, + "audio/mpa-robust": { + source: "iana" + }, + "audio/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] + }, + "audio/mpeg4-generic": { + source: "iana" + }, + "audio/musepack": { + source: "apache" + }, + "audio/ogg": { + source: "iana", + compressible: false, + extensions: ["oga", "ogg", "spx", "opus"] + }, + "audio/opus": { + source: "iana" + }, + "audio/parityfec": { + source: "iana" + }, + "audio/pcma": { + source: "iana" + }, + "audio/pcma-wb": { + source: "iana" + }, + "audio/pcmu": { + source: "iana" + }, + "audio/pcmu-wb": { + source: "iana" + }, + "audio/prs.sid": { + source: "iana" + }, + "audio/qcelp": { + source: "iana" + }, + "audio/raptorfec": { + source: "iana" + }, + "audio/red": { + source: "iana" + }, + "audio/rtp-enc-aescm128": { + source: "iana" + }, + "audio/rtp-midi": { + source: "iana" + }, + "audio/rtploopback": { + source: "iana" + }, + "audio/rtx": { + source: "iana" + }, + "audio/s3m": { + source: "apache", + extensions: ["s3m"] + }, + "audio/scip": { + source: "iana" + }, + "audio/silk": { + source: "apache", + extensions: ["sil"] + }, + "audio/smv": { + source: "iana" + }, + "audio/smv-qcp": { + source: "iana" + }, + "audio/smv0": { + source: "iana" + }, + "audio/sofa": { + source: "iana" + }, + "audio/sp-midi": { + source: "iana" + }, + "audio/speex": { + source: "iana" + }, + "audio/t140c": { + source: "iana" + }, + "audio/t38": { + source: "iana" + }, + "audio/telephone-event": { + source: "iana" + }, + "audio/tetra_acelp": { + source: "iana" + }, + "audio/tetra_acelp_bb": { + source: "iana" + }, + "audio/tone": { + source: "iana" + }, + "audio/tsvcis": { + source: "iana" + }, + "audio/uemclip": { + source: "iana" + }, + "audio/ulpfec": { + source: "iana" + }, + "audio/usac": { + source: "iana" + }, + "audio/vdvi": { + source: "iana" + }, + "audio/vmr-wb": { + source: "iana" + }, + "audio/vnd.3gpp.iufp": { + source: "iana" + }, + "audio/vnd.4sb": { + source: "iana" + }, + "audio/vnd.audiokoz": { + source: "iana" + }, + "audio/vnd.celp": { + source: "iana" + }, + "audio/vnd.cisco.nse": { + source: "iana" + }, + "audio/vnd.cmles.radio-events": { + source: "iana" + }, + "audio/vnd.cns.anp1": { + source: "iana" + }, + "audio/vnd.cns.inf1": { + source: "iana" + }, + "audio/vnd.dece.audio": { + source: "iana", + extensions: ["uva", "uvva"] + }, + "audio/vnd.digital-winds": { + source: "iana", + extensions: ["eol"] + }, + "audio/vnd.dlna.adts": { + source: "iana" + }, + "audio/vnd.dolby.heaac.1": { + source: "iana" + }, + "audio/vnd.dolby.heaac.2": { + source: "iana" + }, + "audio/vnd.dolby.mlp": { + source: "iana" + }, + "audio/vnd.dolby.mps": { + source: "iana" + }, + "audio/vnd.dolby.pl2": { + source: "iana" + }, + "audio/vnd.dolby.pl2x": { + source: "iana" + }, + "audio/vnd.dolby.pl2z": { + source: "iana" + }, + "audio/vnd.dolby.pulse.1": { + source: "iana" + }, + "audio/vnd.dra": { + source: "iana", + extensions: ["dra"] + }, + "audio/vnd.dts": { + source: "iana", + extensions: ["dts"] + }, + "audio/vnd.dts.hd": { + source: "iana", + extensions: ["dtshd"] + }, + "audio/vnd.dts.uhd": { + source: "iana" + }, + "audio/vnd.dvb.file": { + source: "iana" + }, + "audio/vnd.everad.plj": { + source: "iana" + }, + "audio/vnd.hns.audio": { + source: "iana" + }, + "audio/vnd.lucent.voice": { + source: "iana", + extensions: ["lvp"] + }, + "audio/vnd.ms-playready.media.pya": { + source: "iana", + extensions: ["pya"] + }, + "audio/vnd.nokia.mobile-xmf": { + source: "iana" + }, + "audio/vnd.nortel.vbk": { + source: "iana" + }, + "audio/vnd.nuera.ecelp4800": { + source: "iana", + extensions: ["ecelp4800"] + }, + "audio/vnd.nuera.ecelp7470": { + source: "iana", + extensions: ["ecelp7470"] + }, + "audio/vnd.nuera.ecelp9600": { + source: "iana", + extensions: ["ecelp9600"] + }, + "audio/vnd.octel.sbc": { + source: "iana" + }, + "audio/vnd.presonus.multitrack": { + source: "iana" + }, + "audio/vnd.qcelp": { + source: "apache" + }, + "audio/vnd.rhetorex.32kadpcm": { + source: "iana" + }, + "audio/vnd.rip": { + source: "iana", + extensions: ["rip"] + }, + "audio/vnd.rn-realaudio": { + compressible: false + }, + "audio/vnd.sealedmedia.softseal.mpeg": { + source: "iana" + }, + "audio/vnd.vmx.cvsd": { + source: "iana" + }, + "audio/vnd.wave": { + compressible: false + }, + "audio/vorbis": { + source: "iana", + compressible: false + }, + "audio/vorbis-config": { + source: "iana" + }, + "audio/wav": { + compressible: false, + extensions: ["wav"] + }, + "audio/wave": { + compressible: false, + extensions: ["wav"] + }, + "audio/webm": { + source: "apache", + compressible: false, + extensions: ["weba"] + }, + "audio/x-aac": { + source: "apache", + compressible: false, + extensions: ["aac"] + }, + "audio/x-aiff": { + source: "apache", + extensions: ["aif", "aiff", "aifc"] + }, + "audio/x-caf": { + source: "apache", + compressible: false, + extensions: ["caf"] + }, + "audio/x-flac": { + source: "apache", + extensions: ["flac"] + }, + "audio/x-m4a": { + source: "nginx", + extensions: ["m4a"] + }, + "audio/x-matroska": { + source: "apache", + extensions: ["mka"] + }, + "audio/x-mpegurl": { + source: "apache", + extensions: ["m3u"] + }, + "audio/x-ms-wax": { + source: "apache", + extensions: ["wax"] + }, + "audio/x-ms-wma": { + source: "apache", + extensions: ["wma"] + }, + "audio/x-pn-realaudio": { + source: "apache", + extensions: ["ram", "ra"] + }, + "audio/x-pn-realaudio-plugin": { + source: "apache", + extensions: ["rmp"] + }, + "audio/x-realaudio": { + source: "nginx", + extensions: ["ra"] + }, + "audio/x-tta": { + source: "apache" + }, + "audio/x-wav": { + source: "apache", + extensions: ["wav"] + }, + "audio/xm": { + source: "apache", + extensions: ["xm"] + }, + "chemical/x-cdx": { + source: "apache", + extensions: ["cdx"] + }, + "chemical/x-cif": { + source: "apache", + extensions: ["cif"] + }, + "chemical/x-cmdf": { + source: "apache", + extensions: ["cmdf"] + }, + "chemical/x-cml": { + source: "apache", + extensions: ["cml"] + }, + "chemical/x-csml": { + source: "apache", + extensions: ["csml"] + }, + "chemical/x-pdb": { + source: "apache" + }, + "chemical/x-xyz": { + source: "apache", + extensions: ["xyz"] + }, + "font/collection": { + source: "iana", + extensions: ["ttc"] + }, + "font/otf": { + source: "iana", + compressible: true, + extensions: ["otf"] + }, + "font/sfnt": { + source: "iana" + }, + "font/ttf": { + source: "iana", + compressible: true, + extensions: ["ttf"] + }, + "font/woff": { + source: "iana", + extensions: ["woff"] + }, + "font/woff2": { + source: "iana", + extensions: ["woff2"] + }, + "image/aces": { + source: "iana", + extensions: ["exr"] + }, + "image/apng": { + source: "iana", + compressible: false, + extensions: ["apng"] + }, + "image/avci": { + source: "iana", + extensions: ["avci"] + }, + "image/avcs": { + source: "iana", + extensions: ["avcs"] + }, + "image/avif": { + source: "iana", + compressible: false, + extensions: ["avif"] + }, + "image/bmp": { + source: "iana", + compressible: true, + extensions: ["bmp", "dib"] + }, + "image/cgm": { + source: "iana", + extensions: ["cgm"] + }, + "image/dicom-rle": { + source: "iana", + extensions: ["drle"] + }, + "image/dpx": { + source: "iana", + extensions: ["dpx"] + }, + "image/emf": { + source: "iana", + extensions: ["emf"] + }, + "image/fits": { + source: "iana", + extensions: ["fits"] + }, + "image/g3fax": { + source: "iana", + extensions: ["g3"] + }, + "image/gif": { + source: "iana", + compressible: false, + extensions: ["gif"] + }, + "image/heic": { + source: "iana", + extensions: ["heic"] + }, + "image/heic-sequence": { + source: "iana", + extensions: ["heics"] + }, + "image/heif": { + source: "iana", + extensions: ["heif"] + }, + "image/heif-sequence": { + source: "iana", + extensions: ["heifs"] + }, + "image/hej2k": { + source: "iana", + extensions: ["hej2"] + }, + "image/ief": { + source: "iana", + extensions: ["ief"] + }, + "image/j2c": { + source: "iana" + }, + "image/jaii": { + source: "iana", + extensions: ["jaii"] + }, + "image/jais": { + source: "iana", + extensions: ["jais"] + }, + "image/jls": { + source: "iana", + extensions: ["jls"] + }, + "image/jp2": { + source: "iana", + compressible: false, + extensions: ["jp2", "jpg2"] + }, + "image/jpeg": { + source: "iana", + compressible: false, + extensions: ["jpg", "jpeg", "jpe"] + }, + "image/jph": { + source: "iana", + extensions: ["jph"] + }, + "image/jphc": { + source: "iana", + extensions: ["jhc"] + }, + "image/jpm": { + source: "iana", + compressible: false, + extensions: ["jpm", "jpgm"] + }, + "image/jpx": { + source: "iana", + compressible: false, + extensions: ["jpx", "jpf"] + }, + "image/jxl": { + source: "iana", + extensions: ["jxl"] + }, + "image/jxr": { + source: "iana", + extensions: ["jxr"] + }, + "image/jxra": { + source: "iana", + extensions: ["jxra"] + }, + "image/jxrs": { + source: "iana", + extensions: ["jxrs"] + }, + "image/jxs": { + source: "iana", + extensions: ["jxs"] + }, + "image/jxsc": { + source: "iana", + extensions: ["jxsc"] + }, + "image/jxsi": { + source: "iana", + extensions: ["jxsi"] + }, + "image/jxss": { + source: "iana", + extensions: ["jxss"] + }, + "image/ktx": { + source: "iana", + extensions: ["ktx"] + }, + "image/ktx2": { + source: "iana", + extensions: ["ktx2"] + }, + "image/naplps": { + source: "iana" + }, + "image/pjpeg": { + compressible: false, + extensions: ["jfif"] + }, + "image/png": { + source: "iana", + compressible: false, + extensions: ["png"] + }, + "image/prs.btif": { + source: "iana", + extensions: ["btif", "btf"] + }, + "image/prs.pti": { + source: "iana", + extensions: ["pti"] + }, + "image/pwg-raster": { + source: "iana" + }, + "image/sgi": { + source: "apache", + extensions: ["sgi"] + }, + "image/svg+xml": { + source: "iana", + compressible: true, + extensions: ["svg", "svgz"] + }, + "image/t38": { + source: "iana", + extensions: ["t38"] + }, + "image/tiff": { + source: "iana", + compressible: false, + extensions: ["tif", "tiff"] + }, + "image/tiff-fx": { + source: "iana", + extensions: ["tfx"] + }, + "image/vnd.adobe.photoshop": { + source: "iana", + compressible: true, + extensions: ["psd"] + }, + "image/vnd.airzip.accelerator.azv": { + source: "iana", + extensions: ["azv"] + }, + "image/vnd.clip": { + source: "iana" + }, + "image/vnd.cns.inf2": { + source: "iana" + }, + "image/vnd.dece.graphic": { + source: "iana", + extensions: ["uvi", "uvvi", "uvg", "uvvg"] + }, + "image/vnd.djvu": { + source: "iana", + extensions: ["djvu", "djv"] + }, + "image/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "image/vnd.dwg": { + source: "iana", + extensions: ["dwg"] + }, + "image/vnd.dxf": { + source: "iana", + extensions: ["dxf"] + }, + "image/vnd.fastbidsheet": { + source: "iana", + extensions: ["fbs"] + }, + "image/vnd.fpx": { + source: "iana", + extensions: ["fpx"] + }, + "image/vnd.fst": { + source: "iana", + extensions: ["fst"] + }, + "image/vnd.fujixerox.edmics-mmr": { + source: "iana", + extensions: ["mmr"] + }, + "image/vnd.fujixerox.edmics-rlc": { + source: "iana", + extensions: ["rlc"] + }, + "image/vnd.globalgraphics.pgb": { + source: "iana" + }, + "image/vnd.microsoft.icon": { + source: "iana", + compressible: true, + extensions: ["ico"] + }, + "image/vnd.mix": { + source: "iana" + }, + "image/vnd.mozilla.apng": { + source: "iana" + }, + "image/vnd.ms-dds": { + compressible: true, + extensions: ["dds"] + }, + "image/vnd.ms-modi": { + source: "iana", + extensions: ["mdi"] + }, + "image/vnd.ms-photo": { + source: "apache", + extensions: ["wdp"] + }, + "image/vnd.net-fpx": { + source: "iana", + extensions: ["npx"] + }, + "image/vnd.pco.b16": { + source: "iana", + extensions: ["b16"] + }, + "image/vnd.radiance": { + source: "iana" + }, + "image/vnd.sealed.png": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.gif": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.jpg": { + source: "iana" + }, + "image/vnd.svf": { + source: "iana" + }, + "image/vnd.tencent.tap": { + source: "iana", + extensions: ["tap"] + }, + "image/vnd.valve.source.texture": { + source: "iana", + extensions: ["vtf"] + }, + "image/vnd.wap.wbmp": { + source: "iana", + extensions: ["wbmp"] + }, + "image/vnd.xiff": { + source: "iana", + extensions: ["xif"] + }, + "image/vnd.zbrush.pcx": { + source: "iana", + extensions: ["pcx"] + }, + "image/webp": { + source: "iana", + extensions: ["webp"] + }, + "image/wmf": { + source: "iana", + extensions: ["wmf"] + }, + "image/x-3ds": { + source: "apache", + extensions: ["3ds"] + }, + "image/x-adobe-dng": { + extensions: ["dng"] + }, + "image/x-cmu-raster": { + source: "apache", + extensions: ["ras"] + }, + "image/x-cmx": { + source: "apache", + extensions: ["cmx"] + }, + "image/x-emf": { + source: "iana" + }, + "image/x-freehand": { + source: "apache", + extensions: ["fh", "fhc", "fh4", "fh5", "fh7"] + }, + "image/x-icon": { + source: "apache", + compressible: true, + extensions: ["ico"] + }, + "image/x-jng": { + source: "nginx", + extensions: ["jng"] + }, + "image/x-mrsid-image": { + source: "apache", + extensions: ["sid"] + }, + "image/x-ms-bmp": { + source: "nginx", + compressible: true, + extensions: ["bmp"] + }, + "image/x-pcx": { + source: "apache", + extensions: ["pcx"] + }, + "image/x-pict": { + source: "apache", + extensions: ["pic", "pct"] + }, + "image/x-portable-anymap": { + source: "apache", + extensions: ["pnm"] + }, + "image/x-portable-bitmap": { + source: "apache", + extensions: ["pbm"] + }, + "image/x-portable-graymap": { + source: "apache", + extensions: ["pgm"] + }, + "image/x-portable-pixmap": { + source: "apache", + extensions: ["ppm"] + }, + "image/x-rgb": { + source: "apache", + extensions: ["rgb"] + }, + "image/x-tga": { + source: "apache", + extensions: ["tga"] + }, + "image/x-wmf": { + source: "iana" + }, + "image/x-xbitmap": { + source: "apache", + extensions: ["xbm"] + }, + "image/x-xcf": { + compressible: false + }, + "image/x-xpixmap": { + source: "apache", + extensions: ["xpm"] + }, + "image/x-xwindowdump": { + source: "apache", + extensions: ["xwd"] + }, + "message/bhttp": { + source: "iana" + }, + "message/cpim": { + source: "iana" + }, + "message/delivery-status": { + source: "iana" + }, + "message/disposition-notification": { + source: "iana", + extensions: [ + "disposition-notification" + ] + }, + "message/external-body": { + source: "iana" + }, + "message/feedback-report": { + source: "iana" + }, + "message/global": { + source: "iana", + extensions: ["u8msg"] + }, + "message/global-delivery-status": { + source: "iana", + extensions: ["u8dsn"] + }, + "message/global-disposition-notification": { + source: "iana", + extensions: ["u8mdn"] + }, + "message/global-headers": { + source: "iana", + extensions: ["u8hdr"] + }, + "message/http": { + source: "iana", + compressible: false + }, + "message/imdn+xml": { + source: "iana", + compressible: true + }, + "message/mls": { + source: "iana" + }, + "message/news": { + source: "apache" + }, + "message/ohttp-req": { + source: "iana" + }, + "message/ohttp-res": { + source: "iana" + }, + "message/partial": { + source: "iana", + compressible: false + }, + "message/rfc822": { + source: "iana", + compressible: true, + extensions: ["eml", "mime", "mht", "mhtml"] + }, + "message/s-http": { + source: "apache" + }, + "message/sip": { + source: "iana" + }, + "message/sipfrag": { + source: "iana" + }, + "message/tracking-status": { + source: "iana" + }, + "message/vnd.si.simp": { + source: "apache" + }, + "message/vnd.wfa.wsc": { + source: "iana", + extensions: ["wsc"] + }, + "model/3mf": { + source: "iana", + extensions: ["3mf"] + }, + "model/e57": { + source: "iana" + }, + "model/gltf+json": { + source: "iana", + compressible: true, + extensions: ["gltf"] + }, + "model/gltf-binary": { + source: "iana", + compressible: true, + extensions: ["glb"] + }, + "model/iges": { + source: "iana", + compressible: false, + extensions: ["igs", "iges"] + }, + "model/jt": { + source: "iana", + extensions: ["jt"] + }, + "model/mesh": { + source: "iana", + compressible: false, + extensions: ["msh", "mesh", "silo"] + }, + "model/mtl": { + source: "iana", + extensions: ["mtl"] + }, + "model/obj": { + source: "iana", + extensions: ["obj"] + }, + "model/prc": { + source: "iana", + extensions: ["prc"] + }, + "model/step": { + source: "iana", + extensions: ["step", "stp", "stpnc", "p21", "210"] + }, + "model/step+xml": { + source: "iana", + compressible: true, + extensions: ["stpx"] + }, + "model/step+zip": { + source: "iana", + compressible: false, + extensions: ["stpz"] + }, + "model/step-xml+zip": { + source: "iana", + compressible: false, + extensions: ["stpxz"] + }, + "model/stl": { + source: "iana", + extensions: ["stl"] + }, + "model/u3d": { + source: "iana", + extensions: ["u3d"] + }, + "model/vnd.bary": { + source: "iana", + extensions: ["bary"] + }, + "model/vnd.cld": { + source: "iana", + extensions: ["cld"] + }, + "model/vnd.collada+xml": { + source: "iana", + compressible: true, + extensions: ["dae"] + }, + "model/vnd.dwf": { + source: "iana", + extensions: ["dwf"] + }, + "model/vnd.flatland.3dml": { + source: "iana" + }, + "model/vnd.gdl": { + source: "iana", + extensions: ["gdl"] + }, + "model/vnd.gs-gdl": { + source: "apache" + }, + "model/vnd.gs.gdl": { + source: "iana" + }, + "model/vnd.gtw": { + source: "iana", + extensions: ["gtw"] + }, + "model/vnd.moml+xml": { + source: "iana", + compressible: true + }, + "model/vnd.mts": { + source: "iana", + extensions: ["mts"] + }, + "model/vnd.opengex": { + source: "iana", + extensions: ["ogex"] + }, + "model/vnd.parasolid.transmit.binary": { + source: "iana", + extensions: ["x_b"] + }, + "model/vnd.parasolid.transmit.text": { + source: "iana", + extensions: ["x_t"] + }, + "model/vnd.pytha.pyox": { + source: "iana", + extensions: ["pyo", "pyox"] + }, + "model/vnd.rosette.annotated-data-model": { + source: "iana" + }, + "model/vnd.sap.vds": { + source: "iana", + extensions: ["vds"] + }, + "model/vnd.usda": { + source: "iana", + extensions: ["usda"] + }, + "model/vnd.usdz+zip": { + source: "iana", + compressible: false, + extensions: ["usdz"] + }, + "model/vnd.valve.source.compiled-map": { + source: "iana", + extensions: ["bsp"] + }, + "model/vnd.vtu": { + source: "iana", + extensions: ["vtu"] + }, + "model/vrml": { + source: "iana", + compressible: false, + extensions: ["wrl", "vrml"] + }, + "model/x3d+binary": { + source: "apache", + compressible: false, + extensions: ["x3db", "x3dbz"] + }, + "model/x3d+fastinfoset": { + source: "iana", + extensions: ["x3db"] + }, + "model/x3d+vrml": { + source: "apache", + compressible: false, + extensions: ["x3dv", "x3dvz"] + }, + "model/x3d+xml": { + source: "iana", + compressible: true, + extensions: ["x3d", "x3dz"] + }, + "model/x3d-vrml": { + source: "iana", + extensions: ["x3dv"] + }, + "multipart/alternative": { + source: "iana", + compressible: false + }, + "multipart/appledouble": { + source: "iana" + }, + "multipart/byteranges": { + source: "iana" + }, + "multipart/digest": { + source: "iana" + }, + "multipart/encrypted": { + source: "iana", + compressible: false + }, + "multipart/form-data": { + source: "iana", + compressible: false + }, + "multipart/header-set": { + source: "iana" + }, + "multipart/mixed": { + source: "iana" + }, + "multipart/multilingual": { + source: "iana" + }, + "multipart/parallel": { + source: "iana" + }, + "multipart/related": { + source: "iana", + compressible: false + }, + "multipart/report": { + source: "iana" + }, + "multipart/signed": { + source: "iana", + compressible: false + }, + "multipart/vnd.bint.med-plus": { + source: "iana" + }, + "multipart/voice-message": { + source: "iana" + }, + "multipart/x-mixed-replace": { + source: "iana" + }, + "text/1d-interleaved-parityfec": { + source: "iana" + }, + "text/cache-manifest": { + source: "iana", + compressible: true, + extensions: ["appcache", "manifest"] + }, + "text/calendar": { + source: "iana", + extensions: ["ics", "ifb"] + }, + "text/calender": { + compressible: true + }, + "text/cmd": { + compressible: true + }, + "text/coffeescript": { + extensions: ["coffee", "litcoffee"] + }, + "text/cql": { + source: "iana" + }, + "text/cql-expression": { + source: "iana" + }, + "text/cql-identifier": { + source: "iana" + }, + "text/css": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["css"] + }, + "text/csv": { + source: "iana", + compressible: true, + extensions: ["csv"] + }, + "text/csv-schema": { + source: "iana" + }, + "text/directory": { + source: "iana" + }, + "text/dns": { + source: "iana" + }, + "text/ecmascript": { + source: "apache" + }, + "text/encaprtp": { + source: "iana" + }, + "text/enriched": { + source: "iana" + }, + "text/fhirpath": { + source: "iana" + }, + "text/flexfec": { + source: "iana" + }, + "text/fwdred": { + source: "iana" + }, + "text/gff3": { + source: "iana" + }, + "text/grammar-ref-list": { + source: "iana" + }, + "text/hl7v2": { + source: "iana" + }, + "text/html": { + source: "iana", + compressible: true, + extensions: ["html", "htm", "shtml"] + }, + "text/jade": { + extensions: ["jade"] + }, + "text/javascript": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["js", "mjs"] + }, + "text/jcr-cnd": { + source: "iana" + }, + "text/jsx": { + compressible: true, + extensions: ["jsx"] + }, + "text/less": { + compressible: true, + extensions: ["less"] + }, + "text/markdown": { + source: "iana", + compressible: true, + extensions: ["md", "markdown"] + }, + "text/mathml": { + source: "nginx", + extensions: ["mml"] + }, + "text/mdx": { + compressible: true, + extensions: ["mdx"] + }, + "text/mizar": { + source: "iana" + }, + "text/n3": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["n3"] + }, + "text/parameters": { + source: "iana", + charset: "UTF-8" + }, + "text/parityfec": { + source: "iana" + }, + "text/plain": { + source: "iana", + compressible: true, + extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"] + }, + "text/provenance-notation": { + source: "iana", + charset: "UTF-8" + }, + "text/prs.fallenstein.rst": { + source: "iana" + }, + "text/prs.lines.tag": { + source: "iana", + extensions: ["dsc"] + }, + "text/prs.prop.logic": { + source: "iana" + }, + "text/prs.texi": { + source: "iana" + }, + "text/raptorfec": { + source: "iana" + }, + "text/red": { + source: "iana" + }, + "text/rfc822-headers": { + source: "iana" + }, + "text/richtext": { + source: "iana", + compressible: true, + extensions: ["rtx"] + }, + "text/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "text/rtp-enc-aescm128": { + source: "iana" + }, + "text/rtploopback": { + source: "iana" + }, + "text/rtx": { + source: "iana" + }, + "text/sgml": { + source: "iana", + extensions: ["sgml", "sgm"] + }, + "text/shaclc": { + source: "iana" + }, + "text/shex": { + source: "iana", + extensions: ["shex"] + }, + "text/slim": { + extensions: ["slim", "slm"] + }, + "text/spdx": { + source: "iana", + extensions: ["spdx"] + }, + "text/strings": { + source: "iana" + }, + "text/stylus": { + extensions: ["stylus", "styl"] + }, + "text/t140": { + source: "iana" + }, + "text/tab-separated-values": { + source: "iana", + compressible: true, + extensions: ["tsv"] + }, + "text/troff": { + source: "iana", + extensions: ["t", "tr", "roff", "man", "me", "ms"] + }, + "text/turtle": { + source: "iana", + charset: "UTF-8", + extensions: ["ttl"] + }, + "text/ulpfec": { + source: "iana" + }, + "text/uri-list": { + source: "iana", + compressible: true, + extensions: ["uri", "uris", "urls"] + }, + "text/vcard": { + source: "iana", + compressible: true, + extensions: ["vcard"] + }, + "text/vnd.a": { + source: "iana" + }, + "text/vnd.abc": { + source: "iana" + }, + "text/vnd.ascii-art": { + source: "iana" + }, + "text/vnd.curl": { + source: "iana", + extensions: ["curl"] + }, + "text/vnd.curl.dcurl": { + source: "apache", + extensions: ["dcurl"] + }, + "text/vnd.curl.mcurl": { + source: "apache", + extensions: ["mcurl"] + }, + "text/vnd.curl.scurl": { + source: "apache", + extensions: ["scurl"] + }, + "text/vnd.debian.copyright": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.dmclientscript": { + source: "iana" + }, + "text/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "text/vnd.esmertec.theme-descriptor": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.exchangeable": { + source: "iana" + }, + "text/vnd.familysearch.gedcom": { + source: "iana", + extensions: ["ged"] + }, + "text/vnd.ficlab.flt": { + source: "iana" + }, + "text/vnd.fly": { + source: "iana", + extensions: ["fly"] + }, + "text/vnd.fmi.flexstor": { + source: "iana", + extensions: ["flx"] + }, + "text/vnd.gml": { + source: "iana" + }, + "text/vnd.graphviz": { + source: "iana", + extensions: ["gv"] + }, + "text/vnd.hans": { + source: "iana" + }, + "text/vnd.hgl": { + source: "iana" + }, + "text/vnd.in3d.3dml": { + source: "iana", + extensions: ["3dml"] + }, + "text/vnd.in3d.spot": { + source: "iana", + extensions: ["spot"] + }, + "text/vnd.iptc.newsml": { + source: "iana" + }, + "text/vnd.iptc.nitf": { + source: "iana" + }, + "text/vnd.latex-z": { + source: "iana" + }, + "text/vnd.motorola.reflex": { + source: "iana" + }, + "text/vnd.ms-mediapackage": { + source: "iana" + }, + "text/vnd.net2phone.commcenter.command": { + source: "iana" + }, + "text/vnd.radisys.msml-basic-layout": { + source: "iana" + }, + "text/vnd.senx.warpscript": { + source: "iana" + }, + "text/vnd.si.uricatalogue": { + source: "apache" + }, + "text/vnd.sosi": { + source: "iana" + }, + "text/vnd.sun.j2me.app-descriptor": { + source: "iana", + charset: "UTF-8", + extensions: ["jad"] + }, + "text/vnd.trolltech.linguist": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.vcf": { + source: "iana" + }, + "text/vnd.wap.si": { + source: "iana" + }, + "text/vnd.wap.sl": { + source: "iana" + }, + "text/vnd.wap.wml": { + source: "iana", + extensions: ["wml"] + }, + "text/vnd.wap.wmlscript": { + source: "iana", + extensions: ["wmls"] + }, + "text/vnd.zoo.kcl": { + source: "iana" + }, + "text/vtt": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["vtt"] + }, + "text/wgsl": { + source: "iana", + extensions: ["wgsl"] + }, + "text/x-asm": { + source: "apache", + extensions: ["s", "asm"] + }, + "text/x-c": { + source: "apache", + extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] + }, + "text/x-component": { + source: "nginx", + extensions: ["htc"] + }, + "text/x-fortran": { + source: "apache", + extensions: ["f", "for", "f77", "f90"] + }, + "text/x-gwt-rpc": { + compressible: true + }, + "text/x-handlebars-template": { + extensions: ["hbs"] + }, + "text/x-java-source": { + source: "apache", + extensions: ["java"] + }, + "text/x-jquery-tmpl": { + compressible: true + }, + "text/x-lua": { + extensions: ["lua"] + }, + "text/x-markdown": { + compressible: true, + extensions: ["mkd"] + }, + "text/x-nfo": { + source: "apache", + extensions: ["nfo"] + }, + "text/x-opml": { + source: "apache", + extensions: ["opml"] + }, + "text/x-org": { + compressible: true, + extensions: ["org"] + }, + "text/x-pascal": { + source: "apache", + extensions: ["p", "pas"] + }, + "text/x-processing": { + compressible: true, + extensions: ["pde"] + }, + "text/x-sass": { + extensions: ["sass"] + }, + "text/x-scss": { + extensions: ["scss"] + }, + "text/x-setext": { + source: "apache", + extensions: ["etx"] + }, + "text/x-sfv": { + source: "apache", + extensions: ["sfv"] + }, + "text/x-suse-ymp": { + compressible: true, + extensions: ["ymp"] + }, + "text/x-uuencode": { + source: "apache", + extensions: ["uu"] + }, + "text/x-vcalendar": { + source: "apache", + extensions: ["vcs"] + }, + "text/x-vcard": { + source: "apache", + extensions: ["vcf"] + }, + "text/xml": { + source: "iana", + compressible: true, + extensions: ["xml"] + }, + "text/xml-external-parsed-entity": { + source: "iana" + }, + "text/yaml": { + compressible: true, + extensions: ["yaml", "yml"] + }, + "video/1d-interleaved-parityfec": { + source: "iana" + }, + "video/3gpp": { + source: "iana", + extensions: ["3gp", "3gpp"] + }, + "video/3gpp-tt": { + source: "iana" + }, + "video/3gpp2": { + source: "iana", + extensions: ["3g2"] + }, + "video/av1": { + source: "iana" + }, + "video/bmpeg": { + source: "iana" + }, + "video/bt656": { + source: "iana" + }, + "video/celb": { + source: "iana" + }, + "video/dv": { + source: "iana" + }, + "video/encaprtp": { + source: "iana" + }, + "video/evc": { + source: "iana" + }, + "video/ffv1": { + source: "iana" + }, + "video/flexfec": { + source: "iana" + }, + "video/h261": { + source: "iana", + extensions: ["h261"] + }, + "video/h263": { + source: "iana", + extensions: ["h263"] + }, + "video/h263-1998": { + source: "iana" + }, + "video/h263-2000": { + source: "iana" + }, + "video/h264": { + source: "iana", + extensions: ["h264"] + }, + "video/h264-rcdo": { + source: "iana" + }, + "video/h264-svc": { + source: "iana" + }, + "video/h265": { + source: "iana" + }, + "video/h266": { + source: "iana" + }, + "video/iso.segment": { + source: "iana", + extensions: ["m4s"] + }, + "video/jpeg": { + source: "iana", + extensions: ["jpgv"] + }, + "video/jpeg2000": { + source: "iana" + }, + "video/jpm": { + source: "apache", + extensions: ["jpm", "jpgm"] + }, + "video/jxsv": { + source: "iana" + }, + "video/lottie+json": { + source: "iana", + compressible: true + }, + "video/matroska": { + source: "iana" + }, + "video/matroska-3d": { + source: "iana" + }, + "video/mj2": { + source: "iana", + extensions: ["mj2", "mjp2"] + }, + "video/mp1s": { + source: "iana" + }, + "video/mp2p": { + source: "iana" + }, + "video/mp2t": { + source: "iana", + extensions: ["ts", "m2t", "m2ts", "mts"] + }, + "video/mp4": { + source: "iana", + compressible: false, + extensions: ["mp4", "mp4v", "mpg4"] + }, + "video/mp4v-es": { + source: "iana" + }, + "video/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"] + }, + "video/mpeg4-generic": { + source: "iana" + }, + "video/mpv": { + source: "iana" + }, + "video/nv": { + source: "iana" + }, + "video/ogg": { + source: "iana", + compressible: false, + extensions: ["ogv"] + }, + "video/parityfec": { + source: "iana" + }, + "video/pointer": { + source: "iana" + }, + "video/quicktime": { + source: "iana", + compressible: false, + extensions: ["qt", "mov"] + }, + "video/raptorfec": { + source: "iana" + }, + "video/raw": { + source: "iana" + }, + "video/rtp-enc-aescm128": { + source: "iana" + }, + "video/rtploopback": { + source: "iana" + }, + "video/rtx": { + source: "iana" + }, + "video/scip": { + source: "iana" + }, + "video/smpte291": { + source: "iana" + }, + "video/smpte292m": { + source: "iana" + }, + "video/ulpfec": { + source: "iana" + }, + "video/vc1": { + source: "iana" + }, + "video/vc2": { + source: "iana" + }, + "video/vnd.cctv": { + source: "iana" + }, + "video/vnd.dece.hd": { + source: "iana", + extensions: ["uvh", "uvvh"] + }, + "video/vnd.dece.mobile": { + source: "iana", + extensions: ["uvm", "uvvm"] + }, + "video/vnd.dece.mp4": { + source: "iana" + }, + "video/vnd.dece.pd": { + source: "iana", + extensions: ["uvp", "uvvp"] + }, + "video/vnd.dece.sd": { + source: "iana", + extensions: ["uvs", "uvvs"] + }, + "video/vnd.dece.video": { + source: "iana", + extensions: ["uvv", "uvvv"] + }, + "video/vnd.directv.mpeg": { + source: "iana" + }, + "video/vnd.directv.mpeg-tts": { + source: "iana" + }, + "video/vnd.dlna.mpeg-tts": { + source: "iana" + }, + "video/vnd.dvb.file": { + source: "iana", + extensions: ["dvb"] + }, + "video/vnd.fvt": { + source: "iana", + extensions: ["fvt"] + }, + "video/vnd.hns.video": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.ttsavc": { + source: "iana" + }, + "video/vnd.iptvforum.ttsmpeg2": { + source: "iana" + }, + "video/vnd.motorola.video": { + source: "iana" + }, + "video/vnd.motorola.videop": { + source: "iana" + }, + "video/vnd.mpegurl": { + source: "iana", + extensions: ["mxu", "m4u"] + }, + "video/vnd.ms-playready.media.pyv": { + source: "iana", + extensions: ["pyv"] + }, + "video/vnd.nokia.interleaved-multimedia": { + source: "iana" + }, + "video/vnd.nokia.mp4vr": { + source: "iana" + }, + "video/vnd.nokia.videovoip": { + source: "iana" + }, + "video/vnd.objectvideo": { + source: "iana" + }, + "video/vnd.planar": { + source: "iana" + }, + "video/vnd.radgamettools.bink": { + source: "iana" + }, + "video/vnd.radgamettools.smacker": { + source: "apache" + }, + "video/vnd.sealed.mpeg1": { + source: "iana" + }, + "video/vnd.sealed.mpeg4": { + source: "iana" + }, + "video/vnd.sealed.swf": { + source: "iana" + }, + "video/vnd.sealedmedia.softseal.mov": { + source: "iana" + }, + "video/vnd.uvvu.mp4": { + source: "iana", + extensions: ["uvu", "uvvu"] + }, + "video/vnd.vivo": { + source: "iana", + extensions: ["viv"] + }, + "video/vnd.youtube.yt": { + source: "iana" + }, + "video/vp8": { + source: "iana" + }, + "video/vp9": { + source: "iana" + }, + "video/webm": { + source: "apache", + compressible: false, + extensions: ["webm"] + }, + "video/x-f4v": { + source: "apache", + extensions: ["f4v"] + }, + "video/x-fli": { + source: "apache", + extensions: ["fli"] + }, + "video/x-flv": { + source: "apache", + compressible: false, + extensions: ["flv"] + }, + "video/x-m4v": { + source: "apache", + extensions: ["m4v"] + }, + "video/x-matroska": { + source: "apache", + compressible: false, + extensions: ["mkv", "mk3d", "mks"] + }, + "video/x-mng": { + source: "apache", + extensions: ["mng"] + }, + "video/x-ms-asf": { + source: "apache", + extensions: ["asf", "asx"] + }, + "video/x-ms-vob": { + source: "apache", + extensions: ["vob"] + }, + "video/x-ms-wm": { + source: "apache", + extensions: ["wm"] + }, + "video/x-ms-wmv": { + source: "apache", + compressible: false, + extensions: ["wmv"] + }, + "video/x-ms-wmx": { + source: "apache", + extensions: ["wmx"] + }, + "video/x-ms-wvx": { + source: "apache", + extensions: ["wvx"] + }, + "video/x-msvideo": { + source: "apache", + extensions: ["avi"] + }, + "video/x-sgi-movie": { + source: "apache", + extensions: ["movie"] + }, + "video/x-smv": { + source: "apache", + extensions: ["smv"] + }, + "x-conference/x-cooltalk": { + source: "apache", + extensions: ["ice"] + }, + "x-shader/x-fragment": { + compressible: true + }, + "x-shader/x-vertex": { + compressible: true + } + }; + } +}); +var require_mime_db = __commonJS2({ + "node_modules/type-is/node_modules/mime-db/index.js"(exports2, module2) { + module2.exports = require_db(); + } +}); +var require_mimeScore = __commonJS2({ + "node_modules/type-is/node_modules/mime-types/mimeScore.js"(exports2, module2) { + var FACET_SCORES = { + "prs.": 100, + "x-": 200, + "x.": 300, + "vnd.": 400, + default: 900 + }; + var SOURCE_SCORES = { + nginx: 10, + apache: 20, + iana: 40, + default: 30 + // definitions added by `jshttp/mime-db` project? + }; + var TYPE_SCORES = { + // prefer application/xml over text/xml + // prefer application/rtf over text/rtf + application: 1, + // prefer font/woff over application/font-woff + font: 2, + default: 0 + }; + module2.exports = function mimeScore(mimeType, source = "default") { + if (mimeType === "application/octet-stream") { + return 0; + } + const [type, subtype] = mimeType.split("/"); + const facet = subtype.replace(/(\.|x-).*/, "$1"); + const facetScore = FACET_SCORES[facet] || FACET_SCORES.default; + const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default; + const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default; + const lengthScore = 1 - mimeType.length / 100; + return facetScore + sourceScore + typeScore + lengthScore; + }; + } +}); +var require_mime_types = __commonJS2({ + "node_modules/type-is/node_modules/mime-types/index.js"(exports2) { + "use strict"; + var db = require_mime_db(); + var extname = require("path").extname; + var mimeScore = require_mimeScore(); + var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/; + var TEXT_TYPE_REGEXP = /^text\//i; + exports2.charset = charset; + exports2.charsets = { lookup: charset }; + exports2.contentType = contentType2; + exports2.extension = extension; + exports2.extensions = /* @__PURE__ */ Object.create(null); + exports2.lookup = lookup; + exports2.types = /* @__PURE__ */ Object.create(null); + exports2._extensionConflicts = []; + populateMaps(exports2.extensions, exports2.types); + function charset(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var mime = match && db[match[1].toLowerCase()]; + if (mime && mime.charset) { + return mime.charset; + } + if (match && TEXT_TYPE_REGEXP.test(match[1])) { + return "UTF-8"; + } + return false; + } + function contentType2(str) { + if (!str || typeof str !== "string") { + return false; + } + var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str; + if (!mime) { + return false; + } + if (mime.indexOf("charset") === -1) { + var charset2 = exports2.charset(mime); + if (charset2) mime += "; charset=" + charset2.toLowerCase(); + } + return mime; + } + function extension(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var exts = match && exports2.extensions[match[1].toLowerCase()]; + if (!exts || !exts.length) { + return false; + } + return exts[0]; + } + function lookup(path) { + if (!path || typeof path !== "string") { + return false; + } + var extension2 = extname("x." + path).toLowerCase().slice(1); + if (!extension2) { + return false; + } + return exports2.types[extension2] || false; + } + function populateMaps(extensions, types) { + Object.keys(db).forEach(function forEachMimeType(type) { + var mime = db[type]; + var exts = mime.extensions; + if (!exts || !exts.length) { + return; + } + extensions[type] = exts; + for (var i = 0; i < exts.length; i++) { + var extension2 = exts[i]; + types[extension2] = _preferredType(extension2, types[extension2], type); + const legacyType = _preferredTypeLegacy( + extension2, + types[extension2], + type + ); + if (legacyType !== types[extension2]) { + exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]); + } + } + }); + } + function _preferredType(ext, type0, type1) { + var score0 = type0 ? mimeScore(type0, db[type0].source) : 0; + var score1 = type1 ? mimeScore(type1, db[type1].source) : 0; + return score0 > score1 ? type0 : type1; + } + function _preferredTypeLegacy(ext, type0, type1) { + var SOURCE_RANK = ["nginx", "apache", void 0, "iana"]; + var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0; + var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0; + if (exports2.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === "application/")) { + return type0; + } + return score0 > score1 ? type0 : type1; + } + } +}); +var require_media_typer = __commonJS2({ + "node_modules/media-typer/index.js"(exports2) { + "use strict"; + var SUBTYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/; + var TYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/; + var TYPE_REGEXP = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/; + exports2.format = format; + exports2.parse = parse; + exports2.test = test; + function format(obj) { + if (!obj || typeof obj !== "object") { + throw new TypeError("argument obj is required"); + } + var subtype = obj.subtype; + var suffix = obj.suffix; + var type = obj.type; + if (!type || !TYPE_NAME_REGEXP.test(type)) { + throw new TypeError("invalid type"); + } + if (!subtype || !SUBTYPE_NAME_REGEXP.test(subtype)) { + throw new TypeError("invalid subtype"); + } + var string = type + "/" + subtype; + if (suffix) { + if (!TYPE_NAME_REGEXP.test(suffix)) { + throw new TypeError("invalid suffix"); + } + string += "+" + suffix; + } + return string; + } + function test(string) { + if (!string) { + throw new TypeError("argument string is required"); + } + if (typeof string !== "string") { + throw new TypeError("argument string is required to be a string"); + } + return TYPE_REGEXP.test(string.toLowerCase()); + } + function parse(string) { + if (!string) { + throw new TypeError("argument string is required"); + } + if (typeof string !== "string") { + throw new TypeError("argument string is required to be a string"); + } + var match = TYPE_REGEXP.exec(string.toLowerCase()); + if (!match) { + throw new TypeError("invalid media type"); + } + var type = match[1]; + var subtype = match[2]; + var suffix; + var index = subtype.lastIndexOf("+"); + if (index !== -1) { + suffix = subtype.substr(index + 1); + subtype = subtype.substr(0, index); + } + return new MediaType(type, subtype, suffix); + } + function MediaType(type, subtype, suffix) { + this.type = type; + this.subtype = subtype; + this.suffix = suffix; + } + } +}); +var require_type_is = __commonJS2({ + "node_modules/type-is/index.js"(exports2, module2) { + "use strict"; + var contentType2 = require_content_type(); + var mime = require_mime_types(); + var typer = require_media_typer(); + module2.exports = typeofrequest; + module2.exports.is = typeis; + module2.exports.hasBody = hasbody; + module2.exports.normalize = normalize; + module2.exports.match = mimeMatch; + function typeis(value, types_) { + var i; + var types = types_; + var val = tryNormalizeType(value); + if (!val) { + return false; + } + if (types && !Array.isArray(types)) { + types = new Array(arguments.length - 1); + for (i = 0; i < types.length; i++) { + types[i] = arguments[i + 1]; + } + } + if (!types || !types.length) { + return val; + } + var type; + for (i = 0; i < types.length; i++) { + if (mimeMatch(normalize(type = types[i]), val)) { + return type[0] === "+" || type.indexOf("*") !== -1 ? val : type; + } + } + return false; + } + function hasbody(req) { + return req.headers["transfer-encoding"] !== void 0 || !isNaN(req.headers["content-length"]); + } + function typeofrequest(req, types_) { + if (!hasbody(req)) return null; + var types = arguments.length > 2 ? Array.prototype.slice.call(arguments, 1) : types_; + var value = req.headers["content-type"]; + return typeis(value, types); + } + function normalize(type) { + if (typeof type !== "string") { + return false; + } + switch (type) { + case "urlencoded": + return "application/x-www-form-urlencoded"; + case "multipart": + return "multipart/*"; + } + if (type[0] === "+") { + return "*/*" + type; + } + return type.indexOf("/") === -1 ? mime.lookup(type) : type; + } + function mimeMatch(expected, actual) { + if (expected === false) { + return false; + } + var actualParts = actual.split("/"); + var expectedParts = expected.split("/"); + if (actualParts.length !== 2 || expectedParts.length !== 2) { + return false; + } + if (expectedParts[0] !== "*" && expectedParts[0] !== actualParts[0]) { + return false; + } + if (expectedParts[1].slice(0, 2) === "*+") { + return expectedParts[1].length <= actualParts[1].length + 1 && expectedParts[1].slice(1) === actualParts[1].slice(1 - expectedParts[1].length); + } + if (expectedParts[1] !== "*" && expectedParts[1] !== actualParts[1]) { + return false; + } + return true; + } + function normalizeType(value) { + var type = contentType2.parse(value).type; + return typer.test(type) ? type : null; + } + function tryNormalizeType(value) { + try { + return value ? normalizeType(value) : null; + } catch (err2) { + return null; + } + } + } +}); +var require_utils = __commonJS2({ + "node_modules/body-parser/lib/utils.js"(exports2, module2) { + "use strict"; + var bytes = require_bytes(); + var contentType2 = require_content_type(); + var typeis = require_type_is(); + module2.exports = { + getCharset, + normalizeOptions + }; + function getCharset(req) { + try { + return (contentType2.parse(req).parameters.charset || "").toLowerCase(); + } catch { + return void 0; + } + } + function typeChecker(type) { + return function checkType(req) { + return Boolean(typeis(req, type)); + }; + } + function normalizeOptions(options, defaultType) { + if (!defaultType) { + throw new TypeError("defaultType must be provided"); + } + var inflate = options?.inflate !== false; + var limit = typeof options?.limit !== "number" ? bytes.parse(options?.limit || "100kb") : options?.limit; + var type = options?.type || defaultType; + var verify = options?.verify || false; + if (verify !== false && typeof verify !== "function") { + throw new TypeError("option verify must be function"); + } + var shouldParse = typeof type !== "function" ? typeChecker(type) : type; + return { + inflate, + limit, + verify, + shouldParse + }; + } + } +}); +var require_json = __commonJS2({ + "node_modules/body-parser/lib/types/json.js"(exports2, module2) { + "use strict"; + var createError = require_http_errors(); + var debug = require_src()("body-parser:json"); + var isFinished = require_on_finished().isFinished; + var read = require_read(); + var typeis = require_type_is(); + var { getCharset, normalizeOptions } = require_utils(); + module2.exports = json; + var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/; + var JSON_SYNTAX_CHAR = "#"; + var JSON_SYNTAX_REGEXP = /#+/g; + function json(options) { + var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/json"); + var reviver = options?.reviver; + var strict = options?.strict !== false; + function parse(body) { + if (body.length === 0) { + return {}; + } + if (strict) { + var first = firstchar(body); + if (first !== "{" && first !== "[") { + debug("strict violation"); + throw createStrictSyntaxError(body, first); + } + } + try { + debug("parse json"); + return JSON.parse(body, reviver); + } catch (e) { + throw normalizeJsonSyntaxError(e, { + message: e.message, + stack: e.stack + }); + } + } + return function jsonParser(req, res, next) { + if (isFinished(req)) { + debug("body already parsed"); + next(); + return; + } + if (!("body" in req)) { + req.body = void 0; + } + if (!typeis.hasBody(req)) { + debug("skip empty body"); + next(); + return; + } + debug("content-type %j", req.headers["content-type"]); + if (!shouldParse(req)) { + debug("skip parsing"); + next(); + return; + } + var charset = getCharset(req) || "utf-8"; + if (charset.slice(0, 4) !== "utf-") { + debug("invalid charset"); + next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', { + charset, + type: "charset.unsupported" + })); + return; + } + read(req, res, next, parse, debug, { + encoding: charset, + inflate, + limit, + verify + }); + }; + } + function createStrictSyntaxError(str, char) { + var index = str.indexOf(char); + var partial = ""; + if (index !== -1) { + partial = str.substring(0, index) + JSON_SYNTAX_CHAR; + for (var i = index + 1; i < str.length; i++) { + partial += JSON_SYNTAX_CHAR; + } + } + try { + JSON.parse(partial); + throw new SyntaxError("strict violation"); + } catch (e) { + return normalizeJsonSyntaxError(e, { + message: e.message.replace(JSON_SYNTAX_REGEXP, function(placeholder) { + return str.substring(index, index + placeholder.length); + }), + stack: e.stack + }); + } + } + function firstchar(str) { + var match = FIRST_CHAR_REGEXP.exec(str); + return match ? match[1] : void 0; + } + function normalizeJsonSyntaxError(error, obj) { + var keys = Object.getOwnPropertyNames(error); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (key !== "stack" && key !== "message") { + delete error[key]; + } + } + error.stack = obj.stack.replace(error.message, obj.message); + error.message = obj.message; + return error; + } + } +}); +var require_raw = __commonJS2({ + "node_modules/body-parser/lib/types/raw.js"(exports2, module2) { + "use strict"; + var debug = require_src()("body-parser:raw"); + var isFinished = require_on_finished().isFinished; + var read = require_read(); + var typeis = require_type_is(); + var { normalizeOptions } = require_utils(); + module2.exports = raw; + function raw(options) { + var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/octet-stream"); + function parse(buf) { + return buf; + } + return function rawParser(req, res, next) { + if (isFinished(req)) { + debug("body already parsed"); + next(); + return; + } + if (!("body" in req)) { + req.body = void 0; + } + if (!typeis.hasBody(req)) { + debug("skip empty body"); + next(); + return; + } + debug("content-type %j", req.headers["content-type"]); + if (!shouldParse(req)) { + debug("skip parsing"); + next(); + return; + } + read(req, res, next, parse, debug, { + encoding: null, + inflate, + limit, + verify + }); + }; + } + } +}); +var require_text = __commonJS2({ + "node_modules/body-parser/lib/types/text.js"(exports2, module2) { + "use strict"; + var debug = require_src()("body-parser:text"); + var isFinished = require_on_finished().isFinished; + var read = require_read(); + var typeis = require_type_is(); + var { getCharset, normalizeOptions } = require_utils(); + module2.exports = text; + function text(options) { + var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "text/plain"); + var defaultCharset = options?.defaultCharset || "utf-8"; + function parse(buf) { + return buf; + } + return function textParser(req, res, next) { + if (isFinished(req)) { + debug("body already parsed"); + next(); + return; + } + if (!("body" in req)) { + req.body = void 0; + } + if (!typeis.hasBody(req)) { + debug("skip empty body"); + next(); + return; + } + debug("content-type %j", req.headers["content-type"]); + if (!shouldParse(req)) { + debug("skip parsing"); + next(); + return; + } + var charset = getCharset(req) || defaultCharset; + read(req, res, next, parse, debug, { + encoding: charset, + inflate, + limit, + verify + }); + }; + } + } +}); +var require_type = __commonJS2({ + "node_modules/es-errors/type.js"(exports2, module2) { + "use strict"; + module2.exports = TypeError; + } +}); +var require_util_inspect = __commonJS2({ + "node_modules/object-inspect/util.inspect.js"(exports2, module2) { + module2.exports = require("util").inspect; + } +}); +var require_object_inspect = __commonJS2({ + "node_modules/object-inspect/index.js"(exports2, module2) { + var hasMap = typeof Map === "function" && Map.prototype; + var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null; + var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null; + var mapForEach = hasMap && Map.prototype.forEach; + var hasSet = typeof Set === "function" && Set.prototype; + var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null; + var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null; + var setForEach = hasSet && Set.prototype.forEach; + var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype; + var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null; + var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype; + var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null; + var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype; + var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null; + var booleanValueOf = Boolean.prototype.valueOf; + var objectToString = Object.prototype.toString; + var functionToString = Function.prototype.toString; + var $match = String.prototype.match; + var $slice = String.prototype.slice; + var $replace = String.prototype.replace; + var $toUpperCase = String.prototype.toUpperCase; + var $toLowerCase = String.prototype.toLowerCase; + var $test = RegExp.prototype.test; + var $concat = Array.prototype.concat; + var $join = Array.prototype.join; + var $arrSlice = Array.prototype.slice; + var $floor = Math.floor; + var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null; + var gOPS = Object.getOwnPropertySymbols; + var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null; + var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object"; + var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null; + var isEnumerable = Object.prototype.propertyIsEnumerable; + var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) { + return O.__proto__; + } : null); + function addNumericSeparator(num, str) { + if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) { + return str; + } + var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g; + if (typeof num === "number") { + var int = num < 0 ? -$floor(-num) : $floor(num); + if (int !== num) { + var intStr = String(int); + var dec = $slice.call(str, intStr.length + 1); + return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, ""); + } + } + return $replace.call(str, sepRegex, "$&_"); + } + var utilInspect = require_util_inspect(); + var inspectCustom = utilInspect.custom; + var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null; + var quotes = { + __proto__: null, + "double": '"', + single: "'" + }; + var quoteREs = { + __proto__: null, + "double": /(["\\])/g, + single: /(['\\])/g + }; + module2.exports = function inspect_(obj, options, depth, seen) { + var opts = options || {}; + if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) { + throw new TypeError('option "quoteStyle" must be "single" or "double"'); + } + if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) { + throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'); + } + var customInspect = has(opts, "customInspect") ? opts.customInspect : true; + if (typeof customInspect !== "boolean" && customInspect !== "symbol") { + throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"); + } + if (has(opts, "indent") && opts.indent !== null && opts.indent !== " " && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) { + throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`'); + } + if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") { + throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`'); + } + var numericSeparator = opts.numericSeparator; + if (typeof obj === "undefined") { + return "undefined"; + } + if (obj === null) { + return "null"; + } + if (typeof obj === "boolean") { + return obj ? "true" : "false"; + } + if (typeof obj === "string") { + return inspectString(obj, opts); + } + if (typeof obj === "number") { + if (obj === 0) { + return Infinity / obj > 0 ? "0" : "-0"; + } + var str = String(obj); + return numericSeparator ? addNumericSeparator(obj, str) : str; + } + if (typeof obj === "bigint") { + var bigIntStr = String(obj) + "n"; + return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr; + } + var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth; + if (typeof depth === "undefined") { + depth = 0; + } + if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") { + return isArray(obj) ? "[Array]" : "[Object]"; + } + var indent = getIndent(opts, depth); + if (typeof seen === "undefined") { + seen = []; + } else if (indexOf(seen, obj) >= 0) { + return "[Circular]"; + } + function inspect(value, from, noIndent) { + if (from) { + seen = $arrSlice.call(seen); + seen.push(from); + } + if (noIndent) { + var newOpts = { + depth: opts.depth + }; + if (has(opts, "quoteStyle")) { + newOpts.quoteStyle = opts.quoteStyle; + } + return inspect_(value, newOpts, depth + 1, seen); + } + return inspect_(value, opts, depth + 1, seen); + } + if (typeof obj === "function" && !isRegExp(obj)) { + var name = nameOf(obj); + var keys = arrObjKeys(obj, inspect); + return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : ""); + } + if (isSymbol(obj)) { + var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj); + return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString; + } + if (isElement(obj)) { + var s = "<" + $toLowerCase.call(String(obj.nodeName)); + var attrs = obj.attributes || []; + for (var i = 0; i < attrs.length; i++) { + s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts); + } + s += ">"; + if (obj.childNodes && obj.childNodes.length) { + s += "..."; + } + s += ""; + return s; + } + if (isArray(obj)) { + if (obj.length === 0) { + return "[]"; + } + var xs = arrObjKeys(obj, inspect); + if (indent && !singleLineValues(xs)) { + return "[" + indentedJoin(xs, indent) + "]"; + } + return "[ " + $join.call(xs, ", ") + " ]"; + } + if (isError(obj)) { + var parts = arrObjKeys(obj, inspect); + if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) { + return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }"; + } + if (parts.length === 0) { + return "[" + String(obj) + "]"; + } + return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }"; + } + if (typeof obj === "object" && customInspect) { + if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) { + return utilInspect(obj, { depth: maxDepth - depth }); + } else if (customInspect !== "symbol" && typeof obj.inspect === "function") { + return obj.inspect(); + } + } + if (isMap(obj)) { + var mapParts = []; + if (mapForEach) { + mapForEach.call(obj, function(value, key) { + mapParts.push(inspect(key, obj, true) + " => " + inspect(value, obj)); + }); + } + return collectionOf("Map", mapSize.call(obj), mapParts, indent); + } + if (isSet(obj)) { + var setParts = []; + if (setForEach) { + setForEach.call(obj, function(value) { + setParts.push(inspect(value, obj)); + }); + } + return collectionOf("Set", setSize.call(obj), setParts, indent); + } + if (isWeakMap(obj)) { + return weakCollectionOf("WeakMap"); + } + if (isWeakSet(obj)) { + return weakCollectionOf("WeakSet"); + } + if (isWeakRef(obj)) { + return weakCollectionOf("WeakRef"); + } + if (isNumber(obj)) { + return markBoxed(inspect(Number(obj))); + } + if (isBigInt(obj)) { + return markBoxed(inspect(bigIntValueOf.call(obj))); + } + if (isBoolean(obj)) { + return markBoxed(booleanValueOf.call(obj)); + } + if (isString(obj)) { + return markBoxed(inspect(String(obj))); + } + if (typeof window !== "undefined" && obj === window) { + return "{ [object Window] }"; + } + if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) { + return "{ [object globalThis] }"; + } + if (!isDate(obj) && !isRegExp(obj)) { + var ys = arrObjKeys(obj, inspect); + var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object; + var protoTag = obj instanceof Object ? "" : "null prototype"; + var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : ""; + var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : ""; + var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : ""); + if (ys.length === 0) { + return tag + "{}"; + } + if (indent) { + return tag + "{" + indentedJoin(ys, indent) + "}"; + } + return tag + "{ " + $join.call(ys, ", ") + " }"; + } + return String(obj); + }; + function wrapQuotes(s, defaultStyle, opts) { + var style = opts.quoteStyle || defaultStyle; + var quoteChar = quotes[style]; + return quoteChar + s + quoteChar; + } + function quote(s) { + return $replace.call(String(s), /"/g, """); + } + function canTrustToString(obj) { + return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined")); + } + function isArray(obj) { + return toStr(obj) === "[object Array]" && canTrustToString(obj); + } + function isDate(obj) { + return toStr(obj) === "[object Date]" && canTrustToString(obj); + } + function isRegExp(obj) { + return toStr(obj) === "[object RegExp]" && canTrustToString(obj); + } + function isError(obj) { + return toStr(obj) === "[object Error]" && canTrustToString(obj); + } + function isString(obj) { + return toStr(obj) === "[object String]" && canTrustToString(obj); + } + function isNumber(obj) { + return toStr(obj) === "[object Number]" && canTrustToString(obj); + } + function isBoolean(obj) { + return toStr(obj) === "[object Boolean]" && canTrustToString(obj); + } + function isSymbol(obj) { + if (hasShammedSymbols) { + return obj && typeof obj === "object" && obj instanceof Symbol; + } + if (typeof obj === "symbol") { + return true; + } + if (!obj || typeof obj !== "object" || !symToString) { + return false; + } + try { + symToString.call(obj); + return true; + } catch (e) { + } + return false; + } + function isBigInt(obj) { + if (!obj || typeof obj !== "object" || !bigIntValueOf) { + return false; + } + try { + bigIntValueOf.call(obj); + return true; + } catch (e) { + } + return false; + } + var hasOwn = Object.prototype.hasOwnProperty || function(key) { + return key in this; + }; + function has(obj, key) { + return hasOwn.call(obj, key); + } + function toStr(obj) { + return objectToString.call(obj); + } + function nameOf(f) { + if (f.name) { + return f.name; + } + var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/); + if (m) { + return m[1]; + } + return null; + } + function indexOf(xs, x) { + if (xs.indexOf) { + return xs.indexOf(x); + } + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) { + return i; + } + } + return -1; + } + function isMap(x) { + if (!mapSize || !x || typeof x !== "object") { + return false; + } + try { + mapSize.call(x); + try { + setSize.call(x); + } catch (s) { + return true; + } + return x instanceof Map; + } catch (e) { + } + return false; + } + function isWeakMap(x) { + if (!weakMapHas || !x || typeof x !== "object") { + return false; + } + try { + weakMapHas.call(x, weakMapHas); + try { + weakSetHas.call(x, weakSetHas); + } catch (s) { + return true; + } + return x instanceof WeakMap; + } catch (e) { + } + return false; + } + function isWeakRef(x) { + if (!weakRefDeref || !x || typeof x !== "object") { + return false; + } + try { + weakRefDeref.call(x); + return true; + } catch (e) { + } + return false; + } + function isSet(x) { + if (!setSize || !x || typeof x !== "object") { + return false; + } + try { + setSize.call(x); + try { + mapSize.call(x); + } catch (m) { + return true; + } + return x instanceof Set; + } catch (e) { + } + return false; + } + function isWeakSet(x) { + if (!weakSetHas || !x || typeof x !== "object") { + return false; + } + try { + weakSetHas.call(x, weakSetHas); + try { + weakMapHas.call(x, weakMapHas); + } catch (s) { + return true; + } + return x instanceof WeakSet; + } catch (e) { + } + return false; + } + function isElement(x) { + if (!x || typeof x !== "object") { + return false; + } + if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) { + return true; + } + return typeof x.nodeName === "string" && typeof x.getAttribute === "function"; + } + function inspectString(str, opts) { + if (str.length > opts.maxStringLength) { + var remaining = str.length - opts.maxStringLength; + var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : ""); + return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer; + } + var quoteRE = quoteREs[opts.quoteStyle || "single"]; + quoteRE.lastIndex = 0; + var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte); + return wrapQuotes(s, "single", opts); + } + function lowbyte(c) { + var n = c.charCodeAt(0); + var x = { + 8: "b", + 9: "t", + 10: "n", + 12: "f", + 13: "r" + }[n]; + if (x) { + return "\\" + x; + } + return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16)); + } + function markBoxed(str) { + return "Object(" + str + ")"; + } + function weakCollectionOf(type) { + return type + " { ? }"; + } + function collectionOf(type, size, entries, indent) { + var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", "); + return type + " (" + size + ") {" + joinedEntries + "}"; + } + function singleLineValues(xs) { + for (var i = 0; i < xs.length; i++) { + if (indexOf(xs[i], "\n") >= 0) { + return false; + } + } + return true; + } + function getIndent(opts, depth) { + var baseIndent; + if (opts.indent === " ") { + baseIndent = " "; + } else if (typeof opts.indent === "number" && opts.indent > 0) { + baseIndent = $join.call(Array(opts.indent + 1), " "); + } else { + return null; + } + return { + base: baseIndent, + prev: $join.call(Array(depth + 1), baseIndent) + }; + } + function indentedJoin(xs, indent) { + if (xs.length === 0) { + return ""; + } + var lineJoiner = "\n" + indent.prev + indent.base; + return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev; + } + function arrObjKeys(obj, inspect) { + var isArr = isArray(obj); + var xs = []; + if (isArr) { + xs.length = obj.length; + for (var i = 0; i < obj.length; i++) { + xs[i] = has(obj, i) ? inspect(obj[i], obj) : ""; + } + } + var syms = typeof gOPS === "function" ? gOPS(obj) : []; + var symMap; + if (hasShammedSymbols) { + symMap = {}; + for (var k = 0; k < syms.length; k++) { + symMap["$" + syms[k]] = syms[k]; + } + } + for (var key in obj) { + if (!has(obj, key)) { + continue; + } + if (isArr && String(Number(key)) === key && key < obj.length) { + continue; + } + if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) { + continue; + } else if ($test.call(/[^\w$]/, key)) { + xs.push(inspect(key, obj) + ": " + inspect(obj[key], obj)); + } else { + xs.push(key + ": " + inspect(obj[key], obj)); + } + } + if (typeof gOPS === "function") { + for (var j = 0; j < syms.length; j++) { + if (isEnumerable.call(obj, syms[j])) { + xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj)); + } + } + } + return xs; + } + } +}); +var require_side_channel_list = __commonJS2({ + "node_modules/side-channel-list/index.js"(exports2, module2) { + "use strict"; + var inspect = require_object_inspect(); + var $TypeError = require_type(); + var listGetNode = function(list, key, isDelete) { + var prev = list; + var curr; + for (; (curr = prev.next) != null; prev = curr) { + if (curr.key === key) { + prev.next = curr.next; + if (!isDelete) { + curr.next = /** @type {NonNullable} */ + list.next; + list.next = curr; + } + return curr; + } + } + }; + var listGet = function(objects, key) { + if (!objects) { + return void 0; + } + var node = listGetNode(objects, key); + return node && node.value; + }; + var listSet = function(objects, key, value) { + var node = listGetNode(objects, key); + if (node) { + node.value = value; + } else { + objects.next = /** @type {import('./list.d.ts').ListNode} */ + { + // eslint-disable-line no-param-reassign, no-extra-parens + key, + next: objects.next, + value + }; + } + }; + var listHas = function(objects, key) { + if (!objects) { + return false; + } + return !!listGetNode(objects, key); + }; + var listDelete = function(objects, key) { + if (objects) { + return listGetNode(objects, key, true); + } + }; + module2.exports = function getSideChannelList() { + var $o; + var channel = { + assert: function(key) { + if (!channel.has(key)) { + throw new $TypeError("Side channel does not contain " + inspect(key)); + } + }, + "delete": function(key) { + var root = $o && $o.next; + var deletedNode = listDelete($o, key); + if (deletedNode && root && root === deletedNode) { + $o = void 0; + } + return !!deletedNode; + }, + get: function(key) { + return listGet($o, key); + }, + has: function(key) { + return listHas($o, key); + }, + set: function(key, value) { + if (!$o) { + $o = { + next: void 0 + }; + } + listSet( + /** @type {NonNullable} */ + $o, + key, + value + ); + } + }; + return channel; + }; + } +}); +var require_es_object_atoms = __commonJS2({ + "node_modules/es-object-atoms/index.js"(exports2, module2) { + "use strict"; + module2.exports = Object; + } +}); +var require_es_errors = __commonJS2({ + "node_modules/es-errors/index.js"(exports2, module2) { + "use strict"; + module2.exports = Error; + } +}); +var require_eval = __commonJS2({ + "node_modules/es-errors/eval.js"(exports2, module2) { + "use strict"; + module2.exports = EvalError; + } +}); +var require_range = __commonJS2({ + "node_modules/es-errors/range.js"(exports2, module2) { + "use strict"; + module2.exports = RangeError; + } +}); +var require_ref2 = __commonJS2({ + "node_modules/es-errors/ref.js"(exports2, module2) { + "use strict"; + module2.exports = ReferenceError; + } +}); +var require_syntax = __commonJS2({ + "node_modules/es-errors/syntax.js"(exports2, module2) { + "use strict"; + module2.exports = SyntaxError; + } +}); +var require_uri = __commonJS2({ + "node_modules/es-errors/uri.js"(exports2, module2) { + "use strict"; + module2.exports = URIError; + } +}); +var require_abs = __commonJS2({ + "node_modules/math-intrinsics/abs.js"(exports2, module2) { + "use strict"; + module2.exports = Math.abs; + } +}); +var require_floor = __commonJS2({ + "node_modules/math-intrinsics/floor.js"(exports2, module2) { + "use strict"; + module2.exports = Math.floor; + } +}); +var require_max = __commonJS2({ + "node_modules/math-intrinsics/max.js"(exports2, module2) { + "use strict"; + module2.exports = Math.max; + } +}); +var require_min = __commonJS2({ + "node_modules/math-intrinsics/min.js"(exports2, module2) { + "use strict"; + module2.exports = Math.min; + } +}); +var require_pow = __commonJS2({ + "node_modules/math-intrinsics/pow.js"(exports2, module2) { + "use strict"; + module2.exports = Math.pow; + } +}); +var require_round = __commonJS2({ + "node_modules/math-intrinsics/round.js"(exports2, module2) { + "use strict"; + module2.exports = Math.round; + } +}); +var require_isNaN = __commonJS2({ + "node_modules/math-intrinsics/isNaN.js"(exports2, module2) { + "use strict"; + module2.exports = Number.isNaN || function isNaN2(a) { + return a !== a; + }; + } +}); +var require_sign = __commonJS2({ + "node_modules/math-intrinsics/sign.js"(exports2, module2) { + "use strict"; + var $isNaN = require_isNaN(); + module2.exports = function sign(number) { + if ($isNaN(number) || number === 0) { + return number; + } + return number < 0 ? -1 : 1; + }; + } +}); +var require_gOPD = __commonJS2({ + "node_modules/gopd/gOPD.js"(exports2, module2) { + "use strict"; + module2.exports = Object.getOwnPropertyDescriptor; + } +}); +var require_gopd = __commonJS2({ + "node_modules/gopd/index.js"(exports2, module2) { + "use strict"; + var $gOPD = require_gOPD(); + if ($gOPD) { + try { + $gOPD([], "length"); + } catch (e) { + $gOPD = null; + } + } + module2.exports = $gOPD; + } +}); +var require_es_define_property = __commonJS2({ + "node_modules/es-define-property/index.js"(exports2, module2) { + "use strict"; + var $defineProperty = Object.defineProperty || false; + if ($defineProperty) { + try { + $defineProperty({}, "a", { value: 1 }); + } catch (e) { + $defineProperty = false; + } + } + module2.exports = $defineProperty; + } +}); +var require_shams = __commonJS2({ + "node_modules/has-symbols/shams.js"(exports2, module2) { + "use strict"; + module2.exports = function hasSymbols() { + if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") { + return false; + } + if (typeof Symbol.iterator === "symbol") { + return true; + } + var obj = {}; + var sym = Symbol("test"); + var symObj = Object(sym); + if (typeof sym === "string") { + return false; + } + if (Object.prototype.toString.call(sym) !== "[object Symbol]") { + return false; + } + if (Object.prototype.toString.call(symObj) !== "[object Symbol]") { + return false; + } + var symVal = 42; + obj[sym] = symVal; + for (var _2 in obj) { + return false; + } + if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) { + return false; + } + if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) { + return false; + } + var syms = Object.getOwnPropertySymbols(obj); + if (syms.length !== 1 || syms[0] !== sym) { + return false; + } + if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { + return false; + } + if (typeof Object.getOwnPropertyDescriptor === "function") { + var descriptor = ( + /** @type {PropertyDescriptor} */ + Object.getOwnPropertyDescriptor(obj, sym) + ); + if (descriptor.value !== symVal || descriptor.enumerable !== true) { + return false; + } + } + return true; + }; + } +}); +var require_has_symbols = __commonJS2({ + "node_modules/has-symbols/index.js"(exports2, module2) { + "use strict"; + var origSymbol = typeof Symbol !== "undefined" && Symbol; + var hasSymbolSham = require_shams(); + module2.exports = function hasNativeSymbols() { + if (typeof origSymbol !== "function") { + return false; + } + if (typeof Symbol !== "function") { + return false; + } + if (typeof origSymbol("foo") !== "symbol") { + return false; + } + if (typeof Symbol("bar") !== "symbol") { + return false; + } + return hasSymbolSham(); + }; + } +}); +var require_Reflect_getPrototypeOf = __commonJS2({ + "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports2, module2) { + "use strict"; + module2.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null; + } +}); +var require_Object_getPrototypeOf = __commonJS2({ + "node_modules/get-proto/Object.getPrototypeOf.js"(exports2, module2) { + "use strict"; + var $Object = require_es_object_atoms(); + module2.exports = $Object.getPrototypeOf || null; + } +}); +var require_implementation = __commonJS2({ + "node_modules/function-bind/implementation.js"(exports2, module2) { + "use strict"; + var ERROR_MESSAGE = "Function.prototype.bind called on incompatible "; + var toStr = Object.prototype.toString; + var max = Math.max; + var funcType = "[object Function]"; + var concatty = function concatty2(a, b) { + var arr = []; + for (var i = 0; i < a.length; i += 1) { + arr[i] = a[i]; + } + for (var j = 0; j < b.length; j += 1) { + arr[j + a.length] = b[j]; + } + return arr; + }; + var slicy = function slicy2(arrLike, offset) { + var arr = []; + for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) { + arr[j] = arrLike[i]; + } + return arr; + }; + var joiny = function(arr, joiner) { + var str = ""; + for (var i = 0; i < arr.length; i += 1) { + str += arr[i]; + if (i + 1 < arr.length) { + str += joiner; + } + } + return str; + }; + module2.exports = function bind(that) { + var target = this; + if (typeof target !== "function" || toStr.apply(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slicy(arguments, 1); + var bound; + var binder = function() { + if (this instanceof bound) { + var result = target.apply( + this, + concatty(args, arguments) + ); + if (Object(result) === result) { + return result; + } + return this; + } + return target.apply( + that, + concatty(args, arguments) + ); + }; + var boundLength = max(0, target.length - args.length); + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + boundArgs[i] = "$" + i; + } + bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder); + if (target.prototype) { + var Empty = function Empty2() { + }; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + return bound; + }; + } +}); +var require_function_bind = __commonJS2({ + "node_modules/function-bind/index.js"(exports2, module2) { + "use strict"; + var implementation = require_implementation(); + module2.exports = Function.prototype.bind || implementation; + } +}); +var require_functionCall = __commonJS2({ + "node_modules/call-bind-apply-helpers/functionCall.js"(exports2, module2) { + "use strict"; + module2.exports = Function.prototype.call; + } +}); +var require_functionApply = __commonJS2({ + "node_modules/call-bind-apply-helpers/functionApply.js"(exports2, module2) { + "use strict"; + module2.exports = Function.prototype.apply; + } +}); +var require_reflectApply = __commonJS2({ + "node_modules/call-bind-apply-helpers/reflectApply.js"(exports2, module2) { + "use strict"; + module2.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply; + } +}); +var require_actualApply = __commonJS2({ + "node_modules/call-bind-apply-helpers/actualApply.js"(exports2, module2) { + "use strict"; + var bind = require_function_bind(); + var $apply = require_functionApply(); + var $call = require_functionCall(); + var $reflectApply = require_reflectApply(); + module2.exports = $reflectApply || bind.call($call, $apply); + } +}); +var require_call_bind_apply_helpers = __commonJS2({ + "node_modules/call-bind-apply-helpers/index.js"(exports2, module2) { + "use strict"; + var bind = require_function_bind(); + var $TypeError = require_type(); + var $call = require_functionCall(); + var $actualApply = require_actualApply(); + module2.exports = function callBindBasic(args) { + if (args.length < 1 || typeof args[0] !== "function") { + throw new $TypeError("a function is required"); + } + return $actualApply(bind, $call, args); + }; + } +}); +var require_get = __commonJS2({ + "node_modules/dunder-proto/get.js"(exports2, module2) { + "use strict"; + var callBind = require_call_bind_apply_helpers(); + var gOPD = require_gopd(); + var hasProtoAccessor; + try { + hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ + [].__proto__ === Array.prototype; + } catch (e) { + if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") { + throw e; + } + } + var desc = !!hasProtoAccessor && gOPD && gOPD( + Object.prototype, + /** @type {keyof typeof Object.prototype} */ + "__proto__" + ); + var $Object = Object; + var $getPrototypeOf = $Object.getPrototypeOf; + module2.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? ( + /** @type {import('./get')} */ + (function getDunder(value) { + return $getPrototypeOf(value == null ? value : $Object(value)); + }) + ) : false; + } +}); +var require_get_proto = __commonJS2({ + "node_modules/get-proto/index.js"(exports2, module2) { + "use strict"; + var reflectGetProto = require_Reflect_getPrototypeOf(); + var originalGetProto = require_Object_getPrototypeOf(); + var getDunderProto = require_get(); + module2.exports = reflectGetProto ? function getProto(O) { + return reflectGetProto(O); + } : originalGetProto ? function getProto(O) { + if (!O || typeof O !== "object" && typeof O !== "function") { + throw new TypeError("getProto: not an object"); + } + return originalGetProto(O); + } : getDunderProto ? function getProto(O) { + return getDunderProto(O); + } : null; + } +}); +var require_hasown = __commonJS2({ + "node_modules/hasown/index.js"(exports2, module2) { + "use strict"; + var call = Function.prototype.call; + var $hasOwn = Object.prototype.hasOwnProperty; + var bind = require_function_bind(); + module2.exports = bind.call(call, $hasOwn); + } +}); +var require_get_intrinsic = __commonJS2({ + "node_modules/get-intrinsic/index.js"(exports2, module2) { + "use strict"; + var undefined2; + var $Object = require_es_object_atoms(); + var $Error = require_es_errors(); + var $EvalError = require_eval(); + var $RangeError = require_range(); + var $ReferenceError = require_ref2(); + var $SyntaxError = require_syntax(); + var $TypeError = require_type(); + var $URIError = require_uri(); + var abs = require_abs(); + var floor = require_floor(); + var max = require_max(); + var min = require_min(); + var pow = require_pow(); + var round = require_round(); + var sign = require_sign(); + var $Function = Function; + var getEvalledConstructor = function(expressionSyntax) { + try { + return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")(); + } catch (e) { + } + }; + var $gOPD = require_gopd(); + var $defineProperty = require_es_define_property(); + var throwTypeError = function() { + throw new $TypeError(); + }; + var ThrowTypeError = $gOPD ? (function() { + try { + arguments.callee; + return throwTypeError; + } catch (calleeThrows) { + try { + return $gOPD(arguments, "callee").get; + } catch (gOPDthrows) { + return throwTypeError; + } + } + })() : throwTypeError; + var hasSymbols = require_has_symbols()(); + var getProto = require_get_proto(); + var $ObjectGPO = require_Object_getPrototypeOf(); + var $ReflectGPO = require_Reflect_getPrototypeOf(); + var $apply = require_functionApply(); + var $call = require_functionCall(); + var needsEval = {}; + var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array); + var INTRINSICS = { + __proto__: null, + "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError, + "%Array%": Array, + "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer, + "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2, + "%AsyncFromSyncIteratorPrototype%": undefined2, + "%AsyncFunction%": needsEval, + "%AsyncGenerator%": needsEval, + "%AsyncGeneratorFunction%": needsEval, + "%AsyncIteratorPrototype%": needsEval, + "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics, + "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt, + "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array, + "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array, + "%Boolean%": Boolean, + "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView, + "%Date%": Date, + "%decodeURI%": decodeURI, + "%decodeURIComponent%": decodeURIComponent, + "%encodeURI%": encodeURI, + "%encodeURIComponent%": encodeURIComponent, + "%Error%": $Error, + "%eval%": eval, + // eslint-disable-line no-eval + "%EvalError%": $EvalError, + "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array, + "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array, + "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array, + "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry, + "%Function%": $Function, + "%GeneratorFunction%": needsEval, + "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array, + "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array, + "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array, + "%isFinite%": isFinite, + "%isNaN%": isNaN, + "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2, + "%JSON%": typeof JSON === "object" ? JSON : undefined2, + "%Map%": typeof Map === "undefined" ? undefined2 : Map, + "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()), + "%Math%": Math, + "%Number%": Number, + "%Object%": $Object, + "%Object.getOwnPropertyDescriptor%": $gOPD, + "%parseFloat%": parseFloat, + "%parseInt%": parseInt, + "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise, + "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy, + "%RangeError%": $RangeError, + "%ReferenceError%": $ReferenceError, + "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect, + "%RegExp%": RegExp, + "%Set%": typeof Set === "undefined" ? undefined2 : Set, + "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()), + "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer, + "%String%": String, + "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2, + "%Symbol%": hasSymbols ? Symbol : undefined2, + "%SyntaxError%": $SyntaxError, + "%ThrowTypeError%": ThrowTypeError, + "%TypedArray%": TypedArray, + "%TypeError%": $TypeError, + "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array, + "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray, + "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array, + "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array, + "%URIError%": $URIError, + "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap, + "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef, + "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet, + "%Function.prototype.call%": $call, + "%Function.prototype.apply%": $apply, + "%Object.defineProperty%": $defineProperty, + "%Object.getPrototypeOf%": $ObjectGPO, + "%Math.abs%": abs, + "%Math.floor%": floor, + "%Math.max%": max, + "%Math.min%": min, + "%Math.pow%": pow, + "%Math.round%": round, + "%Math.sign%": sign, + "%Reflect.getPrototypeOf%": $ReflectGPO + }; + if (getProto) { + try { + null.error; + } catch (e) { + errorProto = getProto(getProto(e)); + INTRINSICS["%Error.prototype%"] = errorProto; + } + } + var errorProto; + var doEval = function doEval2(name) { + var value; + if (name === "%AsyncFunction%") { + value = getEvalledConstructor("async function () {}"); + } else if (name === "%GeneratorFunction%") { + value = getEvalledConstructor("function* () {}"); + } else if (name === "%AsyncGeneratorFunction%") { + value = getEvalledConstructor("async function* () {}"); + } else if (name === "%AsyncGenerator%") { + var fn = doEval2("%AsyncGeneratorFunction%"); + if (fn) { + value = fn.prototype; + } + } else if (name === "%AsyncIteratorPrototype%") { + var gen = doEval2("%AsyncGenerator%"); + if (gen && getProto) { + value = getProto(gen.prototype); + } + } + INTRINSICS[name] = value; + return value; + }; + var LEGACY_ALIASES = { + __proto__: null, + "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], + "%ArrayPrototype%": ["Array", "prototype"], + "%ArrayProto_entries%": ["Array", "prototype", "entries"], + "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], + "%ArrayProto_keys%": ["Array", "prototype", "keys"], + "%ArrayProto_values%": ["Array", "prototype", "values"], + "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], + "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], + "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], + "%BooleanPrototype%": ["Boolean", "prototype"], + "%DataViewPrototype%": ["DataView", "prototype"], + "%DatePrototype%": ["Date", "prototype"], + "%ErrorPrototype%": ["Error", "prototype"], + "%EvalErrorPrototype%": ["EvalError", "prototype"], + "%Float32ArrayPrototype%": ["Float32Array", "prototype"], + "%Float64ArrayPrototype%": ["Float64Array", "prototype"], + "%FunctionPrototype%": ["Function", "prototype"], + "%Generator%": ["GeneratorFunction", "prototype"], + "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], + "%Int8ArrayPrototype%": ["Int8Array", "prototype"], + "%Int16ArrayPrototype%": ["Int16Array", "prototype"], + "%Int32ArrayPrototype%": ["Int32Array", "prototype"], + "%JSONParse%": ["JSON", "parse"], + "%JSONStringify%": ["JSON", "stringify"], + "%MapPrototype%": ["Map", "prototype"], + "%NumberPrototype%": ["Number", "prototype"], + "%ObjectPrototype%": ["Object", "prototype"], + "%ObjProto_toString%": ["Object", "prototype", "toString"], + "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], + "%PromisePrototype%": ["Promise", "prototype"], + "%PromiseProto_then%": ["Promise", "prototype", "then"], + "%Promise_all%": ["Promise", "all"], + "%Promise_reject%": ["Promise", "reject"], + "%Promise_resolve%": ["Promise", "resolve"], + "%RangeErrorPrototype%": ["RangeError", "prototype"], + "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], + "%RegExpPrototype%": ["RegExp", "prototype"], + "%SetPrototype%": ["Set", "prototype"], + "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], + "%StringPrototype%": ["String", "prototype"], + "%SymbolPrototype%": ["Symbol", "prototype"], + "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], + "%TypedArrayPrototype%": ["TypedArray", "prototype"], + "%TypeErrorPrototype%": ["TypeError", "prototype"], + "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], + "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], + "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], + "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], + "%URIErrorPrototype%": ["URIError", "prototype"], + "%WeakMapPrototype%": ["WeakMap", "prototype"], + "%WeakSetPrototype%": ["WeakSet", "prototype"] + }; + var bind = require_function_bind(); + var hasOwn = require_hasown(); + var $concat = bind.call($call, Array.prototype.concat); + var $spliceApply = bind.call($apply, Array.prototype.splice); + var $replace = bind.call($call, String.prototype.replace); + var $strSlice = bind.call($call, String.prototype.slice); + var $exec = bind.call($call, RegExp.prototype.exec); + var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; + var reEscapeChar = /\\(\\)?/g; + var stringToPath = function stringToPath2(string) { + var first = $strSlice(string, 0, 1); + var last = $strSlice(string, -1); + if (first === "%" && last !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`"); + } else if (last === "%" && first !== "%") { + throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`"); + } + var result = []; + $replace(string, rePropName, function(match, number, quote, subString) { + result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match; + }); + return result; + }; + var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) { + var intrinsicName = name; + var alias; + if (hasOwn(LEGACY_ALIASES, intrinsicName)) { + alias = LEGACY_ALIASES[intrinsicName]; + intrinsicName = "%" + alias[0] + "%"; + } + if (hasOwn(INTRINSICS, intrinsicName)) { + var value = INTRINSICS[intrinsicName]; + if (value === needsEval) { + value = doEval(intrinsicName); + } + if (typeof value === "undefined" && !allowMissing) { + throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!"); + } + return { + alias, + name: intrinsicName, + value + }; + } + throw new $SyntaxError("intrinsic " + name + " does not exist!"); + }; + module2.exports = function GetIntrinsic(name, allowMissing) { + if (typeof name !== "string" || name.length === 0) { + throw new $TypeError("intrinsic name must be a non-empty string"); + } + if (arguments.length > 1 && typeof allowMissing !== "boolean") { + throw new $TypeError('"allowMissing" argument must be a boolean'); + } + if ($exec(/^%?[^%]*%?$/, name) === null) { + throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name"); + } + var parts = stringToPath(name); + var intrinsicBaseName = parts.length > 0 ? parts[0] : ""; + var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing); + var intrinsicRealName = intrinsic.name; + var value = intrinsic.value; + var skipFurtherCaching = false; + var alias = intrinsic.alias; + if (alias) { + intrinsicBaseName = alias[0]; + $spliceApply(parts, $concat([0, 1], alias)); + } + for (var i = 1, isOwn = true; i < parts.length; i += 1) { + var part = parts[i]; + var first = $strSlice(part, 0, 1); + var last = $strSlice(part, -1); + if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) { + throw new $SyntaxError("property names with quotes must have matching quotes"); + } + if (part === "constructor" || !isOwn) { + skipFurtherCaching = true; + } + intrinsicBaseName += "." + part; + intrinsicRealName = "%" + intrinsicBaseName + "%"; + if (hasOwn(INTRINSICS, intrinsicRealName)) { + value = INTRINSICS[intrinsicRealName]; + } else if (value != null) { + if (!(part in value)) { + if (!allowMissing) { + throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available."); + } + return void undefined2; + } + if ($gOPD && i + 1 >= parts.length) { + var desc = $gOPD(value, part); + isOwn = !!desc; + if (isOwn && "get" in desc && !("originalValue" in desc.get)) { + value = desc.get; + } else { + value = value[part]; + } + } else { + isOwn = hasOwn(value, part); + value = value[part]; + } + if (isOwn && !skipFurtherCaching) { + INTRINSICS[intrinsicRealName] = value; + } + } + } + return value; + }; + } +}); +var require_call_bound = __commonJS2({ + "node_modules/call-bound/index.js"(exports2, module2) { + "use strict"; + var GetIntrinsic = require_get_intrinsic(); + var callBindBasic = require_call_bind_apply_helpers(); + var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]); + module2.exports = function callBoundIntrinsic(name, allowMissing) { + var intrinsic = ( + /** @type {(this: unknown, ...args: unknown[]) => unknown} */ + GetIntrinsic(name, !!allowMissing) + ); + if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) { + return callBindBasic( + /** @type {const} */ + [intrinsic] + ); + } + return intrinsic; + }; + } +}); +var require_side_channel_map = __commonJS2({ + "node_modules/side-channel-map/index.js"(exports2, module2) { + "use strict"; + var GetIntrinsic = require_get_intrinsic(); + var callBound = require_call_bound(); + var inspect = require_object_inspect(); + var $TypeError = require_type(); + var $Map = GetIntrinsic("%Map%", true); + var $mapGet = callBound("Map.prototype.get", true); + var $mapSet = callBound("Map.prototype.set", true); + var $mapHas = callBound("Map.prototype.has", true); + var $mapDelete = callBound("Map.prototype.delete", true); + var $mapSize = callBound("Map.prototype.size", true); + module2.exports = !!$Map && /** @type {Exclude} */ + function getSideChannelMap() { + var $m; + var channel = { + assert: function(key) { + if (!channel.has(key)) { + throw new $TypeError("Side channel does not contain " + inspect(key)); + } + }, + "delete": function(key) { + if ($m) { + var result = $mapDelete($m, key); + if ($mapSize($m) === 0) { + $m = void 0; + } + return result; + } + return false; + }, + get: function(key) { + if ($m) { + return $mapGet($m, key); + } + }, + has: function(key) { + if ($m) { + return $mapHas($m, key); + } + return false; + }, + set: function(key, value) { + if (!$m) { + $m = new $Map(); + } + $mapSet($m, key, value); + } + }; + return channel; + }; + } +}); +var require_side_channel_weakmap = __commonJS2({ + "node_modules/side-channel-weakmap/index.js"(exports2, module2) { + "use strict"; + var GetIntrinsic = require_get_intrinsic(); + var callBound = require_call_bound(); + var inspect = require_object_inspect(); + var getSideChannelMap = require_side_channel_map(); + var $TypeError = require_type(); + var $WeakMap = GetIntrinsic("%WeakMap%", true); + var $weakMapGet = callBound("WeakMap.prototype.get", true); + var $weakMapSet = callBound("WeakMap.prototype.set", true); + var $weakMapHas = callBound("WeakMap.prototype.has", true); + var $weakMapDelete = callBound("WeakMap.prototype.delete", true); + module2.exports = $WeakMap ? ( + /** @type {Exclude} */ + (function getSideChannelWeakMap() { + var $wm; + var $m; + var channel = { + assert: function(key) { + if (!channel.has(key)) { + throw new $TypeError("Side channel does not contain " + inspect(key)); + } + }, + "delete": function(key) { + if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) { + if ($wm) { + return $weakMapDelete($wm, key); + } + } else if (getSideChannelMap) { + if ($m) { + return $m["delete"](key); + } + } + return false; + }, + get: function(key) { + if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) { + if ($wm) { + return $weakMapGet($wm, key); + } + } + return $m && $m.get(key); + }, + has: function(key) { + if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) { + if ($wm) { + return $weakMapHas($wm, key); + } + } + return !!$m && $m.has(key); + }, + set: function(key, value) { + if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) { + if (!$wm) { + $wm = new $WeakMap(); + } + $weakMapSet($wm, key, value); + } else if (getSideChannelMap) { + if (!$m) { + $m = getSideChannelMap(); + } + $m.set(key, value); + } + } + }; + return channel; + }) + ) : getSideChannelMap; + } +}); +var require_side_channel = __commonJS2({ + "node_modules/side-channel/index.js"(exports2, module2) { + "use strict"; + var $TypeError = require_type(); + var inspect = require_object_inspect(); + var getSideChannelList = require_side_channel_list(); + var getSideChannelMap = require_side_channel_map(); + var getSideChannelWeakMap = require_side_channel_weakmap(); + var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList; + module2.exports = function getSideChannel() { + var $channelData; + var channel = { + assert: function(key) { + if (!channel.has(key)) { + throw new $TypeError("Side channel does not contain " + inspect(key)); + } + }, + "delete": function(key) { + return !!$channelData && $channelData["delete"](key); + }, + get: function(key) { + return $channelData && $channelData.get(key); + }, + has: function(key) { + return !!$channelData && $channelData.has(key); + }, + set: function(key, value) { + if (!$channelData) { + $channelData = makeChannel(); + } + $channelData.set(key, value); + } + }; + return channel; + }; + } +}); +var require_formats2 = __commonJS2({ + "node_modules/qs/lib/formats.js"(exports2, module2) { + "use strict"; + var replace = String.prototype.replace; + var percentTwenties = /%20/g; + var Format = { + RFC1738: "RFC1738", + RFC3986: "RFC3986" + }; + module2.exports = { + "default": Format.RFC3986, + formatters: { + RFC1738: function(value) { + return replace.call(value, percentTwenties, "+"); + }, + RFC3986: function(value) { + return String(value); + } + }, + RFC1738: Format.RFC1738, + RFC3986: Format.RFC3986 + }; + } +}); +var require_utils2 = __commonJS2({ + "node_modules/qs/lib/utils.js"(exports2, module2) { + "use strict"; + var formats = require_formats2(); + var has = Object.prototype.hasOwnProperty; + var isArray = Array.isArray; + var hexTable = (function() { + var array = []; + for (var i = 0; i < 256; ++i) { + array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase()); + } + return array; + })(); + var compactQueue = function compactQueue2(queue) { + while (queue.length > 1) { + var item = queue.pop(); + var obj = item.obj[item.prop]; + if (isArray(obj)) { + var compacted = []; + for (var j = 0; j < obj.length; ++j) { + if (typeof obj[j] !== "undefined") { + compacted.push(obj[j]); + } + } + item.obj[item.prop] = compacted; + } + } + }; + var arrayToObject = function arrayToObject2(source, options) { + var obj = options && options.plainObjects ? { __proto__: null } : {}; + for (var i = 0; i < source.length; ++i) { + if (typeof source[i] !== "undefined") { + obj[i] = source[i]; + } + } + return obj; + }; + var merge = function merge2(target, source, options) { + if (!source) { + return target; + } + if (typeof source !== "object" && typeof source !== "function") { + if (isArray(target)) { + target.push(source); + } else if (target && typeof target === "object") { + if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) { + target[source] = true; + } + } else { + return [target, source]; + } + return target; + } + if (!target || typeof target !== "object") { + return [target].concat(source); + } + var mergeTarget = target; + if (isArray(target) && !isArray(source)) { + mergeTarget = arrayToObject(target, options); + } + if (isArray(target) && isArray(source)) { + source.forEach(function(item, i) { + if (has.call(target, i)) { + var targetItem = target[i]; + if (targetItem && typeof targetItem === "object" && item && typeof item === "object") { + target[i] = merge2(targetItem, item, options); + } else { + target.push(item); + } + } else { + target[i] = item; + } + }); + return target; + } + return Object.keys(source).reduce(function(acc, key) { + var value = source[key]; + if (has.call(acc, key)) { + acc[key] = merge2(acc[key], value, options); + } else { + acc[key] = value; + } + return acc; + }, mergeTarget); + }; + var assign = function assignSingleSource(target, source) { + return Object.keys(source).reduce(function(acc, key) { + acc[key] = source[key]; + return acc; + }, target); + }; + var decode = function(str, defaultDecoder, charset) { + var strWithoutPlus = str.replace(/\+/g, " "); + if (charset === "iso-8859-1") { + return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape); + } + try { + return decodeURIComponent(strWithoutPlus); + } catch (e) { + return strWithoutPlus; + } + }; + var limit = 1024; + var encode = function encode2(str, defaultEncoder, charset, kind, format) { + if (str.length === 0) { + return str; + } + var string = str; + if (typeof str === "symbol") { + string = Symbol.prototype.toString.call(str); + } else if (typeof str !== "string") { + string = String(str); + } + if (charset === "iso-8859-1") { + return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) { + return "%26%23" + parseInt($0.slice(2), 16) + "%3B"; + }); + } + var out = ""; + for (var j = 0; j < string.length; j += limit) { + var segment = string.length >= limit ? string.slice(j, j + limit) : string; + var arr = []; + for (var i = 0; i < segment.length; ++i) { + var c = segment.charCodeAt(i); + if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats.RFC1738 && (c === 40 || c === 41)) { + arr[arr.length] = segment.charAt(i); + continue; + } + if (c < 128) { + arr[arr.length] = hexTable[c]; + continue; + } + if (c < 2048) { + arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63]; + continue; + } + if (c < 55296 || c >= 57344) { + arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63]; + continue; + } + i += 1; + c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023); + arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63]; + } + out += arr.join(""); + } + return out; + }; + var compact = function compact2(value) { + var queue = [{ obj: { o: value }, prop: "o" }]; + var refs = []; + for (var i = 0; i < queue.length; ++i) { + var item = queue[i]; + var obj = item.obj[item.prop]; + var keys = Object.keys(obj); + for (var j = 0; j < keys.length; ++j) { + var key = keys[j]; + var val = obj[key]; + if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) { + queue.push({ obj, prop: key }); + refs.push(val); + } + } + } + compactQueue(queue); + return value; + }; + var isRegExp = function isRegExp2(obj) { + return Object.prototype.toString.call(obj) === "[object RegExp]"; + }; + var isBuffer = function isBuffer2(obj) { + if (!obj || typeof obj !== "object") { + return false; + } + return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj)); + }; + var combine = function combine2(a, b) { + return [].concat(a, b); + }; + var maybeMap = function maybeMap2(val, fn) { + if (isArray(val)) { + var mapped = []; + for (var i = 0; i < val.length; i += 1) { + mapped.push(fn(val[i])); + } + return mapped; + } + return fn(val); + }; + module2.exports = { + arrayToObject, + assign, + combine, + compact, + decode, + encode, + isBuffer, + isRegExp, + maybeMap, + merge + }; + } +}); +var require_stringify = __commonJS2({ + "node_modules/qs/lib/stringify.js"(exports2, module2) { + "use strict"; + var getSideChannel = require_side_channel(); + var utils = require_utils2(); + var formats = require_formats2(); + var has = Object.prototype.hasOwnProperty; + var arrayPrefixGenerators = { + brackets: function brackets(prefix) { + return prefix + "[]"; + }, + comma: "comma", + indices: function indices(prefix, key) { + return prefix + "[" + key + "]"; + }, + repeat: function repeat(prefix) { + return prefix; + } + }; + var isArray = Array.isArray; + var push = Array.prototype.push; + var pushToArray = function(arr, valueOrArray) { + push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]); + }; + var toISO = Date.prototype.toISOString; + var defaultFormat = formats["default"]; + var defaults = { + addQueryPrefix: false, + allowDots: false, + allowEmptyArrays: false, + arrayFormat: "indices", + charset: "utf-8", + charsetSentinel: false, + commaRoundTrip: false, + delimiter: "&", + encode: true, + encodeDotInKeys: false, + encoder: utils.encode, + encodeValuesOnly: false, + filter: void 0, + format: defaultFormat, + formatter: formats.formatters[defaultFormat], + // deprecated + indices: false, + serializeDate: function serializeDate(date) { + return toISO.call(date); + }, + skipNulls: false, + strictNullHandling: false + }; + var isNonNullishPrimitive = function isNonNullishPrimitive2(v) { + return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint"; + }; + var sentinel = {}; + var stringify = function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) { + var obj = object; + var tmpSc = sideChannel; + var step = 0; + var findFlag = false; + while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) { + var pos = tmpSc.get(object); + step += 1; + if (typeof pos !== "undefined") { + if (pos === step) { + throw new RangeError("Cyclic object value"); + } else { + findFlag = true; + } + } + if (typeof tmpSc.get(sentinel) === "undefined") { + step = 0; + } + } + if (typeof filter === "function") { + obj = filter(prefix, obj); + } else if (obj instanceof Date) { + obj = serializeDate(obj); + } else if (generateArrayPrefix === "comma" && isArray(obj)) { + obj = utils.maybeMap(obj, function(value2) { + if (value2 instanceof Date) { + return serializeDate(value2); + } + return value2; + }); + } + if (obj === null) { + if (strictNullHandling) { + return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix; + } + obj = ""; + } + if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) { + if (encoder) { + var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format); + return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format))]; + } + return [formatter(prefix) + "=" + formatter(String(obj))]; + } + var values = []; + if (typeof obj === "undefined") { + return values; + } + var objKeys; + if (generateArrayPrefix === "comma" && isArray(obj)) { + if (encodeValuesOnly && encoder) { + obj = utils.maybeMap(obj, encoder); + } + objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }]; + } else if (isArray(filter)) { + objKeys = filter; + } else { + var keys = Object.keys(obj); + objKeys = sort ? keys.sort(sort) : keys; + } + var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix); + var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix; + if (allowEmptyArrays && isArray(obj) && obj.length === 0) { + return adjustedPrefix + "[]"; + } + for (var j = 0; j < objKeys.length; ++j) { + var key = objKeys[j]; + var value = typeof key === "object" && key && typeof key.value !== "undefined" ? key.value : obj[key]; + if (skipNulls && value === null) { + continue; + } + var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key); + var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]"); + sideChannel.set(object, step); + var valueSideChannel = getSideChannel(); + valueSideChannel.set(sentinel, sideChannel); + pushToArray(values, stringify2( + value, + keyPrefix, + generateArrayPrefix, + commaRoundTrip, + allowEmptyArrays, + strictNullHandling, + skipNulls, + encodeDotInKeys, + generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, + filter, + sort, + allowDots, + serializeDate, + format, + formatter, + encodeValuesOnly, + charset, + valueSideChannel + )); + } + return values; + }; + var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) { + if (!opts) { + return defaults; + } + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") { + throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") { + throw new TypeError("Encoder has to be a function."); + } + var charset = opts.charset || defaults.charset; + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + var format = formats["default"]; + if (typeof opts.format !== "undefined") { + if (!has.call(formats.formatters, opts.format)) { + throw new TypeError("Unknown format option provided."); + } + format = opts.format; + } + var formatter = formats.formatters[format]; + var filter = defaults.filter; + if (typeof opts.filter === "function" || isArray(opts.filter)) { + filter = opts.filter; + } + var arrayFormat; + if (opts.arrayFormat in arrayPrefixGenerators) { + arrayFormat = opts.arrayFormat; + } else if ("indices" in opts) { + arrayFormat = opts.indices ? "indices" : "repeat"; + } else { + arrayFormat = defaults.arrayFormat; + } + if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") { + throw new TypeError("`commaRoundTrip` must be a boolean, or absent"); + } + var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix, + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + arrayFormat, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + commaRoundTrip: !!opts.commaRoundTrip, + delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter, + encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode, + encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys, + encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder, + encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly, + filter, + format, + formatter, + serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate, + skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls, + sort: typeof opts.sort === "function" ? opts.sort : null, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling + }; + }; + module2.exports = function(object, opts) { + var obj = object; + var options = normalizeStringifyOptions(opts); + var objKeys; + var filter; + if (typeof options.filter === "function") { + filter = options.filter; + obj = filter("", obj); + } else if (isArray(options.filter)) { + filter = options.filter; + objKeys = filter; + } + var keys = []; + if (typeof obj !== "object" || obj === null) { + return ""; + } + var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat]; + var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip; + if (!objKeys) { + objKeys = Object.keys(obj); + } + if (options.sort) { + objKeys.sort(options.sort); + } + var sideChannel = getSideChannel(); + for (var i = 0; i < objKeys.length; ++i) { + var key = objKeys[i]; + var value = obj[key]; + if (options.skipNulls && value === null) { + continue; + } + pushToArray(keys, stringify( + value, + key, + generateArrayPrefix, + commaRoundTrip, + options.allowEmptyArrays, + options.strictNullHandling, + options.skipNulls, + options.encodeDotInKeys, + options.encode ? options.encoder : null, + options.filter, + options.sort, + options.allowDots, + options.serializeDate, + options.format, + options.formatter, + options.encodeValuesOnly, + options.charset, + sideChannel + )); + } + var joined = keys.join(options.delimiter); + var prefix = options.addQueryPrefix === true ? "?" : ""; + if (options.charsetSentinel) { + if (options.charset === "iso-8859-1") { + prefix += "utf8=%26%2310003%3B&"; + } else { + prefix += "utf8=%E2%9C%93&"; + } + } + return joined.length > 0 ? prefix + joined : ""; + }; + } +}); +var require_parse = __commonJS2({ + "node_modules/qs/lib/parse.js"(exports2, module2) { + "use strict"; + var utils = require_utils2(); + var has = Object.prototype.hasOwnProperty; + var isArray = Array.isArray; + var defaults = { + allowDots: false, + allowEmptyArrays: false, + allowPrototypes: false, + allowSparse: false, + arrayLimit: 20, + charset: "utf-8", + charsetSentinel: false, + comma: false, + decodeDotInKeys: false, + decoder: utils.decode, + delimiter: "&", + depth: 5, + duplicates: "combine", + ignoreQueryPrefix: false, + interpretNumericEntities: false, + parameterLimit: 1e3, + parseArrays: true, + plainObjects: false, + strictDepth: false, + strictNullHandling: false, + throwOnLimitExceeded: false + }; + var interpretNumericEntities = function(str) { + return str.replace(/&#(\d+);/g, function($0, numberStr) { + return String.fromCharCode(parseInt(numberStr, 10)); + }); + }; + var parseArrayValue = function(val, options, currentArrayLength) { + if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) { + return val.split(","); + } + if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) { + throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array."); + } + return val; + }; + var isoSentinel = "utf8=%26%2310003%3B"; + var charsetSentinel = "utf8=%E2%9C%93"; + var parseValues = function parseQueryStringValues(str, options) { + var obj = { __proto__: null }; + var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str; + cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]"); + var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit; + var parts = cleanStr.split( + options.delimiter, + options.throwOnLimitExceeded ? limit + 1 : limit + ); + if (options.throwOnLimitExceeded && parts.length > limit) { + throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed."); + } + var skipIndex = -1; + var i; + var charset = options.charset; + if (options.charsetSentinel) { + for (i = 0; i < parts.length; ++i) { + if (parts[i].indexOf("utf8=") === 0) { + if (parts[i] === charsetSentinel) { + charset = "utf-8"; + } else if (parts[i] === isoSentinel) { + charset = "iso-8859-1"; + } + skipIndex = i; + i = parts.length; + } + } + } + for (i = 0; i < parts.length; ++i) { + if (i === skipIndex) { + continue; + } + var part = parts[i]; + var bracketEqualsPos = part.indexOf("]="); + var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1; + var key; + var val; + if (pos === -1) { + key = options.decoder(part, defaults.decoder, charset, "key"); + val = options.strictNullHandling ? null : ""; + } else { + key = options.decoder(part.slice(0, pos), defaults.decoder, charset, "key"); + val = utils.maybeMap( + parseArrayValue( + part.slice(pos + 1), + options, + isArray(obj[key]) ? obj[key].length : 0 + ), + function(encodedVal) { + return options.decoder(encodedVal, defaults.decoder, charset, "value"); + } + ); + } + if (val && options.interpretNumericEntities && charset === "iso-8859-1") { + val = interpretNumericEntities(String(val)); + } + if (part.indexOf("[]=") > -1) { + val = isArray(val) ? [val] : val; + } + var existing = has.call(obj, key); + if (existing && options.duplicates === "combine") { + obj[key] = utils.combine(obj[key], val); + } else if (!existing || options.duplicates === "last") { + obj[key] = val; + } + } + return obj; + }; + var parseObject = function(chain, val, options, valuesParsed) { + var currentArrayLength = 0; + if (chain.length > 0 && chain[chain.length - 1] === "[]") { + var parentKey = chain.slice(0, -1).join(""); + currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0; + } + var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength); + for (var i = chain.length - 1; i >= 0; --i) { + var obj; + var root = chain[i]; + if (root === "[]" && options.parseArrays) { + obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine([], leaf); + } else { + obj = options.plainObjects ? { __proto__: null } : {}; + var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root; + var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot; + var index = parseInt(decodedRoot, 10); + if (!options.parseArrays && decodedRoot === "") { + obj = { 0: leaf }; + } else if (!isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) { + obj = []; + obj[index] = leaf; + } else if (decodedRoot !== "__proto__") { + obj[decodedRoot] = leaf; + } + } + leaf = obj; + } + return leaf; + }; + var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) { + if (!givenKey) { + return; + } + var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey; + var brackets = /(\[[^[\]]*])/; + var child = /(\[[^[\]]*])/g; + var segment = options.depth > 0 && brackets.exec(key); + var parent = segment ? key.slice(0, segment.index) : key; + var keys = []; + if (parent) { + if (!options.plainObjects && has.call(Object.prototype, parent)) { + if (!options.allowPrototypes) { + return; + } + } + keys.push(parent); + } + var i = 0; + while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) { + i += 1; + if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) { + if (!options.allowPrototypes) { + return; + } + } + keys.push(segment[1]); + } + if (segment) { + if (options.strictDepth === true) { + throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true"); + } + keys.push("[" + key.slice(segment.index) + "]"); + } + return parseObject(keys, val, options, valuesParsed); + }; + var normalizeParseOptions = function normalizeParseOptions2(opts) { + if (!opts) { + return defaults; + } + if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") { + throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided"); + } + if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") { + throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided"); + } + if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") { + throw new TypeError("Decoder has to be a function."); + } + if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") { + throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined"); + } + if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") { + throw new TypeError("`throwOnLimitExceeded` option must be a boolean"); + } + var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset; + var duplicates = typeof opts.duplicates === "undefined" ? defaults.duplicates : opts.duplicates; + if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") { + throw new TypeError("The duplicates option must be either combine, first, or last"); + } + var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots; + return { + allowDots, + allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays, + allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults.allowPrototypes, + allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults.allowSparse, + arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults.arrayLimit, + charset, + charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel, + comma: typeof opts.comma === "boolean" ? opts.comma : defaults.comma, + decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults.decodeDotInKeys, + decoder: typeof opts.decoder === "function" ? opts.decoder : defaults.decoder, + delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter, + // eslint-disable-next-line no-implicit-coercion, no-extra-parens + depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults.depth, + duplicates, + ignoreQueryPrefix: opts.ignoreQueryPrefix === true, + interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults.interpretNumericEntities, + parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults.parameterLimit, + parseArrays: opts.parseArrays !== false, + plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects, + strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth, + strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling, + throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false + }; + }; + module2.exports = function(str, opts) { + var options = normalizeParseOptions(opts); + if (str === "" || str === null || typeof str === "undefined") { + return options.plainObjects ? { __proto__: null } : {}; + } + var tempObj = typeof str === "string" ? parseValues(str, options) : str; + var obj = options.plainObjects ? { __proto__: null } : {}; + var keys = Object.keys(tempObj); + for (var i = 0; i < keys.length; ++i) { + var key = keys[i]; + var newObj = parseKeys(key, tempObj[key], options, typeof str === "string"); + obj = utils.merge(obj, newObj, options); + } + if (options.allowSparse === true) { + return obj; + } + return utils.compact(obj); + }; + } +}); +var require_lib3 = __commonJS2({ + "node_modules/qs/lib/index.js"(exports2, module2) { + "use strict"; + var stringify = require_stringify(); + var parse = require_parse(); + var formats = require_formats2(); + module2.exports = { + formats, + parse, + stringify + }; + } +}); +var require_urlencoded = __commonJS2({ + "node_modules/body-parser/lib/types/urlencoded.js"(exports2, module2) { + "use strict"; + var createError = require_http_errors(); + var debug = require_src()("body-parser:urlencoded"); + var isFinished = require_on_finished().isFinished; + var read = require_read(); + var typeis = require_type_is(); + var qs = require_lib3(); + var { getCharset, normalizeOptions } = require_utils(); + module2.exports = urlencoded; + function urlencoded(options) { + var { inflate, limit, verify, shouldParse } = normalizeOptions(options, "application/x-www-form-urlencoded"); + var defaultCharset = options?.defaultCharset || "utf-8"; + if (defaultCharset !== "utf-8" && defaultCharset !== "iso-8859-1") { + throw new TypeError("option defaultCharset must be either utf-8 or iso-8859-1"); + } + var queryparse = createQueryParser(options); + function parse(body, encoding) { + return body.length ? queryparse(body, encoding) : {}; + } + return function urlencodedParser(req, res, next) { + if (isFinished(req)) { + debug("body already parsed"); + next(); + return; + } + if (!("body" in req)) { + req.body = void 0; + } + if (!typeis.hasBody(req)) { + debug("skip empty body"); + next(); + return; + } + debug("content-type %j", req.headers["content-type"]); + if (!shouldParse(req)) { + debug("skip parsing"); + next(); + return; + } + var charset = getCharset(req) || defaultCharset; + if (charset !== "utf-8" && charset !== "iso-8859-1") { + debug("invalid charset"); + next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', { + charset, + type: "charset.unsupported" + })); + return; + } + read(req, res, next, parse, debug, { + encoding: charset, + inflate, + limit, + verify + }); + }; + } + function createQueryParser(options) { + var extended = Boolean(options?.extended); + var parameterLimit = options?.parameterLimit !== void 0 ? options?.parameterLimit : 1e3; + var charsetSentinel = options?.charsetSentinel; + var interpretNumericEntities = options?.interpretNumericEntities; + var depth = extended ? options?.depth !== void 0 ? options?.depth : 32 : 0; + if (isNaN(parameterLimit) || parameterLimit < 1) { + throw new TypeError("option parameterLimit must be a positive number"); + } + if (isNaN(depth) || depth < 0) { + throw new TypeError("option depth must be a zero or a positive number"); + } + if (isFinite(parameterLimit)) { + parameterLimit = parameterLimit | 0; + } + return function queryparse(body, encoding) { + var paramCount = parameterCount(body, parameterLimit); + if (paramCount === void 0) { + debug("too many parameters"); + throw createError(413, "too many parameters", { + type: "parameters.too.many" + }); + } + var arrayLimit = extended ? Math.max(100, paramCount) : 0; + debug("parse " + (extended ? "extended " : "") + "urlencoding"); + try { + return qs.parse(body, { + allowPrototypes: true, + arrayLimit, + depth, + charsetSentinel, + interpretNumericEntities, + charset: encoding, + parameterLimit, + strictDepth: true + }); + } catch (err2) { + if (err2 instanceof RangeError) { + throw createError(400, "The input exceeded the depth", { + type: "querystring.parse.rangeError" + }); + } else { + throw err2; + } + } + }; + } + function parameterCount(body, limit) { + var len = body.split("&").length; + return len > limit ? void 0 : len - 1; + } + } +}); +var require_body_parser = __commonJS2({ + "node_modules/body-parser/index.js"(exports2, module2) { + "use strict"; + exports2 = module2.exports = bodyParser; + Object.defineProperty(exports2, "json", { + configurable: true, + enumerable: true, + get: () => require_json() + }); + Object.defineProperty(exports2, "raw", { + configurable: true, + enumerable: true, + get: () => require_raw() + }); + Object.defineProperty(exports2, "text", { + configurable: true, + enumerable: true, + get: () => require_text() + }); + Object.defineProperty(exports2, "urlencoded", { + configurable: true, + enumerable: true, + get: () => require_urlencoded() + }); + function bodyParser() { + throw new Error("The bodyParser() generic has been split into individual middleware to use instead."); + } + } +}); +var require_merge_descriptors = __commonJS2({ + "node_modules/merge-descriptors/index.js"(exports2, module2) { + "use strict"; + function mergeDescriptors(destination, source, overwrite = true) { + if (!destination) { + throw new TypeError("The `destination` argument is required."); + } + if (!source) { + throw new TypeError("The `source` argument is required."); + } + for (const name of Object.getOwnPropertyNames(source)) { + if (!overwrite && Object.hasOwn(destination, name)) { + continue; + } + const descriptor = Object.getOwnPropertyDescriptor(source, name); + Object.defineProperty(destination, name, descriptor); + } + return destination; + } + module2.exports = mergeDescriptors; + } +}); +var require_encodeurl = __commonJS2({ + "node_modules/encodeurl/index.js"(exports2, module2) { + "use strict"; + module2.exports = encodeUrl; + var ENCODE_CHARS_REGEXP = /(?:[^\x21\x23-\x3B\x3D\x3F-\x5F\x61-\x7A\x7C\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g; + var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g; + var UNMATCHED_SURROGATE_PAIR_REPLACE = "$1\uFFFD$2"; + function encodeUrl(url) { + return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI); + } + } +}); +var require_escape_html = __commonJS2({ + "node_modules/escape-html/index.js"(exports2, module2) { + "use strict"; + var matchHtmlRegExp = /["'&<>]/; + module2.exports = escapeHtml; + function escapeHtml(string) { + var str = "" + string; + var match = matchHtmlRegExp.exec(str); + if (!match) { + return str; + } + var escape2; + var html = ""; + var index = 0; + var lastIndex = 0; + for (index = match.index; index < str.length; index++) { + switch (str.charCodeAt(index)) { + case 34: + escape2 = """; + break; + case 38: + escape2 = "&"; + break; + case 39: + escape2 = "'"; + break; + case 60: + escape2 = "<"; + break; + case 62: + escape2 = ">"; + break; + default: + continue; + } + if (lastIndex !== index) { + html += str.substring(lastIndex, index); + } + lastIndex = index + 1; + html += escape2; + } + return lastIndex !== index ? html + str.substring(lastIndex, index) : html; + } + } +}); +var require_parseurl = __commonJS2({ + "node_modules/parseurl/index.js"(exports2, module2) { + "use strict"; + var url = require("url"); + var parse = url.parse; + var Url = url.Url; + module2.exports = parseurl; + module2.exports.original = originalurl; + function parseurl(req) { + var url2 = req.url; + if (url2 === void 0) { + return void 0; + } + var parsed = req._parsedUrl; + if (fresh(url2, parsed)) { + return parsed; + } + parsed = fastparse(url2); + parsed._raw = url2; + return req._parsedUrl = parsed; + } + function originalurl(req) { + var url2 = req.originalUrl; + if (typeof url2 !== "string") { + return parseurl(req); + } + var parsed = req._parsedOriginalUrl; + if (fresh(url2, parsed)) { + return parsed; + } + parsed = fastparse(url2); + parsed._raw = url2; + return req._parsedOriginalUrl = parsed; + } + function fastparse(str) { + if (typeof str !== "string" || str.charCodeAt(0) !== 47) { + return parse(str); + } + var pathname = str; + var query = null; + var search = null; + for (var i = 1; i < str.length; i++) { + switch (str.charCodeAt(i)) { + case 63: + if (search === null) { + pathname = str.substring(0, i); + query = str.substring(i + 1); + search = str.substring(i); + } + break; + case 9: + /* \t */ + case 10: + /* \n */ + case 12: + /* \f */ + case 13: + /* \r */ + case 32: + /* */ + case 35: + /* # */ + case 160: + case 65279: + return parse(str); + } + } + var url2 = Url !== void 0 ? new Url() : {}; + url2.path = str; + url2.href = str; + url2.pathname = pathname; + if (search !== null) { + url2.query = query; + url2.search = search; + } + return url2; + } + function fresh(url2, parsedUrl) { + return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url2; + } + } +}); +var require_finalhandler = __commonJS2({ + "node_modules/finalhandler/index.js"(exports2, module2) { + "use strict"; + var debug = require_src()("finalhandler"); + var encodeUrl = require_encodeurl(); + var escapeHtml = require_escape_html(); + var onFinished = require_on_finished(); + var parseUrl = require_parseurl(); + var statuses = require_statuses(); + var isFinished = onFinished.isFinished; + function createHtmlDocument(message) { + var body = escapeHtml(message).replaceAll("\n", "
").replaceAll(" ", "  "); + return '\n\n\n\nError\n\n\n
' + body + "
\n\n\n"; + } + module2.exports = finalhandler; + function finalhandler(req, res, options) { + var opts = options || {}; + var env2 = opts.env || "development"; + var onerror = opts.onerror; + return function(err2) { + var headers; + var msg; + var status; + if (!err2 && res.headersSent) { + debug("cannot 404 after headers sent"); + return; + } + if (err2) { + status = getErrorStatusCode(err2); + if (status === void 0) { + status = getResponseStatusCode(res); + } else { + headers = getErrorHeaders(err2); + } + msg = getErrorMessage(err2, status, env2); + } else { + status = 404; + msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req)); + } + debug("default %s", status); + if (err2 && onerror) { + setImmediate(onerror, err2, req, res); + } + if (res.headersSent) { + debug("cannot %d after headers sent", status); + if (req.socket) { + req.socket.destroy(); + } + return; + } + send(req, res, status, headers, msg); + }; + } + function getErrorHeaders(err2) { + if (!err2.headers || typeof err2.headers !== "object") { + return void 0; + } + return { ...err2.headers }; + } + function getErrorMessage(err2, status, env2) { + var msg; + if (env2 !== "production") { + msg = err2.stack; + if (!msg && typeof err2.toString === "function") { + msg = err2.toString(); + } + } + return msg || statuses.message[status]; + } + function getErrorStatusCode(err2) { + if (typeof err2.status === "number" && err2.status >= 400 && err2.status < 600) { + return err2.status; + } + if (typeof err2.statusCode === "number" && err2.statusCode >= 400 && err2.statusCode < 600) { + return err2.statusCode; + } + return void 0; + } + function getResourceName(req) { + try { + return parseUrl.original(req).pathname; + } catch (e) { + return "resource"; + } + } + function getResponseStatusCode(res) { + var status = res.statusCode; + if (typeof status !== "number" || status < 400 || status > 599) { + status = 500; + } + return status; + } + function send(req, res, status, headers, message) { + function write() { + var body = createHtmlDocument(message); + res.statusCode = status; + if (req.httpVersionMajor < 2) { + res.statusMessage = statuses.message[status]; + } + res.removeHeader("Content-Encoding"); + res.removeHeader("Content-Language"); + res.removeHeader("Content-Range"); + for (const [key, value] of Object.entries(headers ?? {})) { + res.setHeader(key, value); + } + res.setHeader("Content-Security-Policy", "default-src 'none'"); + res.setHeader("X-Content-Type-Options", "nosniff"); + res.setHeader("Content-Type", "text/html; charset=utf-8"); + res.setHeader("Content-Length", Buffer.byteLength(body, "utf8")); + if (req.method === "HEAD") { + res.end(); + return; + } + res.end(body, "utf8"); + } + if (isFinished(req)) { + write(); + return; + } + req.unpipe(); + onFinished(req, write); + req.resume(); + } + } +}); +var require_view = __commonJS2({ + "node_modules/express/lib/view.js"(exports2, module2) { + "use strict"; + var debug = require_src()("express:view"); + var path = require("node:path"); + var fs = require("node:fs"); + var dirname = path.dirname; + var basename = path.basename; + var extname = path.extname; + var join = path.join; + var resolve = path.resolve; + module2.exports = View; + function View(name, options) { + var opts = options || {}; + this.defaultEngine = opts.defaultEngine; + this.ext = extname(name); + this.name = name; + this.root = opts.root; + if (!this.ext && !this.defaultEngine) { + throw new Error("No default engine was specified and no extension was provided."); + } + var fileName = name; + if (!this.ext) { + this.ext = this.defaultEngine[0] !== "." ? "." + this.defaultEngine : this.defaultEngine; + fileName += this.ext; + } + if (!opts.engines[this.ext]) { + var mod = this.ext.slice(1); + debug('require "%s"', mod); + var fn = require(mod).__express; + if (typeof fn !== "function") { + throw new Error('Module "' + mod + '" does not provide a view engine.'); + } + opts.engines[this.ext] = fn; + } + this.engine = opts.engines[this.ext]; + this.path = this.lookup(fileName); + } + View.prototype.lookup = function lookup(name) { + var path2; + var roots = [].concat(this.root); + debug('lookup "%s"', name); + for (var i = 0; i < roots.length && !path2; i++) { + var root = roots[i]; + var loc = resolve(root, name); + var dir = dirname(loc); + var file = basename(loc); + path2 = this.resolve(dir, file); + } + return path2; + }; + View.prototype.render = function render(options, callback) { + var sync = true; + debug('render "%s"', this.path); + this.engine(this.path, options, function onRender() { + if (!sync) { + return callback.apply(this, arguments); + } + var args = new Array(arguments.length); + var cntx = this; + for (var i = 0; i < arguments.length; i++) { + args[i] = arguments[i]; + } + return process.nextTick(function renderTick() { + return callback.apply(cntx, args); + }); + }); + sync = false; + }; + View.prototype.resolve = function resolve2(dir, file) { + var ext = this.ext; + var path2 = join(dir, file); + var stat = tryStat(path2); + if (stat && stat.isFile()) { + return path2; + } + path2 = join(dir, basename(file, ext), "index" + ext); + stat = tryStat(path2); + if (stat && stat.isFile()) { + return path2; + } + }; + function tryStat(path2) { + debug('stat "%s"', path2); + try { + return fs.statSync(path2); + } catch (e) { + return void 0; + } + } + } +}); +var require_etag = __commonJS2({ + "node_modules/etag/index.js"(exports2, module2) { + "use strict"; + module2.exports = etag; + var crypto = require("crypto"); + var Stats = require("fs").Stats; + var toString = Object.prototype.toString; + function entitytag(entity) { + if (entity.length === 0) { + return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'; + } + var hash = crypto.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27); + var len = typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length; + return '"' + len.toString(16) + "-" + hash + '"'; + } + function etag(entity, options) { + if (entity == null) { + throw new TypeError("argument entity is required"); + } + var isStats = isstats(entity); + var weak = options && typeof options.weak === "boolean" ? options.weak : isStats; + if (!isStats && typeof entity !== "string" && !Buffer.isBuffer(entity)) { + throw new TypeError("argument entity must be string, Buffer, or fs.Stats"); + } + var tag = isStats ? stattag(entity) : entitytag(entity); + return weak ? "W/" + tag : tag; + } + function isstats(obj) { + if (typeof Stats === "function" && obj instanceof Stats) { + return true; + } + return obj && typeof obj === "object" && "ctime" in obj && toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number"; + } + function stattag(stat) { + var mtime = stat.mtime.getTime().toString(16); + var size = stat.size.toString(16); + return '"' + size + "-" + mtime + '"'; + } + } +}); +var require_db2 = __commonJS2({ + "node_modules/express/node_modules/mime-db/db.json"(exports2, module2) { + module2.exports = { + "application/1d-interleaved-parityfec": { + source: "iana" + }, + "application/3gpdash-qoe-report+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/3gpp-ims+xml": { + source: "iana", + compressible: true + }, + "application/3gpphal+json": { + source: "iana", + compressible: true + }, + "application/3gpphalforms+json": { + source: "iana", + compressible: true + }, + "application/a2l": { + source: "iana" + }, + "application/ace+cbor": { + source: "iana" + }, + "application/ace+json": { + source: "iana", + compressible: true + }, + "application/ace-groupcomm+cbor": { + source: "iana" + }, + "application/ace-trl+cbor": { + source: "iana" + }, + "application/activemessage": { + source: "iana" + }, + "application/activity+json": { + source: "iana", + compressible: true + }, + "application/aif+cbor": { + source: "iana" + }, + "application/aif+json": { + source: "iana", + compressible: true + }, + "application/alto-cdni+json": { + source: "iana", + compressible: true + }, + "application/alto-cdnifilter+json": { + source: "iana", + compressible: true + }, + "application/alto-costmap+json": { + source: "iana", + compressible: true + }, + "application/alto-costmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-directory+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcost+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcostparams+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointprop+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointpropparams+json": { + source: "iana", + compressible: true + }, + "application/alto-error+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmap+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-propmap+json": { + source: "iana", + compressible: true + }, + "application/alto-propmapparams+json": { + source: "iana", + compressible: true + }, + "application/alto-tips+json": { + source: "iana", + compressible: true + }, + "application/alto-tipsparams+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamcontrol+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamparams+json": { + source: "iana", + compressible: true + }, + "application/aml": { + source: "iana" + }, + "application/andrew-inset": { + source: "iana", + extensions: ["ez"] + }, + "application/appinstaller": { + compressible: false, + extensions: ["appinstaller"] + }, + "application/applefile": { + source: "iana" + }, + "application/applixware": { + source: "apache", + extensions: ["aw"] + }, + "application/appx": { + compressible: false, + extensions: ["appx"] + }, + "application/appxbundle": { + compressible: false, + extensions: ["appxbundle"] + }, + "application/at+jwt": { + source: "iana" + }, + "application/atf": { + source: "iana" + }, + "application/atfx": { + source: "iana" + }, + "application/atom+xml": { + source: "iana", + compressible: true, + extensions: ["atom"] + }, + "application/atomcat+xml": { + source: "iana", + compressible: true, + extensions: ["atomcat"] + }, + "application/atomdeleted+xml": { + source: "iana", + compressible: true, + extensions: ["atomdeleted"] + }, + "application/atomicmail": { + source: "iana" + }, + "application/atomsvc+xml": { + source: "iana", + compressible: true, + extensions: ["atomsvc"] + }, + "application/atsc-dwd+xml": { + source: "iana", + compressible: true, + extensions: ["dwd"] + }, + "application/atsc-dynamic-event-message": { + source: "iana" + }, + "application/atsc-held+xml": { + source: "iana", + compressible: true, + extensions: ["held"] + }, + "application/atsc-rdt+json": { + source: "iana", + compressible: true + }, + "application/atsc-rsat+xml": { + source: "iana", + compressible: true, + extensions: ["rsat"] + }, + "application/atxml": { + source: "iana" + }, + "application/auth-policy+xml": { + source: "iana", + compressible: true + }, + "application/automationml-aml+xml": { + source: "iana", + compressible: true, + extensions: ["aml"] + }, + "application/automationml-amlx+zip": { + source: "iana", + compressible: false, + extensions: ["amlx"] + }, + "application/bacnet-xdd+zip": { + source: "iana", + compressible: false + }, + "application/batch-smtp": { + source: "iana" + }, + "application/bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/beep+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/bufr": { + source: "iana" + }, + "application/c2pa": { + source: "iana" + }, + "application/calendar+json": { + source: "iana", + compressible: true + }, + "application/calendar+xml": { + source: "iana", + compressible: true, + extensions: ["xcs"] + }, + "application/call-completion": { + source: "iana" + }, + "application/cals-1840": { + source: "iana" + }, + "application/captive+json": { + source: "iana", + compressible: true + }, + "application/cbor": { + source: "iana" + }, + "application/cbor-seq": { + source: "iana" + }, + "application/cccex": { + source: "iana" + }, + "application/ccmp+xml": { + source: "iana", + compressible: true + }, + "application/ccxml+xml": { + source: "iana", + compressible: true, + extensions: ["ccxml"] + }, + "application/cda+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/cdfx+xml": { + source: "iana", + compressible: true, + extensions: ["cdfx"] + }, + "application/cdmi-capability": { + source: "iana", + extensions: ["cdmia"] + }, + "application/cdmi-container": { + source: "iana", + extensions: ["cdmic"] + }, + "application/cdmi-domain": { + source: "iana", + extensions: ["cdmid"] + }, + "application/cdmi-object": { + source: "iana", + extensions: ["cdmio"] + }, + "application/cdmi-queue": { + source: "iana", + extensions: ["cdmiq"] + }, + "application/cdni": { + source: "iana" + }, + "application/ce+cbor": { + source: "iana" + }, + "application/cea": { + source: "iana" + }, + "application/cea-2018+xml": { + source: "iana", + compressible: true + }, + "application/cellml+xml": { + source: "iana", + compressible: true + }, + "application/cfw": { + source: "iana" + }, + "application/cid-edhoc+cbor-seq": { + source: "iana" + }, + "application/city+json": { + source: "iana", + compressible: true + }, + "application/city+json-seq": { + source: "iana" + }, + "application/clr": { + source: "iana" + }, + "application/clue+xml": { + source: "iana", + compressible: true + }, + "application/clue_info+xml": { + source: "iana", + compressible: true + }, + "application/cms": { + source: "iana" + }, + "application/cnrp+xml": { + source: "iana", + compressible: true + }, + "application/coap-eap": { + source: "iana" + }, + "application/coap-group+json": { + source: "iana", + compressible: true + }, + "application/coap-payload": { + source: "iana" + }, + "application/commonground": { + source: "iana" + }, + "application/concise-problem-details+cbor": { + source: "iana" + }, + "application/conference-info+xml": { + source: "iana", + compressible: true + }, + "application/cose": { + source: "iana" + }, + "application/cose-key": { + source: "iana" + }, + "application/cose-key-set": { + source: "iana" + }, + "application/cose-x509": { + source: "iana" + }, + "application/cpl+xml": { + source: "iana", + compressible: true, + extensions: ["cpl"] + }, + "application/csrattrs": { + source: "iana" + }, + "application/csta+xml": { + source: "iana", + compressible: true + }, + "application/cstadata+xml": { + source: "iana", + compressible: true + }, + "application/csvm+json": { + source: "iana", + compressible: true + }, + "application/cu-seeme": { + source: "apache", + extensions: ["cu"] + }, + "application/cwl": { + source: "iana", + extensions: ["cwl"] + }, + "application/cwl+json": { + source: "iana", + compressible: true + }, + "application/cwl+yaml": { + source: "iana" + }, + "application/cwt": { + source: "iana" + }, + "application/cybercash": { + source: "iana" + }, + "application/dart": { + compressible: true + }, + "application/dash+xml": { + source: "iana", + compressible: true, + extensions: ["mpd"] + }, + "application/dash-patch+xml": { + source: "iana", + compressible: true, + extensions: ["mpp"] + }, + "application/dashdelta": { + source: "iana" + }, + "application/davmount+xml": { + source: "iana", + compressible: true, + extensions: ["davmount"] + }, + "application/dca-rft": { + source: "iana" + }, + "application/dcd": { + source: "iana" + }, + "application/dec-dx": { + source: "iana" + }, + "application/dialog-info+xml": { + source: "iana", + compressible: true + }, + "application/dicom": { + source: "iana", + extensions: ["dcm"] + }, + "application/dicom+json": { + source: "iana", + compressible: true + }, + "application/dicom+xml": { + source: "iana", + compressible: true + }, + "application/dii": { + source: "iana" + }, + "application/dit": { + source: "iana" + }, + "application/dns": { + source: "iana" + }, + "application/dns+json": { + source: "iana", + compressible: true + }, + "application/dns-message": { + source: "iana" + }, + "application/docbook+xml": { + source: "apache", + compressible: true, + extensions: ["dbk"] + }, + "application/dots+cbor": { + source: "iana" + }, + "application/dpop+jwt": { + source: "iana" + }, + "application/dskpp+xml": { + source: "iana", + compressible: true + }, + "application/dssc+der": { + source: "iana", + extensions: ["dssc"] + }, + "application/dssc+xml": { + source: "iana", + compressible: true, + extensions: ["xdssc"] + }, + "application/dvcs": { + source: "iana" + }, + "application/eat+cwt": { + source: "iana" + }, + "application/eat+jwt": { + source: "iana" + }, + "application/eat-bun+cbor": { + source: "iana" + }, + "application/eat-bun+json": { + source: "iana", + compressible: true + }, + "application/eat-ucs+cbor": { + source: "iana" + }, + "application/eat-ucs+json": { + source: "iana", + compressible: true + }, + "application/ecmascript": { + source: "apache", + compressible: true, + extensions: ["ecma"] + }, + "application/edhoc+cbor-seq": { + source: "iana" + }, + "application/edi-consent": { + source: "iana" + }, + "application/edi-x12": { + source: "iana", + compressible: false + }, + "application/edifact": { + source: "iana", + compressible: false + }, + "application/efi": { + source: "iana" + }, + "application/elm+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/elm+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.cap+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/emergencycalldata.comment+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.control+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.deviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.ecall.msd": { + source: "iana" + }, + "application/emergencycalldata.legacyesn+json": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.providerinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.serviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.subscriberinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.veds+xml": { + source: "iana", + compressible: true + }, + "application/emma+xml": { + source: "iana", + compressible: true, + extensions: ["emma"] + }, + "application/emotionml+xml": { + source: "iana", + compressible: true, + extensions: ["emotionml"] + }, + "application/encaprtp": { + source: "iana" + }, + "application/entity-statement+jwt": { + source: "iana" + }, + "application/epp+xml": { + source: "iana", + compressible: true + }, + "application/epub+zip": { + source: "iana", + compressible: false, + extensions: ["epub"] + }, + "application/eshop": { + source: "iana" + }, + "application/exi": { + source: "iana", + extensions: ["exi"] + }, + "application/expect-ct-report+json": { + source: "iana", + compressible: true + }, + "application/express": { + source: "iana", + extensions: ["exp"] + }, + "application/fastinfoset": { + source: "iana" + }, + "application/fastsoap": { + source: "iana" + }, + "application/fdf": { + source: "iana", + extensions: ["fdf"] + }, + "application/fdt+xml": { + source: "iana", + compressible: true, + extensions: ["fdt"] + }, + "application/fhir+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fhir+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fido.trusted-apps+json": { + compressible: true + }, + "application/fits": { + source: "iana" + }, + "application/flexfec": { + source: "iana" + }, + "application/font-sfnt": { + source: "iana" + }, + "application/font-tdpfr": { + source: "iana", + extensions: ["pfr"] + }, + "application/font-woff": { + source: "iana", + compressible: false + }, + "application/framework-attributes+xml": { + source: "iana", + compressible: true + }, + "application/geo+json": { + source: "iana", + compressible: true, + extensions: ["geojson"] + }, + "application/geo+json-seq": { + source: "iana" + }, + "application/geopackage+sqlite3": { + source: "iana" + }, + "application/geopose+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+xml": { + source: "iana", + compressible: true + }, + "application/gltf-buffer": { + source: "iana" + }, + "application/gml+xml": { + source: "iana", + compressible: true, + extensions: ["gml"] + }, + "application/gnap-binding-jws": { + source: "iana" + }, + "application/gnap-binding-jwsd": { + source: "iana" + }, + "application/gnap-binding-rotation-jws": { + source: "iana" + }, + "application/gnap-binding-rotation-jwsd": { + source: "iana" + }, + "application/gpx+xml": { + source: "apache", + compressible: true, + extensions: ["gpx"] + }, + "application/grib": { + source: "iana" + }, + "application/gxf": { + source: "apache", + extensions: ["gxf"] + }, + "application/gzip": { + source: "iana", + compressible: false, + extensions: ["gz"] + }, + "application/h224": { + source: "iana" + }, + "application/held+xml": { + source: "iana", + compressible: true + }, + "application/hjson": { + extensions: ["hjson"] + }, + "application/hl7v2+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/http": { + source: "iana" + }, + "application/hyperstudio": { + source: "iana", + extensions: ["stk"] + }, + "application/ibe-key-request+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pkg-reply+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pp-data": { + source: "iana" + }, + "application/iges": { + source: "iana" + }, + "application/im-iscomposing+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/index": { + source: "iana" + }, + "application/index.cmd": { + source: "iana" + }, + "application/index.obj": { + source: "iana" + }, + "application/index.response": { + source: "iana" + }, + "application/index.vnd": { + source: "iana" + }, + "application/inkml+xml": { + source: "iana", + compressible: true, + extensions: ["ink", "inkml"] + }, + "application/iotp": { + source: "iana" + }, + "application/ipfix": { + source: "iana", + extensions: ["ipfix"] + }, + "application/ipp": { + source: "iana" + }, + "application/isup": { + source: "iana" + }, + "application/its+xml": { + source: "iana", + compressible: true, + extensions: ["its"] + }, + "application/java-archive": { + source: "iana", + compressible: false, + extensions: ["jar", "war", "ear"] + }, + "application/java-serialized-object": { + source: "apache", + compressible: false, + extensions: ["ser"] + }, + "application/java-vm": { + source: "apache", + compressible: false, + extensions: ["class"] + }, + "application/javascript": { + source: "apache", + charset: "UTF-8", + compressible: true, + extensions: ["js"] + }, + "application/jf2feed+json": { + source: "iana", + compressible: true + }, + "application/jose": { + source: "iana" + }, + "application/jose+json": { + source: "iana", + compressible: true + }, + "application/jrd+json": { + source: "iana", + compressible: true + }, + "application/jscalendar+json": { + source: "iana", + compressible: true + }, + "application/jscontact+json": { + source: "iana", + compressible: true + }, + "application/json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["json", "map"] + }, + "application/json-patch+json": { + source: "iana", + compressible: true + }, + "application/json-seq": { + source: "iana" + }, + "application/json5": { + extensions: ["json5"] + }, + "application/jsonml+json": { + source: "apache", + compressible: true, + extensions: ["jsonml"] + }, + "application/jsonpath": { + source: "iana" + }, + "application/jwk+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+jwt": { + source: "iana" + }, + "application/jwt": { + source: "iana" + }, + "application/kpml-request+xml": { + source: "iana", + compressible: true + }, + "application/kpml-response+xml": { + source: "iana", + compressible: true + }, + "application/ld+json": { + source: "iana", + compressible: true, + extensions: ["jsonld"] + }, + "application/lgr+xml": { + source: "iana", + compressible: true, + extensions: ["lgr"] + }, + "application/link-format": { + source: "iana" + }, + "application/linkset": { + source: "iana" + }, + "application/linkset+json": { + source: "iana", + compressible: true + }, + "application/load-control+xml": { + source: "iana", + compressible: true + }, + "application/logout+jwt": { + source: "iana" + }, + "application/lost+xml": { + source: "iana", + compressible: true, + extensions: ["lostxml"] + }, + "application/lostsync+xml": { + source: "iana", + compressible: true + }, + "application/lpf+zip": { + source: "iana", + compressible: false + }, + "application/lxf": { + source: "iana" + }, + "application/mac-binhex40": { + source: "iana", + extensions: ["hqx"] + }, + "application/mac-compactpro": { + source: "apache", + extensions: ["cpt"] + }, + "application/macwriteii": { + source: "iana" + }, + "application/mads+xml": { + source: "iana", + compressible: true, + extensions: ["mads"] + }, + "application/manifest+json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["webmanifest"] + }, + "application/marc": { + source: "iana", + extensions: ["mrc"] + }, + "application/marcxml+xml": { + source: "iana", + compressible: true, + extensions: ["mrcx"] + }, + "application/mathematica": { + source: "iana", + extensions: ["ma", "nb", "mb"] + }, + "application/mathml+xml": { + source: "iana", + compressible: true, + extensions: ["mathml"] + }, + "application/mathml-content+xml": { + source: "iana", + compressible: true + }, + "application/mathml-presentation+xml": { + source: "iana", + compressible: true + }, + "application/mbms-associated-procedure-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-deregister+xml": { + source: "iana", + compressible: true + }, + "application/mbms-envelope+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-protection-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-reception-report+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-schedule+xml": { + source: "iana", + compressible: true + }, + "application/mbms-user-service-description+xml": { + source: "iana", + compressible: true + }, + "application/mbox": { + source: "iana", + extensions: ["mbox"] + }, + "application/media-policy-dataset+xml": { + source: "iana", + compressible: true, + extensions: ["mpf"] + }, + "application/media_control+xml": { + source: "iana", + compressible: true + }, + "application/mediaservercontrol+xml": { + source: "iana", + compressible: true, + extensions: ["mscml"] + }, + "application/merge-patch+json": { + source: "iana", + compressible: true + }, + "application/metalink+xml": { + source: "apache", + compressible: true, + extensions: ["metalink"] + }, + "application/metalink4+xml": { + source: "iana", + compressible: true, + extensions: ["meta4"] + }, + "application/mets+xml": { + source: "iana", + compressible: true, + extensions: ["mets"] + }, + "application/mf4": { + source: "iana" + }, + "application/mikey": { + source: "iana" + }, + "application/mipc": { + source: "iana" + }, + "application/missing-blocks+cbor-seq": { + source: "iana" + }, + "application/mmt-aei+xml": { + source: "iana", + compressible: true, + extensions: ["maei"] + }, + "application/mmt-usd+xml": { + source: "iana", + compressible: true, + extensions: ["musd"] + }, + "application/mods+xml": { + source: "iana", + compressible: true, + extensions: ["mods"] + }, + "application/moss-keys": { + source: "iana" + }, + "application/moss-signature": { + source: "iana" + }, + "application/mosskey-data": { + source: "iana" + }, + "application/mosskey-request": { + source: "iana" + }, + "application/mp21": { + source: "iana", + extensions: ["m21", "mp21"] + }, + "application/mp4": { + source: "iana", + extensions: ["mp4", "mpg4", "mp4s", "m4p"] + }, + "application/mpeg4-generic": { + source: "iana" + }, + "application/mpeg4-iod": { + source: "iana" + }, + "application/mpeg4-iod-xmt": { + source: "iana" + }, + "application/mrb-consumer+xml": { + source: "iana", + compressible: true + }, + "application/mrb-publish+xml": { + source: "iana", + compressible: true + }, + "application/msc-ivr+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msc-mixer+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msix": { + compressible: false, + extensions: ["msix"] + }, + "application/msixbundle": { + compressible: false, + extensions: ["msixbundle"] + }, + "application/msword": { + source: "iana", + compressible: false, + extensions: ["doc", "dot"] + }, + "application/mud+json": { + source: "iana", + compressible: true + }, + "application/multipart-core": { + source: "iana" + }, + "application/mxf": { + source: "iana", + extensions: ["mxf"] + }, + "application/n-quads": { + source: "iana", + extensions: ["nq"] + }, + "application/n-triples": { + source: "iana", + extensions: ["nt"] + }, + "application/nasdata": { + source: "iana" + }, + "application/news-checkgroups": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-groupinfo": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-transmission": { + source: "iana" + }, + "application/nlsml+xml": { + source: "iana", + compressible: true + }, + "application/node": { + source: "iana", + extensions: ["cjs"] + }, + "application/nss": { + source: "iana" + }, + "application/oauth-authz-req+jwt": { + source: "iana" + }, + "application/oblivious-dns-message": { + source: "iana" + }, + "application/ocsp-request": { + source: "iana" + }, + "application/ocsp-response": { + source: "iana" + }, + "application/octet-stream": { + source: "iana", + compressible: true, + extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] + }, + "application/oda": { + source: "iana", + extensions: ["oda"] + }, + "application/odm+xml": { + source: "iana", + compressible: true + }, + "application/odx": { + source: "iana" + }, + "application/oebps-package+xml": { + source: "iana", + compressible: true, + extensions: ["opf"] + }, + "application/ogg": { + source: "iana", + compressible: false, + extensions: ["ogx"] + }, + "application/ohttp-keys": { + source: "iana" + }, + "application/omdoc+xml": { + source: "apache", + compressible: true, + extensions: ["omdoc"] + }, + "application/onenote": { + source: "apache", + extensions: ["onetoc", "onetoc2", "onetmp", "onepkg", "one", "onea"] + }, + "application/opc-nodeset+xml": { + source: "iana", + compressible: true + }, + "application/oscore": { + source: "iana" + }, + "application/oxps": { + source: "iana", + extensions: ["oxps"] + }, + "application/p21": { + source: "iana" + }, + "application/p21+zip": { + source: "iana", + compressible: false + }, + "application/p2p-overlay+xml": { + source: "iana", + compressible: true, + extensions: ["relo"] + }, + "application/parityfec": { + source: "iana" + }, + "application/passport": { + source: "iana" + }, + "application/patch-ops-error+xml": { + source: "iana", + compressible: true, + extensions: ["xer"] + }, + "application/pdf": { + source: "iana", + compressible: false, + extensions: ["pdf"] + }, + "application/pdx": { + source: "iana" + }, + "application/pem-certificate-chain": { + source: "iana" + }, + "application/pgp-encrypted": { + source: "iana", + compressible: false, + extensions: ["pgp"] + }, + "application/pgp-keys": { + source: "iana", + extensions: ["asc"] + }, + "application/pgp-signature": { + source: "iana", + extensions: ["sig", "asc"] + }, + "application/pics-rules": { + source: "apache", + extensions: ["prf"] + }, + "application/pidf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pidf-diff+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pkcs10": { + source: "iana", + extensions: ["p10"] + }, + "application/pkcs12": { + source: "iana" + }, + "application/pkcs7-mime": { + source: "iana", + extensions: ["p7m", "p7c"] + }, + "application/pkcs7-signature": { + source: "iana", + extensions: ["p7s"] + }, + "application/pkcs8": { + source: "iana", + extensions: ["p8"] + }, + "application/pkcs8-encrypted": { + source: "iana" + }, + "application/pkix-attr-cert": { + source: "iana", + extensions: ["ac"] + }, + "application/pkix-cert": { + source: "iana", + extensions: ["cer"] + }, + "application/pkix-crl": { + source: "iana", + extensions: ["crl"] + }, + "application/pkix-pkipath": { + source: "iana", + extensions: ["pkipath"] + }, + "application/pkixcmp": { + source: "iana", + extensions: ["pki"] + }, + "application/pls+xml": { + source: "iana", + compressible: true, + extensions: ["pls"] + }, + "application/poc-settings+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/postscript": { + source: "iana", + compressible: true, + extensions: ["ai", "eps", "ps"] + }, + "application/ppsp-tracker+json": { + source: "iana", + compressible: true + }, + "application/private-token-issuer-directory": { + source: "iana" + }, + "application/private-token-request": { + source: "iana" + }, + "application/private-token-response": { + source: "iana" + }, + "application/problem+json": { + source: "iana", + compressible: true + }, + "application/problem+xml": { + source: "iana", + compressible: true + }, + "application/provenance+xml": { + source: "iana", + compressible: true, + extensions: ["provx"] + }, + "application/provided-claims+jwt": { + source: "iana" + }, + "application/prs.alvestrand.titrax-sheet": { + source: "iana" + }, + "application/prs.cww": { + source: "iana", + extensions: ["cww"] + }, + "application/prs.cyn": { + source: "iana", + charset: "7-BIT" + }, + "application/prs.hpub+zip": { + source: "iana", + compressible: false + }, + "application/prs.implied-document+xml": { + source: "iana", + compressible: true + }, + "application/prs.implied-executable": { + source: "iana" + }, + "application/prs.implied-object+json": { + source: "iana", + compressible: true + }, + "application/prs.implied-object+json-seq": { + source: "iana" + }, + "application/prs.implied-object+yaml": { + source: "iana" + }, + "application/prs.implied-structure": { + source: "iana" + }, + "application/prs.mayfile": { + source: "iana" + }, + "application/prs.nprend": { + source: "iana" + }, + "application/prs.plucker": { + source: "iana" + }, + "application/prs.rdf-xml-crypt": { + source: "iana" + }, + "application/prs.vcfbzip2": { + source: "iana" + }, + "application/prs.xsf+xml": { + source: "iana", + compressible: true, + extensions: ["xsf"] + }, + "application/pskc+xml": { + source: "iana", + compressible: true, + extensions: ["pskcxml"] + }, + "application/pvd+json": { + source: "iana", + compressible: true + }, + "application/qsig": { + source: "iana" + }, + "application/raml+yaml": { + compressible: true, + extensions: ["raml"] + }, + "application/raptorfec": { + source: "iana" + }, + "application/rdap+json": { + source: "iana", + compressible: true + }, + "application/rdf+xml": { + source: "iana", + compressible: true, + extensions: ["rdf", "owl"] + }, + "application/reginfo+xml": { + source: "iana", + compressible: true, + extensions: ["rif"] + }, + "application/relax-ng-compact-syntax": { + source: "iana", + extensions: ["rnc"] + }, + "application/remote-printing": { + source: "apache" + }, + "application/reputon+json": { + source: "iana", + compressible: true + }, + "application/resolve-response+jwt": { + source: "iana" + }, + "application/resource-lists+xml": { + source: "iana", + compressible: true, + extensions: ["rl"] + }, + "application/resource-lists-diff+xml": { + source: "iana", + compressible: true, + extensions: ["rld"] + }, + "application/rfc+xml": { + source: "iana", + compressible: true + }, + "application/riscos": { + source: "iana" + }, + "application/rlmi+xml": { + source: "iana", + compressible: true + }, + "application/rls-services+xml": { + source: "iana", + compressible: true, + extensions: ["rs"] + }, + "application/route-apd+xml": { + source: "iana", + compressible: true, + extensions: ["rapd"] + }, + "application/route-s-tsid+xml": { + source: "iana", + compressible: true, + extensions: ["sls"] + }, + "application/route-usd+xml": { + source: "iana", + compressible: true, + extensions: ["rusd"] + }, + "application/rpki-checklist": { + source: "iana" + }, + "application/rpki-ghostbusters": { + source: "iana", + extensions: ["gbr"] + }, + "application/rpki-manifest": { + source: "iana", + extensions: ["mft"] + }, + "application/rpki-publication": { + source: "iana" + }, + "application/rpki-roa": { + source: "iana", + extensions: ["roa"] + }, + "application/rpki-signed-tal": { + source: "iana" + }, + "application/rpki-updown": { + source: "iana" + }, + "application/rsd+xml": { + source: "apache", + compressible: true, + extensions: ["rsd"] + }, + "application/rss+xml": { + source: "apache", + compressible: true, + extensions: ["rss"] + }, + "application/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "application/rtploopback": { + source: "iana" + }, + "application/rtx": { + source: "iana" + }, + "application/samlassertion+xml": { + source: "iana", + compressible: true + }, + "application/samlmetadata+xml": { + source: "iana", + compressible: true + }, + "application/sarif+json": { + source: "iana", + compressible: true + }, + "application/sarif-external-properties+json": { + source: "iana", + compressible: true + }, + "application/sbe": { + source: "iana" + }, + "application/sbml+xml": { + source: "iana", + compressible: true, + extensions: ["sbml"] + }, + "application/scaip+xml": { + source: "iana", + compressible: true + }, + "application/scim+json": { + source: "iana", + compressible: true + }, + "application/scvp-cv-request": { + source: "iana", + extensions: ["scq"] + }, + "application/scvp-cv-response": { + source: "iana", + extensions: ["scs"] + }, + "application/scvp-vp-request": { + source: "iana", + extensions: ["spq"] + }, + "application/scvp-vp-response": { + source: "iana", + extensions: ["spp"] + }, + "application/sdp": { + source: "iana", + extensions: ["sdp"] + }, + "application/secevent+jwt": { + source: "iana" + }, + "application/senml+cbor": { + source: "iana" + }, + "application/senml+json": { + source: "iana", + compressible: true + }, + "application/senml+xml": { + source: "iana", + compressible: true, + extensions: ["senmlx"] + }, + "application/senml-etch+cbor": { + source: "iana" + }, + "application/senml-etch+json": { + source: "iana", + compressible: true + }, + "application/senml-exi": { + source: "iana" + }, + "application/sensml+cbor": { + source: "iana" + }, + "application/sensml+json": { + source: "iana", + compressible: true + }, + "application/sensml+xml": { + source: "iana", + compressible: true, + extensions: ["sensmlx"] + }, + "application/sensml-exi": { + source: "iana" + }, + "application/sep+xml": { + source: "iana", + compressible: true + }, + "application/sep-exi": { + source: "iana" + }, + "application/session-info": { + source: "iana" + }, + "application/set-payment": { + source: "iana" + }, + "application/set-payment-initiation": { + source: "iana", + extensions: ["setpay"] + }, + "application/set-registration": { + source: "iana" + }, + "application/set-registration-initiation": { + source: "iana", + extensions: ["setreg"] + }, + "application/sgml": { + source: "iana" + }, + "application/sgml-open-catalog": { + source: "iana" + }, + "application/shf+xml": { + source: "iana", + compressible: true, + extensions: ["shf"] + }, + "application/sieve": { + source: "iana", + extensions: ["siv", "sieve"] + }, + "application/simple-filter+xml": { + source: "iana", + compressible: true + }, + "application/simple-message-summary": { + source: "iana" + }, + "application/simplesymbolcontainer": { + source: "iana" + }, + "application/sipc": { + source: "iana" + }, + "application/slate": { + source: "iana" + }, + "application/smil": { + source: "apache" + }, + "application/smil+xml": { + source: "iana", + compressible: true, + extensions: ["smi", "smil"] + }, + "application/smpte336m": { + source: "iana" + }, + "application/soap+fastinfoset": { + source: "iana" + }, + "application/soap+xml": { + source: "iana", + compressible: true + }, + "application/sparql-query": { + source: "iana", + extensions: ["rq"] + }, + "application/sparql-results+xml": { + source: "iana", + compressible: true, + extensions: ["srx"] + }, + "application/spdx+json": { + source: "iana", + compressible: true + }, + "application/spirits-event+xml": { + source: "iana", + compressible: true + }, + "application/sql": { + source: "iana", + extensions: ["sql"] + }, + "application/srgs": { + source: "iana", + extensions: ["gram"] + }, + "application/srgs+xml": { + source: "iana", + compressible: true, + extensions: ["grxml"] + }, + "application/sru+xml": { + source: "iana", + compressible: true, + extensions: ["sru"] + }, + "application/ssdl+xml": { + source: "apache", + compressible: true, + extensions: ["ssdl"] + }, + "application/sslkeylogfile": { + source: "iana" + }, + "application/ssml+xml": { + source: "iana", + compressible: true, + extensions: ["ssml"] + }, + "application/st2110-41": { + source: "iana" + }, + "application/stix+json": { + source: "iana", + compressible: true + }, + "application/stratum": { + source: "iana" + }, + "application/swid+cbor": { + source: "iana" + }, + "application/swid+xml": { + source: "iana", + compressible: true, + extensions: ["swidtag"] + }, + "application/tamp-apex-update": { + source: "iana" + }, + "application/tamp-apex-update-confirm": { + source: "iana" + }, + "application/tamp-community-update": { + source: "iana" + }, + "application/tamp-community-update-confirm": { + source: "iana" + }, + "application/tamp-error": { + source: "iana" + }, + "application/tamp-sequence-adjust": { + source: "iana" + }, + "application/tamp-sequence-adjust-confirm": { + source: "iana" + }, + "application/tamp-status-query": { + source: "iana" + }, + "application/tamp-status-response": { + source: "iana" + }, + "application/tamp-update": { + source: "iana" + }, + "application/tamp-update-confirm": { + source: "iana" + }, + "application/tar": { + compressible: true + }, + "application/taxii+json": { + source: "iana", + compressible: true + }, + "application/td+json": { + source: "iana", + compressible: true + }, + "application/tei+xml": { + source: "iana", + compressible: true, + extensions: ["tei", "teicorpus"] + }, + "application/tetra_isi": { + source: "iana" + }, + "application/thraud+xml": { + source: "iana", + compressible: true, + extensions: ["tfi"] + }, + "application/timestamp-query": { + source: "iana" + }, + "application/timestamp-reply": { + source: "iana" + }, + "application/timestamped-data": { + source: "iana", + extensions: ["tsd"] + }, + "application/tlsrpt+gzip": { + source: "iana" + }, + "application/tlsrpt+json": { + source: "iana", + compressible: true + }, + "application/tm+json": { + source: "iana", + compressible: true + }, + "application/tnauthlist": { + source: "iana" + }, + "application/toc+cbor": { + source: "iana" + }, + "application/token-introspection+jwt": { + source: "iana" + }, + "application/toml": { + source: "iana", + compressible: true, + extensions: ["toml"] + }, + "application/trickle-ice-sdpfrag": { + source: "iana" + }, + "application/trig": { + source: "iana", + extensions: ["trig"] + }, + "application/trust-chain+json": { + source: "iana", + compressible: true + }, + "application/trust-mark+jwt": { + source: "iana" + }, + "application/trust-mark-delegation+jwt": { + source: "iana" + }, + "application/ttml+xml": { + source: "iana", + compressible: true, + extensions: ["ttml"] + }, + "application/tve-trigger": { + source: "iana" + }, + "application/tzif": { + source: "iana" + }, + "application/tzif-leap": { + source: "iana" + }, + "application/ubjson": { + compressible: false, + extensions: ["ubj"] + }, + "application/uccs+cbor": { + source: "iana" + }, + "application/ujcs+json": { + source: "iana", + compressible: true + }, + "application/ulpfec": { + source: "iana" + }, + "application/urc-grpsheet+xml": { + source: "iana", + compressible: true + }, + "application/urc-ressheet+xml": { + source: "iana", + compressible: true, + extensions: ["rsheet"] + }, + "application/urc-targetdesc+xml": { + source: "iana", + compressible: true, + extensions: ["td"] + }, + "application/urc-uisocketdesc+xml": { + source: "iana", + compressible: true + }, + "application/vc": { + source: "iana" + }, + "application/vc+cose": { + source: "iana" + }, + "application/vc+jwt": { + source: "iana" + }, + "application/vcard+json": { + source: "iana", + compressible: true + }, + "application/vcard+xml": { + source: "iana", + compressible: true + }, + "application/vemmi": { + source: "iana" + }, + "application/vividence.scriptfile": { + source: "apache" + }, + "application/vnd.1000minds.decision-model+xml": { + source: "iana", + compressible: true, + extensions: ["1km"] + }, + "application/vnd.1ob": { + source: "iana" + }, + "application/vnd.3gpp-prose+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3a+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ach+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ch+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc8+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-v2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gnas": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.access-transfer-events+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.bsf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.crs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.current-location-discovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gmop+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gtpc": { + source: "iana" + }, + "application/vnd.3gpp.interworking-data": { + source: "iana" + }, + "application/vnd.3gpp.lpp": { + source: "iana" + }, + "application/vnd.3gpp.mc-signalling-ear": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-payload": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-signalling": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-floor-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-signed+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-init-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-transmission-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mid-call+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ngap": { + source: "iana" + }, + "application/vnd.3gpp.pfcp": { + source: "iana" + }, + "application/vnd.3gpp.pic-bw-large": { + source: "iana", + extensions: ["plb"] + }, + "application/vnd.3gpp.pic-bw-small": { + source: "iana", + extensions: ["psb"] + }, + "application/vnd.3gpp.pic-bw-var": { + source: "iana", + extensions: ["pvb"] + }, + "application/vnd.3gpp.pinapp-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.s1ap": { + source: "iana" + }, + "application/vnd.3gpp.seal-group-doc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-network-qos-management-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-ue-config-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-unicast-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-user-profile-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.sms": { + source: "iana" + }, + "application/vnd.3gpp.sms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-ext+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.state-and-event-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ussd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.v2x": { + source: "iana" + }, + "application/vnd.3gpp.vae-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.bcmcsinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.sms": { + source: "iana" + }, + "application/vnd.3gpp2.tcap": { + source: "iana", + extensions: ["tcap"] + }, + "application/vnd.3lightssoftware.imagescal": { + source: "iana" + }, + "application/vnd.3m.post-it-notes": { + source: "iana", + extensions: ["pwn"] + }, + "application/vnd.accpac.simply.aso": { + source: "iana", + extensions: ["aso"] + }, + "application/vnd.accpac.simply.imp": { + source: "iana", + extensions: ["imp"] + }, + "application/vnd.acm.addressxfer+json": { + source: "iana", + compressible: true + }, + "application/vnd.acm.chatbot+json": { + source: "iana", + compressible: true + }, + "application/vnd.acucobol": { + source: "iana", + extensions: ["acu"] + }, + "application/vnd.acucorp": { + source: "iana", + extensions: ["atc", "acutc"] + }, + "application/vnd.adobe.air-application-installer-package+zip": { + source: "apache", + compressible: false, + extensions: ["air"] + }, + "application/vnd.adobe.flash.movie": { + source: "iana" + }, + "application/vnd.adobe.formscentral.fcdt": { + source: "iana", + extensions: ["fcdt"] + }, + "application/vnd.adobe.fxp": { + source: "iana", + extensions: ["fxp", "fxpl"] + }, + "application/vnd.adobe.partial-upload": { + source: "iana" + }, + "application/vnd.adobe.xdp+xml": { + source: "iana", + compressible: true, + extensions: ["xdp"] + }, + "application/vnd.adobe.xfdf": { + source: "apache", + extensions: ["xfdf"] + }, + "application/vnd.aether.imp": { + source: "iana" + }, + "application/vnd.afpc.afplinedata": { + source: "iana" + }, + "application/vnd.afpc.afplinedata-pagedef": { + source: "iana" + }, + "application/vnd.afpc.cmoca-cmresource": { + source: "iana" + }, + "application/vnd.afpc.foca-charset": { + source: "iana" + }, + "application/vnd.afpc.foca-codedfont": { + source: "iana" + }, + "application/vnd.afpc.foca-codepage": { + source: "iana" + }, + "application/vnd.afpc.modca": { + source: "iana" + }, + "application/vnd.afpc.modca-cmtable": { + source: "iana" + }, + "application/vnd.afpc.modca-formdef": { + source: "iana" + }, + "application/vnd.afpc.modca-mediummap": { + source: "iana" + }, + "application/vnd.afpc.modca-objectcontainer": { + source: "iana" + }, + "application/vnd.afpc.modca-overlay": { + source: "iana" + }, + "application/vnd.afpc.modca-pagesegment": { + source: "iana" + }, + "application/vnd.age": { + source: "iana", + extensions: ["age"] + }, + "application/vnd.ah-barcode": { + source: "apache" + }, + "application/vnd.ahead.space": { + source: "iana", + extensions: ["ahead"] + }, + "application/vnd.airzip.filesecure.azf": { + source: "iana", + extensions: ["azf"] + }, + "application/vnd.airzip.filesecure.azs": { + source: "iana", + extensions: ["azs"] + }, + "application/vnd.amadeus+json": { + source: "iana", + compressible: true + }, + "application/vnd.amazon.ebook": { + source: "apache", + extensions: ["azw"] + }, + "application/vnd.amazon.mobi8-ebook": { + source: "iana" + }, + "application/vnd.americandynamics.acc": { + source: "iana", + extensions: ["acc"] + }, + "application/vnd.amiga.ami": { + source: "iana", + extensions: ["ami"] + }, + "application/vnd.amundsen.maze+xml": { + source: "iana", + compressible: true + }, + "application/vnd.android.ota": { + source: "iana" + }, + "application/vnd.android.package-archive": { + source: "apache", + compressible: false, + extensions: ["apk"] + }, + "application/vnd.anki": { + source: "iana" + }, + "application/vnd.anser-web-certificate-issue-initiation": { + source: "iana", + extensions: ["cii"] + }, + "application/vnd.anser-web-funds-transfer-initiation": { + source: "apache", + extensions: ["fti"] + }, + "application/vnd.antix.game-component": { + source: "iana", + extensions: ["atx"] + }, + "application/vnd.apache.arrow.file": { + source: "iana" + }, + "application/vnd.apache.arrow.stream": { + source: "iana" + }, + "application/vnd.apache.parquet": { + source: "iana" + }, + "application/vnd.apache.thrift.binary": { + source: "iana" + }, + "application/vnd.apache.thrift.compact": { + source: "iana" + }, + "application/vnd.apache.thrift.json": { + source: "iana" + }, + "application/vnd.apexlang": { + source: "iana" + }, + "application/vnd.api+json": { + source: "iana", + compressible: true + }, + "application/vnd.aplextor.warrp+json": { + source: "iana", + compressible: true + }, + "application/vnd.apothekende.reservation+json": { + source: "iana", + compressible: true + }, + "application/vnd.apple.installer+xml": { + source: "iana", + compressible: true, + extensions: ["mpkg"] + }, + "application/vnd.apple.keynote": { + source: "iana", + extensions: ["key"] + }, + "application/vnd.apple.mpegurl": { + source: "iana", + extensions: ["m3u8"] + }, + "application/vnd.apple.numbers": { + source: "iana", + extensions: ["numbers"] + }, + "application/vnd.apple.pages": { + source: "iana", + extensions: ["pages"] + }, + "application/vnd.apple.pkpass": { + compressible: false, + extensions: ["pkpass"] + }, + "application/vnd.arastra.swi": { + source: "apache" + }, + "application/vnd.aristanetworks.swi": { + source: "iana", + extensions: ["swi"] + }, + "application/vnd.artisan+json": { + source: "iana", + compressible: true + }, + "application/vnd.artsquare": { + source: "iana" + }, + "application/vnd.astraea-software.iota": { + source: "iana", + extensions: ["iota"] + }, + "application/vnd.audiograph": { + source: "iana", + extensions: ["aep"] + }, + "application/vnd.autodesk.fbx": { + extensions: ["fbx"] + }, + "application/vnd.autopackage": { + source: "iana" + }, + "application/vnd.avalon+json": { + source: "iana", + compressible: true + }, + "application/vnd.avistar+xml": { + source: "iana", + compressible: true + }, + "application/vnd.balsamiq.bmml+xml": { + source: "iana", + compressible: true, + extensions: ["bmml"] + }, + "application/vnd.balsamiq.bmpr": { + source: "iana" + }, + "application/vnd.banana-accounting": { + source: "iana" + }, + "application/vnd.bbf.usp.error": { + source: "iana" + }, + "application/vnd.bbf.usp.msg": { + source: "iana" + }, + "application/vnd.bbf.usp.msg+json": { + source: "iana", + compressible: true + }, + "application/vnd.bekitzur-stech+json": { + source: "iana", + compressible: true + }, + "application/vnd.belightsoft.lhzd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.belightsoft.lhzl+zip": { + source: "iana", + compressible: false + }, + "application/vnd.bint.med-content": { + source: "iana" + }, + "application/vnd.biopax.rdf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.blink-idb-value-wrapper": { + source: "iana" + }, + "application/vnd.blueice.multipass": { + source: "iana", + extensions: ["mpm"] + }, + "application/vnd.bluetooth.ep.oob": { + source: "iana" + }, + "application/vnd.bluetooth.le.oob": { + source: "iana" + }, + "application/vnd.bmi": { + source: "iana", + extensions: ["bmi"] + }, + "application/vnd.bpf": { + source: "iana" + }, + "application/vnd.bpf3": { + source: "iana" + }, + "application/vnd.businessobjects": { + source: "iana", + extensions: ["rep"] + }, + "application/vnd.byu.uapi+json": { + source: "iana", + compressible: true + }, + "application/vnd.bzip3": { + source: "iana" + }, + "application/vnd.c3voc.schedule+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cab-jscript": { + source: "iana" + }, + "application/vnd.canon-cpdl": { + source: "iana" + }, + "application/vnd.canon-lips": { + source: "iana" + }, + "application/vnd.capasystems-pg+json": { + source: "iana", + compressible: true + }, + "application/vnd.cendio.thinlinc.clientconf": { + source: "iana" + }, + "application/vnd.century-systems.tcp_stream": { + source: "iana" + }, + "application/vnd.chemdraw+xml": { + source: "iana", + compressible: true, + extensions: ["cdxml"] + }, + "application/vnd.chess-pgn": { + source: "iana" + }, + "application/vnd.chipnuts.karaoke-mmd": { + source: "iana", + extensions: ["mmd"] + }, + "application/vnd.ciedi": { + source: "iana" + }, + "application/vnd.cinderella": { + source: "iana", + extensions: ["cdy"] + }, + "application/vnd.cirpack.isdn-ext": { + source: "iana" + }, + "application/vnd.citationstyles.style+xml": { + source: "iana", + compressible: true, + extensions: ["csl"] + }, + "application/vnd.claymore": { + source: "iana", + extensions: ["cla"] + }, + "application/vnd.cloanto.rp9": { + source: "iana", + extensions: ["rp9"] + }, + "application/vnd.clonk.c4group": { + source: "iana", + extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"] + }, + "application/vnd.cluetrust.cartomobile-config": { + source: "iana", + extensions: ["c11amc"] + }, + "application/vnd.cluetrust.cartomobile-config-pkg": { + source: "iana", + extensions: ["c11amz"] + }, + "application/vnd.cncf.helm.chart.content.v1.tar+gzip": { + source: "iana" + }, + "application/vnd.cncf.helm.chart.provenance.v1.prov": { + source: "iana" + }, + "application/vnd.cncf.helm.config.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.coffeescript": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet-template": { + source: "iana" + }, + "application/vnd.collection+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.doc+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.next+json": { + source: "iana", + compressible: true + }, + "application/vnd.comicbook+zip": { + source: "iana", + compressible: false + }, + "application/vnd.comicbook-rar": { + source: "iana" + }, + "application/vnd.commerce-battelle": { + source: "iana" + }, + "application/vnd.commonspace": { + source: "iana", + extensions: ["csp"] + }, + "application/vnd.contact.cmsg": { + source: "iana", + extensions: ["cdbcmsg"] + }, + "application/vnd.coreos.ignition+json": { + source: "iana", + compressible: true + }, + "application/vnd.cosmocaller": { + source: "iana", + extensions: ["cmc"] + }, + "application/vnd.crick.clicker": { + source: "iana", + extensions: ["clkx"] + }, + "application/vnd.crick.clicker.keyboard": { + source: "iana", + extensions: ["clkk"] + }, + "application/vnd.crick.clicker.palette": { + source: "iana", + extensions: ["clkp"] + }, + "application/vnd.crick.clicker.template": { + source: "iana", + extensions: ["clkt"] + }, + "application/vnd.crick.clicker.wordbank": { + source: "iana", + extensions: ["clkw"] + }, + "application/vnd.criticaltools.wbs+xml": { + source: "iana", + compressible: true, + extensions: ["wbs"] + }, + "application/vnd.cryptii.pipe+json": { + source: "iana", + compressible: true + }, + "application/vnd.crypto-shade-file": { + source: "iana" + }, + "application/vnd.cryptomator.encrypted": { + source: "iana" + }, + "application/vnd.cryptomator.vault": { + source: "iana" + }, + "application/vnd.ctc-posml": { + source: "iana", + extensions: ["pml"] + }, + "application/vnd.ctct.ws+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cups-pdf": { + source: "iana" + }, + "application/vnd.cups-postscript": { + source: "iana" + }, + "application/vnd.cups-ppd": { + source: "iana", + extensions: ["ppd"] + }, + "application/vnd.cups-raster": { + source: "iana" + }, + "application/vnd.cups-raw": { + source: "iana" + }, + "application/vnd.curl": { + source: "iana" + }, + "application/vnd.curl.car": { + source: "apache", + extensions: ["car"] + }, + "application/vnd.curl.pcurl": { + source: "apache", + extensions: ["pcurl"] + }, + "application/vnd.cyan.dean.root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cybank": { + source: "iana" + }, + "application/vnd.cyclonedx+json": { + source: "iana", + compressible: true + }, + "application/vnd.cyclonedx+xml": { + source: "iana", + compressible: true + }, + "application/vnd.d2l.coursepackage1p0+zip": { + source: "iana", + compressible: false + }, + "application/vnd.d3m-dataset": { + source: "iana" + }, + "application/vnd.d3m-problem": { + source: "iana" + }, + "application/vnd.dart": { + source: "iana", + compressible: true, + extensions: ["dart"] + }, + "application/vnd.data-vision.rdz": { + source: "iana", + extensions: ["rdz"] + }, + "application/vnd.datalog": { + source: "iana" + }, + "application/vnd.datapackage+json": { + source: "iana", + compressible: true + }, + "application/vnd.dataresource+json": { + source: "iana", + compressible: true + }, + "application/vnd.dbf": { + source: "iana", + extensions: ["dbf"] + }, + "application/vnd.dcmp+xml": { + source: "iana", + compressible: true, + extensions: ["dcmp"] + }, + "application/vnd.debian.binary-package": { + source: "iana" + }, + "application/vnd.dece.data": { + source: "iana", + extensions: ["uvf", "uvvf", "uvd", "uvvd"] + }, + "application/vnd.dece.ttml+xml": { + source: "iana", + compressible: true, + extensions: ["uvt", "uvvt"] + }, + "application/vnd.dece.unspecified": { + source: "iana", + extensions: ["uvx", "uvvx"] + }, + "application/vnd.dece.zip": { + source: "iana", + extensions: ["uvz", "uvvz"] + }, + "application/vnd.denovo.fcselayout-link": { + source: "iana", + extensions: ["fe_launch"] + }, + "application/vnd.desmume.movie": { + source: "iana" + }, + "application/vnd.dir-bi.plate-dl-nosuffix": { + source: "iana" + }, + "application/vnd.dm.delegation+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dna": { + source: "iana", + extensions: ["dna"] + }, + "application/vnd.document+json": { + source: "iana", + compressible: true + }, + "application/vnd.dolby.mlp": { + source: "apache", + extensions: ["mlp"] + }, + "application/vnd.dolby.mobile.1": { + source: "iana" + }, + "application/vnd.dolby.mobile.2": { + source: "iana" + }, + "application/vnd.doremir.scorecloud-binary-document": { + source: "iana" + }, + "application/vnd.dpgraph": { + source: "iana", + extensions: ["dpg"] + }, + "application/vnd.dreamfactory": { + source: "iana", + extensions: ["dfac"] + }, + "application/vnd.drive+json": { + source: "iana", + compressible: true + }, + "application/vnd.ds-keypoint": { + source: "apache", + extensions: ["kpxx"] + }, + "application/vnd.dtg.local": { + source: "iana" + }, + "application/vnd.dtg.local.flash": { + source: "iana" + }, + "application/vnd.dtg.local.html": { + source: "iana" + }, + "application/vnd.dvb.ait": { + source: "iana", + extensions: ["ait"] + }, + "application/vnd.dvb.dvbisl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.dvbj": { + source: "iana" + }, + "application/vnd.dvb.esgcontainer": { + source: "iana" + }, + "application/vnd.dvb.ipdcdftnotifaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess2": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgpdd": { + source: "iana" + }, + "application/vnd.dvb.ipdcroaming": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-base": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-enhancement": { + source: "iana" + }, + "application/vnd.dvb.notif-aggregate-root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-container+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-generic+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-msglist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-response+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-init+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.pfr": { + source: "iana" + }, + "application/vnd.dvb.service": { + source: "iana", + extensions: ["svc"] + }, + "application/vnd.dxr": { + source: "iana" + }, + "application/vnd.dynageo": { + source: "iana", + extensions: ["geo"] + }, + "application/vnd.dzr": { + source: "iana" + }, + "application/vnd.easykaraoke.cdgdownload": { + source: "iana" + }, + "application/vnd.ecdis-update": { + source: "iana" + }, + "application/vnd.ecip.rlp": { + source: "iana" + }, + "application/vnd.eclipse.ditto+json": { + source: "iana", + compressible: true + }, + "application/vnd.ecowin.chart": { + source: "iana", + extensions: ["mag"] + }, + "application/vnd.ecowin.filerequest": { + source: "iana" + }, + "application/vnd.ecowin.fileupdate": { + source: "iana" + }, + "application/vnd.ecowin.series": { + source: "iana" + }, + "application/vnd.ecowin.seriesrequest": { + source: "iana" + }, + "application/vnd.ecowin.seriesupdate": { + source: "iana" + }, + "application/vnd.efi.img": { + source: "iana" + }, + "application/vnd.efi.iso": { + source: "iana" + }, + "application/vnd.eln+zip": { + source: "iana", + compressible: false + }, + "application/vnd.emclient.accessrequest+xml": { + source: "iana", + compressible: true + }, + "application/vnd.enliven": { + source: "iana", + extensions: ["nml"] + }, + "application/vnd.enphase.envoy": { + source: "iana" + }, + "application/vnd.eprints.data+xml": { + source: "iana", + compressible: true + }, + "application/vnd.epson.esf": { + source: "iana", + extensions: ["esf"] + }, + "application/vnd.epson.msf": { + source: "iana", + extensions: ["msf"] + }, + "application/vnd.epson.quickanime": { + source: "iana", + extensions: ["qam"] + }, + "application/vnd.epson.salt": { + source: "iana", + extensions: ["slt"] + }, + "application/vnd.epson.ssf": { + source: "iana", + extensions: ["ssf"] + }, + "application/vnd.ericsson.quickcall": { + source: "iana" + }, + "application/vnd.erofs": { + source: "iana" + }, + "application/vnd.espass-espass+zip": { + source: "iana", + compressible: false + }, + "application/vnd.eszigno3+xml": { + source: "iana", + compressible: true, + extensions: ["es3", "et3"] + }, + "application/vnd.etsi.aoc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.asic-e+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.asic-s+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.cug+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvcommand+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-bc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-cod+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-npvr+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvservice+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsync+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mcid+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mheg5": { + source: "iana" + }, + "application/vnd.etsi.overload-control-policy-dataset+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.pstn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.sci+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.simservs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.timestamp-token": { + source: "iana" + }, + "application/vnd.etsi.tsl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.tsl.der": { + source: "iana" + }, + "application/vnd.eu.kasparian.car+json": { + source: "iana", + compressible: true + }, + "application/vnd.eudora.data": { + source: "iana" + }, + "application/vnd.evolv.ecig.profile": { + source: "iana" + }, + "application/vnd.evolv.ecig.settings": { + source: "iana" + }, + "application/vnd.evolv.ecig.theme": { + source: "iana" + }, + "application/vnd.exstream-empower+zip": { + source: "iana", + compressible: false + }, + "application/vnd.exstream-package": { + source: "iana" + }, + "application/vnd.ezpix-album": { + source: "iana", + extensions: ["ez2"] + }, + "application/vnd.ezpix-package": { + source: "iana", + extensions: ["ez3"] + }, + "application/vnd.f-secure.mobile": { + source: "iana" + }, + "application/vnd.familysearch.gedcom+zip": { + source: "iana", + compressible: false + }, + "application/vnd.fastcopy-disk-image": { + source: "iana" + }, + "application/vnd.fdf": { + source: "apache", + extensions: ["fdf"] + }, + "application/vnd.fdsn.mseed": { + source: "iana", + extensions: ["mseed"] + }, + "application/vnd.fdsn.seed": { + source: "iana", + extensions: ["seed", "dataless"] + }, + "application/vnd.fdsn.stationxml+xml": { + source: "iana", + charset: "XML-BASED", + compressible: true + }, + "application/vnd.ffsns": { + source: "iana" + }, + "application/vnd.ficlab.flb+zip": { + source: "iana", + compressible: false + }, + "application/vnd.filmit.zfc": { + source: "iana" + }, + "application/vnd.fints": { + source: "iana" + }, + "application/vnd.firemonkeys.cloudcell": { + source: "iana" + }, + "application/vnd.flographit": { + source: "iana", + extensions: ["gph"] + }, + "application/vnd.fluxtime.clip": { + source: "iana", + extensions: ["ftc"] + }, + "application/vnd.font-fontforge-sfd": { + source: "iana" + }, + "application/vnd.framemaker": { + source: "iana", + extensions: ["fm", "frame", "maker", "book"] + }, + "application/vnd.freelog.comic": { + source: "iana" + }, + "application/vnd.frogans.fnc": { + source: "apache", + extensions: ["fnc"] + }, + "application/vnd.frogans.ltf": { + source: "apache", + extensions: ["ltf"] + }, + "application/vnd.fsc.weblaunch": { + source: "iana", + extensions: ["fsc"] + }, + "application/vnd.fujifilm.fb.docuworks": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.binder": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.container": { + source: "iana" + }, + "application/vnd.fujifilm.fb.jfi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.fujitsu.oasys": { + source: "iana", + extensions: ["oas"] + }, + "application/vnd.fujitsu.oasys2": { + source: "iana", + extensions: ["oa2"] + }, + "application/vnd.fujitsu.oasys3": { + source: "iana", + extensions: ["oa3"] + }, + "application/vnd.fujitsu.oasysgp": { + source: "iana", + extensions: ["fg5"] + }, + "application/vnd.fujitsu.oasysprs": { + source: "iana", + extensions: ["bh2"] + }, + "application/vnd.fujixerox.art-ex": { + source: "iana" + }, + "application/vnd.fujixerox.art4": { + source: "iana" + }, + "application/vnd.fujixerox.ddd": { + source: "iana", + extensions: ["ddd"] + }, + "application/vnd.fujixerox.docuworks": { + source: "iana", + extensions: ["xdw"] + }, + "application/vnd.fujixerox.docuworks.binder": { + source: "iana", + extensions: ["xbd"] + }, + "application/vnd.fujixerox.docuworks.container": { + source: "iana" + }, + "application/vnd.fujixerox.hbpl": { + source: "iana" + }, + "application/vnd.fut-misnet": { + source: "iana" + }, + "application/vnd.futoin+cbor": { + source: "iana" + }, + "application/vnd.futoin+json": { + source: "iana", + compressible: true + }, + "application/vnd.fuzzysheet": { + source: "iana", + extensions: ["fzs"] + }, + "application/vnd.ga4gh.passport+jwt": { + source: "iana" + }, + "application/vnd.genomatix.tuxedo": { + source: "iana", + extensions: ["txd"] + }, + "application/vnd.genozip": { + source: "iana" + }, + "application/vnd.gentics.grd+json": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.catmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.ebuild": { + source: "iana" + }, + "application/vnd.gentoo.eclass": { + source: "iana" + }, + "application/vnd.gentoo.gpkg": { + source: "iana" + }, + "application/vnd.gentoo.manifest": { + source: "iana" + }, + "application/vnd.gentoo.pkgmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.xpak": { + source: "iana" + }, + "application/vnd.geo+json": { + source: "apache", + compressible: true + }, + "application/vnd.geocube+xml": { + source: "apache", + compressible: true + }, + "application/vnd.geogebra.file": { + source: "iana", + extensions: ["ggb"] + }, + "application/vnd.geogebra.pinboard": { + source: "iana" + }, + "application/vnd.geogebra.slides": { + source: "iana", + extensions: ["ggs"] + }, + "application/vnd.geogebra.tool": { + source: "iana", + extensions: ["ggt"] + }, + "application/vnd.geometry-explorer": { + source: "iana", + extensions: ["gex", "gre"] + }, + "application/vnd.geonext": { + source: "iana", + extensions: ["gxt"] + }, + "application/vnd.geoplan": { + source: "iana", + extensions: ["g2w"] + }, + "application/vnd.geospace": { + source: "iana", + extensions: ["g3w"] + }, + "application/vnd.gerber": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt-response": { + source: "iana" + }, + "application/vnd.gmx": { + source: "iana", + extensions: ["gmx"] + }, + "application/vnd.gnu.taler.exchange+json": { + source: "iana", + compressible: true + }, + "application/vnd.gnu.taler.merchant+json": { + source: "iana", + compressible: true + }, + "application/vnd.google-apps.audio": {}, + "application/vnd.google-apps.document": { + compressible: false, + extensions: ["gdoc"] + }, + "application/vnd.google-apps.drawing": { + compressible: false, + extensions: ["gdraw"] + }, + "application/vnd.google-apps.drive-sdk": { + compressible: false + }, + "application/vnd.google-apps.file": {}, + "application/vnd.google-apps.folder": { + compressible: false + }, + "application/vnd.google-apps.form": { + compressible: false, + extensions: ["gform"] + }, + "application/vnd.google-apps.fusiontable": {}, + "application/vnd.google-apps.jam": { + compressible: false, + extensions: ["gjam"] + }, + "application/vnd.google-apps.mail-layout": {}, + "application/vnd.google-apps.map": { + compressible: false, + extensions: ["gmap"] + }, + "application/vnd.google-apps.photo": {}, + "application/vnd.google-apps.presentation": { + compressible: false, + extensions: ["gslides"] + }, + "application/vnd.google-apps.script": { + compressible: false, + extensions: ["gscript"] + }, + "application/vnd.google-apps.shortcut": {}, + "application/vnd.google-apps.site": { + compressible: false, + extensions: ["gsite"] + }, + "application/vnd.google-apps.spreadsheet": { + compressible: false, + extensions: ["gsheet"] + }, + "application/vnd.google-apps.unknown": {}, + "application/vnd.google-apps.video": {}, + "application/vnd.google-earth.kml+xml": { + source: "iana", + compressible: true, + extensions: ["kml"] + }, + "application/vnd.google-earth.kmz": { + source: "iana", + compressible: false, + extensions: ["kmz"] + }, + "application/vnd.gov.sk.e-form+xml": { + source: "apache", + compressible: true + }, + "application/vnd.gov.sk.e-form+zip": { + source: "iana", + compressible: false + }, + "application/vnd.gov.sk.xmldatacontainer+xml": { + source: "iana", + compressible: true, + extensions: ["xdcf"] + }, + "application/vnd.gpxsee.map+xml": { + source: "iana", + compressible: true + }, + "application/vnd.grafeq": { + source: "iana", + extensions: ["gqf", "gqs"] + }, + "application/vnd.gridmp": { + source: "iana" + }, + "application/vnd.groove-account": { + source: "iana", + extensions: ["gac"] + }, + "application/vnd.groove-help": { + source: "iana", + extensions: ["ghf"] + }, + "application/vnd.groove-identity-message": { + source: "iana", + extensions: ["gim"] + }, + "application/vnd.groove-injector": { + source: "iana", + extensions: ["grv"] + }, + "application/vnd.groove-tool-message": { + source: "iana", + extensions: ["gtm"] + }, + "application/vnd.groove-tool-template": { + source: "iana", + extensions: ["tpl"] + }, + "application/vnd.groove-vcard": { + source: "iana", + extensions: ["vcg"] + }, + "application/vnd.hal+json": { + source: "iana", + compressible: true + }, + "application/vnd.hal+xml": { + source: "iana", + compressible: true, + extensions: ["hal"] + }, + "application/vnd.handheld-entertainment+xml": { + source: "iana", + compressible: true, + extensions: ["zmm"] + }, + "application/vnd.hbci": { + source: "iana", + extensions: ["hbci"] + }, + "application/vnd.hc+json": { + source: "iana", + compressible: true + }, + "application/vnd.hcl-bireports": { + source: "iana" + }, + "application/vnd.hdt": { + source: "iana" + }, + "application/vnd.heroku+json": { + source: "iana", + compressible: true + }, + "application/vnd.hhe.lesson-player": { + source: "iana", + extensions: ["les"] + }, + "application/vnd.hp-hpgl": { + source: "iana", + extensions: ["hpgl"] + }, + "application/vnd.hp-hpid": { + source: "iana", + extensions: ["hpid"] + }, + "application/vnd.hp-hps": { + source: "iana", + extensions: ["hps"] + }, + "application/vnd.hp-jlyt": { + source: "iana", + extensions: ["jlt"] + }, + "application/vnd.hp-pcl": { + source: "iana", + extensions: ["pcl"] + }, + "application/vnd.hp-pclxl": { + source: "iana", + extensions: ["pclxl"] + }, + "application/vnd.hsl": { + source: "iana" + }, + "application/vnd.httphone": { + source: "iana" + }, + "application/vnd.hydrostatix.sof-data": { + source: "iana", + extensions: ["sfd-hdstx"] + }, + "application/vnd.hyper+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyper-item+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyperdrive+json": { + source: "iana", + compressible: true + }, + "application/vnd.hzn-3d-crossword": { + source: "iana" + }, + "application/vnd.ibm.afplinedata": { + source: "apache" + }, + "application/vnd.ibm.electronic-media": { + source: "iana" + }, + "application/vnd.ibm.minipay": { + source: "iana", + extensions: ["mpy"] + }, + "application/vnd.ibm.modcap": { + source: "apache", + extensions: ["afp", "listafp", "list3820"] + }, + "application/vnd.ibm.rights-management": { + source: "iana", + extensions: ["irm"] + }, + "application/vnd.ibm.secure-container": { + source: "iana", + extensions: ["sc"] + }, + "application/vnd.iccprofile": { + source: "iana", + extensions: ["icc", "icm"] + }, + "application/vnd.ieee.1905": { + source: "iana" + }, + "application/vnd.igloader": { + source: "iana", + extensions: ["igl"] + }, + "application/vnd.imagemeter.folder+zip": { + source: "iana", + compressible: false + }, + "application/vnd.imagemeter.image+zip": { + source: "iana", + compressible: false + }, + "application/vnd.immervision-ivp": { + source: "iana", + extensions: ["ivp"] + }, + "application/vnd.immervision-ivu": { + source: "iana", + extensions: ["ivu"] + }, + "application/vnd.ims.imsccv1p1": { + source: "iana" + }, + "application/vnd.ims.imsccv1p2": { + source: "iana" + }, + "application/vnd.ims.imsccv1p3": { + source: "iana" + }, + "application/vnd.ims.lis.v2.result+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolconsumerprofile+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy.id+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings.simple+json": { + source: "iana", + compressible: true + }, + "application/vnd.informedcontrol.rms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.informix-visionary": { + source: "apache" + }, + "application/vnd.infotech.project": { + source: "iana" + }, + "application/vnd.infotech.project+xml": { + source: "iana", + compressible: true + }, + "application/vnd.innopath.wamp.notification": { + source: "iana" + }, + "application/vnd.insors.igm": { + source: "iana", + extensions: ["igm"] + }, + "application/vnd.intercon.formnet": { + source: "iana", + extensions: ["xpw", "xpx"] + }, + "application/vnd.intergeo": { + source: "iana", + extensions: ["i2g"] + }, + "application/vnd.intertrust.digibox": { + source: "iana" + }, + "application/vnd.intertrust.nncp": { + source: "iana" + }, + "application/vnd.intu.qbo": { + source: "iana", + extensions: ["qbo"] + }, + "application/vnd.intu.qfx": { + source: "iana", + extensions: ["qfx"] + }, + "application/vnd.ipfs.ipns-record": { + source: "iana" + }, + "application/vnd.ipld.car": { + source: "iana" + }, + "application/vnd.ipld.dag-cbor": { + source: "iana" + }, + "application/vnd.ipld.dag-json": { + source: "iana" + }, + "application/vnd.ipld.raw": { + source: "iana" + }, + "application/vnd.iptc.g2.catalogitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.conceptitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.knowledgeitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.packageitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.planningitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ipunplugged.rcprofile": { + source: "iana", + extensions: ["rcprofile"] + }, + "application/vnd.irepository.package+xml": { + source: "iana", + compressible: true, + extensions: ["irp"] + }, + "application/vnd.is-xpr": { + source: "iana", + extensions: ["xpr"] + }, + "application/vnd.isac.fcs": { + source: "iana", + extensions: ["fcs"] + }, + "application/vnd.iso11783-10+zip": { + source: "iana", + compressible: false + }, + "application/vnd.jam": { + source: "iana", + extensions: ["jam"] + }, + "application/vnd.japannet-directory-service": { + source: "iana" + }, + "application/vnd.japannet-jpnstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-payment-wakeup": { + source: "iana" + }, + "application/vnd.japannet-registration": { + source: "iana" + }, + "application/vnd.japannet-registration-wakeup": { + source: "iana" + }, + "application/vnd.japannet-setstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-verification": { + source: "iana" + }, + "application/vnd.japannet-verification-wakeup": { + source: "iana" + }, + "application/vnd.jcp.javame.midlet-rms": { + source: "iana", + extensions: ["rms"] + }, + "application/vnd.jisp": { + source: "iana", + extensions: ["jisp"] + }, + "application/vnd.joost.joda-archive": { + source: "iana", + extensions: ["joda"] + }, + "application/vnd.jsk.isdn-ngn": { + source: "iana" + }, + "application/vnd.kahootz": { + source: "iana", + extensions: ["ktz", "ktr"] + }, + "application/vnd.kde.karbon": { + source: "iana", + extensions: ["karbon"] + }, + "application/vnd.kde.kchart": { + source: "iana", + extensions: ["chrt"] + }, + "application/vnd.kde.kformula": { + source: "iana", + extensions: ["kfo"] + }, + "application/vnd.kde.kivio": { + source: "iana", + extensions: ["flw"] + }, + "application/vnd.kde.kontour": { + source: "iana", + extensions: ["kon"] + }, + "application/vnd.kde.kpresenter": { + source: "iana", + extensions: ["kpr", "kpt"] + }, + "application/vnd.kde.kspread": { + source: "iana", + extensions: ["ksp"] + }, + "application/vnd.kde.kword": { + source: "iana", + extensions: ["kwd", "kwt"] + }, + "application/vnd.kdl": { + source: "iana" + }, + "application/vnd.kenameaapp": { + source: "iana", + extensions: ["htke"] + }, + "application/vnd.keyman.kmp+zip": { + source: "iana", + compressible: false + }, + "application/vnd.keyman.kmx": { + source: "iana" + }, + "application/vnd.kidspiration": { + source: "iana", + extensions: ["kia"] + }, + "application/vnd.kinar": { + source: "iana", + extensions: ["kne", "knp"] + }, + "application/vnd.koan": { + source: "iana", + extensions: ["skp", "skd", "skt", "skm"] + }, + "application/vnd.kodak-descriptor": { + source: "iana", + extensions: ["sse"] + }, + "application/vnd.las": { + source: "iana" + }, + "application/vnd.las.las+json": { + source: "iana", + compressible: true + }, + "application/vnd.las.las+xml": { + source: "iana", + compressible: true, + extensions: ["lasxml"] + }, + "application/vnd.laszip": { + source: "iana" + }, + "application/vnd.ldev.productlicensing": { + source: "iana" + }, + "application/vnd.leap+json": { + source: "iana", + compressible: true + }, + "application/vnd.liberty-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.llamagraphics.life-balance.desktop": { + source: "iana", + extensions: ["lbd"] + }, + "application/vnd.llamagraphics.life-balance.exchange+xml": { + source: "iana", + compressible: true, + extensions: ["lbe"] + }, + "application/vnd.logipipe.circuit+zip": { + source: "iana", + compressible: false + }, + "application/vnd.loom": { + source: "iana" + }, + "application/vnd.lotus-1-2-3": { + source: "iana", + extensions: ["123"] + }, + "application/vnd.lotus-approach": { + source: "iana", + extensions: ["apr"] + }, + "application/vnd.lotus-freelance": { + source: "iana", + extensions: ["pre"] + }, + "application/vnd.lotus-notes": { + source: "iana", + extensions: ["nsf"] + }, + "application/vnd.lotus-organizer": { + source: "iana", + extensions: ["org"] + }, + "application/vnd.lotus-screencam": { + source: "iana", + extensions: ["scm"] + }, + "application/vnd.lotus-wordpro": { + source: "iana", + extensions: ["lwp"] + }, + "application/vnd.macports.portpkg": { + source: "iana", + extensions: ["portpkg"] + }, + "application/vnd.mapbox-vector-tile": { + source: "iana", + extensions: ["mvt"] + }, + "application/vnd.marlin.drm.actiontoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.conftoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.license+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.mdcf": { + source: "iana" + }, + "application/vnd.mason+json": { + source: "iana", + compressible: true + }, + "application/vnd.maxar.archive.3tz+zip": { + source: "iana", + compressible: false + }, + "application/vnd.maxmind.maxmind-db": { + source: "iana" + }, + "application/vnd.mcd": { + source: "iana", + extensions: ["mcd"] + }, + "application/vnd.mdl": { + source: "iana" + }, + "application/vnd.mdl-mbsdf": { + source: "iana" + }, + "application/vnd.medcalcdata": { + source: "iana", + extensions: ["mc1"] + }, + "application/vnd.mediastation.cdkey": { + source: "iana", + extensions: ["cdkey"] + }, + "application/vnd.medicalholodeck.recordxr": { + source: "iana" + }, + "application/vnd.meridian-slingshot": { + source: "iana" + }, + "application/vnd.mermaid": { + source: "iana" + }, + "application/vnd.mfer": { + source: "iana", + extensions: ["mwf"] + }, + "application/vnd.mfmp": { + source: "iana", + extensions: ["mfm"] + }, + "application/vnd.micro+json": { + source: "iana", + compressible: true + }, + "application/vnd.micrografx.flo": { + source: "iana", + extensions: ["flo"] + }, + "application/vnd.micrografx.igx": { + source: "iana", + extensions: ["igx"] + }, + "application/vnd.microsoft.portable-executable": { + source: "iana" + }, + "application/vnd.microsoft.windows.thumbnail-cache": { + source: "iana" + }, + "application/vnd.miele+json": { + source: "iana", + compressible: true + }, + "application/vnd.mif": { + source: "iana", + extensions: ["mif"] + }, + "application/vnd.minisoft-hp3000-save": { + source: "iana" + }, + "application/vnd.mitsubishi.misty-guard.trustweb": { + source: "iana" + }, + "application/vnd.mobius.daf": { + source: "iana", + extensions: ["daf"] + }, + "application/vnd.mobius.dis": { + source: "iana", + extensions: ["dis"] + }, + "application/vnd.mobius.mbk": { + source: "iana", + extensions: ["mbk"] + }, + "application/vnd.mobius.mqy": { + source: "iana", + extensions: ["mqy"] + }, + "application/vnd.mobius.msl": { + source: "iana", + extensions: ["msl"] + }, + "application/vnd.mobius.plc": { + source: "iana", + extensions: ["plc"] + }, + "application/vnd.mobius.txf": { + source: "iana", + extensions: ["txf"] + }, + "application/vnd.modl": { + source: "iana" + }, + "application/vnd.mophun.application": { + source: "iana", + extensions: ["mpn"] + }, + "application/vnd.mophun.certificate": { + source: "iana", + extensions: ["mpc"] + }, + "application/vnd.motorola.flexsuite": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.adsi": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.fis": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.gotap": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.kmr": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.ttc": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.wem": { + source: "iana" + }, + "application/vnd.motorola.iprm": { + source: "iana" + }, + "application/vnd.mozilla.xul+xml": { + source: "iana", + compressible: true, + extensions: ["xul"] + }, + "application/vnd.ms-3mfdocument": { + source: "iana" + }, + "application/vnd.ms-artgalry": { + source: "iana", + extensions: ["cil"] + }, + "application/vnd.ms-asf": { + source: "iana" + }, + "application/vnd.ms-cab-compressed": { + source: "iana", + extensions: ["cab"] + }, + "application/vnd.ms-color.iccprofile": { + source: "apache" + }, + "application/vnd.ms-excel": { + source: "iana", + compressible: false, + extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] + }, + "application/vnd.ms-excel.addin.macroenabled.12": { + source: "iana", + extensions: ["xlam"] + }, + "application/vnd.ms-excel.sheet.binary.macroenabled.12": { + source: "iana", + extensions: ["xlsb"] + }, + "application/vnd.ms-excel.sheet.macroenabled.12": { + source: "iana", + extensions: ["xlsm"] + }, + "application/vnd.ms-excel.template.macroenabled.12": { + source: "iana", + extensions: ["xltm"] + }, + "application/vnd.ms-fontobject": { + source: "iana", + compressible: true, + extensions: ["eot"] + }, + "application/vnd.ms-htmlhelp": { + source: "iana", + extensions: ["chm"] + }, + "application/vnd.ms-ims": { + source: "iana", + extensions: ["ims"] + }, + "application/vnd.ms-lrm": { + source: "iana", + extensions: ["lrm"] + }, + "application/vnd.ms-office.activex+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-officetheme": { + source: "iana", + extensions: ["thmx"] + }, + "application/vnd.ms-opentype": { + source: "apache", + compressible: true + }, + "application/vnd.ms-outlook": { + compressible: false, + extensions: ["msg"] + }, + "application/vnd.ms-package.obfuscated-opentype": { + source: "apache" + }, + "application/vnd.ms-pki.seccat": { + source: "apache", + extensions: ["cat"] + }, + "application/vnd.ms-pki.stl": { + source: "apache", + extensions: ["stl"] + }, + "application/vnd.ms-playready.initiator+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-powerpoint": { + source: "iana", + compressible: false, + extensions: ["ppt", "pps", "pot"] + }, + "application/vnd.ms-powerpoint.addin.macroenabled.12": { + source: "iana", + extensions: ["ppam"] + }, + "application/vnd.ms-powerpoint.presentation.macroenabled.12": { + source: "iana", + extensions: ["pptm"] + }, + "application/vnd.ms-powerpoint.slide.macroenabled.12": { + source: "iana", + extensions: ["sldm"] + }, + "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { + source: "iana", + extensions: ["ppsm"] + }, + "application/vnd.ms-powerpoint.template.macroenabled.12": { + source: "iana", + extensions: ["potm"] + }, + "application/vnd.ms-printdevicecapabilities+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-printing.printticket+xml": { + source: "apache", + compressible: true + }, + "application/vnd.ms-printschematicket+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-project": { + source: "iana", + extensions: ["mpp", "mpt"] + }, + "application/vnd.ms-tnef": { + source: "iana" + }, + "application/vnd.ms-visio.viewer": { + extensions: ["vdx"] + }, + "application/vnd.ms-windows.devicepairing": { + source: "iana" + }, + "application/vnd.ms-windows.nwprinting.oob": { + source: "iana" + }, + "application/vnd.ms-windows.printerpairing": { + source: "iana" + }, + "application/vnd.ms-windows.wsd.oob": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-resp": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-resp": { + source: "iana" + }, + "application/vnd.ms-word.document.macroenabled.12": { + source: "iana", + extensions: ["docm"] + }, + "application/vnd.ms-word.template.macroenabled.12": { + source: "iana", + extensions: ["dotm"] + }, + "application/vnd.ms-works": { + source: "iana", + extensions: ["wps", "wks", "wcm", "wdb"] + }, + "application/vnd.ms-wpl": { + source: "iana", + extensions: ["wpl"] + }, + "application/vnd.ms-xpsdocument": { + source: "iana", + compressible: false, + extensions: ["xps"] + }, + "application/vnd.msa-disk-image": { + source: "iana" + }, + "application/vnd.mseq": { + source: "iana", + extensions: ["mseq"] + }, + "application/vnd.msgpack": { + source: "iana" + }, + "application/vnd.msign": { + source: "iana" + }, + "application/vnd.multiad.creator": { + source: "iana" + }, + "application/vnd.multiad.creator.cif": { + source: "iana" + }, + "application/vnd.music-niff": { + source: "iana" + }, + "application/vnd.musician": { + source: "iana", + extensions: ["mus"] + }, + "application/vnd.muvee.style": { + source: "iana", + extensions: ["msty"] + }, + "application/vnd.mynfc": { + source: "iana", + extensions: ["taglet"] + }, + "application/vnd.nacamar.ybrid+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+cbor": { + source: "iana" + }, + "application/vnd.nato.bindingdataobject+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+xml": { + source: "iana", + compressible: true, + extensions: ["bdo"] + }, + "application/vnd.nato.openxmlformats-package.iepd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.ncd.control": { + source: "iana" + }, + "application/vnd.ncd.reference": { + source: "iana" + }, + "application/vnd.nearst.inv+json": { + source: "iana", + compressible: true + }, + "application/vnd.nebumind.line": { + source: "iana" + }, + "application/vnd.nervana": { + source: "iana" + }, + "application/vnd.netfpx": { + source: "iana" + }, + "application/vnd.neurolanguage.nlu": { + source: "iana", + extensions: ["nlu"] + }, + "application/vnd.nimn": { + source: "iana" + }, + "application/vnd.nintendo.nitro.rom": { + source: "iana" + }, + "application/vnd.nintendo.snes.rom": { + source: "iana" + }, + "application/vnd.nitf": { + source: "iana", + extensions: ["ntf", "nitf"] + }, + "application/vnd.noblenet-directory": { + source: "iana", + extensions: ["nnd"] + }, + "application/vnd.noblenet-sealer": { + source: "iana", + extensions: ["nns"] + }, + "application/vnd.noblenet-web": { + source: "iana", + extensions: ["nnw"] + }, + "application/vnd.nokia.catalogs": { + source: "iana" + }, + "application/vnd.nokia.conml+wbxml": { + source: "iana" + }, + "application/vnd.nokia.conml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.iptv.config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.isds-radio-presets": { + source: "iana" + }, + "application/vnd.nokia.landmark+wbxml": { + source: "iana" + }, + "application/vnd.nokia.landmark+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.landmarkcollection+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.n-gage.ac+xml": { + source: "iana", + compressible: true, + extensions: ["ac"] + }, + "application/vnd.nokia.n-gage.data": { + source: "iana", + extensions: ["ngdat"] + }, + "application/vnd.nokia.n-gage.symbian.install": { + source: "apache", + extensions: ["n-gage"] + }, + "application/vnd.nokia.ncd": { + source: "iana" + }, + "application/vnd.nokia.pcd+wbxml": { + source: "iana" + }, + "application/vnd.nokia.pcd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.radio-preset": { + source: "iana", + extensions: ["rpst"] + }, + "application/vnd.nokia.radio-presets": { + source: "iana", + extensions: ["rpss"] + }, + "application/vnd.novadigm.edm": { + source: "iana", + extensions: ["edm"] + }, + "application/vnd.novadigm.edx": { + source: "iana", + extensions: ["edx"] + }, + "application/vnd.novadigm.ext": { + source: "iana", + extensions: ["ext"] + }, + "application/vnd.ntt-local.content-share": { + source: "iana" + }, + "application/vnd.ntt-local.file-transfer": { + source: "iana" + }, + "application/vnd.ntt-local.ogw_remote-access": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_remote": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_tcp_stream": { + source: "iana" + }, + "application/vnd.oai.workflows": { + source: "iana" + }, + "application/vnd.oai.workflows+json": { + source: "iana", + compressible: true + }, + "application/vnd.oai.workflows+yaml": { + source: "iana" + }, + "application/vnd.oasis.opendocument.base": { + source: "iana" + }, + "application/vnd.oasis.opendocument.chart": { + source: "iana", + extensions: ["odc"] + }, + "application/vnd.oasis.opendocument.chart-template": { + source: "iana", + extensions: ["otc"] + }, + "application/vnd.oasis.opendocument.database": { + source: "apache", + extensions: ["odb"] + }, + "application/vnd.oasis.opendocument.formula": { + source: "iana", + extensions: ["odf"] + }, + "application/vnd.oasis.opendocument.formula-template": { + source: "iana", + extensions: ["odft"] + }, + "application/vnd.oasis.opendocument.graphics": { + source: "iana", + compressible: false, + extensions: ["odg"] + }, + "application/vnd.oasis.opendocument.graphics-template": { + source: "iana", + extensions: ["otg"] + }, + "application/vnd.oasis.opendocument.image": { + source: "iana", + extensions: ["odi"] + }, + "application/vnd.oasis.opendocument.image-template": { + source: "iana", + extensions: ["oti"] + }, + "application/vnd.oasis.opendocument.presentation": { + source: "iana", + compressible: false, + extensions: ["odp"] + }, + "application/vnd.oasis.opendocument.presentation-template": { + source: "iana", + extensions: ["otp"] + }, + "application/vnd.oasis.opendocument.spreadsheet": { + source: "iana", + compressible: false, + extensions: ["ods"] + }, + "application/vnd.oasis.opendocument.spreadsheet-template": { + source: "iana", + extensions: ["ots"] + }, + "application/vnd.oasis.opendocument.text": { + source: "iana", + compressible: false, + extensions: ["odt"] + }, + "application/vnd.oasis.opendocument.text-master": { + source: "iana", + extensions: ["odm"] + }, + "application/vnd.oasis.opendocument.text-master-template": { + source: "iana" + }, + "application/vnd.oasis.opendocument.text-template": { + source: "iana", + extensions: ["ott"] + }, + "application/vnd.oasis.opendocument.text-web": { + source: "iana", + extensions: ["oth"] + }, + "application/vnd.obn": { + source: "iana" + }, + "application/vnd.ocf+cbor": { + source: "iana" + }, + "application/vnd.oci.image.manifest.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.oftn.l10n+json": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessdownload+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessstreaming+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.cspg-hexbinary": { + source: "iana" + }, + "application/vnd.oipf.dae.svg+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.dae.xhtml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.mippvcontrolmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.pae.gem": { + source: "iana" + }, + "application/vnd.oipf.spdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.spdlist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.ueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.userprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.olpc-sugar": { + source: "iana", + extensions: ["xo"] + }, + "application/vnd.oma-scws-config": { + source: "iana" + }, + "application/vnd.oma-scws-http-request": { + source: "iana" + }, + "application/vnd.oma-scws-http-response": { + source: "iana" + }, + "application/vnd.oma.bcast.associated-procedure-parameter+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.drm-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.imd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.ltkm": { + source: "iana" + }, + "application/vnd.oma.bcast.notification+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.provisioningtrigger": { + source: "iana" + }, + "application/vnd.oma.bcast.sgboot": { + source: "iana" + }, + "application/vnd.oma.bcast.sgdd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sgdu": { + source: "iana" + }, + "application/vnd.oma.bcast.simple-symbol-container": { + source: "iana" + }, + "application/vnd.oma.bcast.smartcard-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.sprov+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.stkm": { + source: "iana" + }, + "application/vnd.oma.cab-address-book+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-feature-handler+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-pcc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-subs-invite+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-user-prefs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.dcd": { + source: "iana" + }, + "application/vnd.oma.dcdc": { + source: "iana" + }, + "application/vnd.oma.dd2+xml": { + source: "iana", + compressible: true, + extensions: ["dd2"] + }, + "application/vnd.oma.drm.risd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.group-usage-list+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+cbor": { + source: "iana" + }, + "application/vnd.oma.lwm2m+json": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+tlv": { + source: "iana" + }, + "application/vnd.oma.pal+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.detailed-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.final-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.groups+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.invocation-descriptor+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.optimized-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.push": { + source: "iana" + }, + "application/vnd.oma.scidm.messages+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.xcap-directory+xml": { + source: "iana", + compressible: true + }, + "application/vnd.omads-email+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-file+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-folder+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omaloc-supl-init": { + source: "iana" + }, + "application/vnd.onepager": { + source: "iana" + }, + "application/vnd.onepagertamp": { + source: "iana" + }, + "application/vnd.onepagertamx": { + source: "iana" + }, + "application/vnd.onepagertat": { + source: "iana" + }, + "application/vnd.onepagertatp": { + source: "iana" + }, + "application/vnd.onepagertatx": { + source: "iana" + }, + "application/vnd.onvif.metadata": { + source: "iana" + }, + "application/vnd.openblox.game+xml": { + source: "iana", + compressible: true, + extensions: ["obgx"] + }, + "application/vnd.openblox.game-binary": { + source: "iana" + }, + "application/vnd.openeye.oeb": { + source: "iana" + }, + "application/vnd.openofficeorg.extension": { + source: "apache", + extensions: ["oxt"] + }, + "application/vnd.openstreetmap.data+xml": { + source: "iana", + compressible: true, + extensions: ["osm"] + }, + "application/vnd.opentimestamps.ots": { + source: "iana" + }, + "application/vnd.openvpi.dspx+json": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.custom-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawing+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.extended-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation": { + source: "iana", + compressible: false, + extensions: ["pptx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide": { + source: "iana", + extensions: ["sldx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { + source: "iana", + extensions: ["ppsx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.template": { + source: "iana", + extensions: ["potx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { + source: "iana", + compressible: false, + extensions: ["xlsx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { + source: "iana", + extensions: ["xltx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.theme+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.themeoverride+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.vmldrawing": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { + source: "iana", + compressible: false, + extensions: ["docx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { + source: "iana", + extensions: ["dotx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.core-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.relationships+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oracle.resource+json": { + source: "iana", + compressible: true + }, + "application/vnd.orange.indata": { + source: "iana" + }, + "application/vnd.osa.netdeploy": { + source: "iana" + }, + "application/vnd.osgeo.mapguide.package": { + source: "iana", + extensions: ["mgp"] + }, + "application/vnd.osgi.bundle": { + source: "iana" + }, + "application/vnd.osgi.dp": { + source: "iana", + extensions: ["dp"] + }, + "application/vnd.osgi.subsystem": { + source: "iana", + extensions: ["esa"] + }, + "application/vnd.otps.ct-kip+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oxli.countgraph": { + source: "iana" + }, + "application/vnd.pagerduty+json": { + source: "iana", + compressible: true + }, + "application/vnd.palm": { + source: "iana", + extensions: ["pdb", "pqa", "oprc"] + }, + "application/vnd.panoply": { + source: "iana" + }, + "application/vnd.paos.xml": { + source: "iana" + }, + "application/vnd.patentdive": { + source: "iana" + }, + "application/vnd.patientecommsdoc": { + source: "iana" + }, + "application/vnd.pawaafile": { + source: "iana", + extensions: ["paw"] + }, + "application/vnd.pcos": { + source: "iana" + }, + "application/vnd.pg.format": { + source: "iana", + extensions: ["str"] + }, + "application/vnd.pg.osasli": { + source: "iana", + extensions: ["ei6"] + }, + "application/vnd.piaccess.application-licence": { + source: "iana" + }, + "application/vnd.picsel": { + source: "iana", + extensions: ["efif"] + }, + "application/vnd.pmi.widget": { + source: "iana", + extensions: ["wg"] + }, + "application/vnd.poc.group-advertisement+xml": { + source: "iana", + compressible: true + }, + "application/vnd.pocketlearn": { + source: "iana", + extensions: ["plf"] + }, + "application/vnd.powerbuilder6": { + source: "iana", + extensions: ["pbd"] + }, + "application/vnd.powerbuilder6-s": { + source: "iana" + }, + "application/vnd.powerbuilder7": { + source: "iana" + }, + "application/vnd.powerbuilder7-s": { + source: "iana" + }, + "application/vnd.powerbuilder75": { + source: "iana" + }, + "application/vnd.powerbuilder75-s": { + source: "iana" + }, + "application/vnd.preminet": { + source: "iana" + }, + "application/vnd.previewsystems.box": { + source: "iana", + extensions: ["box"] + }, + "application/vnd.procrate.brushset": { + extensions: ["brushset"] + }, + "application/vnd.procreate.brush": { + extensions: ["brush"] + }, + "application/vnd.procreate.dream": { + extensions: ["drm"] + }, + "application/vnd.proteus.magazine": { + source: "iana", + extensions: ["mgz"] + }, + "application/vnd.psfs": { + source: "iana" + }, + "application/vnd.pt.mundusmundi": { + source: "iana" + }, + "application/vnd.publishare-delta-tree": { + source: "iana", + extensions: ["qps"] + }, + "application/vnd.pvi.ptid1": { + source: "iana", + extensions: ["ptid"] + }, + "application/vnd.pwg-multiplexed": { + source: "iana" + }, + "application/vnd.pwg-xhtml-print+xml": { + source: "iana", + compressible: true, + extensions: ["xhtm"] + }, + "application/vnd.qualcomm.brew-app-res": { + source: "iana" + }, + "application/vnd.quarantainenet": { + source: "iana" + }, + "application/vnd.quark.quarkxpress": { + source: "iana", + extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] + }, + "application/vnd.quobject-quoxdocument": { + source: "iana" + }, + "application/vnd.radisys.moml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-stream+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-base+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-detect+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-group+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-speech+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-transform+xml": { + source: "iana", + compressible: true + }, + "application/vnd.rainstor.data": { + source: "iana" + }, + "application/vnd.rapid": { + source: "iana" + }, + "application/vnd.rar": { + source: "iana", + extensions: ["rar"] + }, + "application/vnd.realvnc.bed": { + source: "iana", + extensions: ["bed"] + }, + "application/vnd.recordare.musicxml": { + source: "iana", + extensions: ["mxl"] + }, + "application/vnd.recordare.musicxml+xml": { + source: "iana", + compressible: true, + extensions: ["musicxml"] + }, + "application/vnd.relpipe": { + source: "iana" + }, + "application/vnd.renlearn.rlprint": { + source: "iana" + }, + "application/vnd.resilient.logic": { + source: "iana" + }, + "application/vnd.restful+json": { + source: "iana", + compressible: true + }, + "application/vnd.rig.cryptonote": { + source: "iana", + extensions: ["cryptonote"] + }, + "application/vnd.rim.cod": { + source: "apache", + extensions: ["cod"] + }, + "application/vnd.rn-realmedia": { + source: "apache", + extensions: ["rm"] + }, + "application/vnd.rn-realmedia-vbr": { + source: "apache", + extensions: ["rmvb"] + }, + "application/vnd.route66.link66+xml": { + source: "iana", + compressible: true, + extensions: ["link66"] + }, + "application/vnd.rs-274x": { + source: "iana" + }, + "application/vnd.ruckus.download": { + source: "iana" + }, + "application/vnd.s3sms": { + source: "iana" + }, + "application/vnd.sailingtracker.track": { + source: "iana", + extensions: ["st"] + }, + "application/vnd.sar": { + source: "iana" + }, + "application/vnd.sbm.cid": { + source: "iana" + }, + "application/vnd.sbm.mid2": { + source: "iana" + }, + "application/vnd.scribus": { + source: "iana" + }, + "application/vnd.sealed.3df": { + source: "iana" + }, + "application/vnd.sealed.csf": { + source: "iana" + }, + "application/vnd.sealed.doc": { + source: "iana" + }, + "application/vnd.sealed.eml": { + source: "iana" + }, + "application/vnd.sealed.mht": { + source: "iana" + }, + "application/vnd.sealed.net": { + source: "iana" + }, + "application/vnd.sealed.ppt": { + source: "iana" + }, + "application/vnd.sealed.tiff": { + source: "iana" + }, + "application/vnd.sealed.xls": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.html": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.pdf": { + source: "iana" + }, + "application/vnd.seemail": { + source: "iana", + extensions: ["see"] + }, + "application/vnd.seis+json": { + source: "iana", + compressible: true + }, + "application/vnd.sema": { + source: "iana", + extensions: ["sema"] + }, + "application/vnd.semd": { + source: "iana", + extensions: ["semd"] + }, + "application/vnd.semf": { + source: "iana", + extensions: ["semf"] + }, + "application/vnd.shade-save-file": { + source: "iana" + }, + "application/vnd.shana.informed.formdata": { + source: "iana", + extensions: ["ifm"] + }, + "application/vnd.shana.informed.formtemplate": { + source: "iana", + extensions: ["itp"] + }, + "application/vnd.shana.informed.interchange": { + source: "iana", + extensions: ["iif"] + }, + "application/vnd.shana.informed.package": { + source: "iana", + extensions: ["ipk"] + }, + "application/vnd.shootproof+json": { + source: "iana", + compressible: true + }, + "application/vnd.shopkick+json": { + source: "iana", + compressible: true + }, + "application/vnd.shp": { + source: "iana" + }, + "application/vnd.shx": { + source: "iana" + }, + "application/vnd.sigrok.session": { + source: "iana" + }, + "application/vnd.simtech-mindmapper": { + source: "iana", + extensions: ["twd", "twds"] + }, + "application/vnd.siren+json": { + source: "iana", + compressible: true + }, + "application/vnd.sketchometry": { + source: "iana" + }, + "application/vnd.smaf": { + source: "iana", + extensions: ["mmf"] + }, + "application/vnd.smart.notebook": { + source: "iana" + }, + "application/vnd.smart.teacher": { + source: "iana", + extensions: ["teacher"] + }, + "application/vnd.smintio.portals.archive": { + source: "iana" + }, + "application/vnd.snesdev-page-table": { + source: "iana" + }, + "application/vnd.software602.filler.form+xml": { + source: "iana", + compressible: true, + extensions: ["fo"] + }, + "application/vnd.software602.filler.form-xml-zip": { + source: "iana" + }, + "application/vnd.solent.sdkm+xml": { + source: "iana", + compressible: true, + extensions: ["sdkm", "sdkd"] + }, + "application/vnd.spotfire.dxp": { + source: "iana", + extensions: ["dxp"] + }, + "application/vnd.spotfire.sfs": { + source: "iana", + extensions: ["sfs"] + }, + "application/vnd.sqlite3": { + source: "iana" + }, + "application/vnd.sss-cod": { + source: "iana" + }, + "application/vnd.sss-dtf": { + source: "iana" + }, + "application/vnd.sss-ntf": { + source: "iana" + }, + "application/vnd.stardivision.calc": { + source: "apache", + extensions: ["sdc"] + }, + "application/vnd.stardivision.draw": { + source: "apache", + extensions: ["sda"] + }, + "application/vnd.stardivision.impress": { + source: "apache", + extensions: ["sdd"] + }, + "application/vnd.stardivision.math": { + source: "apache", + extensions: ["smf"] + }, + "application/vnd.stardivision.writer": { + source: "apache", + extensions: ["sdw", "vor"] + }, + "application/vnd.stardivision.writer-global": { + source: "apache", + extensions: ["sgl"] + }, + "application/vnd.stepmania.package": { + source: "iana", + extensions: ["smzip"] + }, + "application/vnd.stepmania.stepchart": { + source: "iana", + extensions: ["sm"] + }, + "application/vnd.street-stream": { + source: "iana" + }, + "application/vnd.sun.wadl+xml": { + source: "iana", + compressible: true, + extensions: ["wadl"] + }, + "application/vnd.sun.xml.calc": { + source: "apache", + extensions: ["sxc"] + }, + "application/vnd.sun.xml.calc.template": { + source: "apache", + extensions: ["stc"] + }, + "application/vnd.sun.xml.draw": { + source: "apache", + extensions: ["sxd"] + }, + "application/vnd.sun.xml.draw.template": { + source: "apache", + extensions: ["std"] + }, + "application/vnd.sun.xml.impress": { + source: "apache", + extensions: ["sxi"] + }, + "application/vnd.sun.xml.impress.template": { + source: "apache", + extensions: ["sti"] + }, + "application/vnd.sun.xml.math": { + source: "apache", + extensions: ["sxm"] + }, + "application/vnd.sun.xml.writer": { + source: "apache", + extensions: ["sxw"] + }, + "application/vnd.sun.xml.writer.global": { + source: "apache", + extensions: ["sxg"] + }, + "application/vnd.sun.xml.writer.template": { + source: "apache", + extensions: ["stw"] + }, + "application/vnd.sus-calendar": { + source: "iana", + extensions: ["sus", "susp"] + }, + "application/vnd.svd": { + source: "iana", + extensions: ["svd"] + }, + "application/vnd.swiftview-ics": { + source: "iana" + }, + "application/vnd.sybyl.mol2": { + source: "iana" + }, + "application/vnd.sycle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.syft+json": { + source: "iana", + compressible: true + }, + "application/vnd.symbian.install": { + source: "apache", + extensions: ["sis", "sisx"] + }, + "application/vnd.syncml+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xsm"] + }, + "application/vnd.syncml.dm+wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["bdm"] + }, + "application/vnd.syncml.dm+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xdm"] + }, + "application/vnd.syncml.dm.notification": { + source: "iana" + }, + "application/vnd.syncml.dmddf+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmddf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["ddf"] + }, + "application/vnd.syncml.dmtnds+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmtnds+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.syncml.ds.notification": { + source: "iana" + }, + "application/vnd.tableschema+json": { + source: "iana", + compressible: true + }, + "application/vnd.tao.intent-module-archive": { + source: "iana", + extensions: ["tao"] + }, + "application/vnd.tcpdump.pcap": { + source: "iana", + extensions: ["pcap", "cap", "dmp"] + }, + "application/vnd.think-cell.ppttc+json": { + source: "iana", + compressible: true + }, + "application/vnd.tmd.mediaflex.api+xml": { + source: "iana", + compressible: true + }, + "application/vnd.tml": { + source: "iana" + }, + "application/vnd.tmobile-livetv": { + source: "iana", + extensions: ["tmo"] + }, + "application/vnd.tri.onesource": { + source: "iana" + }, + "application/vnd.trid.tpt": { + source: "iana", + extensions: ["tpt"] + }, + "application/vnd.triscape.mxs": { + source: "iana", + extensions: ["mxs"] + }, + "application/vnd.trueapp": { + source: "iana", + extensions: ["tra"] + }, + "application/vnd.truedoc": { + source: "iana" + }, + "application/vnd.ubisoft.webplayer": { + source: "iana" + }, + "application/vnd.ufdl": { + source: "iana", + extensions: ["ufd", "ufdl"] + }, + "application/vnd.uic.osdm+json": { + source: "iana", + compressible: true + }, + "application/vnd.uiq.theme": { + source: "iana", + extensions: ["utz"] + }, + "application/vnd.umajin": { + source: "iana", + extensions: ["umj"] + }, + "application/vnd.unity": { + source: "iana", + extensions: ["unityweb"] + }, + "application/vnd.uoml+xml": { + source: "iana", + compressible: true, + extensions: ["uoml", "uo"] + }, + "application/vnd.uplanet.alert": { + source: "iana" + }, + "application/vnd.uplanet.alert-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.cacheop": { + source: "iana" + }, + "application/vnd.uplanet.cacheop-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.channel": { + source: "iana" + }, + "application/vnd.uplanet.channel-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.list": { + source: "iana" + }, + "application/vnd.uplanet.list-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.listcmd": { + source: "iana" + }, + "application/vnd.uplanet.listcmd-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.signal": { + source: "iana" + }, + "application/vnd.uri-map": { + source: "iana" + }, + "application/vnd.valve.source.material": { + source: "iana" + }, + "application/vnd.vcx": { + source: "iana", + extensions: ["vcx"] + }, + "application/vnd.vd-study": { + source: "iana" + }, + "application/vnd.vectorworks": { + source: "iana" + }, + "application/vnd.vel+json": { + source: "iana", + compressible: true + }, + "application/vnd.veraison.tsm-report+cbor": { + source: "iana" + }, + "application/vnd.veraison.tsm-report+json": { + source: "iana", + compressible: true + }, + "application/vnd.verimatrix.vcas": { + source: "iana" + }, + "application/vnd.veritone.aion+json": { + source: "iana", + compressible: true + }, + "application/vnd.veryant.thin": { + source: "iana" + }, + "application/vnd.ves.encrypted": { + source: "iana" + }, + "application/vnd.vidsoft.vidconference": { + source: "iana" + }, + "application/vnd.visio": { + source: "iana", + extensions: ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"] + }, + "application/vnd.visionary": { + source: "iana", + extensions: ["vis"] + }, + "application/vnd.vividence.scriptfile": { + source: "iana" + }, + "application/vnd.vocalshaper.vsp4": { + source: "iana" + }, + "application/vnd.vsf": { + source: "iana", + extensions: ["vsf"] + }, + "application/vnd.wap.sic": { + source: "iana" + }, + "application/vnd.wap.slc": { + source: "iana" + }, + "application/vnd.wap.wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["wbxml"] + }, + "application/vnd.wap.wmlc": { + source: "iana", + extensions: ["wmlc"] + }, + "application/vnd.wap.wmlscriptc": { + source: "iana", + extensions: ["wmlsc"] + }, + "application/vnd.wasmflow.wafl": { + source: "iana" + }, + "application/vnd.webturbo": { + source: "iana", + extensions: ["wtb"] + }, + "application/vnd.wfa.dpp": { + source: "iana" + }, + "application/vnd.wfa.p2p": { + source: "iana" + }, + "application/vnd.wfa.wsc": { + source: "iana" + }, + "application/vnd.windows.devicepairing": { + source: "iana" + }, + "application/vnd.wmc": { + source: "iana" + }, + "application/vnd.wmf.bootstrap": { + source: "iana" + }, + "application/vnd.wolfram.mathematica": { + source: "iana" + }, + "application/vnd.wolfram.mathematica.package": { + source: "iana" + }, + "application/vnd.wolfram.player": { + source: "iana", + extensions: ["nbp"] + }, + "application/vnd.wordlift": { + source: "iana" + }, + "application/vnd.wordperfect": { + source: "iana", + extensions: ["wpd"] + }, + "application/vnd.wqd": { + source: "iana", + extensions: ["wqd"] + }, + "application/vnd.wrq-hp3000-labelled": { + source: "iana" + }, + "application/vnd.wt.stf": { + source: "iana", + extensions: ["stf"] + }, + "application/vnd.wv.csp+wbxml": { + source: "iana" + }, + "application/vnd.wv.csp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.wv.ssp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xacml+json": { + source: "iana", + compressible: true + }, + "application/vnd.xara": { + source: "iana", + extensions: ["xar"] + }, + "application/vnd.xarin.cpj": { + source: "iana" + }, + "application/vnd.xecrets-encrypted": { + source: "iana" + }, + "application/vnd.xfdl": { + source: "iana", + extensions: ["xfdl"] + }, + "application/vnd.xfdl.webform": { + source: "iana" + }, + "application/vnd.xmi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xmpie.cpkg": { + source: "iana" + }, + "application/vnd.xmpie.dpkg": { + source: "iana" + }, + "application/vnd.xmpie.plan": { + source: "iana" + }, + "application/vnd.xmpie.ppkg": { + source: "iana" + }, + "application/vnd.xmpie.xlim": { + source: "iana" + }, + "application/vnd.yamaha.hv-dic": { + source: "iana", + extensions: ["hvd"] + }, + "application/vnd.yamaha.hv-script": { + source: "iana", + extensions: ["hvs"] + }, + "application/vnd.yamaha.hv-voice": { + source: "iana", + extensions: ["hvp"] + }, + "application/vnd.yamaha.openscoreformat": { + source: "iana", + extensions: ["osf"] + }, + "application/vnd.yamaha.openscoreformat.osfpvg+xml": { + source: "iana", + compressible: true, + extensions: ["osfpvg"] + }, + "application/vnd.yamaha.remote-setup": { + source: "iana" + }, + "application/vnd.yamaha.smaf-audio": { + source: "iana", + extensions: ["saf"] + }, + "application/vnd.yamaha.smaf-phrase": { + source: "iana", + extensions: ["spf"] + }, + "application/vnd.yamaha.through-ngn": { + source: "iana" + }, + "application/vnd.yamaha.tunnel-udpencap": { + source: "iana" + }, + "application/vnd.yaoweme": { + source: "iana" + }, + "application/vnd.yellowriver-custom-menu": { + source: "iana", + extensions: ["cmp"] + }, + "application/vnd.zul": { + source: "iana", + extensions: ["zir", "zirz"] + }, + "application/vnd.zzazz.deck+xml": { + source: "iana", + compressible: true, + extensions: ["zaz"] + }, + "application/voicexml+xml": { + source: "iana", + compressible: true, + extensions: ["vxml"] + }, + "application/voucher-cms+json": { + source: "iana", + compressible: true + }, + "application/voucher-jws+json": { + source: "iana", + compressible: true + }, + "application/vp": { + source: "iana" + }, + "application/vp+cose": { + source: "iana" + }, + "application/vp+jwt": { + source: "iana" + }, + "application/vq-rtcpxr": { + source: "iana" + }, + "application/wasm": { + source: "iana", + compressible: true, + extensions: ["wasm"] + }, + "application/watcherinfo+xml": { + source: "iana", + compressible: true, + extensions: ["wif"] + }, + "application/webpush-options+json": { + source: "iana", + compressible: true + }, + "application/whoispp-query": { + source: "iana" + }, + "application/whoispp-response": { + source: "iana" + }, + "application/widget": { + source: "iana", + extensions: ["wgt"] + }, + "application/winhlp": { + source: "apache", + extensions: ["hlp"] + }, + "application/wita": { + source: "iana" + }, + "application/wordperfect5.1": { + source: "iana" + }, + "application/wsdl+xml": { + source: "iana", + compressible: true, + extensions: ["wsdl"] + }, + "application/wspolicy+xml": { + source: "iana", + compressible: true, + extensions: ["wspolicy"] + }, + "application/x-7z-compressed": { + source: "apache", + compressible: false, + extensions: ["7z"] + }, + "application/x-abiword": { + source: "apache", + extensions: ["abw"] + }, + "application/x-ace-compressed": { + source: "apache", + extensions: ["ace"] + }, + "application/x-amf": { + source: "apache" + }, + "application/x-apple-diskimage": { + source: "apache", + extensions: ["dmg"] + }, + "application/x-arj": { + compressible: false, + extensions: ["arj"] + }, + "application/x-authorware-bin": { + source: "apache", + extensions: ["aab", "x32", "u32", "vox"] + }, + "application/x-authorware-map": { + source: "apache", + extensions: ["aam"] + }, + "application/x-authorware-seg": { + source: "apache", + extensions: ["aas"] + }, + "application/x-bcpio": { + source: "apache", + extensions: ["bcpio"] + }, + "application/x-bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/x-bittorrent": { + source: "apache", + extensions: ["torrent"] + }, + "application/x-blender": { + extensions: ["blend"] + }, + "application/x-blorb": { + source: "apache", + extensions: ["blb", "blorb"] + }, + "application/x-bzip": { + source: "apache", + compressible: false, + extensions: ["bz"] + }, + "application/x-bzip2": { + source: "apache", + compressible: false, + extensions: ["bz2", "boz"] + }, + "application/x-cbr": { + source: "apache", + extensions: ["cbr", "cba", "cbt", "cbz", "cb7"] + }, + "application/x-cdlink": { + source: "apache", + extensions: ["vcd"] + }, + "application/x-cfs-compressed": { + source: "apache", + extensions: ["cfs"] + }, + "application/x-chat": { + source: "apache", + extensions: ["chat"] + }, + "application/x-chess-pgn": { + source: "apache", + extensions: ["pgn"] + }, + "application/x-chrome-extension": { + extensions: ["crx"] + }, + "application/x-cocoa": { + source: "nginx", + extensions: ["cco"] + }, + "application/x-compress": { + source: "apache" + }, + "application/x-compressed": { + extensions: ["rar"] + }, + "application/x-conference": { + source: "apache", + extensions: ["nsc"] + }, + "application/x-cpio": { + source: "apache", + extensions: ["cpio"] + }, + "application/x-csh": { + source: "apache", + extensions: ["csh"] + }, + "application/x-deb": { + compressible: false + }, + "application/x-debian-package": { + source: "apache", + extensions: ["deb", "udeb"] + }, + "application/x-dgc-compressed": { + source: "apache", + extensions: ["dgc"] + }, + "application/x-director": { + source: "apache", + extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] + }, + "application/x-doom": { + source: "apache", + extensions: ["wad"] + }, + "application/x-dtbncx+xml": { + source: "apache", + compressible: true, + extensions: ["ncx"] + }, + "application/x-dtbook+xml": { + source: "apache", + compressible: true, + extensions: ["dtb"] + }, + "application/x-dtbresource+xml": { + source: "apache", + compressible: true, + extensions: ["res"] + }, + "application/x-dvi": { + source: "apache", + compressible: false, + extensions: ["dvi"] + }, + "application/x-envoy": { + source: "apache", + extensions: ["evy"] + }, + "application/x-eva": { + source: "apache", + extensions: ["eva"] + }, + "application/x-font-bdf": { + source: "apache", + extensions: ["bdf"] + }, + "application/x-font-dos": { + source: "apache" + }, + "application/x-font-framemaker": { + source: "apache" + }, + "application/x-font-ghostscript": { + source: "apache", + extensions: ["gsf"] + }, + "application/x-font-libgrx": { + source: "apache" + }, + "application/x-font-linux-psf": { + source: "apache", + extensions: ["psf"] + }, + "application/x-font-pcf": { + source: "apache", + extensions: ["pcf"] + }, + "application/x-font-snf": { + source: "apache", + extensions: ["snf"] + }, + "application/x-font-speedo": { + source: "apache" + }, + "application/x-font-sunos-news": { + source: "apache" + }, + "application/x-font-type1": { + source: "apache", + extensions: ["pfa", "pfb", "pfm", "afm"] + }, + "application/x-font-vfont": { + source: "apache" + }, + "application/x-freearc": { + source: "apache", + extensions: ["arc"] + }, + "application/x-futuresplash": { + source: "apache", + extensions: ["spl"] + }, + "application/x-gca-compressed": { + source: "apache", + extensions: ["gca"] + }, + "application/x-glulx": { + source: "apache", + extensions: ["ulx"] + }, + "application/x-gnumeric": { + source: "apache", + extensions: ["gnumeric"] + }, + "application/x-gramps-xml": { + source: "apache", + extensions: ["gramps"] + }, + "application/x-gtar": { + source: "apache", + extensions: ["gtar"] + }, + "application/x-gzip": { + source: "apache" + }, + "application/x-hdf": { + source: "apache", + extensions: ["hdf"] + }, + "application/x-httpd-php": { + compressible: true, + extensions: ["php"] + }, + "application/x-install-instructions": { + source: "apache", + extensions: ["install"] + }, + "application/x-ipynb+json": { + compressible: true, + extensions: ["ipynb"] + }, + "application/x-iso9660-image": { + source: "apache", + extensions: ["iso"] + }, + "application/x-iwork-keynote-sffkey": { + extensions: ["key"] + }, + "application/x-iwork-numbers-sffnumbers": { + extensions: ["numbers"] + }, + "application/x-iwork-pages-sffpages": { + extensions: ["pages"] + }, + "application/x-java-archive-diff": { + source: "nginx", + extensions: ["jardiff"] + }, + "application/x-java-jnlp-file": { + source: "apache", + compressible: false, + extensions: ["jnlp"] + }, + "application/x-javascript": { + compressible: true + }, + "application/x-keepass2": { + extensions: ["kdbx"] + }, + "application/x-latex": { + source: "apache", + compressible: false, + extensions: ["latex"] + }, + "application/x-lua-bytecode": { + extensions: ["luac"] + }, + "application/x-lzh-compressed": { + source: "apache", + extensions: ["lzh", "lha"] + }, + "application/x-makeself": { + source: "nginx", + extensions: ["run"] + }, + "application/x-mie": { + source: "apache", + extensions: ["mie"] + }, + "application/x-mobipocket-ebook": { + source: "apache", + extensions: ["prc", "mobi"] + }, + "application/x-mpegurl": { + compressible: false + }, + "application/x-ms-application": { + source: "apache", + extensions: ["application"] + }, + "application/x-ms-shortcut": { + source: "apache", + extensions: ["lnk"] + }, + "application/x-ms-wmd": { + source: "apache", + extensions: ["wmd"] + }, + "application/x-ms-wmz": { + source: "apache", + extensions: ["wmz"] + }, + "application/x-ms-xbap": { + source: "apache", + extensions: ["xbap"] + }, + "application/x-msaccess": { + source: "apache", + extensions: ["mdb"] + }, + "application/x-msbinder": { + source: "apache", + extensions: ["obd"] + }, + "application/x-mscardfile": { + source: "apache", + extensions: ["crd"] + }, + "application/x-msclip": { + source: "apache", + extensions: ["clp"] + }, + "application/x-msdos-program": { + extensions: ["exe"] + }, + "application/x-msdownload": { + source: "apache", + extensions: ["exe", "dll", "com", "bat", "msi"] + }, + "application/x-msmediaview": { + source: "apache", + extensions: ["mvb", "m13", "m14"] + }, + "application/x-msmetafile": { + source: "apache", + extensions: ["wmf", "wmz", "emf", "emz"] + }, + "application/x-msmoney": { + source: "apache", + extensions: ["mny"] + }, + "application/x-mspublisher": { + source: "apache", + extensions: ["pub"] + }, + "application/x-msschedule": { + source: "apache", + extensions: ["scd"] + }, + "application/x-msterminal": { + source: "apache", + extensions: ["trm"] + }, + "application/x-mswrite": { + source: "apache", + extensions: ["wri"] + }, + "application/x-netcdf": { + source: "apache", + extensions: ["nc", "cdf"] + }, + "application/x-ns-proxy-autoconfig": { + compressible: true, + extensions: ["pac"] + }, + "application/x-nzb": { + source: "apache", + extensions: ["nzb"] + }, + "application/x-perl": { + source: "nginx", + extensions: ["pl", "pm"] + }, + "application/x-pilot": { + source: "nginx", + extensions: ["prc", "pdb"] + }, + "application/x-pkcs12": { + source: "apache", + compressible: false, + extensions: ["p12", "pfx"] + }, + "application/x-pkcs7-certificates": { + source: "apache", + extensions: ["p7b", "spc"] + }, + "application/x-pkcs7-certreqresp": { + source: "apache", + extensions: ["p7r"] + }, + "application/x-pki-message": { + source: "iana" + }, + "application/x-rar-compressed": { + source: "apache", + compressible: false, + extensions: ["rar"] + }, + "application/x-redhat-package-manager": { + source: "nginx", + extensions: ["rpm"] + }, + "application/x-research-info-systems": { + source: "apache", + extensions: ["ris"] + }, + "application/x-sea": { + source: "nginx", + extensions: ["sea"] + }, + "application/x-sh": { + source: "apache", + compressible: true, + extensions: ["sh"] + }, + "application/x-shar": { + source: "apache", + extensions: ["shar"] + }, + "application/x-shockwave-flash": { + source: "apache", + compressible: false, + extensions: ["swf"] + }, + "application/x-silverlight-app": { + source: "apache", + extensions: ["xap"] + }, + "application/x-sql": { + source: "apache", + extensions: ["sql"] + }, + "application/x-stuffit": { + source: "apache", + compressible: false, + extensions: ["sit"] + }, + "application/x-stuffitx": { + source: "apache", + extensions: ["sitx"] + }, + "application/x-subrip": { + source: "apache", + extensions: ["srt"] + }, + "application/x-sv4cpio": { + source: "apache", + extensions: ["sv4cpio"] + }, + "application/x-sv4crc": { + source: "apache", + extensions: ["sv4crc"] + }, + "application/x-t3vm-image": { + source: "apache", + extensions: ["t3"] + }, + "application/x-tads": { + source: "apache", + extensions: ["gam"] + }, + "application/x-tar": { + source: "apache", + compressible: true, + extensions: ["tar"] + }, + "application/x-tcl": { + source: "apache", + extensions: ["tcl", "tk"] + }, + "application/x-tex": { + source: "apache", + extensions: ["tex"] + }, + "application/x-tex-tfm": { + source: "apache", + extensions: ["tfm"] + }, + "application/x-texinfo": { + source: "apache", + extensions: ["texinfo", "texi"] + }, + "application/x-tgif": { + source: "apache", + extensions: ["obj"] + }, + "application/x-ustar": { + source: "apache", + extensions: ["ustar"] + }, + "application/x-virtualbox-hdd": { + compressible: true, + extensions: ["hdd"] + }, + "application/x-virtualbox-ova": { + compressible: true, + extensions: ["ova"] + }, + "application/x-virtualbox-ovf": { + compressible: true, + extensions: ["ovf"] + }, + "application/x-virtualbox-vbox": { + compressible: true, + extensions: ["vbox"] + }, + "application/x-virtualbox-vbox-extpack": { + compressible: false, + extensions: ["vbox-extpack"] + }, + "application/x-virtualbox-vdi": { + compressible: true, + extensions: ["vdi"] + }, + "application/x-virtualbox-vhd": { + compressible: true, + extensions: ["vhd"] + }, + "application/x-virtualbox-vmdk": { + compressible: true, + extensions: ["vmdk"] + }, + "application/x-wais-source": { + source: "apache", + extensions: ["src"] + }, + "application/x-web-app-manifest+json": { + compressible: true, + extensions: ["webapp"] + }, + "application/x-www-form-urlencoded": { + source: "iana", + compressible: true + }, + "application/x-x509-ca-cert": { + source: "iana", + extensions: ["der", "crt", "pem"] + }, + "application/x-x509-ca-ra-cert": { + source: "iana" + }, + "application/x-x509-next-ca-cert": { + source: "iana" + }, + "application/x-xfig": { + source: "apache", + extensions: ["fig"] + }, + "application/x-xliff+xml": { + source: "apache", + compressible: true, + extensions: ["xlf"] + }, + "application/x-xpinstall": { + source: "apache", + compressible: false, + extensions: ["xpi"] + }, + "application/x-xz": { + source: "apache", + extensions: ["xz"] + }, + "application/x-zip-compressed": { + extensions: ["zip"] + }, + "application/x-zmachine": { + source: "apache", + extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] + }, + "application/x400-bp": { + source: "iana" + }, + "application/xacml+xml": { + source: "iana", + compressible: true + }, + "application/xaml+xml": { + source: "apache", + compressible: true, + extensions: ["xaml"] + }, + "application/xcap-att+xml": { + source: "iana", + compressible: true, + extensions: ["xav"] + }, + "application/xcap-caps+xml": { + source: "iana", + compressible: true, + extensions: ["xca"] + }, + "application/xcap-diff+xml": { + source: "iana", + compressible: true, + extensions: ["xdf"] + }, + "application/xcap-el+xml": { + source: "iana", + compressible: true, + extensions: ["xel"] + }, + "application/xcap-error+xml": { + source: "iana", + compressible: true + }, + "application/xcap-ns+xml": { + source: "iana", + compressible: true, + extensions: ["xns"] + }, + "application/xcon-conference-info+xml": { + source: "iana", + compressible: true + }, + "application/xcon-conference-info-diff+xml": { + source: "iana", + compressible: true + }, + "application/xenc+xml": { + source: "iana", + compressible: true, + extensions: ["xenc"] + }, + "application/xfdf": { + source: "iana", + extensions: ["xfdf"] + }, + "application/xhtml+xml": { + source: "iana", + compressible: true, + extensions: ["xhtml", "xht"] + }, + "application/xhtml-voice+xml": { + source: "apache", + compressible: true + }, + "application/xliff+xml": { + source: "iana", + compressible: true, + extensions: ["xlf"] + }, + "application/xml": { + source: "iana", + compressible: true, + extensions: ["xml", "xsl", "xsd", "rng"] + }, + "application/xml-dtd": { + source: "iana", + compressible: true, + extensions: ["dtd"] + }, + "application/xml-external-parsed-entity": { + source: "iana" + }, + "application/xml-patch+xml": { + source: "iana", + compressible: true + }, + "application/xmpp+xml": { + source: "iana", + compressible: true + }, + "application/xop+xml": { + source: "iana", + compressible: true, + extensions: ["xop"] + }, + "application/xproc+xml": { + source: "apache", + compressible: true, + extensions: ["xpl"] + }, + "application/xslt+xml": { + source: "iana", + compressible: true, + extensions: ["xsl", "xslt"] + }, + "application/xspf+xml": { + source: "apache", + compressible: true, + extensions: ["xspf"] + }, + "application/xv+xml": { + source: "iana", + compressible: true, + extensions: ["mxml", "xhvml", "xvml", "xvm"] + }, + "application/yaml": { + source: "iana" + }, + "application/yang": { + source: "iana", + extensions: ["yang"] + }, + "application/yang-data+cbor": { + source: "iana" + }, + "application/yang-data+json": { + source: "iana", + compressible: true + }, + "application/yang-data+xml": { + source: "iana", + compressible: true + }, + "application/yang-patch+json": { + source: "iana", + compressible: true + }, + "application/yang-patch+xml": { + source: "iana", + compressible: true + }, + "application/yang-sid+json": { + source: "iana", + compressible: true + }, + "application/yin+xml": { + source: "iana", + compressible: true, + extensions: ["yin"] + }, + "application/zip": { + source: "iana", + compressible: false, + extensions: ["zip"] + }, + "application/zip+dotlottie": { + extensions: ["lottie"] + }, + "application/zlib": { + source: "iana" + }, + "application/zstd": { + source: "iana" + }, + "audio/1d-interleaved-parityfec": { + source: "iana" + }, + "audio/32kadpcm": { + source: "iana" + }, + "audio/3gpp": { + source: "iana", + compressible: false, + extensions: ["3gpp"] + }, + "audio/3gpp2": { + source: "iana" + }, + "audio/aac": { + source: "iana", + extensions: ["adts", "aac"] + }, + "audio/ac3": { + source: "iana" + }, + "audio/adpcm": { + source: "apache", + extensions: ["adp"] + }, + "audio/amr": { + source: "iana", + extensions: ["amr"] + }, + "audio/amr-wb": { + source: "iana" + }, + "audio/amr-wb+": { + source: "iana" + }, + "audio/aptx": { + source: "iana" + }, + "audio/asc": { + source: "iana" + }, + "audio/atrac-advanced-lossless": { + source: "iana" + }, + "audio/atrac-x": { + source: "iana" + }, + "audio/atrac3": { + source: "iana" + }, + "audio/basic": { + source: "iana", + compressible: false, + extensions: ["au", "snd"] + }, + "audio/bv16": { + source: "iana" + }, + "audio/bv32": { + source: "iana" + }, + "audio/clearmode": { + source: "iana" + }, + "audio/cn": { + source: "iana" + }, + "audio/dat12": { + source: "iana" + }, + "audio/dls": { + source: "iana" + }, + "audio/dsr-es201108": { + source: "iana" + }, + "audio/dsr-es202050": { + source: "iana" + }, + "audio/dsr-es202211": { + source: "iana" + }, + "audio/dsr-es202212": { + source: "iana" + }, + "audio/dv": { + source: "iana" + }, + "audio/dvi4": { + source: "iana" + }, + "audio/eac3": { + source: "iana" + }, + "audio/encaprtp": { + source: "iana" + }, + "audio/evrc": { + source: "iana" + }, + "audio/evrc-qcp": { + source: "iana" + }, + "audio/evrc0": { + source: "iana" + }, + "audio/evrc1": { + source: "iana" + }, + "audio/evrcb": { + source: "iana" + }, + "audio/evrcb0": { + source: "iana" + }, + "audio/evrcb1": { + source: "iana" + }, + "audio/evrcnw": { + source: "iana" + }, + "audio/evrcnw0": { + source: "iana" + }, + "audio/evrcnw1": { + source: "iana" + }, + "audio/evrcwb": { + source: "iana" + }, + "audio/evrcwb0": { + source: "iana" + }, + "audio/evrcwb1": { + source: "iana" + }, + "audio/evs": { + source: "iana" + }, + "audio/flac": { + source: "iana" + }, + "audio/flexfec": { + source: "iana" + }, + "audio/fwdred": { + source: "iana" + }, + "audio/g711-0": { + source: "iana" + }, + "audio/g719": { + source: "iana" + }, + "audio/g722": { + source: "iana" + }, + "audio/g7221": { + source: "iana" + }, + "audio/g723": { + source: "iana" + }, + "audio/g726-16": { + source: "iana" + }, + "audio/g726-24": { + source: "iana" + }, + "audio/g726-32": { + source: "iana" + }, + "audio/g726-40": { + source: "iana" + }, + "audio/g728": { + source: "iana" + }, + "audio/g729": { + source: "iana" + }, + "audio/g7291": { + source: "iana" + }, + "audio/g729d": { + source: "iana" + }, + "audio/g729e": { + source: "iana" + }, + "audio/gsm": { + source: "iana" + }, + "audio/gsm-efr": { + source: "iana" + }, + "audio/gsm-hr-08": { + source: "iana" + }, + "audio/ilbc": { + source: "iana" + }, + "audio/ip-mr_v2.5": { + source: "iana" + }, + "audio/isac": { + source: "apache" + }, + "audio/l16": { + source: "iana" + }, + "audio/l20": { + source: "iana" + }, + "audio/l24": { + source: "iana", + compressible: false + }, + "audio/l8": { + source: "iana" + }, + "audio/lpc": { + source: "iana" + }, + "audio/matroska": { + source: "iana" + }, + "audio/melp": { + source: "iana" + }, + "audio/melp1200": { + source: "iana" + }, + "audio/melp2400": { + source: "iana" + }, + "audio/melp600": { + source: "iana" + }, + "audio/mhas": { + source: "iana" + }, + "audio/midi": { + source: "apache", + extensions: ["mid", "midi", "kar", "rmi"] + }, + "audio/midi-clip": { + source: "iana" + }, + "audio/mobile-xmf": { + source: "iana", + extensions: ["mxmf"] + }, + "audio/mp3": { + compressible: false, + extensions: ["mp3"] + }, + "audio/mp4": { + source: "iana", + compressible: false, + extensions: ["m4a", "mp4a", "m4b"] + }, + "audio/mp4a-latm": { + source: "iana" + }, + "audio/mpa": { + source: "iana" + }, + "audio/mpa-robust": { + source: "iana" + }, + "audio/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] + }, + "audio/mpeg4-generic": { + source: "iana" + }, + "audio/musepack": { + source: "apache" + }, + "audio/ogg": { + source: "iana", + compressible: false, + extensions: ["oga", "ogg", "spx", "opus"] + }, + "audio/opus": { + source: "iana" + }, + "audio/parityfec": { + source: "iana" + }, + "audio/pcma": { + source: "iana" + }, + "audio/pcma-wb": { + source: "iana" + }, + "audio/pcmu": { + source: "iana" + }, + "audio/pcmu-wb": { + source: "iana" + }, + "audio/prs.sid": { + source: "iana" + }, + "audio/qcelp": { + source: "iana" + }, + "audio/raptorfec": { + source: "iana" + }, + "audio/red": { + source: "iana" + }, + "audio/rtp-enc-aescm128": { + source: "iana" + }, + "audio/rtp-midi": { + source: "iana" + }, + "audio/rtploopback": { + source: "iana" + }, + "audio/rtx": { + source: "iana" + }, + "audio/s3m": { + source: "apache", + extensions: ["s3m"] + }, + "audio/scip": { + source: "iana" + }, + "audio/silk": { + source: "apache", + extensions: ["sil"] + }, + "audio/smv": { + source: "iana" + }, + "audio/smv-qcp": { + source: "iana" + }, + "audio/smv0": { + source: "iana" + }, + "audio/sofa": { + source: "iana" + }, + "audio/sp-midi": { + source: "iana" + }, + "audio/speex": { + source: "iana" + }, + "audio/t140c": { + source: "iana" + }, + "audio/t38": { + source: "iana" + }, + "audio/telephone-event": { + source: "iana" + }, + "audio/tetra_acelp": { + source: "iana" + }, + "audio/tetra_acelp_bb": { + source: "iana" + }, + "audio/tone": { + source: "iana" + }, + "audio/tsvcis": { + source: "iana" + }, + "audio/uemclip": { + source: "iana" + }, + "audio/ulpfec": { + source: "iana" + }, + "audio/usac": { + source: "iana" + }, + "audio/vdvi": { + source: "iana" + }, + "audio/vmr-wb": { + source: "iana" + }, + "audio/vnd.3gpp.iufp": { + source: "iana" + }, + "audio/vnd.4sb": { + source: "iana" + }, + "audio/vnd.audiokoz": { + source: "iana" + }, + "audio/vnd.celp": { + source: "iana" + }, + "audio/vnd.cisco.nse": { + source: "iana" + }, + "audio/vnd.cmles.radio-events": { + source: "iana" + }, + "audio/vnd.cns.anp1": { + source: "iana" + }, + "audio/vnd.cns.inf1": { + source: "iana" + }, + "audio/vnd.dece.audio": { + source: "iana", + extensions: ["uva", "uvva"] + }, + "audio/vnd.digital-winds": { + source: "iana", + extensions: ["eol"] + }, + "audio/vnd.dlna.adts": { + source: "iana" + }, + "audio/vnd.dolby.heaac.1": { + source: "iana" + }, + "audio/vnd.dolby.heaac.2": { + source: "iana" + }, + "audio/vnd.dolby.mlp": { + source: "iana" + }, + "audio/vnd.dolby.mps": { + source: "iana" + }, + "audio/vnd.dolby.pl2": { + source: "iana" + }, + "audio/vnd.dolby.pl2x": { + source: "iana" + }, + "audio/vnd.dolby.pl2z": { + source: "iana" + }, + "audio/vnd.dolby.pulse.1": { + source: "iana" + }, + "audio/vnd.dra": { + source: "iana", + extensions: ["dra"] + }, + "audio/vnd.dts": { + source: "iana", + extensions: ["dts"] + }, + "audio/vnd.dts.hd": { + source: "iana", + extensions: ["dtshd"] + }, + "audio/vnd.dts.uhd": { + source: "iana" + }, + "audio/vnd.dvb.file": { + source: "iana" + }, + "audio/vnd.everad.plj": { + source: "iana" + }, + "audio/vnd.hns.audio": { + source: "iana" + }, + "audio/vnd.lucent.voice": { + source: "iana", + extensions: ["lvp"] + }, + "audio/vnd.ms-playready.media.pya": { + source: "iana", + extensions: ["pya"] + }, + "audio/vnd.nokia.mobile-xmf": { + source: "iana" + }, + "audio/vnd.nortel.vbk": { + source: "iana" + }, + "audio/vnd.nuera.ecelp4800": { + source: "iana", + extensions: ["ecelp4800"] + }, + "audio/vnd.nuera.ecelp7470": { + source: "iana", + extensions: ["ecelp7470"] + }, + "audio/vnd.nuera.ecelp9600": { + source: "iana", + extensions: ["ecelp9600"] + }, + "audio/vnd.octel.sbc": { + source: "iana" + }, + "audio/vnd.presonus.multitrack": { + source: "iana" + }, + "audio/vnd.qcelp": { + source: "apache" + }, + "audio/vnd.rhetorex.32kadpcm": { + source: "iana" + }, + "audio/vnd.rip": { + source: "iana", + extensions: ["rip"] + }, + "audio/vnd.rn-realaudio": { + compressible: false + }, + "audio/vnd.sealedmedia.softseal.mpeg": { + source: "iana" + }, + "audio/vnd.vmx.cvsd": { + source: "iana" + }, + "audio/vnd.wave": { + compressible: false + }, + "audio/vorbis": { + source: "iana", + compressible: false + }, + "audio/vorbis-config": { + source: "iana" + }, + "audio/wav": { + compressible: false, + extensions: ["wav"] + }, + "audio/wave": { + compressible: false, + extensions: ["wav"] + }, + "audio/webm": { + source: "apache", + compressible: false, + extensions: ["weba"] + }, + "audio/x-aac": { + source: "apache", + compressible: false, + extensions: ["aac"] + }, + "audio/x-aiff": { + source: "apache", + extensions: ["aif", "aiff", "aifc"] + }, + "audio/x-caf": { + source: "apache", + compressible: false, + extensions: ["caf"] + }, + "audio/x-flac": { + source: "apache", + extensions: ["flac"] + }, + "audio/x-m4a": { + source: "nginx", + extensions: ["m4a"] + }, + "audio/x-matroska": { + source: "apache", + extensions: ["mka"] + }, + "audio/x-mpegurl": { + source: "apache", + extensions: ["m3u"] + }, + "audio/x-ms-wax": { + source: "apache", + extensions: ["wax"] + }, + "audio/x-ms-wma": { + source: "apache", + extensions: ["wma"] + }, + "audio/x-pn-realaudio": { + source: "apache", + extensions: ["ram", "ra"] + }, + "audio/x-pn-realaudio-plugin": { + source: "apache", + extensions: ["rmp"] + }, + "audio/x-realaudio": { + source: "nginx", + extensions: ["ra"] + }, + "audio/x-tta": { + source: "apache" + }, + "audio/x-wav": { + source: "apache", + extensions: ["wav"] + }, + "audio/xm": { + source: "apache", + extensions: ["xm"] + }, + "chemical/x-cdx": { + source: "apache", + extensions: ["cdx"] + }, + "chemical/x-cif": { + source: "apache", + extensions: ["cif"] + }, + "chemical/x-cmdf": { + source: "apache", + extensions: ["cmdf"] + }, + "chemical/x-cml": { + source: "apache", + extensions: ["cml"] + }, + "chemical/x-csml": { + source: "apache", + extensions: ["csml"] + }, + "chemical/x-pdb": { + source: "apache" + }, + "chemical/x-xyz": { + source: "apache", + extensions: ["xyz"] + }, + "font/collection": { + source: "iana", + extensions: ["ttc"] + }, + "font/otf": { + source: "iana", + compressible: true, + extensions: ["otf"] + }, + "font/sfnt": { + source: "iana" + }, + "font/ttf": { + source: "iana", + compressible: true, + extensions: ["ttf"] + }, + "font/woff": { + source: "iana", + extensions: ["woff"] + }, + "font/woff2": { + source: "iana", + extensions: ["woff2"] + }, + "image/aces": { + source: "iana", + extensions: ["exr"] + }, + "image/apng": { + source: "iana", + compressible: false, + extensions: ["apng"] + }, + "image/avci": { + source: "iana", + extensions: ["avci"] + }, + "image/avcs": { + source: "iana", + extensions: ["avcs"] + }, + "image/avif": { + source: "iana", + compressible: false, + extensions: ["avif"] + }, + "image/bmp": { + source: "iana", + compressible: true, + extensions: ["bmp", "dib"] + }, + "image/cgm": { + source: "iana", + extensions: ["cgm"] + }, + "image/dicom-rle": { + source: "iana", + extensions: ["drle"] + }, + "image/dpx": { + source: "iana", + extensions: ["dpx"] + }, + "image/emf": { + source: "iana", + extensions: ["emf"] + }, + "image/fits": { + source: "iana", + extensions: ["fits"] + }, + "image/g3fax": { + source: "iana", + extensions: ["g3"] + }, + "image/gif": { + source: "iana", + compressible: false, + extensions: ["gif"] + }, + "image/heic": { + source: "iana", + extensions: ["heic"] + }, + "image/heic-sequence": { + source: "iana", + extensions: ["heics"] + }, + "image/heif": { + source: "iana", + extensions: ["heif"] + }, + "image/heif-sequence": { + source: "iana", + extensions: ["heifs"] + }, + "image/hej2k": { + source: "iana", + extensions: ["hej2"] + }, + "image/ief": { + source: "iana", + extensions: ["ief"] + }, + "image/j2c": { + source: "iana" + }, + "image/jaii": { + source: "iana", + extensions: ["jaii"] + }, + "image/jais": { + source: "iana", + extensions: ["jais"] + }, + "image/jls": { + source: "iana", + extensions: ["jls"] + }, + "image/jp2": { + source: "iana", + compressible: false, + extensions: ["jp2", "jpg2"] + }, + "image/jpeg": { + source: "iana", + compressible: false, + extensions: ["jpg", "jpeg", "jpe"] + }, + "image/jph": { + source: "iana", + extensions: ["jph"] + }, + "image/jphc": { + source: "iana", + extensions: ["jhc"] + }, + "image/jpm": { + source: "iana", + compressible: false, + extensions: ["jpm", "jpgm"] + }, + "image/jpx": { + source: "iana", + compressible: false, + extensions: ["jpx", "jpf"] + }, + "image/jxl": { + source: "iana", + extensions: ["jxl"] + }, + "image/jxr": { + source: "iana", + extensions: ["jxr"] + }, + "image/jxra": { + source: "iana", + extensions: ["jxra"] + }, + "image/jxrs": { + source: "iana", + extensions: ["jxrs"] + }, + "image/jxs": { + source: "iana", + extensions: ["jxs"] + }, + "image/jxsc": { + source: "iana", + extensions: ["jxsc"] + }, + "image/jxsi": { + source: "iana", + extensions: ["jxsi"] + }, + "image/jxss": { + source: "iana", + extensions: ["jxss"] + }, + "image/ktx": { + source: "iana", + extensions: ["ktx"] + }, + "image/ktx2": { + source: "iana", + extensions: ["ktx2"] + }, + "image/naplps": { + source: "iana" + }, + "image/pjpeg": { + compressible: false, + extensions: ["jfif"] + }, + "image/png": { + source: "iana", + compressible: false, + extensions: ["png"] + }, + "image/prs.btif": { + source: "iana", + extensions: ["btif", "btf"] + }, + "image/prs.pti": { + source: "iana", + extensions: ["pti"] + }, + "image/pwg-raster": { + source: "iana" + }, + "image/sgi": { + source: "apache", + extensions: ["sgi"] + }, + "image/svg+xml": { + source: "iana", + compressible: true, + extensions: ["svg", "svgz"] + }, + "image/t38": { + source: "iana", + extensions: ["t38"] + }, + "image/tiff": { + source: "iana", + compressible: false, + extensions: ["tif", "tiff"] + }, + "image/tiff-fx": { + source: "iana", + extensions: ["tfx"] + }, + "image/vnd.adobe.photoshop": { + source: "iana", + compressible: true, + extensions: ["psd"] + }, + "image/vnd.airzip.accelerator.azv": { + source: "iana", + extensions: ["azv"] + }, + "image/vnd.clip": { + source: "iana" + }, + "image/vnd.cns.inf2": { + source: "iana" + }, + "image/vnd.dece.graphic": { + source: "iana", + extensions: ["uvi", "uvvi", "uvg", "uvvg"] + }, + "image/vnd.djvu": { + source: "iana", + extensions: ["djvu", "djv"] + }, + "image/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "image/vnd.dwg": { + source: "iana", + extensions: ["dwg"] + }, + "image/vnd.dxf": { + source: "iana", + extensions: ["dxf"] + }, + "image/vnd.fastbidsheet": { + source: "iana", + extensions: ["fbs"] + }, + "image/vnd.fpx": { + source: "iana", + extensions: ["fpx"] + }, + "image/vnd.fst": { + source: "iana", + extensions: ["fst"] + }, + "image/vnd.fujixerox.edmics-mmr": { + source: "iana", + extensions: ["mmr"] + }, + "image/vnd.fujixerox.edmics-rlc": { + source: "iana", + extensions: ["rlc"] + }, + "image/vnd.globalgraphics.pgb": { + source: "iana" + }, + "image/vnd.microsoft.icon": { + source: "iana", + compressible: true, + extensions: ["ico"] + }, + "image/vnd.mix": { + source: "iana" + }, + "image/vnd.mozilla.apng": { + source: "iana" + }, + "image/vnd.ms-dds": { + compressible: true, + extensions: ["dds"] + }, + "image/vnd.ms-modi": { + source: "iana", + extensions: ["mdi"] + }, + "image/vnd.ms-photo": { + source: "apache", + extensions: ["wdp"] + }, + "image/vnd.net-fpx": { + source: "iana", + extensions: ["npx"] + }, + "image/vnd.pco.b16": { + source: "iana", + extensions: ["b16"] + }, + "image/vnd.radiance": { + source: "iana" + }, + "image/vnd.sealed.png": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.gif": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.jpg": { + source: "iana" + }, + "image/vnd.svf": { + source: "iana" + }, + "image/vnd.tencent.tap": { + source: "iana", + extensions: ["tap"] + }, + "image/vnd.valve.source.texture": { + source: "iana", + extensions: ["vtf"] + }, + "image/vnd.wap.wbmp": { + source: "iana", + extensions: ["wbmp"] + }, + "image/vnd.xiff": { + source: "iana", + extensions: ["xif"] + }, + "image/vnd.zbrush.pcx": { + source: "iana", + extensions: ["pcx"] + }, + "image/webp": { + source: "iana", + extensions: ["webp"] + }, + "image/wmf": { + source: "iana", + extensions: ["wmf"] + }, + "image/x-3ds": { + source: "apache", + extensions: ["3ds"] + }, + "image/x-adobe-dng": { + extensions: ["dng"] + }, + "image/x-cmu-raster": { + source: "apache", + extensions: ["ras"] + }, + "image/x-cmx": { + source: "apache", + extensions: ["cmx"] + }, + "image/x-emf": { + source: "iana" + }, + "image/x-freehand": { + source: "apache", + extensions: ["fh", "fhc", "fh4", "fh5", "fh7"] + }, + "image/x-icon": { + source: "apache", + compressible: true, + extensions: ["ico"] + }, + "image/x-jng": { + source: "nginx", + extensions: ["jng"] + }, + "image/x-mrsid-image": { + source: "apache", + extensions: ["sid"] + }, + "image/x-ms-bmp": { + source: "nginx", + compressible: true, + extensions: ["bmp"] + }, + "image/x-pcx": { + source: "apache", + extensions: ["pcx"] + }, + "image/x-pict": { + source: "apache", + extensions: ["pic", "pct"] + }, + "image/x-portable-anymap": { + source: "apache", + extensions: ["pnm"] + }, + "image/x-portable-bitmap": { + source: "apache", + extensions: ["pbm"] + }, + "image/x-portable-graymap": { + source: "apache", + extensions: ["pgm"] + }, + "image/x-portable-pixmap": { + source: "apache", + extensions: ["ppm"] + }, + "image/x-rgb": { + source: "apache", + extensions: ["rgb"] + }, + "image/x-tga": { + source: "apache", + extensions: ["tga"] + }, + "image/x-wmf": { + source: "iana" + }, + "image/x-xbitmap": { + source: "apache", + extensions: ["xbm"] + }, + "image/x-xcf": { + compressible: false + }, + "image/x-xpixmap": { + source: "apache", + extensions: ["xpm"] + }, + "image/x-xwindowdump": { + source: "apache", + extensions: ["xwd"] + }, + "message/bhttp": { + source: "iana" + }, + "message/cpim": { + source: "iana" + }, + "message/delivery-status": { + source: "iana" + }, + "message/disposition-notification": { + source: "iana", + extensions: [ + "disposition-notification" + ] + }, + "message/external-body": { + source: "iana" + }, + "message/feedback-report": { + source: "iana" + }, + "message/global": { + source: "iana", + extensions: ["u8msg"] + }, + "message/global-delivery-status": { + source: "iana", + extensions: ["u8dsn"] + }, + "message/global-disposition-notification": { + source: "iana", + extensions: ["u8mdn"] + }, + "message/global-headers": { + source: "iana", + extensions: ["u8hdr"] + }, + "message/http": { + source: "iana", + compressible: false + }, + "message/imdn+xml": { + source: "iana", + compressible: true + }, + "message/mls": { + source: "iana" + }, + "message/news": { + source: "apache" + }, + "message/ohttp-req": { + source: "iana" + }, + "message/ohttp-res": { + source: "iana" + }, + "message/partial": { + source: "iana", + compressible: false + }, + "message/rfc822": { + source: "iana", + compressible: true, + extensions: ["eml", "mime", "mht", "mhtml"] + }, + "message/s-http": { + source: "apache" + }, + "message/sip": { + source: "iana" + }, + "message/sipfrag": { + source: "iana" + }, + "message/tracking-status": { + source: "iana" + }, + "message/vnd.si.simp": { + source: "apache" + }, + "message/vnd.wfa.wsc": { + source: "iana", + extensions: ["wsc"] + }, + "model/3mf": { + source: "iana", + extensions: ["3mf"] + }, + "model/e57": { + source: "iana" + }, + "model/gltf+json": { + source: "iana", + compressible: true, + extensions: ["gltf"] + }, + "model/gltf-binary": { + source: "iana", + compressible: true, + extensions: ["glb"] + }, + "model/iges": { + source: "iana", + compressible: false, + extensions: ["igs", "iges"] + }, + "model/jt": { + source: "iana", + extensions: ["jt"] + }, + "model/mesh": { + source: "iana", + compressible: false, + extensions: ["msh", "mesh", "silo"] + }, + "model/mtl": { + source: "iana", + extensions: ["mtl"] + }, + "model/obj": { + source: "iana", + extensions: ["obj"] + }, + "model/prc": { + source: "iana", + extensions: ["prc"] + }, + "model/step": { + source: "iana", + extensions: ["step", "stp", "stpnc", "p21", "210"] + }, + "model/step+xml": { + source: "iana", + compressible: true, + extensions: ["stpx"] + }, + "model/step+zip": { + source: "iana", + compressible: false, + extensions: ["stpz"] + }, + "model/step-xml+zip": { + source: "iana", + compressible: false, + extensions: ["stpxz"] + }, + "model/stl": { + source: "iana", + extensions: ["stl"] + }, + "model/u3d": { + source: "iana", + extensions: ["u3d"] + }, + "model/vnd.bary": { + source: "iana", + extensions: ["bary"] + }, + "model/vnd.cld": { + source: "iana", + extensions: ["cld"] + }, + "model/vnd.collada+xml": { + source: "iana", + compressible: true, + extensions: ["dae"] + }, + "model/vnd.dwf": { + source: "iana", + extensions: ["dwf"] + }, + "model/vnd.flatland.3dml": { + source: "iana" + }, + "model/vnd.gdl": { + source: "iana", + extensions: ["gdl"] + }, + "model/vnd.gs-gdl": { + source: "apache" + }, + "model/vnd.gs.gdl": { + source: "iana" + }, + "model/vnd.gtw": { + source: "iana", + extensions: ["gtw"] + }, + "model/vnd.moml+xml": { + source: "iana", + compressible: true + }, + "model/vnd.mts": { + source: "iana", + extensions: ["mts"] + }, + "model/vnd.opengex": { + source: "iana", + extensions: ["ogex"] + }, + "model/vnd.parasolid.transmit.binary": { + source: "iana", + extensions: ["x_b"] + }, + "model/vnd.parasolid.transmit.text": { + source: "iana", + extensions: ["x_t"] + }, + "model/vnd.pytha.pyox": { + source: "iana", + extensions: ["pyo", "pyox"] + }, + "model/vnd.rosette.annotated-data-model": { + source: "iana" + }, + "model/vnd.sap.vds": { + source: "iana", + extensions: ["vds"] + }, + "model/vnd.usda": { + source: "iana", + extensions: ["usda"] + }, + "model/vnd.usdz+zip": { + source: "iana", + compressible: false, + extensions: ["usdz"] + }, + "model/vnd.valve.source.compiled-map": { + source: "iana", + extensions: ["bsp"] + }, + "model/vnd.vtu": { + source: "iana", + extensions: ["vtu"] + }, + "model/vrml": { + source: "iana", + compressible: false, + extensions: ["wrl", "vrml"] + }, + "model/x3d+binary": { + source: "apache", + compressible: false, + extensions: ["x3db", "x3dbz"] + }, + "model/x3d+fastinfoset": { + source: "iana", + extensions: ["x3db"] + }, + "model/x3d+vrml": { + source: "apache", + compressible: false, + extensions: ["x3dv", "x3dvz"] + }, + "model/x3d+xml": { + source: "iana", + compressible: true, + extensions: ["x3d", "x3dz"] + }, + "model/x3d-vrml": { + source: "iana", + extensions: ["x3dv"] + }, + "multipart/alternative": { + source: "iana", + compressible: false + }, + "multipart/appledouble": { + source: "iana" + }, + "multipart/byteranges": { + source: "iana" + }, + "multipart/digest": { + source: "iana" + }, + "multipart/encrypted": { + source: "iana", + compressible: false + }, + "multipart/form-data": { + source: "iana", + compressible: false + }, + "multipart/header-set": { + source: "iana" + }, + "multipart/mixed": { + source: "iana" + }, + "multipart/multilingual": { + source: "iana" + }, + "multipart/parallel": { + source: "iana" + }, + "multipart/related": { + source: "iana", + compressible: false + }, + "multipart/report": { + source: "iana" + }, + "multipart/signed": { + source: "iana", + compressible: false + }, + "multipart/vnd.bint.med-plus": { + source: "iana" + }, + "multipart/voice-message": { + source: "iana" + }, + "multipart/x-mixed-replace": { + source: "iana" + }, + "text/1d-interleaved-parityfec": { + source: "iana" + }, + "text/cache-manifest": { + source: "iana", + compressible: true, + extensions: ["appcache", "manifest"] + }, + "text/calendar": { + source: "iana", + extensions: ["ics", "ifb"] + }, + "text/calender": { + compressible: true + }, + "text/cmd": { + compressible: true + }, + "text/coffeescript": { + extensions: ["coffee", "litcoffee"] + }, + "text/cql": { + source: "iana" + }, + "text/cql-expression": { + source: "iana" + }, + "text/cql-identifier": { + source: "iana" + }, + "text/css": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["css"] + }, + "text/csv": { + source: "iana", + compressible: true, + extensions: ["csv"] + }, + "text/csv-schema": { + source: "iana" + }, + "text/directory": { + source: "iana" + }, + "text/dns": { + source: "iana" + }, + "text/ecmascript": { + source: "apache" + }, + "text/encaprtp": { + source: "iana" + }, + "text/enriched": { + source: "iana" + }, + "text/fhirpath": { + source: "iana" + }, + "text/flexfec": { + source: "iana" + }, + "text/fwdred": { + source: "iana" + }, + "text/gff3": { + source: "iana" + }, + "text/grammar-ref-list": { + source: "iana" + }, + "text/hl7v2": { + source: "iana" + }, + "text/html": { + source: "iana", + compressible: true, + extensions: ["html", "htm", "shtml"] + }, + "text/jade": { + extensions: ["jade"] + }, + "text/javascript": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["js", "mjs"] + }, + "text/jcr-cnd": { + source: "iana" + }, + "text/jsx": { + compressible: true, + extensions: ["jsx"] + }, + "text/less": { + compressible: true, + extensions: ["less"] + }, + "text/markdown": { + source: "iana", + compressible: true, + extensions: ["md", "markdown"] + }, + "text/mathml": { + source: "nginx", + extensions: ["mml"] + }, + "text/mdx": { + compressible: true, + extensions: ["mdx"] + }, + "text/mizar": { + source: "iana" + }, + "text/n3": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["n3"] + }, + "text/parameters": { + source: "iana", + charset: "UTF-8" + }, + "text/parityfec": { + source: "iana" + }, + "text/plain": { + source: "iana", + compressible: true, + extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"] + }, + "text/provenance-notation": { + source: "iana", + charset: "UTF-8" + }, + "text/prs.fallenstein.rst": { + source: "iana" + }, + "text/prs.lines.tag": { + source: "iana", + extensions: ["dsc"] + }, + "text/prs.prop.logic": { + source: "iana" + }, + "text/prs.texi": { + source: "iana" + }, + "text/raptorfec": { + source: "iana" + }, + "text/red": { + source: "iana" + }, + "text/rfc822-headers": { + source: "iana" + }, + "text/richtext": { + source: "iana", + compressible: true, + extensions: ["rtx"] + }, + "text/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "text/rtp-enc-aescm128": { + source: "iana" + }, + "text/rtploopback": { + source: "iana" + }, + "text/rtx": { + source: "iana" + }, + "text/sgml": { + source: "iana", + extensions: ["sgml", "sgm"] + }, + "text/shaclc": { + source: "iana" + }, + "text/shex": { + source: "iana", + extensions: ["shex"] + }, + "text/slim": { + extensions: ["slim", "slm"] + }, + "text/spdx": { + source: "iana", + extensions: ["spdx"] + }, + "text/strings": { + source: "iana" + }, + "text/stylus": { + extensions: ["stylus", "styl"] + }, + "text/t140": { + source: "iana" + }, + "text/tab-separated-values": { + source: "iana", + compressible: true, + extensions: ["tsv"] + }, + "text/troff": { + source: "iana", + extensions: ["t", "tr", "roff", "man", "me", "ms"] + }, + "text/turtle": { + source: "iana", + charset: "UTF-8", + extensions: ["ttl"] + }, + "text/ulpfec": { + source: "iana" + }, + "text/uri-list": { + source: "iana", + compressible: true, + extensions: ["uri", "uris", "urls"] + }, + "text/vcard": { + source: "iana", + compressible: true, + extensions: ["vcard"] + }, + "text/vnd.a": { + source: "iana" + }, + "text/vnd.abc": { + source: "iana" + }, + "text/vnd.ascii-art": { + source: "iana" + }, + "text/vnd.curl": { + source: "iana", + extensions: ["curl"] + }, + "text/vnd.curl.dcurl": { + source: "apache", + extensions: ["dcurl"] + }, + "text/vnd.curl.mcurl": { + source: "apache", + extensions: ["mcurl"] + }, + "text/vnd.curl.scurl": { + source: "apache", + extensions: ["scurl"] + }, + "text/vnd.debian.copyright": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.dmclientscript": { + source: "iana" + }, + "text/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "text/vnd.esmertec.theme-descriptor": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.exchangeable": { + source: "iana" + }, + "text/vnd.familysearch.gedcom": { + source: "iana", + extensions: ["ged"] + }, + "text/vnd.ficlab.flt": { + source: "iana" + }, + "text/vnd.fly": { + source: "iana", + extensions: ["fly"] + }, + "text/vnd.fmi.flexstor": { + source: "iana", + extensions: ["flx"] + }, + "text/vnd.gml": { + source: "iana" + }, + "text/vnd.graphviz": { + source: "iana", + extensions: ["gv"] + }, + "text/vnd.hans": { + source: "iana" + }, + "text/vnd.hgl": { + source: "iana" + }, + "text/vnd.in3d.3dml": { + source: "iana", + extensions: ["3dml"] + }, + "text/vnd.in3d.spot": { + source: "iana", + extensions: ["spot"] + }, + "text/vnd.iptc.newsml": { + source: "iana" + }, + "text/vnd.iptc.nitf": { + source: "iana" + }, + "text/vnd.latex-z": { + source: "iana" + }, + "text/vnd.motorola.reflex": { + source: "iana" + }, + "text/vnd.ms-mediapackage": { + source: "iana" + }, + "text/vnd.net2phone.commcenter.command": { + source: "iana" + }, + "text/vnd.radisys.msml-basic-layout": { + source: "iana" + }, + "text/vnd.senx.warpscript": { + source: "iana" + }, + "text/vnd.si.uricatalogue": { + source: "apache" + }, + "text/vnd.sosi": { + source: "iana" + }, + "text/vnd.sun.j2me.app-descriptor": { + source: "iana", + charset: "UTF-8", + extensions: ["jad"] + }, + "text/vnd.trolltech.linguist": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.vcf": { + source: "iana" + }, + "text/vnd.wap.si": { + source: "iana" + }, + "text/vnd.wap.sl": { + source: "iana" + }, + "text/vnd.wap.wml": { + source: "iana", + extensions: ["wml"] + }, + "text/vnd.wap.wmlscript": { + source: "iana", + extensions: ["wmls"] + }, + "text/vnd.zoo.kcl": { + source: "iana" + }, + "text/vtt": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["vtt"] + }, + "text/wgsl": { + source: "iana", + extensions: ["wgsl"] + }, + "text/x-asm": { + source: "apache", + extensions: ["s", "asm"] + }, + "text/x-c": { + source: "apache", + extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] + }, + "text/x-component": { + source: "nginx", + extensions: ["htc"] + }, + "text/x-fortran": { + source: "apache", + extensions: ["f", "for", "f77", "f90"] + }, + "text/x-gwt-rpc": { + compressible: true + }, + "text/x-handlebars-template": { + extensions: ["hbs"] + }, + "text/x-java-source": { + source: "apache", + extensions: ["java"] + }, + "text/x-jquery-tmpl": { + compressible: true + }, + "text/x-lua": { + extensions: ["lua"] + }, + "text/x-markdown": { + compressible: true, + extensions: ["mkd"] + }, + "text/x-nfo": { + source: "apache", + extensions: ["nfo"] + }, + "text/x-opml": { + source: "apache", + extensions: ["opml"] + }, + "text/x-org": { + compressible: true, + extensions: ["org"] + }, + "text/x-pascal": { + source: "apache", + extensions: ["p", "pas"] + }, + "text/x-processing": { + compressible: true, + extensions: ["pde"] + }, + "text/x-sass": { + extensions: ["sass"] + }, + "text/x-scss": { + extensions: ["scss"] + }, + "text/x-setext": { + source: "apache", + extensions: ["etx"] + }, + "text/x-sfv": { + source: "apache", + extensions: ["sfv"] + }, + "text/x-suse-ymp": { + compressible: true, + extensions: ["ymp"] + }, + "text/x-uuencode": { + source: "apache", + extensions: ["uu"] + }, + "text/x-vcalendar": { + source: "apache", + extensions: ["vcs"] + }, + "text/x-vcard": { + source: "apache", + extensions: ["vcf"] + }, + "text/xml": { + source: "iana", + compressible: true, + extensions: ["xml"] + }, + "text/xml-external-parsed-entity": { + source: "iana" + }, + "text/yaml": { + compressible: true, + extensions: ["yaml", "yml"] + }, + "video/1d-interleaved-parityfec": { + source: "iana" + }, + "video/3gpp": { + source: "iana", + extensions: ["3gp", "3gpp"] + }, + "video/3gpp-tt": { + source: "iana" + }, + "video/3gpp2": { + source: "iana", + extensions: ["3g2"] + }, + "video/av1": { + source: "iana" + }, + "video/bmpeg": { + source: "iana" + }, + "video/bt656": { + source: "iana" + }, + "video/celb": { + source: "iana" + }, + "video/dv": { + source: "iana" + }, + "video/encaprtp": { + source: "iana" + }, + "video/evc": { + source: "iana" + }, + "video/ffv1": { + source: "iana" + }, + "video/flexfec": { + source: "iana" + }, + "video/h261": { + source: "iana", + extensions: ["h261"] + }, + "video/h263": { + source: "iana", + extensions: ["h263"] + }, + "video/h263-1998": { + source: "iana" + }, + "video/h263-2000": { + source: "iana" + }, + "video/h264": { + source: "iana", + extensions: ["h264"] + }, + "video/h264-rcdo": { + source: "iana" + }, + "video/h264-svc": { + source: "iana" + }, + "video/h265": { + source: "iana" + }, + "video/h266": { + source: "iana" + }, + "video/iso.segment": { + source: "iana", + extensions: ["m4s"] + }, + "video/jpeg": { + source: "iana", + extensions: ["jpgv"] + }, + "video/jpeg2000": { + source: "iana" + }, + "video/jpm": { + source: "apache", + extensions: ["jpm", "jpgm"] + }, + "video/jxsv": { + source: "iana" + }, + "video/lottie+json": { + source: "iana", + compressible: true + }, + "video/matroska": { + source: "iana" + }, + "video/matroska-3d": { + source: "iana" + }, + "video/mj2": { + source: "iana", + extensions: ["mj2", "mjp2"] + }, + "video/mp1s": { + source: "iana" + }, + "video/mp2p": { + source: "iana" + }, + "video/mp2t": { + source: "iana", + extensions: ["ts", "m2t", "m2ts", "mts"] + }, + "video/mp4": { + source: "iana", + compressible: false, + extensions: ["mp4", "mp4v", "mpg4"] + }, + "video/mp4v-es": { + source: "iana" + }, + "video/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"] + }, + "video/mpeg4-generic": { + source: "iana" + }, + "video/mpv": { + source: "iana" + }, + "video/nv": { + source: "iana" + }, + "video/ogg": { + source: "iana", + compressible: false, + extensions: ["ogv"] + }, + "video/parityfec": { + source: "iana" + }, + "video/pointer": { + source: "iana" + }, + "video/quicktime": { + source: "iana", + compressible: false, + extensions: ["qt", "mov"] + }, + "video/raptorfec": { + source: "iana" + }, + "video/raw": { + source: "iana" + }, + "video/rtp-enc-aescm128": { + source: "iana" + }, + "video/rtploopback": { + source: "iana" + }, + "video/rtx": { + source: "iana" + }, + "video/scip": { + source: "iana" + }, + "video/smpte291": { + source: "iana" + }, + "video/smpte292m": { + source: "iana" + }, + "video/ulpfec": { + source: "iana" + }, + "video/vc1": { + source: "iana" + }, + "video/vc2": { + source: "iana" + }, + "video/vnd.cctv": { + source: "iana" + }, + "video/vnd.dece.hd": { + source: "iana", + extensions: ["uvh", "uvvh"] + }, + "video/vnd.dece.mobile": { + source: "iana", + extensions: ["uvm", "uvvm"] + }, + "video/vnd.dece.mp4": { + source: "iana" + }, + "video/vnd.dece.pd": { + source: "iana", + extensions: ["uvp", "uvvp"] + }, + "video/vnd.dece.sd": { + source: "iana", + extensions: ["uvs", "uvvs"] + }, + "video/vnd.dece.video": { + source: "iana", + extensions: ["uvv", "uvvv"] + }, + "video/vnd.directv.mpeg": { + source: "iana" + }, + "video/vnd.directv.mpeg-tts": { + source: "iana" + }, + "video/vnd.dlna.mpeg-tts": { + source: "iana" + }, + "video/vnd.dvb.file": { + source: "iana", + extensions: ["dvb"] + }, + "video/vnd.fvt": { + source: "iana", + extensions: ["fvt"] + }, + "video/vnd.hns.video": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.ttsavc": { + source: "iana" + }, + "video/vnd.iptvforum.ttsmpeg2": { + source: "iana" + }, + "video/vnd.motorola.video": { + source: "iana" + }, + "video/vnd.motorola.videop": { + source: "iana" + }, + "video/vnd.mpegurl": { + source: "iana", + extensions: ["mxu", "m4u"] + }, + "video/vnd.ms-playready.media.pyv": { + source: "iana", + extensions: ["pyv"] + }, + "video/vnd.nokia.interleaved-multimedia": { + source: "iana" + }, + "video/vnd.nokia.mp4vr": { + source: "iana" + }, + "video/vnd.nokia.videovoip": { + source: "iana" + }, + "video/vnd.objectvideo": { + source: "iana" + }, + "video/vnd.planar": { + source: "iana" + }, + "video/vnd.radgamettools.bink": { + source: "iana" + }, + "video/vnd.radgamettools.smacker": { + source: "apache" + }, + "video/vnd.sealed.mpeg1": { + source: "iana" + }, + "video/vnd.sealed.mpeg4": { + source: "iana" + }, + "video/vnd.sealed.swf": { + source: "iana" + }, + "video/vnd.sealedmedia.softseal.mov": { + source: "iana" + }, + "video/vnd.uvvu.mp4": { + source: "iana", + extensions: ["uvu", "uvvu"] + }, + "video/vnd.vivo": { + source: "iana", + extensions: ["viv"] + }, + "video/vnd.youtube.yt": { + source: "iana" + }, + "video/vp8": { + source: "iana" + }, + "video/vp9": { + source: "iana" + }, + "video/webm": { + source: "apache", + compressible: false, + extensions: ["webm"] + }, + "video/x-f4v": { + source: "apache", + extensions: ["f4v"] + }, + "video/x-fli": { + source: "apache", + extensions: ["fli"] + }, + "video/x-flv": { + source: "apache", + compressible: false, + extensions: ["flv"] + }, + "video/x-m4v": { + source: "apache", + extensions: ["m4v"] + }, + "video/x-matroska": { + source: "apache", + compressible: false, + extensions: ["mkv", "mk3d", "mks"] + }, + "video/x-mng": { + source: "apache", + extensions: ["mng"] + }, + "video/x-ms-asf": { + source: "apache", + extensions: ["asf", "asx"] + }, + "video/x-ms-vob": { + source: "apache", + extensions: ["vob"] + }, + "video/x-ms-wm": { + source: "apache", + extensions: ["wm"] + }, + "video/x-ms-wmv": { + source: "apache", + compressible: false, + extensions: ["wmv"] + }, + "video/x-ms-wmx": { + source: "apache", + extensions: ["wmx"] + }, + "video/x-ms-wvx": { + source: "apache", + extensions: ["wvx"] + }, + "video/x-msvideo": { + source: "apache", + extensions: ["avi"] + }, + "video/x-sgi-movie": { + source: "apache", + extensions: ["movie"] + }, + "video/x-smv": { + source: "apache", + extensions: ["smv"] + }, + "x-conference/x-cooltalk": { + source: "apache", + extensions: ["ice"] + }, + "x-shader/x-fragment": { + compressible: true + }, + "x-shader/x-vertex": { + compressible: true + } + }; + } +}); +var require_mime_db2 = __commonJS2({ + "node_modules/express/node_modules/mime-db/index.js"(exports2, module2) { + module2.exports = require_db2(); + } +}); +var require_mimeScore2 = __commonJS2({ + "node_modules/express/node_modules/mime-types/mimeScore.js"(exports2, module2) { + var FACET_SCORES = { + "prs.": 100, + "x-": 200, + "x.": 300, + "vnd.": 400, + default: 900 + }; + var SOURCE_SCORES = { + nginx: 10, + apache: 20, + iana: 40, + default: 30 + // definitions added by `jshttp/mime-db` project? + }; + var TYPE_SCORES = { + // prefer application/xml over text/xml + // prefer application/rtf over text/rtf + application: 1, + // prefer font/woff over application/font-woff + font: 2, + default: 0 + }; + module2.exports = function mimeScore(mimeType, source = "default") { + if (mimeType === "application/octet-stream") { + return 0; + } + const [type, subtype] = mimeType.split("/"); + const facet = subtype.replace(/(\.|x-).*/, "$1"); + const facetScore = FACET_SCORES[facet] || FACET_SCORES.default; + const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default; + const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default; + const lengthScore = 1 - mimeType.length / 100; + return facetScore + sourceScore + typeScore + lengthScore; + }; + } +}); +var require_mime_types2 = __commonJS2({ + "node_modules/express/node_modules/mime-types/index.js"(exports2) { + "use strict"; + var db = require_mime_db2(); + var extname = require("path").extname; + var mimeScore = require_mimeScore2(); + var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/; + var TEXT_TYPE_REGEXP = /^text\//i; + exports2.charset = charset; + exports2.charsets = { lookup: charset }; + exports2.contentType = contentType2; + exports2.extension = extension; + exports2.extensions = /* @__PURE__ */ Object.create(null); + exports2.lookup = lookup; + exports2.types = /* @__PURE__ */ Object.create(null); + exports2._extensionConflicts = []; + populateMaps(exports2.extensions, exports2.types); + function charset(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var mime = match && db[match[1].toLowerCase()]; + if (mime && mime.charset) { + return mime.charset; + } + if (match && TEXT_TYPE_REGEXP.test(match[1])) { + return "UTF-8"; + } + return false; + } + function contentType2(str) { + if (!str || typeof str !== "string") { + return false; + } + var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str; + if (!mime) { + return false; + } + if (mime.indexOf("charset") === -1) { + var charset2 = exports2.charset(mime); + if (charset2) mime += "; charset=" + charset2.toLowerCase(); + } + return mime; + } + function extension(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var exts = match && exports2.extensions[match[1].toLowerCase()]; + if (!exts || !exts.length) { + return false; + } + return exts[0]; + } + function lookup(path) { + if (!path || typeof path !== "string") { + return false; + } + var extension2 = extname("x." + path).toLowerCase().slice(1); + if (!extension2) { + return false; + } + return exports2.types[extension2] || false; + } + function populateMaps(extensions, types) { + Object.keys(db).forEach(function forEachMimeType(type) { + var mime = db[type]; + var exts = mime.extensions; + if (!exts || !exts.length) { + return; + } + extensions[type] = exts; + for (var i = 0; i < exts.length; i++) { + var extension2 = exts[i]; + types[extension2] = _preferredType(extension2, types[extension2], type); + const legacyType = _preferredTypeLegacy( + extension2, + types[extension2], + type + ); + if (legacyType !== types[extension2]) { + exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]); + } + } + }); + } + function _preferredType(ext, type0, type1) { + var score0 = type0 ? mimeScore(type0, db[type0].source) : 0; + var score1 = type1 ? mimeScore(type1, db[type1].source) : 0; + return score0 > score1 ? type0 : type1; + } + function _preferredTypeLegacy(ext, type0, type1) { + var SOURCE_RANK = ["nginx", "apache", void 0, "iana"]; + var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0; + var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0; + if (exports2.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === "application/")) { + return type0; + } + return score0 > score1 ? type0 : type1; + } + } +}); +var require_forwarded = __commonJS2({ + "node_modules/forwarded/index.js"(exports2, module2) { + "use strict"; + module2.exports = forwarded; + function forwarded(req) { + if (!req) { + throw new TypeError("argument req is required"); + } + var proxyAddrs = parse(req.headers["x-forwarded-for"] || ""); + var socketAddr = getSocketAddr(req); + var addrs = [socketAddr].concat(proxyAddrs); + return addrs; + } + function getSocketAddr(req) { + return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress; + } + function parse(header) { + var end = header.length; + var list = []; + var start = header.length; + for (var i = header.length - 1; i >= 0; i--) { + switch (header.charCodeAt(i)) { + case 32: + if (start === end) { + start = end = i; + } + break; + case 44: + if (start !== end) { + list.push(header.substring(start, end)); + } + start = end = i; + break; + default: + start = i; + break; + } + } + if (start !== end) { + list.push(header.substring(start, end)); + } + return list; + } + } +}); +var require_ipaddr = __commonJS2({ + "node_modules/ipaddr.js/lib/ipaddr.js"(exports2, module2) { + (function() { + var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex; + ipaddr = {}; + root = this; + if (typeof module2 !== "undefined" && module2 !== null && module2.exports) { + module2.exports = ipaddr; + } else { + root["ipaddr"] = ipaddr; + } + matchCIDR = function(first, second, partSize, cidrBits) { + var part, shift; + if (first.length !== second.length) { + throw new Error("ipaddr: cannot match CIDR for objects with different lengths"); + } + part = 0; + while (cidrBits > 0) { + shift = partSize - cidrBits; + if (shift < 0) { + shift = 0; + } + if (first[part] >> shift !== second[part] >> shift) { + return false; + } + cidrBits -= partSize; + part += 1; + } + return true; + }; + ipaddr.subnetMatch = function(address, rangeList, defaultName) { + var k, len, rangeName, rangeSubnets, subnet; + if (defaultName == null) { + defaultName = "unicast"; + } + for (rangeName in rangeList) { + rangeSubnets = rangeList[rangeName]; + if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) { + rangeSubnets = [rangeSubnets]; + } + for (k = 0, len = rangeSubnets.length; k < len; k++) { + subnet = rangeSubnets[k]; + if (address.kind() === subnet[0].kind()) { + if (address.match.apply(address, subnet)) { + return rangeName; + } + } + } + } + return defaultName; + }; + ipaddr.IPv4 = (function() { + function IPv4(octets) { + var k, len, octet; + if (octets.length !== 4) { + throw new Error("ipaddr: ipv4 octet count should be 4"); + } + for (k = 0, len = octets.length; k < len; k++) { + octet = octets[k]; + if (!(0 <= octet && octet <= 255)) { + throw new Error("ipaddr: ipv4 octet should fit in 8 bits"); + } + } + this.octets = octets; + } + IPv4.prototype.kind = function() { + return "ipv4"; + }; + IPv4.prototype.toString = function() { + return this.octets.join("."); + }; + IPv4.prototype.toNormalizedString = function() { + return this.toString(); + }; + IPv4.prototype.toByteArray = function() { + return this.octets.slice(0); + }; + IPv4.prototype.match = function(other, cidrRange) { + var ref; + if (cidrRange === void 0) { + ref = other, other = ref[0], cidrRange = ref[1]; + } + if (other.kind() !== "ipv4") { + throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one"); + } + return matchCIDR(this.octets, other.octets, 8, cidrRange); + }; + IPv4.prototype.SpecialRanges = { + unspecified: [[new IPv4([0, 0, 0, 0]), 8]], + broadcast: [[new IPv4([255, 255, 255, 255]), 32]], + multicast: [[new IPv4([224, 0, 0, 0]), 4]], + linkLocal: [[new IPv4([169, 254, 0, 0]), 16]], + loopback: [[new IPv4([127, 0, 0, 0]), 8]], + carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]], + "private": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]], + reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]] + }; + IPv4.prototype.range = function() { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + IPv4.prototype.toIPv4MappedAddress = function() { + return ipaddr.IPv6.parse("::ffff:" + this.toString()); + }; + IPv4.prototype.prefixLengthFromSubnetMask = function() { + var cidr, i, k, octet, stop, zeros, zerotable; + zerotable = { + 0: 8, + 128: 7, + 192: 6, + 224: 5, + 240: 4, + 248: 3, + 252: 2, + 254: 1, + 255: 0 + }; + cidr = 0; + stop = false; + for (i = k = 3; k >= 0; i = k += -1) { + octet = this.octets[i]; + if (octet in zerotable) { + zeros = zerotable[octet]; + if (stop && zeros !== 0) { + return null; + } + if (zeros !== 8) { + stop = true; + } + cidr += zeros; + } else { + return null; + } + } + return 32 - cidr; + }; + return IPv4; + })(); + ipv4Part = "(0?\\d+|0x[a-f0-9]+)"; + ipv4Regexes = { + fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", "i"), + longValue: new RegExp("^" + ipv4Part + "$", "i") + }; + ipaddr.IPv4.parser = function(string) { + var match, parseIntAuto, part, shift, value; + parseIntAuto = function(string2) { + if (string2[0] === "0" && string2[1] !== "x") { + return parseInt(string2, 8); + } else { + return parseInt(string2); + } + }; + if (match = string.match(ipv4Regexes.fourOctet)) { + return (function() { + var k, len, ref, results; + ref = match.slice(1, 6); + results = []; + for (k = 0, len = ref.length; k < len; k++) { + part = ref[k]; + results.push(parseIntAuto(part)); + } + return results; + })(); + } else if (match = string.match(ipv4Regexes.longValue)) { + value = parseIntAuto(match[1]); + if (value > 4294967295 || value < 0) { + throw new Error("ipaddr: address outside defined range"); + } + return (function() { + var k, results; + results = []; + for (shift = k = 0; k <= 24; shift = k += 8) { + results.push(value >> shift & 255); + } + return results; + })().reverse(); + } else { + return null; + } + }; + ipaddr.IPv6 = (function() { + function IPv6(parts, zoneId) { + var i, k, l, len, part, ref; + if (parts.length === 16) { + this.parts = []; + for (i = k = 0; k <= 14; i = k += 2) { + this.parts.push(parts[i] << 8 | parts[i + 1]); + } + } else if (parts.length === 8) { + this.parts = parts; + } else { + throw new Error("ipaddr: ipv6 part count should be 8 or 16"); + } + ref = this.parts; + for (l = 0, len = ref.length; l < len; l++) { + part = ref[l]; + if (!(0 <= part && part <= 65535)) { + throw new Error("ipaddr: ipv6 part should fit in 16 bits"); + } + } + if (zoneId) { + this.zoneId = zoneId; + } + } + IPv6.prototype.kind = function() { + return "ipv6"; + }; + IPv6.prototype.toString = function() { + return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, "::"); + }; + IPv6.prototype.toRFC5952String = function() { + var bestMatchIndex, bestMatchLength, match, regex, string; + regex = /((^|:)(0(:|$)){2,})/g; + string = this.toNormalizedString(); + bestMatchIndex = 0; + bestMatchLength = -1; + while (match = regex.exec(string)) { + if (match[0].length > bestMatchLength) { + bestMatchIndex = match.index; + bestMatchLength = match[0].length; + } + } + if (bestMatchLength < 0) { + return string; + } + return string.substring(0, bestMatchIndex) + "::" + string.substring(bestMatchIndex + bestMatchLength); + }; + IPv6.prototype.toByteArray = function() { + var bytes, k, len, part, ref; + bytes = []; + ref = this.parts; + for (k = 0, len = ref.length; k < len; k++) { + part = ref[k]; + bytes.push(part >> 8); + bytes.push(part & 255); + } + return bytes; + }; + IPv6.prototype.toNormalizedString = function() { + var addr, part, suffix; + addr = function() { + var k, len, ref, results; + ref = this.parts; + results = []; + for (k = 0, len = ref.length; k < len; k++) { + part = ref[k]; + results.push(part.toString(16)); + } + return results; + }.call(this).join(":"); + suffix = ""; + if (this.zoneId) { + suffix = "%" + this.zoneId; + } + return addr + suffix; + }; + IPv6.prototype.toFixedLengthString = function() { + var addr, part, suffix; + addr = function() { + var k, len, ref, results; + ref = this.parts; + results = []; + for (k = 0, len = ref.length; k < len; k++) { + part = ref[k]; + results.push(part.toString(16).padStart(4, "0")); + } + return results; + }.call(this).join(":"); + suffix = ""; + if (this.zoneId) { + suffix = "%" + this.zoneId; + } + return addr + suffix; + }; + IPv6.prototype.match = function(other, cidrRange) { + var ref; + if (cidrRange === void 0) { + ref = other, other = ref[0], cidrRange = ref[1]; + } + if (other.kind() !== "ipv6") { + throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one"); + } + return matchCIDR(this.parts, other.parts, 16, cidrRange); + }; + IPv6.prototype.SpecialRanges = { + unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128], + linkLocal: [new IPv6([65152, 0, 0, 0, 0, 0, 0, 0]), 10], + multicast: [new IPv6([65280, 0, 0, 0, 0, 0, 0, 0]), 8], + loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128], + uniqueLocal: [new IPv6([64512, 0, 0, 0, 0, 0, 0, 0]), 7], + ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 65535, 0, 0]), 96], + rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96], + rfc6052: [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96], + "6to4": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16], + teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32], + reserved: [[new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32]] + }; + IPv6.prototype.range = function() { + return ipaddr.subnetMatch(this, this.SpecialRanges); + }; + IPv6.prototype.isIPv4MappedAddress = function() { + return this.range() === "ipv4Mapped"; + }; + IPv6.prototype.toIPv4Address = function() { + var high, low, ref; + if (!this.isIPv4MappedAddress()) { + throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4"); + } + ref = this.parts.slice(-2), high = ref[0], low = ref[1]; + return new ipaddr.IPv4([high >> 8, high & 255, low >> 8, low & 255]); + }; + IPv6.prototype.prefixLengthFromSubnetMask = function() { + var cidr, i, k, part, stop, zeros, zerotable; + zerotable = { + 0: 16, + 32768: 15, + 49152: 14, + 57344: 13, + 61440: 12, + 63488: 11, + 64512: 10, + 65024: 9, + 65280: 8, + 65408: 7, + 65472: 6, + 65504: 5, + 65520: 4, + 65528: 3, + 65532: 2, + 65534: 1, + 65535: 0 + }; + cidr = 0; + stop = false; + for (i = k = 7; k >= 0; i = k += -1) { + part = this.parts[i]; + if (part in zerotable) { + zeros = zerotable[part]; + if (stop && zeros !== 0) { + return null; + } + if (zeros !== 16) { + stop = true; + } + cidr += zeros; + } else { + return null; + } + } + return 128 - cidr; + }; + return IPv6; + })(); + ipv6Part = "(?:[0-9a-f]+::?)+"; + zoneIndex = "%[0-9a-z]{1,}"; + ipv6Regexes = { + zoneIndex: new RegExp(zoneIndex, "i"), + "native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?(" + zoneIndex + ")?$", "i"), + transitional: new RegExp("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)" + (ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part) + ("(" + zoneIndex + ")?$"), "i") + }; + expandIPv6 = function(string, parts) { + var colonCount, lastColon, part, replacement, replacementCount, zoneId; + if (string.indexOf("::") !== string.lastIndexOf("::")) { + return null; + } + zoneId = (string.match(ipv6Regexes["zoneIndex"]) || [])[0]; + if (zoneId) { + zoneId = zoneId.substring(1); + string = string.replace(/%.+$/, ""); + } + colonCount = 0; + lastColon = -1; + while ((lastColon = string.indexOf(":", lastColon + 1)) >= 0) { + colonCount++; + } + if (string.substr(0, 2) === "::") { + colonCount--; + } + if (string.substr(-2, 2) === "::") { + colonCount--; + } + if (colonCount > parts) { + return null; + } + replacementCount = parts - colonCount; + replacement = ":"; + while (replacementCount--) { + replacement += "0:"; + } + string = string.replace("::", replacement); + if (string[0] === ":") { + string = string.slice(1); + } + if (string[string.length - 1] === ":") { + string = string.slice(0, -1); + } + parts = (function() { + var k, len, ref, results; + ref = string.split(":"); + results = []; + for (k = 0, len = ref.length; k < len; k++) { + part = ref[k]; + results.push(parseInt(part, 16)); + } + return results; + })(); + return { + parts, + zoneId + }; + }; + ipaddr.IPv6.parser = function(string) { + var addr, k, len, match, octet, octets, zoneId; + if (ipv6Regexes["native"].test(string)) { + return expandIPv6(string, 8); + } else if (match = string.match(ipv6Regexes["transitional"])) { + zoneId = match[6] || ""; + addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6); + if (addr.parts) { + octets = [parseInt(match[2]), parseInt(match[3]), parseInt(match[4]), parseInt(match[5])]; + for (k = 0, len = octets.length; k < len; k++) { + octet = octets[k]; + if (!(0 <= octet && octet <= 255)) { + return null; + } + } + addr.parts.push(octets[0] << 8 | octets[1]); + addr.parts.push(octets[2] << 8 | octets[3]); + return { + parts: addr.parts, + zoneId: addr.zoneId + }; + } + } + return null; + }; + ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string) { + return this.parser(string) !== null; + }; + ipaddr.IPv4.isValid = function(string) { + var e; + try { + new this(this.parser(string)); + return true; + } catch (error1) { + e = error1; + return false; + } + }; + ipaddr.IPv4.isValidFourPartDecimal = function(string) { + if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) { + return true; + } else { + return false; + } + }; + ipaddr.IPv6.isValid = function(string) { + var addr, e; + if (typeof string === "string" && string.indexOf(":") === -1) { + return false; + } + try { + addr = this.parser(string); + new this(addr.parts, addr.zoneId); + return true; + } catch (error1) { + e = error1; + return false; + } + }; + ipaddr.IPv4.parse = function(string) { + var parts; + parts = this.parser(string); + if (parts === null) { + throw new Error("ipaddr: string is not formatted like ip address"); + } + return new this(parts); + }; + ipaddr.IPv6.parse = function(string) { + var addr; + addr = this.parser(string); + if (addr.parts === null) { + throw new Error("ipaddr: string is not formatted like ip address"); + } + return new this(addr.parts, addr.zoneId); + }; + ipaddr.IPv4.parseCIDR = function(string) { + var maskLength, match, parsed; + if (match = string.match(/^(.+)\/(\d+)$/)) { + maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 32) { + parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, "toString", { + value: function() { + return this.join("/"); + } + }); + return parsed; + } + } + throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range"); + }; + ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) { + var filledOctetCount, j, octets; + prefix = parseInt(prefix); + if (prefix < 0 || prefix > 32) { + throw new Error("ipaddr: invalid IPv4 prefix length"); + } + octets = [0, 0, 0, 0]; + j = 0; + filledOctetCount = Math.floor(prefix / 8); + while (j < filledOctetCount) { + octets[j] = 255; + j++; + } + if (filledOctetCount < 4) { + octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8; + } + return new this(octets); + }; + ipaddr.IPv4.broadcastAddressFromCIDR = function(string) { + var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets; + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 4) { + octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255); + i++; + } + return new this(octets); + } catch (error1) { + error = error1; + throw new Error("ipaddr: the address does not have IPv4 CIDR format"); + } + }; + ipaddr.IPv4.networkAddressFromCIDR = function(string) { + var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets; + try { + cidr = this.parseCIDR(string); + ipInterfaceOctets = cidr[0].toByteArray(); + subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray(); + octets = []; + i = 0; + while (i < 4) { + octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10)); + i++; + } + return new this(octets); + } catch (error1) { + error = error1; + throw new Error("ipaddr: the address does not have IPv4 CIDR format"); + } + }; + ipaddr.IPv6.parseCIDR = function(string) { + var maskLength, match, parsed; + if (match = string.match(/^(.+)\/(\d+)$/)) { + maskLength = parseInt(match[2]); + if (maskLength >= 0 && maskLength <= 128) { + parsed = [this.parse(match[1]), maskLength]; + Object.defineProperty(parsed, "toString", { + value: function() { + return this.join("/"); + } + }); + return parsed; + } + } + throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range"); + }; + ipaddr.isValid = function(string) { + return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string); + }; + ipaddr.parse = function(string) { + if (ipaddr.IPv6.isValid(string)) { + return ipaddr.IPv6.parse(string); + } else if (ipaddr.IPv4.isValid(string)) { + return ipaddr.IPv4.parse(string); + } else { + throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format"); + } + }; + ipaddr.parseCIDR = function(string) { + var e; + try { + return ipaddr.IPv6.parseCIDR(string); + } catch (error1) { + e = error1; + try { + return ipaddr.IPv4.parseCIDR(string); + } catch (error12) { + e = error12; + throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format"); + } + } + }; + ipaddr.fromByteArray = function(bytes) { + var length; + length = bytes.length; + if (length === 4) { + return new ipaddr.IPv4(bytes); + } else if (length === 16) { + return new ipaddr.IPv6(bytes); + } else { + throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address"); + } + }; + ipaddr.process = function(string) { + var addr; + addr = this.parse(string); + if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) { + return addr.toIPv4Address(); + } else { + return addr; + } + }; + }).call(exports2); + } +}); +var require_proxy_addr = __commonJS2({ + "node_modules/proxy-addr/index.js"(exports2, module2) { + "use strict"; + module2.exports = proxyaddr; + module2.exports.all = alladdrs; + module2.exports.compile = compile; + var forwarded = require_forwarded(); + var ipaddr = require_ipaddr(); + var DIGIT_REGEXP = /^[0-9]+$/; + var isip = ipaddr.isValid; + var parseip = ipaddr.parse; + var IP_RANGES = { + linklocal: ["169.254.0.0/16", "fe80::/10"], + loopback: ["127.0.0.1/8", "::1/128"], + uniquelocal: ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "fc00::/7"] + }; + function alladdrs(req, trust) { + var addrs = forwarded(req); + if (!trust) { + return addrs; + } + if (typeof trust !== "function") { + trust = compile(trust); + } + for (var i = 0; i < addrs.length - 1; i++) { + if (trust(addrs[i], i)) continue; + addrs.length = i + 1; + } + return addrs; + } + function compile(val) { + if (!val) { + throw new TypeError("argument is required"); + } + var trust; + if (typeof val === "string") { + trust = [val]; + } else if (Array.isArray(val)) { + trust = val.slice(); + } else { + throw new TypeError("unsupported trust argument"); + } + for (var i = 0; i < trust.length; i++) { + val = trust[i]; + if (!Object.prototype.hasOwnProperty.call(IP_RANGES, val)) { + continue; + } + val = IP_RANGES[val]; + trust.splice.apply(trust, [i, 1].concat(val)); + i += val.length - 1; + } + return compileTrust(compileRangeSubnets(trust)); + } + function compileRangeSubnets(arr) { + var rangeSubnets = new Array(arr.length); + for (var i = 0; i < arr.length; i++) { + rangeSubnets[i] = parseipNotation(arr[i]); + } + return rangeSubnets; + } + function compileTrust(rangeSubnets) { + var len = rangeSubnets.length; + return len === 0 ? trustNone : len === 1 ? trustSingle(rangeSubnets[0]) : trustMulti(rangeSubnets); + } + function parseipNotation(note) { + var pos = note.lastIndexOf("/"); + var str = pos !== -1 ? note.substring(0, pos) : note; + if (!isip(str)) { + throw new TypeError("invalid IP address: " + str); + } + var ip = parseip(str); + if (pos === -1 && ip.kind() === "ipv6" && ip.isIPv4MappedAddress()) { + ip = ip.toIPv4Address(); + } + var max = ip.kind() === "ipv6" ? 128 : 32; + var range = pos !== -1 ? note.substring(pos + 1, note.length) : null; + if (range === null) { + range = max; + } else if (DIGIT_REGEXP.test(range)) { + range = parseInt(range, 10); + } else if (ip.kind() === "ipv4" && isip(range)) { + range = parseNetmask(range); + } else { + range = null; + } + if (range <= 0 || range > max) { + throw new TypeError("invalid range on address: " + note); + } + return [ip, range]; + } + function parseNetmask(netmask) { + var ip = parseip(netmask); + var kind = ip.kind(); + return kind === "ipv4" ? ip.prefixLengthFromSubnetMask() : null; + } + function proxyaddr(req, trust) { + if (!req) { + throw new TypeError("req argument is required"); + } + if (!trust) { + throw new TypeError("trust argument is required"); + } + var addrs = alladdrs(req, trust); + var addr = addrs[addrs.length - 1]; + return addr; + } + function trustNone() { + return false; + } + function trustMulti(subnets) { + return function trust(addr) { + if (!isip(addr)) return false; + var ip = parseip(addr); + var ipconv; + var kind = ip.kind(); + for (var i = 0; i < subnets.length; i++) { + var subnet = subnets[i]; + var subnetip = subnet[0]; + var subnetkind = subnetip.kind(); + var subnetrange = subnet[1]; + var trusted = ip; + if (kind !== subnetkind) { + if (subnetkind === "ipv4" && !ip.isIPv4MappedAddress()) { + continue; + } + if (!ipconv) { + ipconv = subnetkind === "ipv4" ? ip.toIPv4Address() : ip.toIPv4MappedAddress(); + } + trusted = ipconv; + } + if (trusted.match(subnetip, subnetrange)) { + return true; + } + } + return false; + }; + } + function trustSingle(subnet) { + var subnetip = subnet[0]; + var subnetkind = subnetip.kind(); + var subnetisipv4 = subnetkind === "ipv4"; + var subnetrange = subnet[1]; + return function trust(addr) { + if (!isip(addr)) return false; + var ip = parseip(addr); + var kind = ip.kind(); + if (kind !== subnetkind) { + if (subnetisipv4 && !ip.isIPv4MappedAddress()) { + return false; + } + ip = subnetisipv4 ? ip.toIPv4Address() : ip.toIPv4MappedAddress(); + } + return ip.match(subnetip, subnetrange); + }; + } + } +}); +var require_utils3 = __commonJS2({ + "node_modules/express/lib/utils.js"(exports2) { + "use strict"; + var { METHODS } = require("node:http"); + var contentType2 = require_content_type(); + var etag = require_etag(); + var mime = require_mime_types2(); + var proxyaddr = require_proxy_addr(); + var qs = require_lib3(); + var querystring = require("querystring"); + exports2.methods = METHODS.map((method) => method.toLowerCase()); + exports2.etag = createETagGenerator({ weak: false }); + exports2.wetag = createETagGenerator({ weak: true }); + exports2.normalizeType = function(type) { + return ~type.indexOf("/") ? acceptParams(type) : { value: mime.lookup(type) || "application/octet-stream", params: {} }; + }; + exports2.normalizeTypes = function(types) { + return types.map(exports2.normalizeType); + }; + function acceptParams(str) { + var length = str.length; + var colonIndex = str.indexOf(";"); + var index = colonIndex === -1 ? length : colonIndex; + var ret = { value: str.slice(0, index).trim(), quality: 1, params: {} }; + while (index < length) { + var splitIndex = str.indexOf("=", index); + if (splitIndex === -1) break; + var colonIndex = str.indexOf(";", index); + var endIndex = colonIndex === -1 ? length : colonIndex; + if (splitIndex > endIndex) { + index = str.lastIndexOf(";", splitIndex - 1) + 1; + continue; + } + var key = str.slice(index, splitIndex).trim(); + var value = str.slice(splitIndex + 1, endIndex).trim(); + if (key === "q") { + ret.quality = parseFloat(value); + } else { + ret.params[key] = value; + } + index = endIndex + 1; + } + return ret; + } + exports2.compileETag = function(val) { + var fn; + if (typeof val === "function") { + return val; + } + switch (val) { + case true: + case "weak": + fn = exports2.wetag; + break; + case false: + break; + case "strong": + fn = exports2.etag; + break; + default: + throw new TypeError("unknown value for etag function: " + val); + } + return fn; + }; + exports2.compileQueryParser = function compileQueryParser(val) { + var fn; + if (typeof val === "function") { + return val; + } + switch (val) { + case true: + case "simple": + fn = querystring.parse; + break; + case false: + break; + case "extended": + fn = parseExtendedQueryString; + break; + default: + throw new TypeError("unknown value for query parser function: " + val); + } + return fn; + }; + exports2.compileTrust = function(val) { + if (typeof val === "function") return val; + if (val === true) { + return function() { + return true; + }; + } + if (typeof val === "number") { + return function(a, i) { + return i < val; + }; + } + if (typeof val === "string") { + val = val.split(",").map(function(v) { + return v.trim(); + }); + } + return proxyaddr.compile(val || []); + }; + exports2.setCharset = function setCharset(type, charset) { + if (!type || !charset) { + return type; + } + var parsed = contentType2.parse(type); + parsed.parameters.charset = charset; + return contentType2.format(parsed); + }; + function createETagGenerator(options) { + return function generateETag(body, encoding) { + var buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body; + return etag(buf, options); + }; + } + function parseExtendedQueryString(str) { + return qs.parse(str, { + allowPrototypes: true + }); + } + } +}); +var require_wrappy = __commonJS2({ + "node_modules/wrappy/wrappy.js"(exports2, module2) { + module2.exports = wrappy; + function wrappy(fn, cb) { + if (fn && cb) return wrappy(fn)(cb); + if (typeof fn !== "function") + throw new TypeError("need wrapper function"); + Object.keys(fn).forEach(function(k) { + wrapper[k] = fn[k]; + }); + return wrapper; + function wrapper() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + var ret = fn.apply(this, args); + var cb2 = args[args.length - 1]; + if (typeof ret === "function" && ret !== cb2) { + Object.keys(cb2).forEach(function(k) { + ret[k] = cb2[k]; + }); + } + return ret; + } + } + } +}); +var require_once = __commonJS2({ + "node_modules/once/once.js"(exports2, module2) { + var wrappy = require_wrappy(); + module2.exports = wrappy(once); + module2.exports.strict = wrappy(onceStrict); + once.proto = once(function() { + Object.defineProperty(Function.prototype, "once", { + value: function() { + return once(this); + }, + configurable: true + }); + Object.defineProperty(Function.prototype, "onceStrict", { + value: function() { + return onceStrict(this); + }, + configurable: true + }); + }); + function once(fn) { + var f = function() { + if (f.called) return f.value; + f.called = true; + return f.value = fn.apply(this, arguments); + }; + f.called = false; + return f; + } + function onceStrict(fn) { + var f = function() { + if (f.called) + throw new Error(f.onceError); + f.called = true; + return f.value = fn.apply(this, arguments); + }; + var name = fn.name || "Function wrapped with `once`"; + f.onceError = name + " shouldn't be called more than once"; + f.called = false; + return f; + } + } +}); +var require_is_promise = __commonJS2({ + "node_modules/is-promise/index.js"(exports2, module2) { + module2.exports = isPromise; + module2.exports.default = isPromise; + function isPromise(obj) { + return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function"; + } + } +}); +var require_dist = __commonJS2({ + "node_modules/path-to-regexp/dist/index.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.TokenData = void 0; + exports2.parse = parse; + exports2.compile = compile; + exports2.match = match; + exports2.pathToRegexp = pathToRegexp; + exports2.stringify = stringify; + var DEFAULT_DELIMITER = "/"; + var NOOP_VALUE = (value) => value; + var ID_START = /^[$_\p{ID_Start}]$/u; + var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u; + var DEBUG_URL = "https://git.new/pathToRegexpError"; + var SIMPLE_TOKENS = { + // Groups. + "{": "{", + "}": "}", + // Reserved. + "(": "(", + ")": ")", + "[": "[", + "]": "]", + "+": "+", + "?": "?", + "!": "!" + }; + function escapeText(str) { + return str.replace(/[{}()\[\]+?!:*]/g, "\\$&"); + } + function escape2(str) { + return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&"); + } + function* lexer(str) { + const chars = [...str]; + let i = 0; + function name() { + let value = ""; + if (ID_START.test(chars[++i])) { + value += chars[i]; + while (ID_CONTINUE.test(chars[++i])) { + value += chars[i]; + } + } else if (chars[i] === '"') { + let pos = i; + while (i < chars.length) { + if (chars[++i] === '"') { + i++; + pos = 0; + break; + } + if (chars[i] === "\\") { + value += chars[++i]; + } else { + value += chars[i]; + } + } + if (pos) { + throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`); + } + } + if (!value) { + throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`); + } + return value; + } + while (i < chars.length) { + const value = chars[i]; + const type = SIMPLE_TOKENS[value]; + if (type) { + yield { type, index: i++, value }; + } else if (value === "\\") { + yield { type: "ESCAPED", index: i++, value: chars[i++] }; + } else if (value === ":") { + const value2 = name(); + yield { type: "PARAM", index: i, value: value2 }; + } else if (value === "*") { + const value2 = name(); + yield { type: "WILDCARD", index: i, value: value2 }; + } else { + yield { type: "CHAR", index: i, value: chars[i++] }; + } + } + return { type: "END", index: i, value: "" }; + } + var Iter = class { + constructor(tokens) { + this.tokens = tokens; + } + peek() { + if (!this._peek) { + const next = this.tokens.next(); + this._peek = next.value; + } + return this._peek; + } + tryConsume(type) { + const token = this.peek(); + if (token.type !== type) + return; + this._peek = void 0; + return token.value; + } + consume(type) { + const value = this.tryConsume(type); + if (value !== void 0) + return value; + const { type: nextType, index } = this.peek(); + throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`); + } + text() { + let result = ""; + let value; + while (value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED")) { + result += value; + } + return result; + } + }; + var TokenData = class { + constructor(tokens) { + this.tokens = tokens; + } + }; + exports2.TokenData = TokenData; + function parse(str, options = {}) { + const { encodePath = NOOP_VALUE } = options; + const it = new Iter(lexer(str)); + function consume(endType) { + const tokens2 = []; + while (true) { + const path = it.text(); + if (path) + tokens2.push({ type: "text", value: encodePath(path) }); + const param = it.tryConsume("PARAM"); + if (param) { + tokens2.push({ + type: "param", + name: param + }); + continue; + } + const wildcard = it.tryConsume("WILDCARD"); + if (wildcard) { + tokens2.push({ + type: "wildcard", + name: wildcard + }); + continue; + } + const open = it.tryConsume("{"); + if (open) { + tokens2.push({ + type: "group", + tokens: consume("}") + }); + continue; + } + it.consume(endType); + return tokens2; + } + } + const tokens = consume("END"); + return new TokenData(tokens); + } + function compile(path, options = {}) { + const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options; + const data = path instanceof TokenData ? path : parse(path, options); + const fn = tokensToFunction(data.tokens, delimiter, encode); + return function path2(data2 = {}) { + const [path3, ...missing] = fn(data2); + if (missing.length) { + throw new TypeError(`Missing parameters: ${missing.join(", ")}`); + } + return path3; + }; + } + function tokensToFunction(tokens, delimiter, encode) { + const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode)); + return (data) => { + const result = [""]; + for (const encoder of encoders) { + const [value, ...extras] = encoder(data); + result[0] += value; + result.push(...extras); + } + return result; + }; + } + function tokenToFunction(token, delimiter, encode) { + if (token.type === "text") + return () => [token.value]; + if (token.type === "group") { + const fn = tokensToFunction(token.tokens, delimiter, encode); + return (data) => { + const [value, ...missing] = fn(data); + if (!missing.length) + return [value]; + return [""]; + }; + } + const encodeValue = encode || NOOP_VALUE; + if (token.type === "wildcard" && encode !== false) { + return (data) => { + const value = data[token.name]; + if (value == null) + return ["", token.name]; + if (!Array.isArray(value) || value.length === 0) { + throw new TypeError(`Expected "${token.name}" to be a non-empty array`); + } + return [ + value.map((value2, index) => { + if (typeof value2 !== "string") { + throw new TypeError(`Expected "${token.name}/${index}" to be a string`); + } + return encodeValue(value2); + }).join(delimiter) + ]; + }; + } + return (data) => { + const value = data[token.name]; + if (value == null) + return ["", token.name]; + if (typeof value !== "string") { + throw new TypeError(`Expected "${token.name}" to be a string`); + } + return [encodeValue(value)]; + }; + } + function match(path, options = {}) { + const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options; + const { regexp, keys } = pathToRegexp(path, options); + const decoders = keys.map((key) => { + if (decode === false) + return NOOP_VALUE; + if (key.type === "param") + return decode; + return (value) => value.split(delimiter).map(decode); + }); + return function match2(input) { + const m = regexp.exec(input); + if (!m) + return false; + const path2 = m[0]; + const params = /* @__PURE__ */ Object.create(null); + for (let i = 1; i < m.length; i++) { + if (m[i] === void 0) + continue; + const key = keys[i - 1]; + const decoder = decoders[i - 1]; + params[key.name] = decoder(m[i]); + } + return { path: path2, params }; + }; + } + function pathToRegexp(path, options = {}) { + const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options; + const keys = []; + const sources = []; + const flags = sensitive ? "" : "i"; + const paths = Array.isArray(path) ? path : [path]; + const items = paths.map((path2) => path2 instanceof TokenData ? path2 : parse(path2, options)); + for (const { tokens } of items) { + for (const seq of flatten(tokens, 0, [])) { + const regexp2 = sequenceToRegExp(seq, delimiter, keys); + sources.push(regexp2); + } + } + let pattern = `^(?:${sources.join("|")})`; + if (trailing) + pattern += `(?:${escape2(delimiter)}$)?`; + pattern += end ? "$" : `(?=${escape2(delimiter)}|$)`; + const regexp = new RegExp(pattern, flags); + return { regexp, keys }; + } + function* flatten(tokens, index, init) { + if (index === tokens.length) { + return yield init; + } + const token = tokens[index]; + if (token.type === "group") { + const fork = init.slice(); + for (const seq of flatten(token.tokens, 0, fork)) { + yield* flatten(tokens, index + 1, seq); + } + } else { + init.push(token); + } + yield* flatten(tokens, index + 1, init); + } + function sequenceToRegExp(tokens, delimiter, keys) { + let result = ""; + let backtrack = ""; + let isSafeSegmentParam = true; + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i]; + if (token.type === "text") { + result += escape2(token.value); + backtrack += token.value; + isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter)); + continue; + } + if (token.type === "param" || token.type === "wildcard") { + if (!isSafeSegmentParam && !backtrack) { + throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`); + } + if (token.type === "param") { + result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`; + } else { + result += `([\\s\\S]+)`; + } + keys.push(token); + backtrack = ""; + isSafeSegmentParam = false; + continue; + } + } + return result; + } + function negate(delimiter, backtrack) { + if (backtrack.length < 2) { + if (delimiter.length < 2) + return `[^${escape2(delimiter + backtrack)}]`; + return `(?:(?!${escape2(delimiter)})[^${escape2(backtrack)}])`; + } + if (delimiter.length < 2) { + return `(?:(?!${escape2(backtrack)})[^${escape2(delimiter)}])`; + } + return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\s\\S])`; + } + function stringify(data) { + return data.tokens.map(function stringifyToken(token, index, tokens) { + if (token.type === "text") + return escapeText(token.value); + if (token.type === "group") { + return `{${token.tokens.map(stringifyToken).join("")}}`; + } + const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]); + const key = isSafe ? token.name : JSON.stringify(token.name); + if (token.type === "param") + return `:${key}`; + if (token.type === "wildcard") + return `*${key}`; + throw new TypeError(`Unexpected token: ${token}`); + }).join(""); + } + function isNameSafe(name) { + const [first, ...rest] = name; + if (!ID_START.test(first)) + return false; + return rest.every((char) => ID_CONTINUE.test(char)); + } + function isNextNameSafe(token) { + if ((token === null || token === void 0 ? void 0 : token.type) !== "text") + return true; + return !ID_CONTINUE.test(token.value[0]); + } + } +}); +var require_layer = __commonJS2({ + "node_modules/router/lib/layer.js"(exports2, module2) { + "use strict"; + var isPromise = require_is_promise(); + var pathRegexp = require_dist(); + var debug = require_src()("router:layer"); + var deprecate = require_depd()("router"); + var TRAILING_SLASH_REGEXP = /\/+$/; + var MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g; + module2.exports = Layer; + function Layer(path, options, fn) { + if (!(this instanceof Layer)) { + return new Layer(path, options, fn); + } + debug("new %o", path); + const opts = options || {}; + this.handle = fn; + this.keys = []; + this.name = fn.name || ""; + this.params = void 0; + this.path = void 0; + this.slash = path === "/" && opts.end === false; + function matcher(_path) { + if (_path instanceof RegExp) { + const keys = []; + let name = 0; + let m; + while (m = MATCHING_GROUP_REGEXP.exec(_path.source)) { + keys.push({ + name: m[1] || name++, + offset: m.index + }); + } + return function regexpMatcher(p) { + const match = _path.exec(p); + if (!match) { + return false; + } + const params = {}; + for (let i = 1; i < match.length; i++) { + const key = keys[i - 1]; + const prop = key.name; + const val = decodeParam(match[i]); + if (val !== void 0) { + params[prop] = val; + } + } + return { + params, + path: match[0] + }; + }; + } + return pathRegexp.match(opts.strict ? _path : loosen(_path), { + sensitive: opts.sensitive, + end: opts.end, + trailing: !opts.strict, + decode: decodeParam + }); + } + this.matchers = Array.isArray(path) ? path.map(matcher) : [matcher(path)]; + } + Layer.prototype.handleError = function handleError(error, req, res, next) { + const fn = this.handle; + if (fn.length !== 4) { + return next(error); + } + try { + const ret = fn(error, req, res, next); + if (isPromise(ret)) { + if (!(ret instanceof Promise)) { + deprecate("handlers that are Promise-like are deprecated, use a native Promise instead"); + } + ret.then(null, function(error2) { + next(error2 || new Error("Rejected promise")); + }); + } + } catch (err2) { + next(err2); + } + }; + Layer.prototype.handleRequest = function handleRequest(req, res, next) { + const fn = this.handle; + if (fn.length > 3) { + return next(); + } + try { + const ret = fn(req, res, next); + if (isPromise(ret)) { + if (!(ret instanceof Promise)) { + deprecate("handlers that are Promise-like are deprecated, use a native Promise instead"); + } + ret.then(null, function(error) { + next(error || new Error("Rejected promise")); + }); + } + } catch (err2) { + next(err2); + } + }; + Layer.prototype.match = function match(path) { + let match2; + if (path != null) { + if (this.slash) { + this.params = {}; + this.path = ""; + return true; + } + let i = 0; + while (!match2 && i < this.matchers.length) { + match2 = this.matchers[i](path); + i++; + } + } + if (!match2) { + this.params = void 0; + this.path = void 0; + return false; + } + this.params = match2.params; + this.path = match2.path; + this.keys = Object.keys(match2.params); + return true; + }; + function decodeParam(val) { + if (typeof val !== "string" || val.length === 0) { + return val; + } + try { + return decodeURIComponent(val); + } catch (err2) { + if (err2 instanceof URIError) { + err2.message = "Failed to decode param '" + val + "'"; + err2.status = 400; + } + throw err2; + } + } + function loosen(path) { + if (path instanceof RegExp || path === "/") { + return path; + } + return Array.isArray(path) ? path.map(function(p) { + return loosen(p); + }) : String(path).replace(TRAILING_SLASH_REGEXP, ""); + } + } +}); +var require_route = __commonJS2({ + "node_modules/router/lib/route.js"(exports2, module2) { + "use strict"; + var debug = require_src()("router:route"); + var Layer = require_layer(); + var { METHODS } = require("node:http"); + var slice = Array.prototype.slice; + var flatten = Array.prototype.flat; + var methods = METHODS.map((method) => method.toLowerCase()); + module2.exports = Route; + function Route(path) { + debug("new %o", path); + this.path = path; + this.stack = []; + this.methods = /* @__PURE__ */ Object.create(null); + } + Route.prototype._handlesMethod = function _handlesMethod(method) { + if (this.methods._all) { + return true; + } + let name = typeof method === "string" ? method.toLowerCase() : method; + if (name === "head" && !this.methods.head) { + name = "get"; + } + return Boolean(this.methods[name]); + }; + Route.prototype._methods = function _methods() { + const methods2 = Object.keys(this.methods); + if (this.methods.get && !this.methods.head) { + methods2.push("head"); + } + for (let i = 0; i < methods2.length; i++) { + methods2[i] = methods2[i].toUpperCase(); + } + return methods2; + }; + Route.prototype.dispatch = function dispatch(req, res, done) { + let idx = 0; + const stack = this.stack; + let sync = 0; + if (stack.length === 0) { + return done(); + } + let method = typeof req.method === "string" ? req.method.toLowerCase() : req.method; + if (method === "head" && !this.methods.head) { + method = "get"; + } + req.route = this; + next(); + function next(err2) { + if (err2 && err2 === "route") { + return done(); + } + if (err2 && err2 === "router") { + return done(err2); + } + if (idx >= stack.length) { + return done(err2); + } + if (++sync > 100) { + return setImmediate(next, err2); + } + let layer; + let match; + while (match !== true && idx < stack.length) { + layer = stack[idx++]; + match = !layer.method || layer.method === method; + } + if (match !== true) { + return done(err2); + } + if (err2) { + layer.handleError(err2, req, res, next); + } else { + layer.handleRequest(req, res, next); + } + sync = 0; + } + }; + Route.prototype.all = function all(handler) { + const callbacks = flatten.call(slice.call(arguments), Infinity); + if (callbacks.length === 0) { + throw new TypeError("argument handler is required"); + } + for (let i = 0; i < callbacks.length; i++) { + const fn = callbacks[i]; + if (typeof fn !== "function") { + throw new TypeError("argument handler must be a function"); + } + const layer = Layer("/", {}, fn); + layer.method = void 0; + this.methods._all = true; + this.stack.push(layer); + } + return this; + }; + methods.forEach(function(method) { + Route.prototype[method] = function(handler) { + const callbacks = flatten.call(slice.call(arguments), Infinity); + if (callbacks.length === 0) { + throw new TypeError("argument handler is required"); + } + for (let i = 0; i < callbacks.length; i++) { + const fn = callbacks[i]; + if (typeof fn !== "function") { + throw new TypeError("argument handler must be a function"); + } + debug("%s %s", method, this.path); + const layer = Layer("/", {}, fn); + layer.method = method; + this.methods[method] = true; + this.stack.push(layer); + } + return this; + }; + }); + } +}); +var require_router = __commonJS2({ + "node_modules/router/index.js"(exports2, module2) { + "use strict"; + var isPromise = require_is_promise(); + var Layer = require_layer(); + var { METHODS } = require("node:http"); + var parseUrl = require_parseurl(); + var Route = require_route(); + var debug = require_src()("router"); + var deprecate = require_depd()("router"); + var slice = Array.prototype.slice; + var flatten = Array.prototype.flat; + var methods = METHODS.map((method) => method.toLowerCase()); + module2.exports = Router; + module2.exports.Route = Route; + function Router(options) { + if (!(this instanceof Router)) { + return new Router(options); + } + const opts = options || {}; + function router(req, res, next) { + router.handle(req, res, next); + } + Object.setPrototypeOf(router, this); + router.caseSensitive = opts.caseSensitive; + router.mergeParams = opts.mergeParams; + router.params = {}; + router.strict = opts.strict; + router.stack = []; + return router; + } + Router.prototype = function() { + }; + Router.prototype.param = function param(name, fn) { + if (!name) { + throw new TypeError("argument name is required"); + } + if (typeof name !== "string") { + throw new TypeError("argument name must be a string"); + } + if (!fn) { + throw new TypeError("argument fn is required"); + } + if (typeof fn !== "function") { + throw new TypeError("argument fn must be a function"); + } + let params = this.params[name]; + if (!params) { + params = this.params[name] = []; + } + params.push(fn); + return this; + }; + Router.prototype.handle = function handle(req, res, callback) { + if (!callback) { + throw new TypeError("argument callback is required"); + } + debug("dispatching %s %s", req.method, req.url); + let idx = 0; + let methods2; + const protohost = getProtohost(req.url) || ""; + let removed = ""; + const self2 = this; + let slashAdded = false; + let sync = 0; + const paramcalled = {}; + const stack = this.stack; + const parentParams = req.params; + const parentUrl = req.baseUrl || ""; + let done = restore(callback, req, "baseUrl", "next", "params"); + req.next = next; + if (req.method === "OPTIONS") { + methods2 = []; + done = wrap(done, generateOptionsResponder(res, methods2)); + } + req.baseUrl = parentUrl; + req.originalUrl = req.originalUrl || req.url; + next(); + function next(err2) { + let layerError = err2 === "route" ? null : err2; + if (slashAdded) { + req.url = req.url.slice(1); + slashAdded = false; + } + if (removed.length !== 0) { + req.baseUrl = parentUrl; + req.url = protohost + removed + req.url.slice(protohost.length); + removed = ""; + } + if (layerError === "router") { + setImmediate(done, null); + return; + } + if (idx >= stack.length) { + setImmediate(done, layerError); + return; + } + if (++sync > 100) { + return setImmediate(next, err2); + } + const path = getPathname(req); + if (path == null) { + return done(layerError); + } + let layer; + let match; + let route; + while (match !== true && idx < stack.length) { + layer = stack[idx++]; + match = matchLayer(layer, path); + route = layer.route; + if (typeof match !== "boolean") { + layerError = layerError || match; + } + if (match !== true) { + continue; + } + if (!route) { + continue; + } + if (layerError) { + match = false; + continue; + } + const method = req.method; + const hasMethod = route._handlesMethod(method); + if (!hasMethod && method === "OPTIONS" && methods2) { + methods2.push.apply(methods2, route._methods()); + } + if (!hasMethod && method !== "HEAD") { + match = false; + } + } + if (match !== true) { + return done(layerError); + } + if (route) { + req.route = route; + } + req.params = self2.mergeParams ? mergeParams(layer.params, parentParams) : layer.params; + const layerPath = layer.path; + processParams(self2.params, layer, paramcalled, req, res, function(err3) { + if (err3) { + next(layerError || err3); + } else if (route) { + layer.handleRequest(req, res, next); + } else { + trimPrefix(layer, layerError, layerPath, path); + } + sync = 0; + }); + } + function trimPrefix(layer, layerError, layerPath, path) { + if (layerPath.length !== 0) { + if (layerPath !== path.substring(0, layerPath.length)) { + next(layerError); + return; + } + const c = path[layerPath.length]; + if (c && c !== "/") { + next(layerError); + return; + } + debug("trim prefix (%s) from url %s", layerPath, req.url); + removed = layerPath; + req.url = protohost + req.url.slice(protohost.length + removed.length); + if (!protohost && req.url[0] !== "/") { + req.url = "/" + req.url; + slashAdded = true; + } + req.baseUrl = parentUrl + (removed[removed.length - 1] === "/" ? removed.substring(0, removed.length - 1) : removed); + } + debug("%s %s : %s", layer.name, layerPath, req.originalUrl); + if (layerError) { + layer.handleError(layerError, req, res, next); + } else { + layer.handleRequest(req, res, next); + } + } + }; + Router.prototype.use = function use(handler) { + let offset = 0; + let path = "/"; + if (typeof handler !== "function") { + let arg = handler; + while (Array.isArray(arg) && arg.length !== 0) { + arg = arg[0]; + } + if (typeof arg !== "function") { + offset = 1; + path = handler; + } + } + const callbacks = flatten.call(slice.call(arguments, offset), Infinity); + if (callbacks.length === 0) { + throw new TypeError("argument handler is required"); + } + for (let i = 0; i < callbacks.length; i++) { + const fn = callbacks[i]; + if (typeof fn !== "function") { + throw new TypeError("argument handler must be a function"); + } + debug("use %o %s", path, fn.name || ""); + const layer = new Layer(path, { + sensitive: this.caseSensitive, + strict: false, + end: false + }, fn); + layer.route = void 0; + this.stack.push(layer); + } + return this; + }; + Router.prototype.route = function route(path) { + const route2 = new Route(path); + const layer = new Layer(path, { + sensitive: this.caseSensitive, + strict: this.strict, + end: true + }, handle); + function handle(req, res, next) { + route2.dispatch(req, res, next); + } + layer.route = route2; + this.stack.push(layer); + return route2; + }; + methods.concat("all").forEach(function(method) { + Router.prototype[method] = function(path) { + const route = this.route(path); + route[method].apply(route, slice.call(arguments, 1)); + return this; + }; + }); + function generateOptionsResponder(res, methods2) { + return function onDone(fn, err2) { + if (err2 || methods2.length === 0) { + return fn(err2); + } + trySendOptionsResponse(res, methods2, fn); + }; + } + function getPathname(req) { + try { + return parseUrl(req).pathname; + } catch (err2) { + return void 0; + } + } + function getProtohost(url) { + if (typeof url !== "string" || url.length === 0 || url[0] === "/") { + return void 0; + } + const searchIndex = url.indexOf("?"); + const pathLength = searchIndex !== -1 ? searchIndex : url.length; + const fqdnIndex = url.substring(0, pathLength).indexOf("://"); + return fqdnIndex !== -1 ? url.substring(0, url.indexOf("/", 3 + fqdnIndex)) : void 0; + } + function matchLayer(layer, path) { + try { + return layer.match(path); + } catch (err2) { + return err2; + } + } + function mergeParams(params, parent) { + if (typeof parent !== "object" || !parent) { + return params; + } + const obj = Object.assign({}, parent); + if (!(0 in params) || !(0 in parent)) { + return Object.assign(obj, params); + } + let i = 0; + let o = 0; + while (i in params) { + i++; + } + while (o in parent) { + o++; + } + for (i--; i >= 0; i--) { + params[i + o] = params[i]; + if (i < o) { + delete params[i]; + } + } + return Object.assign(obj, params); + } + function processParams(params, layer, called, req, res, done) { + const keys = layer.keys; + if (!keys || keys.length === 0) { + return done(); + } + let i = 0; + let paramIndex = 0; + let key; + let paramVal; + let paramCallbacks; + let paramCalled; + function param(err2) { + if (err2) { + return done(err2); + } + if (i >= keys.length) { + return done(); + } + paramIndex = 0; + key = keys[i++]; + paramVal = req.params[key]; + paramCallbacks = params[key]; + paramCalled = called[key]; + if (paramVal === void 0 || !paramCallbacks) { + return param(); + } + if (paramCalled && (paramCalled.match === paramVal || paramCalled.error && paramCalled.error !== "route")) { + req.params[key] = paramCalled.value; + return param(paramCalled.error); + } + called[key] = paramCalled = { + error: null, + match: paramVal, + value: paramVal + }; + paramCallback(); + } + function paramCallback(err2) { + const fn = paramCallbacks[paramIndex++]; + paramCalled.value = req.params[key]; + if (err2) { + paramCalled.error = err2; + param(err2); + return; + } + if (!fn) return param(); + try { + const ret = fn(req, res, paramCallback, paramVal, key); + if (isPromise(ret)) { + if (!(ret instanceof Promise)) { + deprecate("parameters that are Promise-like are deprecated, use a native Promise instead"); + } + ret.then(null, function(error) { + paramCallback(error || new Error("Rejected promise")); + }); + } + } catch (e) { + paramCallback(e); + } + } + param(); + } + function restore(fn, obj) { + const props = new Array(arguments.length - 2); + const vals = new Array(arguments.length - 2); + for (let i = 0; i < props.length; i++) { + props[i] = arguments[i + 2]; + vals[i] = obj[props[i]]; + } + return function() { + for (let i = 0; i < props.length; i++) { + obj[props[i]] = vals[i]; + } + return fn.apply(this, arguments); + }; + } + function sendOptionsResponse(res, methods2) { + const options = /* @__PURE__ */ Object.create(null); + for (let i = 0; i < methods2.length; i++) { + options[methods2[i]] = true; + } + const allow = Object.keys(options).sort().join(", "); + res.setHeader("Allow", allow); + res.setHeader("Content-Length", Buffer.byteLength(allow)); + res.setHeader("Content-Type", "text/plain"); + res.setHeader("X-Content-Type-Options", "nosniff"); + res.end(allow); + } + function trySendOptionsResponse(res, methods2, next) { + try { + sendOptionsResponse(res, methods2); + } catch (err2) { + next(err2); + } + } + function wrap(old, fn) { + return function proxy() { + const args = new Array(arguments.length + 1); + args[0] = old; + for (let i = 0, len = arguments.length; i < len; i++) { + args[i + 1] = arguments[i]; + } + fn.apply(this, args); + }; + } + } +}); +var require_application = __commonJS2({ + "node_modules/express/lib/application.js"(exports2, module2) { + "use strict"; + var finalhandler = require_finalhandler(); + var debug = require_src()("express:application"); + var View = require_view(); + var http = require("node:http"); + var methods = require_utils3().methods; + var compileETag = require_utils3().compileETag; + var compileQueryParser = require_utils3().compileQueryParser; + var compileTrust = require_utils3().compileTrust; + var resolve = require("node:path").resolve; + var once = require_once(); + var Router = require_router(); + var slice = Array.prototype.slice; + var flatten = Array.prototype.flat; + var app = exports2 = module2.exports = {}; + var trustProxyDefaultSymbol = "@@symbol:trust_proxy_default"; + app.init = function init() { + var router = null; + this.cache = /* @__PURE__ */ Object.create(null); + this.engines = /* @__PURE__ */ Object.create(null); + this.settings = /* @__PURE__ */ Object.create(null); + this.defaultConfiguration(); + Object.defineProperty(this, "router", { + configurable: true, + enumerable: true, + get: function getrouter() { + if (router === null) { + router = new Router({ + caseSensitive: this.enabled("case sensitive routing"), + strict: this.enabled("strict routing") + }); + } + return router; + } + }); + }; + app.defaultConfiguration = function defaultConfiguration() { + var env2 = "development"; + this.enable("x-powered-by"); + this.set("etag", "weak"); + this.set("env", env2); + this.set("query parser", "simple"); + this.set("subdomain offset", 2); + this.set("trust proxy", false); + Object.defineProperty(this.settings, trustProxyDefaultSymbol, { + configurable: true, + value: true + }); + debug("booting in %s mode", env2); + this.on("mount", function onmount(parent) { + if (this.settings[trustProxyDefaultSymbol] === true && typeof parent.settings["trust proxy fn"] === "function") { + delete this.settings["trust proxy"]; + delete this.settings["trust proxy fn"]; + } + Object.setPrototypeOf(this.request, parent.request); + Object.setPrototypeOf(this.response, parent.response); + Object.setPrototypeOf(this.engines, parent.engines); + Object.setPrototypeOf(this.settings, parent.settings); + }); + this.locals = /* @__PURE__ */ Object.create(null); + this.mountpath = "/"; + this.locals.settings = this.settings; + this.set("view", View); + this.set("views", resolve("views")); + this.set("jsonp callback name", "callback"); + if (env2 === "production") { + this.enable("view cache"); + } + }; + app.handle = function handle(req, res, callback) { + var done = callback || finalhandler(req, res, { + env: this.get("env"), + onerror: logerror.bind(this) + }); + if (this.enabled("x-powered-by")) { + res.setHeader("X-Powered-By", "Express"); + } + req.res = res; + res.req = req; + Object.setPrototypeOf(req, this.request); + Object.setPrototypeOf(res, this.response); + if (!res.locals) { + res.locals = /* @__PURE__ */ Object.create(null); + } + this.router.handle(req, res, done); + }; + app.use = function use(fn) { + var offset = 0; + var path = "/"; + if (typeof fn !== "function") { + var arg = fn; + while (Array.isArray(arg) && arg.length !== 0) { + arg = arg[0]; + } + if (typeof arg !== "function") { + offset = 1; + path = fn; + } + } + var fns = flatten.call(slice.call(arguments, offset), Infinity); + if (fns.length === 0) { + throw new TypeError("app.use() requires a middleware function"); + } + var router = this.router; + fns.forEach(function(fn2) { + if (!fn2 || !fn2.handle || !fn2.set) { + return router.use(path, fn2); + } + debug(".use app under %s", path); + fn2.mountpath = path; + fn2.parent = this; + router.use(path, function mounted_app(req, res, next) { + var orig = req.app; + fn2.handle(req, res, function(err2) { + Object.setPrototypeOf(req, orig.request); + Object.setPrototypeOf(res, orig.response); + next(err2); + }); + }); + fn2.emit("mount", this); + }, this); + return this; + }; + app.route = function route(path) { + return this.router.route(path); + }; + app.engine = function engine(ext, fn) { + if (typeof fn !== "function") { + throw new Error("callback function required"); + } + var extension = ext[0] !== "." ? "." + ext : ext; + this.engines[extension] = fn; + return this; + }; + app.param = function param(name, fn) { + if (Array.isArray(name)) { + for (var i = 0; i < name.length; i++) { + this.param(name[i], fn); + } + return this; + } + this.router.param(name, fn); + return this; + }; + app.set = function set(setting, val) { + if (arguments.length === 1) { + return this.settings[setting]; + } + debug('set "%s" to %o', setting, val); + this.settings[setting] = val; + switch (setting) { + case "etag": + this.set("etag fn", compileETag(val)); + break; + case "query parser": + this.set("query parser fn", compileQueryParser(val)); + break; + case "trust proxy": + this.set("trust proxy fn", compileTrust(val)); + Object.defineProperty(this.settings, trustProxyDefaultSymbol, { + configurable: true, + value: false + }); + break; + } + return this; + }; + app.path = function path() { + return this.parent ? this.parent.path() + this.mountpath : ""; + }; + app.enabled = function enabled(setting) { + return Boolean(this.set(setting)); + }; + app.disabled = function disabled(setting) { + return !this.set(setting); + }; + app.enable = function enable(setting) { + return this.set(setting, true); + }; + app.disable = function disable(setting) { + return this.set(setting, false); + }; + methods.forEach(function(method) { + app[method] = function(path) { + if (method === "get" && arguments.length === 1) { + return this.set(path); + } + var route = this.route(path); + route[method].apply(route, slice.call(arguments, 1)); + return this; + }; + }); + app.all = function all(path) { + var route = this.route(path); + var args = slice.call(arguments, 1); + for (var i = 0; i < methods.length; i++) { + route[methods[i]].apply(route, args); + } + return this; + }; + app.render = function render(name, options, callback) { + var cache = this.cache; + var done = callback; + var engines = this.engines; + var opts = options; + var view; + if (typeof options === "function") { + done = options; + opts = {}; + } + var renderOptions = { ...this.locals, ...opts._locals, ...opts }; + if (renderOptions.cache == null) { + renderOptions.cache = this.enabled("view cache"); + } + if (renderOptions.cache) { + view = cache[name]; + } + if (!view) { + var View2 = this.get("view"); + view = new View2(name, { + defaultEngine: this.get("view engine"), + root: this.get("views"), + engines + }); + if (!view.path) { + var dirs = Array.isArray(view.root) && view.root.length > 1 ? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"' : 'directory "' + view.root + '"'; + var err2 = new Error('Failed to lookup view "' + name + '" in views ' + dirs); + err2.view = view; + return done(err2); + } + if (renderOptions.cache) { + cache[name] = view; + } + } + tryRender(view, renderOptions, done); + }; + app.listen = function listen() { + var server = http.createServer(this); + var args = Array.prototype.slice.call(arguments); + if (typeof args[args.length - 1] === "function") { + var done = args[args.length - 1] = once(args[args.length - 1]); + server.once("error", done); + } + return server.listen.apply(server, args); + }; + function logerror(err2) { + if (this.get("env") !== "test") console.error(err2.stack || err2.toString()); + } + function tryRender(view, options, callback) { + try { + view.render(options, callback); + } catch (err2) { + callback(err2); + } + } + } +}); +var require_charset = __commonJS2({ + "node_modules/negotiator/lib/charset.js"(exports2, module2) { + "use strict"; + module2.exports = preferredCharsets; + module2.exports.preferredCharsets = preferredCharsets; + var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/; + function parseAcceptCharset(accept) { + var accepts = accept.split(","); + for (var i = 0, j = 0; i < accepts.length; i++) { + var charset = parseCharset(accepts[i].trim(), i); + if (charset) { + accepts[j++] = charset; + } + } + accepts.length = j; + return accepts; + } + function parseCharset(str, i) { + var match = simpleCharsetRegExp.exec(str); + if (!match) return null; + var charset = match[1]; + var q = 1; + if (match[2]) { + var params = match[2].split(";"); + for (var j = 0; j < params.length; j++) { + var p = params[j].trim().split("="); + if (p[0] === "q") { + q = parseFloat(p[1]); + break; + } + } + } + return { + charset, + q, + i + }; + } + function getCharsetPriority(charset, accepted, index) { + var priority = { o: -1, q: 0, s: 0 }; + for (var i = 0; i < accepted.length; i++) { + var spec = specify(charset, accepted[i], index); + if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) { + priority = spec; + } + } + return priority; + } + function specify(charset, spec, index) { + var s = 0; + if (spec.charset.toLowerCase() === charset.toLowerCase()) { + s |= 1; + } else if (spec.charset !== "*") { + return null; + } + return { + i: index, + o: spec.i, + q: spec.q, + s + }; + } + function preferredCharsets(accept, provided) { + var accepts = parseAcceptCharset(accept === void 0 ? "*" : accept || ""); + if (!provided) { + return accepts.filter(isQuality).sort(compareSpecs).map(getFullCharset); + } + var priorities = provided.map(function getPriority(type, index) { + return getCharsetPriority(type, accepts, index); + }); + return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(priority) { + return provided[priorities.indexOf(priority)]; + }); + } + function compareSpecs(a, b) { + return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0; + } + function getFullCharset(spec) { + return spec.charset; + } + function isQuality(spec) { + return spec.q > 0; + } + } +}); +var require_encoding = __commonJS2({ + "node_modules/negotiator/lib/encoding.js"(exports2, module2) { + "use strict"; + module2.exports = preferredEncodings; + module2.exports.preferredEncodings = preferredEncodings; + var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/; + function parseAcceptEncoding(accept) { + var accepts = accept.split(","); + var hasIdentity = false; + var minQuality = 1; + for (var i = 0, j = 0; i < accepts.length; i++) { + var encoding = parseEncoding(accepts[i].trim(), i); + if (encoding) { + accepts[j++] = encoding; + hasIdentity = hasIdentity || specify("identity", encoding); + minQuality = Math.min(minQuality, encoding.q || 1); + } + } + if (!hasIdentity) { + accepts[j++] = { + encoding: "identity", + q: minQuality, + i + }; + } + accepts.length = j; + return accepts; + } + function parseEncoding(str, i) { + var match = simpleEncodingRegExp.exec(str); + if (!match) return null; + var encoding = match[1]; + var q = 1; + if (match[2]) { + var params = match[2].split(";"); + for (var j = 0; j < params.length; j++) { + var p = params[j].trim().split("="); + if (p[0] === "q") { + q = parseFloat(p[1]); + break; + } + } + } + return { + encoding, + q, + i + }; + } + function getEncodingPriority(encoding, accepted, index) { + var priority = { encoding, o: -1, q: 0, s: 0 }; + for (var i = 0; i < accepted.length; i++) { + var spec = specify(encoding, accepted[i], index); + if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) { + priority = spec; + } + } + return priority; + } + function specify(encoding, spec, index) { + var s = 0; + if (spec.encoding.toLowerCase() === encoding.toLowerCase()) { + s |= 1; + } else if (spec.encoding !== "*") { + return null; + } + return { + encoding, + i: index, + o: spec.i, + q: spec.q, + s + }; + } + function preferredEncodings(accept, provided, preferred) { + var accepts = parseAcceptEncoding(accept || ""); + var comparator = preferred ? function comparator2(a, b) { + if (a.q !== b.q) { + return b.q - a.q; + } + var aPreferred = preferred.indexOf(a.encoding); + var bPreferred = preferred.indexOf(b.encoding); + if (aPreferred === -1 && bPreferred === -1) { + return b.s - a.s || a.o - b.o || a.i - b.i; + } + if (aPreferred !== -1 && bPreferred !== -1) { + return aPreferred - bPreferred; + } + return aPreferred === -1 ? 1 : -1; + } : compareSpecs; + if (!provided) { + return accepts.filter(isQuality).sort(comparator).map(getFullEncoding); + } + var priorities = provided.map(function getPriority(type, index) { + return getEncodingPriority(type, accepts, index); + }); + return priorities.filter(isQuality).sort(comparator).map(function getEncoding(priority) { + return provided[priorities.indexOf(priority)]; + }); + } + function compareSpecs(a, b) { + return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i; + } + function getFullEncoding(spec) { + return spec.encoding; + } + function isQuality(spec) { + return spec.q > 0; + } + } +}); +var require_language = __commonJS2({ + "node_modules/negotiator/lib/language.js"(exports2, module2) { + "use strict"; + module2.exports = preferredLanguages; + module2.exports.preferredLanguages = preferredLanguages; + var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/; + function parseAcceptLanguage(accept) { + var accepts = accept.split(","); + for (var i = 0, j = 0; i < accepts.length; i++) { + var language = parseLanguage(accepts[i].trim(), i); + if (language) { + accepts[j++] = language; + } + } + accepts.length = j; + return accepts; + } + function parseLanguage(str, i) { + var match = simpleLanguageRegExp.exec(str); + if (!match) return null; + var prefix = match[1]; + var suffix = match[2]; + var full = prefix; + if (suffix) full += "-" + suffix; + var q = 1; + if (match[3]) { + var params = match[3].split(";"); + for (var j = 0; j < params.length; j++) { + var p = params[j].split("="); + if (p[0] === "q") q = parseFloat(p[1]); + } + } + return { + prefix, + suffix, + q, + i, + full + }; + } + function getLanguagePriority(language, accepted, index) { + var priority = { o: -1, q: 0, s: 0 }; + for (var i = 0; i < accepted.length; i++) { + var spec = specify(language, accepted[i], index); + if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) { + priority = spec; + } + } + return priority; + } + function specify(language, spec, index) { + var p = parseLanguage(language); + if (!p) return null; + var s = 0; + if (spec.full.toLowerCase() === p.full.toLowerCase()) { + s |= 4; + } else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) { + s |= 2; + } else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) { + s |= 1; + } else if (spec.full !== "*") { + return null; + } + return { + i: index, + o: spec.i, + q: spec.q, + s + }; + } + function preferredLanguages(accept, provided) { + var accepts = parseAcceptLanguage(accept === void 0 ? "*" : accept || ""); + if (!provided) { + return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage); + } + var priorities = provided.map(function getPriority(type, index) { + return getLanguagePriority(type, accepts, index); + }); + return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) { + return provided[priorities.indexOf(priority)]; + }); + } + function compareSpecs(a, b) { + return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0; + } + function getFullLanguage(spec) { + return spec.full; + } + function isQuality(spec) { + return spec.q > 0; + } + } +}); +var require_mediaType = __commonJS2({ + "node_modules/negotiator/lib/mediaType.js"(exports2, module2) { + "use strict"; + module2.exports = preferredMediaTypes; + module2.exports.preferredMediaTypes = preferredMediaTypes; + var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/; + function parseAccept(accept) { + var accepts = splitMediaTypes(accept); + for (var i = 0, j = 0; i < accepts.length; i++) { + var mediaType = parseMediaType(accepts[i].trim(), i); + if (mediaType) { + accepts[j++] = mediaType; + } + } + accepts.length = j; + return accepts; + } + function parseMediaType(str, i) { + var match = simpleMediaTypeRegExp.exec(str); + if (!match) return null; + var params = /* @__PURE__ */ Object.create(null); + var q = 1; + var subtype = match[2]; + var type = match[1]; + if (match[3]) { + var kvps = splitParameters(match[3]).map(splitKeyValuePair); + for (var j = 0; j < kvps.length; j++) { + var pair = kvps[j]; + var key = pair[0].toLowerCase(); + var val = pair[1]; + var value = val && val[0] === '"' && val[val.length - 1] === '"' ? val.slice(1, -1) : val; + if (key === "q") { + q = parseFloat(value); + break; + } + params[key] = value; + } + } + return { + type, + subtype, + params, + q, + i + }; + } + function getMediaTypePriority(type, accepted, index) { + var priority = { o: -1, q: 0, s: 0 }; + for (var i = 0; i < accepted.length; i++) { + var spec = specify(type, accepted[i], index); + if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) { + priority = spec; + } + } + return priority; + } + function specify(type, spec, index) { + var p = parseMediaType(type); + var s = 0; + if (!p) { + return null; + } + if (spec.type.toLowerCase() == p.type.toLowerCase()) { + s |= 4; + } else if (spec.type != "*") { + return null; + } + if (spec.subtype.toLowerCase() == p.subtype.toLowerCase()) { + s |= 2; + } else if (spec.subtype != "*") { + return null; + } + var keys = Object.keys(spec.params); + if (keys.length > 0) { + if (keys.every(function(k) { + return spec.params[k] == "*" || (spec.params[k] || "").toLowerCase() == (p.params[k] || "").toLowerCase(); + })) { + s |= 1; + } else { + return null; + } + } + return { + i: index, + o: spec.i, + q: spec.q, + s + }; + } + function preferredMediaTypes(accept, provided) { + var accepts = parseAccept(accept === void 0 ? "*/*" : accept || ""); + if (!provided) { + return accepts.filter(isQuality).sort(compareSpecs).map(getFullType); + } + var priorities = provided.map(function getPriority(type, index) { + return getMediaTypePriority(type, accepts, index); + }); + return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) { + return provided[priorities.indexOf(priority)]; + }); + } + function compareSpecs(a, b) { + return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0; + } + function getFullType(spec) { + return spec.type + "/" + spec.subtype; + } + function isQuality(spec) { + return spec.q > 0; + } + function quoteCount(string) { + var count = 0; + var index = 0; + while ((index = string.indexOf('"', index)) !== -1) { + count++; + index++; + } + return count; + } + function splitKeyValuePair(str) { + var index = str.indexOf("="); + var key; + var val; + if (index === -1) { + key = str; + } else { + key = str.slice(0, index); + val = str.slice(index + 1); + } + return [key, val]; + } + function splitMediaTypes(accept) { + var accepts = accept.split(","); + for (var i = 1, j = 0; i < accepts.length; i++) { + if (quoteCount(accepts[j]) % 2 == 0) { + accepts[++j] = accepts[i]; + } else { + accepts[j] += "," + accepts[i]; + } + } + accepts.length = j + 1; + return accepts; + } + function splitParameters(str) { + var parameters = str.split(";"); + for (var i = 1, j = 0; i < parameters.length; i++) { + if (quoteCount(parameters[j]) % 2 == 0) { + parameters[++j] = parameters[i]; + } else { + parameters[j] += ";" + parameters[i]; + } + } + parameters.length = j + 1; + for (var i = 0; i < parameters.length; i++) { + parameters[i] = parameters[i].trim(); + } + return parameters; + } + } +}); +var require_negotiator = __commonJS2({ + "node_modules/negotiator/index.js"(exports2, module2) { + "use strict"; + var preferredCharsets = require_charset(); + var preferredEncodings = require_encoding(); + var preferredLanguages = require_language(); + var preferredMediaTypes = require_mediaType(); + module2.exports = Negotiator; + module2.exports.Negotiator = Negotiator; + function Negotiator(request) { + if (!(this instanceof Negotiator)) { + return new Negotiator(request); + } + this.request = request; + } + Negotiator.prototype.charset = function charset(available) { + var set = this.charsets(available); + return set && set[0]; + }; + Negotiator.prototype.charsets = function charsets(available) { + return preferredCharsets(this.request.headers["accept-charset"], available); + }; + Negotiator.prototype.encoding = function encoding(available, opts) { + var set = this.encodings(available, opts); + return set && set[0]; + }; + Negotiator.prototype.encodings = function encodings(available, options) { + var opts = options || {}; + return preferredEncodings(this.request.headers["accept-encoding"], available, opts.preferred); + }; + Negotiator.prototype.language = function language(available) { + var set = this.languages(available); + return set && set[0]; + }; + Negotiator.prototype.languages = function languages(available) { + return preferredLanguages(this.request.headers["accept-language"], available); + }; + Negotiator.prototype.mediaType = function mediaType(available) { + var set = this.mediaTypes(available); + return set && set[0]; + }; + Negotiator.prototype.mediaTypes = function mediaTypes(available) { + return preferredMediaTypes(this.request.headers.accept, available); + }; + Negotiator.prototype.preferredCharset = Negotiator.prototype.charset; + Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets; + Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding; + Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings; + Negotiator.prototype.preferredLanguage = Negotiator.prototype.language; + Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages; + Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType; + Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes; + } +}); +var require_db3 = __commonJS2({ + "node_modules/accepts/node_modules/mime-db/db.json"(exports2, module2) { + module2.exports = { + "application/1d-interleaved-parityfec": { + source: "iana" + }, + "application/3gpdash-qoe-report+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/3gpp-ims+xml": { + source: "iana", + compressible: true + }, + "application/3gpphal+json": { + source: "iana", + compressible: true + }, + "application/3gpphalforms+json": { + source: "iana", + compressible: true + }, + "application/a2l": { + source: "iana" + }, + "application/ace+cbor": { + source: "iana" + }, + "application/ace+json": { + source: "iana", + compressible: true + }, + "application/ace-groupcomm+cbor": { + source: "iana" + }, + "application/ace-trl+cbor": { + source: "iana" + }, + "application/activemessage": { + source: "iana" + }, + "application/activity+json": { + source: "iana", + compressible: true + }, + "application/aif+cbor": { + source: "iana" + }, + "application/aif+json": { + source: "iana", + compressible: true + }, + "application/alto-cdni+json": { + source: "iana", + compressible: true + }, + "application/alto-cdnifilter+json": { + source: "iana", + compressible: true + }, + "application/alto-costmap+json": { + source: "iana", + compressible: true + }, + "application/alto-costmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-directory+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcost+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcostparams+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointprop+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointpropparams+json": { + source: "iana", + compressible: true + }, + "application/alto-error+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmap+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-propmap+json": { + source: "iana", + compressible: true + }, + "application/alto-propmapparams+json": { + source: "iana", + compressible: true + }, + "application/alto-tips+json": { + source: "iana", + compressible: true + }, + "application/alto-tipsparams+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamcontrol+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamparams+json": { + source: "iana", + compressible: true + }, + "application/aml": { + source: "iana" + }, + "application/andrew-inset": { + source: "iana", + extensions: ["ez"] + }, + "application/appinstaller": { + compressible: false, + extensions: ["appinstaller"] + }, + "application/applefile": { + source: "iana" + }, + "application/applixware": { + source: "apache", + extensions: ["aw"] + }, + "application/appx": { + compressible: false, + extensions: ["appx"] + }, + "application/appxbundle": { + compressible: false, + extensions: ["appxbundle"] + }, + "application/at+jwt": { + source: "iana" + }, + "application/atf": { + source: "iana" + }, + "application/atfx": { + source: "iana" + }, + "application/atom+xml": { + source: "iana", + compressible: true, + extensions: ["atom"] + }, + "application/atomcat+xml": { + source: "iana", + compressible: true, + extensions: ["atomcat"] + }, + "application/atomdeleted+xml": { + source: "iana", + compressible: true, + extensions: ["atomdeleted"] + }, + "application/atomicmail": { + source: "iana" + }, + "application/atomsvc+xml": { + source: "iana", + compressible: true, + extensions: ["atomsvc"] + }, + "application/atsc-dwd+xml": { + source: "iana", + compressible: true, + extensions: ["dwd"] + }, + "application/atsc-dynamic-event-message": { + source: "iana" + }, + "application/atsc-held+xml": { + source: "iana", + compressible: true, + extensions: ["held"] + }, + "application/atsc-rdt+json": { + source: "iana", + compressible: true + }, + "application/atsc-rsat+xml": { + source: "iana", + compressible: true, + extensions: ["rsat"] + }, + "application/atxml": { + source: "iana" + }, + "application/auth-policy+xml": { + source: "iana", + compressible: true + }, + "application/automationml-aml+xml": { + source: "iana", + compressible: true, + extensions: ["aml"] + }, + "application/automationml-amlx+zip": { + source: "iana", + compressible: false, + extensions: ["amlx"] + }, + "application/bacnet-xdd+zip": { + source: "iana", + compressible: false + }, + "application/batch-smtp": { + source: "iana" + }, + "application/bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/beep+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/bufr": { + source: "iana" + }, + "application/c2pa": { + source: "iana" + }, + "application/calendar+json": { + source: "iana", + compressible: true + }, + "application/calendar+xml": { + source: "iana", + compressible: true, + extensions: ["xcs"] + }, + "application/call-completion": { + source: "iana" + }, + "application/cals-1840": { + source: "iana" + }, + "application/captive+json": { + source: "iana", + compressible: true + }, + "application/cbor": { + source: "iana" + }, + "application/cbor-seq": { + source: "iana" + }, + "application/cccex": { + source: "iana" + }, + "application/ccmp+xml": { + source: "iana", + compressible: true + }, + "application/ccxml+xml": { + source: "iana", + compressible: true, + extensions: ["ccxml"] + }, + "application/cda+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/cdfx+xml": { + source: "iana", + compressible: true, + extensions: ["cdfx"] + }, + "application/cdmi-capability": { + source: "iana", + extensions: ["cdmia"] + }, + "application/cdmi-container": { + source: "iana", + extensions: ["cdmic"] + }, + "application/cdmi-domain": { + source: "iana", + extensions: ["cdmid"] + }, + "application/cdmi-object": { + source: "iana", + extensions: ["cdmio"] + }, + "application/cdmi-queue": { + source: "iana", + extensions: ["cdmiq"] + }, + "application/cdni": { + source: "iana" + }, + "application/ce+cbor": { + source: "iana" + }, + "application/cea": { + source: "iana" + }, + "application/cea-2018+xml": { + source: "iana", + compressible: true + }, + "application/cellml+xml": { + source: "iana", + compressible: true + }, + "application/cfw": { + source: "iana" + }, + "application/cid-edhoc+cbor-seq": { + source: "iana" + }, + "application/city+json": { + source: "iana", + compressible: true + }, + "application/city+json-seq": { + source: "iana" + }, + "application/clr": { + source: "iana" + }, + "application/clue+xml": { + source: "iana", + compressible: true + }, + "application/clue_info+xml": { + source: "iana", + compressible: true + }, + "application/cms": { + source: "iana" + }, + "application/cnrp+xml": { + source: "iana", + compressible: true + }, + "application/coap-eap": { + source: "iana" + }, + "application/coap-group+json": { + source: "iana", + compressible: true + }, + "application/coap-payload": { + source: "iana" + }, + "application/commonground": { + source: "iana" + }, + "application/concise-problem-details+cbor": { + source: "iana" + }, + "application/conference-info+xml": { + source: "iana", + compressible: true + }, + "application/cose": { + source: "iana" + }, + "application/cose-key": { + source: "iana" + }, + "application/cose-key-set": { + source: "iana" + }, + "application/cose-x509": { + source: "iana" + }, + "application/cpl+xml": { + source: "iana", + compressible: true, + extensions: ["cpl"] + }, + "application/csrattrs": { + source: "iana" + }, + "application/csta+xml": { + source: "iana", + compressible: true + }, + "application/cstadata+xml": { + source: "iana", + compressible: true + }, + "application/csvm+json": { + source: "iana", + compressible: true + }, + "application/cu-seeme": { + source: "apache", + extensions: ["cu"] + }, + "application/cwl": { + source: "iana", + extensions: ["cwl"] + }, + "application/cwl+json": { + source: "iana", + compressible: true + }, + "application/cwl+yaml": { + source: "iana" + }, + "application/cwt": { + source: "iana" + }, + "application/cybercash": { + source: "iana" + }, + "application/dart": { + compressible: true + }, + "application/dash+xml": { + source: "iana", + compressible: true, + extensions: ["mpd"] + }, + "application/dash-patch+xml": { + source: "iana", + compressible: true, + extensions: ["mpp"] + }, + "application/dashdelta": { + source: "iana" + }, + "application/davmount+xml": { + source: "iana", + compressible: true, + extensions: ["davmount"] + }, + "application/dca-rft": { + source: "iana" + }, + "application/dcd": { + source: "iana" + }, + "application/dec-dx": { + source: "iana" + }, + "application/dialog-info+xml": { + source: "iana", + compressible: true + }, + "application/dicom": { + source: "iana", + extensions: ["dcm"] + }, + "application/dicom+json": { + source: "iana", + compressible: true + }, + "application/dicom+xml": { + source: "iana", + compressible: true + }, + "application/dii": { + source: "iana" + }, + "application/dit": { + source: "iana" + }, + "application/dns": { + source: "iana" + }, + "application/dns+json": { + source: "iana", + compressible: true + }, + "application/dns-message": { + source: "iana" + }, + "application/docbook+xml": { + source: "apache", + compressible: true, + extensions: ["dbk"] + }, + "application/dots+cbor": { + source: "iana" + }, + "application/dpop+jwt": { + source: "iana" + }, + "application/dskpp+xml": { + source: "iana", + compressible: true + }, + "application/dssc+der": { + source: "iana", + extensions: ["dssc"] + }, + "application/dssc+xml": { + source: "iana", + compressible: true, + extensions: ["xdssc"] + }, + "application/dvcs": { + source: "iana" + }, + "application/eat+cwt": { + source: "iana" + }, + "application/eat+jwt": { + source: "iana" + }, + "application/eat-bun+cbor": { + source: "iana" + }, + "application/eat-bun+json": { + source: "iana", + compressible: true + }, + "application/eat-ucs+cbor": { + source: "iana" + }, + "application/eat-ucs+json": { + source: "iana", + compressible: true + }, + "application/ecmascript": { + source: "apache", + compressible: true, + extensions: ["ecma"] + }, + "application/edhoc+cbor-seq": { + source: "iana" + }, + "application/edi-consent": { + source: "iana" + }, + "application/edi-x12": { + source: "iana", + compressible: false + }, + "application/edifact": { + source: "iana", + compressible: false + }, + "application/efi": { + source: "iana" + }, + "application/elm+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/elm+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.cap+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/emergencycalldata.comment+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.control+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.deviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.ecall.msd": { + source: "iana" + }, + "application/emergencycalldata.legacyesn+json": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.providerinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.serviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.subscriberinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.veds+xml": { + source: "iana", + compressible: true + }, + "application/emma+xml": { + source: "iana", + compressible: true, + extensions: ["emma"] + }, + "application/emotionml+xml": { + source: "iana", + compressible: true, + extensions: ["emotionml"] + }, + "application/encaprtp": { + source: "iana" + }, + "application/entity-statement+jwt": { + source: "iana" + }, + "application/epp+xml": { + source: "iana", + compressible: true + }, + "application/epub+zip": { + source: "iana", + compressible: false, + extensions: ["epub"] + }, + "application/eshop": { + source: "iana" + }, + "application/exi": { + source: "iana", + extensions: ["exi"] + }, + "application/expect-ct-report+json": { + source: "iana", + compressible: true + }, + "application/express": { + source: "iana", + extensions: ["exp"] + }, + "application/fastinfoset": { + source: "iana" + }, + "application/fastsoap": { + source: "iana" + }, + "application/fdf": { + source: "iana", + extensions: ["fdf"] + }, + "application/fdt+xml": { + source: "iana", + compressible: true, + extensions: ["fdt"] + }, + "application/fhir+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fhir+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fido.trusted-apps+json": { + compressible: true + }, + "application/fits": { + source: "iana" + }, + "application/flexfec": { + source: "iana" + }, + "application/font-sfnt": { + source: "iana" + }, + "application/font-tdpfr": { + source: "iana", + extensions: ["pfr"] + }, + "application/font-woff": { + source: "iana", + compressible: false + }, + "application/framework-attributes+xml": { + source: "iana", + compressible: true + }, + "application/geo+json": { + source: "iana", + compressible: true, + extensions: ["geojson"] + }, + "application/geo+json-seq": { + source: "iana" + }, + "application/geopackage+sqlite3": { + source: "iana" + }, + "application/geopose+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+xml": { + source: "iana", + compressible: true + }, + "application/gltf-buffer": { + source: "iana" + }, + "application/gml+xml": { + source: "iana", + compressible: true, + extensions: ["gml"] + }, + "application/gnap-binding-jws": { + source: "iana" + }, + "application/gnap-binding-jwsd": { + source: "iana" + }, + "application/gnap-binding-rotation-jws": { + source: "iana" + }, + "application/gnap-binding-rotation-jwsd": { + source: "iana" + }, + "application/gpx+xml": { + source: "apache", + compressible: true, + extensions: ["gpx"] + }, + "application/grib": { + source: "iana" + }, + "application/gxf": { + source: "apache", + extensions: ["gxf"] + }, + "application/gzip": { + source: "iana", + compressible: false, + extensions: ["gz"] + }, + "application/h224": { + source: "iana" + }, + "application/held+xml": { + source: "iana", + compressible: true + }, + "application/hjson": { + extensions: ["hjson"] + }, + "application/hl7v2+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/http": { + source: "iana" + }, + "application/hyperstudio": { + source: "iana", + extensions: ["stk"] + }, + "application/ibe-key-request+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pkg-reply+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pp-data": { + source: "iana" + }, + "application/iges": { + source: "iana" + }, + "application/im-iscomposing+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/index": { + source: "iana" + }, + "application/index.cmd": { + source: "iana" + }, + "application/index.obj": { + source: "iana" + }, + "application/index.response": { + source: "iana" + }, + "application/index.vnd": { + source: "iana" + }, + "application/inkml+xml": { + source: "iana", + compressible: true, + extensions: ["ink", "inkml"] + }, + "application/iotp": { + source: "iana" + }, + "application/ipfix": { + source: "iana", + extensions: ["ipfix"] + }, + "application/ipp": { + source: "iana" + }, + "application/isup": { + source: "iana" + }, + "application/its+xml": { + source: "iana", + compressible: true, + extensions: ["its"] + }, + "application/java-archive": { + source: "iana", + compressible: false, + extensions: ["jar", "war", "ear"] + }, + "application/java-serialized-object": { + source: "apache", + compressible: false, + extensions: ["ser"] + }, + "application/java-vm": { + source: "apache", + compressible: false, + extensions: ["class"] + }, + "application/javascript": { + source: "apache", + charset: "UTF-8", + compressible: true, + extensions: ["js"] + }, + "application/jf2feed+json": { + source: "iana", + compressible: true + }, + "application/jose": { + source: "iana" + }, + "application/jose+json": { + source: "iana", + compressible: true + }, + "application/jrd+json": { + source: "iana", + compressible: true + }, + "application/jscalendar+json": { + source: "iana", + compressible: true + }, + "application/jscontact+json": { + source: "iana", + compressible: true + }, + "application/json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["json", "map"] + }, + "application/json-patch+json": { + source: "iana", + compressible: true + }, + "application/json-seq": { + source: "iana" + }, + "application/json5": { + extensions: ["json5"] + }, + "application/jsonml+json": { + source: "apache", + compressible: true, + extensions: ["jsonml"] + }, + "application/jsonpath": { + source: "iana" + }, + "application/jwk+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+jwt": { + source: "iana" + }, + "application/jwt": { + source: "iana" + }, + "application/kpml-request+xml": { + source: "iana", + compressible: true + }, + "application/kpml-response+xml": { + source: "iana", + compressible: true + }, + "application/ld+json": { + source: "iana", + compressible: true, + extensions: ["jsonld"] + }, + "application/lgr+xml": { + source: "iana", + compressible: true, + extensions: ["lgr"] + }, + "application/link-format": { + source: "iana" + }, + "application/linkset": { + source: "iana" + }, + "application/linkset+json": { + source: "iana", + compressible: true + }, + "application/load-control+xml": { + source: "iana", + compressible: true + }, + "application/logout+jwt": { + source: "iana" + }, + "application/lost+xml": { + source: "iana", + compressible: true, + extensions: ["lostxml"] + }, + "application/lostsync+xml": { + source: "iana", + compressible: true + }, + "application/lpf+zip": { + source: "iana", + compressible: false + }, + "application/lxf": { + source: "iana" + }, + "application/mac-binhex40": { + source: "iana", + extensions: ["hqx"] + }, + "application/mac-compactpro": { + source: "apache", + extensions: ["cpt"] + }, + "application/macwriteii": { + source: "iana" + }, + "application/mads+xml": { + source: "iana", + compressible: true, + extensions: ["mads"] + }, + "application/manifest+json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["webmanifest"] + }, + "application/marc": { + source: "iana", + extensions: ["mrc"] + }, + "application/marcxml+xml": { + source: "iana", + compressible: true, + extensions: ["mrcx"] + }, + "application/mathematica": { + source: "iana", + extensions: ["ma", "nb", "mb"] + }, + "application/mathml+xml": { + source: "iana", + compressible: true, + extensions: ["mathml"] + }, + "application/mathml-content+xml": { + source: "iana", + compressible: true + }, + "application/mathml-presentation+xml": { + source: "iana", + compressible: true + }, + "application/mbms-associated-procedure-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-deregister+xml": { + source: "iana", + compressible: true + }, + "application/mbms-envelope+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-protection-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-reception-report+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-schedule+xml": { + source: "iana", + compressible: true + }, + "application/mbms-user-service-description+xml": { + source: "iana", + compressible: true + }, + "application/mbox": { + source: "iana", + extensions: ["mbox"] + }, + "application/media-policy-dataset+xml": { + source: "iana", + compressible: true, + extensions: ["mpf"] + }, + "application/media_control+xml": { + source: "iana", + compressible: true + }, + "application/mediaservercontrol+xml": { + source: "iana", + compressible: true, + extensions: ["mscml"] + }, + "application/merge-patch+json": { + source: "iana", + compressible: true + }, + "application/metalink+xml": { + source: "apache", + compressible: true, + extensions: ["metalink"] + }, + "application/metalink4+xml": { + source: "iana", + compressible: true, + extensions: ["meta4"] + }, + "application/mets+xml": { + source: "iana", + compressible: true, + extensions: ["mets"] + }, + "application/mf4": { + source: "iana" + }, + "application/mikey": { + source: "iana" + }, + "application/mipc": { + source: "iana" + }, + "application/missing-blocks+cbor-seq": { + source: "iana" + }, + "application/mmt-aei+xml": { + source: "iana", + compressible: true, + extensions: ["maei"] + }, + "application/mmt-usd+xml": { + source: "iana", + compressible: true, + extensions: ["musd"] + }, + "application/mods+xml": { + source: "iana", + compressible: true, + extensions: ["mods"] + }, + "application/moss-keys": { + source: "iana" + }, + "application/moss-signature": { + source: "iana" + }, + "application/mosskey-data": { + source: "iana" + }, + "application/mosskey-request": { + source: "iana" + }, + "application/mp21": { + source: "iana", + extensions: ["m21", "mp21"] + }, + "application/mp4": { + source: "iana", + extensions: ["mp4", "mpg4", "mp4s", "m4p"] + }, + "application/mpeg4-generic": { + source: "iana" + }, + "application/mpeg4-iod": { + source: "iana" + }, + "application/mpeg4-iod-xmt": { + source: "iana" + }, + "application/mrb-consumer+xml": { + source: "iana", + compressible: true + }, + "application/mrb-publish+xml": { + source: "iana", + compressible: true + }, + "application/msc-ivr+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msc-mixer+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msix": { + compressible: false, + extensions: ["msix"] + }, + "application/msixbundle": { + compressible: false, + extensions: ["msixbundle"] + }, + "application/msword": { + source: "iana", + compressible: false, + extensions: ["doc", "dot"] + }, + "application/mud+json": { + source: "iana", + compressible: true + }, + "application/multipart-core": { + source: "iana" + }, + "application/mxf": { + source: "iana", + extensions: ["mxf"] + }, + "application/n-quads": { + source: "iana", + extensions: ["nq"] + }, + "application/n-triples": { + source: "iana", + extensions: ["nt"] + }, + "application/nasdata": { + source: "iana" + }, + "application/news-checkgroups": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-groupinfo": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-transmission": { + source: "iana" + }, + "application/nlsml+xml": { + source: "iana", + compressible: true + }, + "application/node": { + source: "iana", + extensions: ["cjs"] + }, + "application/nss": { + source: "iana" + }, + "application/oauth-authz-req+jwt": { + source: "iana" + }, + "application/oblivious-dns-message": { + source: "iana" + }, + "application/ocsp-request": { + source: "iana" + }, + "application/ocsp-response": { + source: "iana" + }, + "application/octet-stream": { + source: "iana", + compressible: true, + extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] + }, + "application/oda": { + source: "iana", + extensions: ["oda"] + }, + "application/odm+xml": { + source: "iana", + compressible: true + }, + "application/odx": { + source: "iana" + }, + "application/oebps-package+xml": { + source: "iana", + compressible: true, + extensions: ["opf"] + }, + "application/ogg": { + source: "iana", + compressible: false, + extensions: ["ogx"] + }, + "application/ohttp-keys": { + source: "iana" + }, + "application/omdoc+xml": { + source: "apache", + compressible: true, + extensions: ["omdoc"] + }, + "application/onenote": { + source: "apache", + extensions: ["onetoc", "onetoc2", "onetmp", "onepkg", "one", "onea"] + }, + "application/opc-nodeset+xml": { + source: "iana", + compressible: true + }, + "application/oscore": { + source: "iana" + }, + "application/oxps": { + source: "iana", + extensions: ["oxps"] + }, + "application/p21": { + source: "iana" + }, + "application/p21+zip": { + source: "iana", + compressible: false + }, + "application/p2p-overlay+xml": { + source: "iana", + compressible: true, + extensions: ["relo"] + }, + "application/parityfec": { + source: "iana" + }, + "application/passport": { + source: "iana" + }, + "application/patch-ops-error+xml": { + source: "iana", + compressible: true, + extensions: ["xer"] + }, + "application/pdf": { + source: "iana", + compressible: false, + extensions: ["pdf"] + }, + "application/pdx": { + source: "iana" + }, + "application/pem-certificate-chain": { + source: "iana" + }, + "application/pgp-encrypted": { + source: "iana", + compressible: false, + extensions: ["pgp"] + }, + "application/pgp-keys": { + source: "iana", + extensions: ["asc"] + }, + "application/pgp-signature": { + source: "iana", + extensions: ["sig", "asc"] + }, + "application/pics-rules": { + source: "apache", + extensions: ["prf"] + }, + "application/pidf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pidf-diff+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pkcs10": { + source: "iana", + extensions: ["p10"] + }, + "application/pkcs12": { + source: "iana" + }, + "application/pkcs7-mime": { + source: "iana", + extensions: ["p7m", "p7c"] + }, + "application/pkcs7-signature": { + source: "iana", + extensions: ["p7s"] + }, + "application/pkcs8": { + source: "iana", + extensions: ["p8"] + }, + "application/pkcs8-encrypted": { + source: "iana" + }, + "application/pkix-attr-cert": { + source: "iana", + extensions: ["ac"] + }, + "application/pkix-cert": { + source: "iana", + extensions: ["cer"] + }, + "application/pkix-crl": { + source: "iana", + extensions: ["crl"] + }, + "application/pkix-pkipath": { + source: "iana", + extensions: ["pkipath"] + }, + "application/pkixcmp": { + source: "iana", + extensions: ["pki"] + }, + "application/pls+xml": { + source: "iana", + compressible: true, + extensions: ["pls"] + }, + "application/poc-settings+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/postscript": { + source: "iana", + compressible: true, + extensions: ["ai", "eps", "ps"] + }, + "application/ppsp-tracker+json": { + source: "iana", + compressible: true + }, + "application/private-token-issuer-directory": { + source: "iana" + }, + "application/private-token-request": { + source: "iana" + }, + "application/private-token-response": { + source: "iana" + }, + "application/problem+json": { + source: "iana", + compressible: true + }, + "application/problem+xml": { + source: "iana", + compressible: true + }, + "application/provenance+xml": { + source: "iana", + compressible: true, + extensions: ["provx"] + }, + "application/provided-claims+jwt": { + source: "iana" + }, + "application/prs.alvestrand.titrax-sheet": { + source: "iana" + }, + "application/prs.cww": { + source: "iana", + extensions: ["cww"] + }, + "application/prs.cyn": { + source: "iana", + charset: "7-BIT" + }, + "application/prs.hpub+zip": { + source: "iana", + compressible: false + }, + "application/prs.implied-document+xml": { + source: "iana", + compressible: true + }, + "application/prs.implied-executable": { + source: "iana" + }, + "application/prs.implied-object+json": { + source: "iana", + compressible: true + }, + "application/prs.implied-object+json-seq": { + source: "iana" + }, + "application/prs.implied-object+yaml": { + source: "iana" + }, + "application/prs.implied-structure": { + source: "iana" + }, + "application/prs.mayfile": { + source: "iana" + }, + "application/prs.nprend": { + source: "iana" + }, + "application/prs.plucker": { + source: "iana" + }, + "application/prs.rdf-xml-crypt": { + source: "iana" + }, + "application/prs.vcfbzip2": { + source: "iana" + }, + "application/prs.xsf+xml": { + source: "iana", + compressible: true, + extensions: ["xsf"] + }, + "application/pskc+xml": { + source: "iana", + compressible: true, + extensions: ["pskcxml"] + }, + "application/pvd+json": { + source: "iana", + compressible: true + }, + "application/qsig": { + source: "iana" + }, + "application/raml+yaml": { + compressible: true, + extensions: ["raml"] + }, + "application/raptorfec": { + source: "iana" + }, + "application/rdap+json": { + source: "iana", + compressible: true + }, + "application/rdf+xml": { + source: "iana", + compressible: true, + extensions: ["rdf", "owl"] + }, + "application/reginfo+xml": { + source: "iana", + compressible: true, + extensions: ["rif"] + }, + "application/relax-ng-compact-syntax": { + source: "iana", + extensions: ["rnc"] + }, + "application/remote-printing": { + source: "apache" + }, + "application/reputon+json": { + source: "iana", + compressible: true + }, + "application/resolve-response+jwt": { + source: "iana" + }, + "application/resource-lists+xml": { + source: "iana", + compressible: true, + extensions: ["rl"] + }, + "application/resource-lists-diff+xml": { + source: "iana", + compressible: true, + extensions: ["rld"] + }, + "application/rfc+xml": { + source: "iana", + compressible: true + }, + "application/riscos": { + source: "iana" + }, + "application/rlmi+xml": { + source: "iana", + compressible: true + }, + "application/rls-services+xml": { + source: "iana", + compressible: true, + extensions: ["rs"] + }, + "application/route-apd+xml": { + source: "iana", + compressible: true, + extensions: ["rapd"] + }, + "application/route-s-tsid+xml": { + source: "iana", + compressible: true, + extensions: ["sls"] + }, + "application/route-usd+xml": { + source: "iana", + compressible: true, + extensions: ["rusd"] + }, + "application/rpki-checklist": { + source: "iana" + }, + "application/rpki-ghostbusters": { + source: "iana", + extensions: ["gbr"] + }, + "application/rpki-manifest": { + source: "iana", + extensions: ["mft"] + }, + "application/rpki-publication": { + source: "iana" + }, + "application/rpki-roa": { + source: "iana", + extensions: ["roa"] + }, + "application/rpki-signed-tal": { + source: "iana" + }, + "application/rpki-updown": { + source: "iana" + }, + "application/rsd+xml": { + source: "apache", + compressible: true, + extensions: ["rsd"] + }, + "application/rss+xml": { + source: "apache", + compressible: true, + extensions: ["rss"] + }, + "application/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "application/rtploopback": { + source: "iana" + }, + "application/rtx": { + source: "iana" + }, + "application/samlassertion+xml": { + source: "iana", + compressible: true + }, + "application/samlmetadata+xml": { + source: "iana", + compressible: true + }, + "application/sarif+json": { + source: "iana", + compressible: true + }, + "application/sarif-external-properties+json": { + source: "iana", + compressible: true + }, + "application/sbe": { + source: "iana" + }, + "application/sbml+xml": { + source: "iana", + compressible: true, + extensions: ["sbml"] + }, + "application/scaip+xml": { + source: "iana", + compressible: true + }, + "application/scim+json": { + source: "iana", + compressible: true + }, + "application/scvp-cv-request": { + source: "iana", + extensions: ["scq"] + }, + "application/scvp-cv-response": { + source: "iana", + extensions: ["scs"] + }, + "application/scvp-vp-request": { + source: "iana", + extensions: ["spq"] + }, + "application/scvp-vp-response": { + source: "iana", + extensions: ["spp"] + }, + "application/sdp": { + source: "iana", + extensions: ["sdp"] + }, + "application/secevent+jwt": { + source: "iana" + }, + "application/senml+cbor": { + source: "iana" + }, + "application/senml+json": { + source: "iana", + compressible: true + }, + "application/senml+xml": { + source: "iana", + compressible: true, + extensions: ["senmlx"] + }, + "application/senml-etch+cbor": { + source: "iana" + }, + "application/senml-etch+json": { + source: "iana", + compressible: true + }, + "application/senml-exi": { + source: "iana" + }, + "application/sensml+cbor": { + source: "iana" + }, + "application/sensml+json": { + source: "iana", + compressible: true + }, + "application/sensml+xml": { + source: "iana", + compressible: true, + extensions: ["sensmlx"] + }, + "application/sensml-exi": { + source: "iana" + }, + "application/sep+xml": { + source: "iana", + compressible: true + }, + "application/sep-exi": { + source: "iana" + }, + "application/session-info": { + source: "iana" + }, + "application/set-payment": { + source: "iana" + }, + "application/set-payment-initiation": { + source: "iana", + extensions: ["setpay"] + }, + "application/set-registration": { + source: "iana" + }, + "application/set-registration-initiation": { + source: "iana", + extensions: ["setreg"] + }, + "application/sgml": { + source: "iana" + }, + "application/sgml-open-catalog": { + source: "iana" + }, + "application/shf+xml": { + source: "iana", + compressible: true, + extensions: ["shf"] + }, + "application/sieve": { + source: "iana", + extensions: ["siv", "sieve"] + }, + "application/simple-filter+xml": { + source: "iana", + compressible: true + }, + "application/simple-message-summary": { + source: "iana" + }, + "application/simplesymbolcontainer": { + source: "iana" + }, + "application/sipc": { + source: "iana" + }, + "application/slate": { + source: "iana" + }, + "application/smil": { + source: "apache" + }, + "application/smil+xml": { + source: "iana", + compressible: true, + extensions: ["smi", "smil"] + }, + "application/smpte336m": { + source: "iana" + }, + "application/soap+fastinfoset": { + source: "iana" + }, + "application/soap+xml": { + source: "iana", + compressible: true + }, + "application/sparql-query": { + source: "iana", + extensions: ["rq"] + }, + "application/sparql-results+xml": { + source: "iana", + compressible: true, + extensions: ["srx"] + }, + "application/spdx+json": { + source: "iana", + compressible: true + }, + "application/spirits-event+xml": { + source: "iana", + compressible: true + }, + "application/sql": { + source: "iana", + extensions: ["sql"] + }, + "application/srgs": { + source: "iana", + extensions: ["gram"] + }, + "application/srgs+xml": { + source: "iana", + compressible: true, + extensions: ["grxml"] + }, + "application/sru+xml": { + source: "iana", + compressible: true, + extensions: ["sru"] + }, + "application/ssdl+xml": { + source: "apache", + compressible: true, + extensions: ["ssdl"] + }, + "application/sslkeylogfile": { + source: "iana" + }, + "application/ssml+xml": { + source: "iana", + compressible: true, + extensions: ["ssml"] + }, + "application/st2110-41": { + source: "iana" + }, + "application/stix+json": { + source: "iana", + compressible: true + }, + "application/stratum": { + source: "iana" + }, + "application/swid+cbor": { + source: "iana" + }, + "application/swid+xml": { + source: "iana", + compressible: true, + extensions: ["swidtag"] + }, + "application/tamp-apex-update": { + source: "iana" + }, + "application/tamp-apex-update-confirm": { + source: "iana" + }, + "application/tamp-community-update": { + source: "iana" + }, + "application/tamp-community-update-confirm": { + source: "iana" + }, + "application/tamp-error": { + source: "iana" + }, + "application/tamp-sequence-adjust": { + source: "iana" + }, + "application/tamp-sequence-adjust-confirm": { + source: "iana" + }, + "application/tamp-status-query": { + source: "iana" + }, + "application/tamp-status-response": { + source: "iana" + }, + "application/tamp-update": { + source: "iana" + }, + "application/tamp-update-confirm": { + source: "iana" + }, + "application/tar": { + compressible: true + }, + "application/taxii+json": { + source: "iana", + compressible: true + }, + "application/td+json": { + source: "iana", + compressible: true + }, + "application/tei+xml": { + source: "iana", + compressible: true, + extensions: ["tei", "teicorpus"] + }, + "application/tetra_isi": { + source: "iana" + }, + "application/thraud+xml": { + source: "iana", + compressible: true, + extensions: ["tfi"] + }, + "application/timestamp-query": { + source: "iana" + }, + "application/timestamp-reply": { + source: "iana" + }, + "application/timestamped-data": { + source: "iana", + extensions: ["tsd"] + }, + "application/tlsrpt+gzip": { + source: "iana" + }, + "application/tlsrpt+json": { + source: "iana", + compressible: true + }, + "application/tm+json": { + source: "iana", + compressible: true + }, + "application/tnauthlist": { + source: "iana" + }, + "application/toc+cbor": { + source: "iana" + }, + "application/token-introspection+jwt": { + source: "iana" + }, + "application/toml": { + source: "iana", + compressible: true, + extensions: ["toml"] + }, + "application/trickle-ice-sdpfrag": { + source: "iana" + }, + "application/trig": { + source: "iana", + extensions: ["trig"] + }, + "application/trust-chain+json": { + source: "iana", + compressible: true + }, + "application/trust-mark+jwt": { + source: "iana" + }, + "application/trust-mark-delegation+jwt": { + source: "iana" + }, + "application/ttml+xml": { + source: "iana", + compressible: true, + extensions: ["ttml"] + }, + "application/tve-trigger": { + source: "iana" + }, + "application/tzif": { + source: "iana" + }, + "application/tzif-leap": { + source: "iana" + }, + "application/ubjson": { + compressible: false, + extensions: ["ubj"] + }, + "application/uccs+cbor": { + source: "iana" + }, + "application/ujcs+json": { + source: "iana", + compressible: true + }, + "application/ulpfec": { + source: "iana" + }, + "application/urc-grpsheet+xml": { + source: "iana", + compressible: true + }, + "application/urc-ressheet+xml": { + source: "iana", + compressible: true, + extensions: ["rsheet"] + }, + "application/urc-targetdesc+xml": { + source: "iana", + compressible: true, + extensions: ["td"] + }, + "application/urc-uisocketdesc+xml": { + source: "iana", + compressible: true + }, + "application/vc": { + source: "iana" + }, + "application/vc+cose": { + source: "iana" + }, + "application/vc+jwt": { + source: "iana" + }, + "application/vcard+json": { + source: "iana", + compressible: true + }, + "application/vcard+xml": { + source: "iana", + compressible: true + }, + "application/vemmi": { + source: "iana" + }, + "application/vividence.scriptfile": { + source: "apache" + }, + "application/vnd.1000minds.decision-model+xml": { + source: "iana", + compressible: true, + extensions: ["1km"] + }, + "application/vnd.1ob": { + source: "iana" + }, + "application/vnd.3gpp-prose+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3a+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ach+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ch+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc8+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-v2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gnas": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.access-transfer-events+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.bsf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.crs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.current-location-discovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gmop+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gtpc": { + source: "iana" + }, + "application/vnd.3gpp.interworking-data": { + source: "iana" + }, + "application/vnd.3gpp.lpp": { + source: "iana" + }, + "application/vnd.3gpp.mc-signalling-ear": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-payload": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-signalling": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-floor-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-signed+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-init-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-transmission-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mid-call+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ngap": { + source: "iana" + }, + "application/vnd.3gpp.pfcp": { + source: "iana" + }, + "application/vnd.3gpp.pic-bw-large": { + source: "iana", + extensions: ["plb"] + }, + "application/vnd.3gpp.pic-bw-small": { + source: "iana", + extensions: ["psb"] + }, + "application/vnd.3gpp.pic-bw-var": { + source: "iana", + extensions: ["pvb"] + }, + "application/vnd.3gpp.pinapp-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.s1ap": { + source: "iana" + }, + "application/vnd.3gpp.seal-group-doc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-network-qos-management-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-ue-config-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-unicast-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-user-profile-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.sms": { + source: "iana" + }, + "application/vnd.3gpp.sms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-ext+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.state-and-event-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ussd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.v2x": { + source: "iana" + }, + "application/vnd.3gpp.vae-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.bcmcsinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.sms": { + source: "iana" + }, + "application/vnd.3gpp2.tcap": { + source: "iana", + extensions: ["tcap"] + }, + "application/vnd.3lightssoftware.imagescal": { + source: "iana" + }, + "application/vnd.3m.post-it-notes": { + source: "iana", + extensions: ["pwn"] + }, + "application/vnd.accpac.simply.aso": { + source: "iana", + extensions: ["aso"] + }, + "application/vnd.accpac.simply.imp": { + source: "iana", + extensions: ["imp"] + }, + "application/vnd.acm.addressxfer+json": { + source: "iana", + compressible: true + }, + "application/vnd.acm.chatbot+json": { + source: "iana", + compressible: true + }, + "application/vnd.acucobol": { + source: "iana", + extensions: ["acu"] + }, + "application/vnd.acucorp": { + source: "iana", + extensions: ["atc", "acutc"] + }, + "application/vnd.adobe.air-application-installer-package+zip": { + source: "apache", + compressible: false, + extensions: ["air"] + }, + "application/vnd.adobe.flash.movie": { + source: "iana" + }, + "application/vnd.adobe.formscentral.fcdt": { + source: "iana", + extensions: ["fcdt"] + }, + "application/vnd.adobe.fxp": { + source: "iana", + extensions: ["fxp", "fxpl"] + }, + "application/vnd.adobe.partial-upload": { + source: "iana" + }, + "application/vnd.adobe.xdp+xml": { + source: "iana", + compressible: true, + extensions: ["xdp"] + }, + "application/vnd.adobe.xfdf": { + source: "apache", + extensions: ["xfdf"] + }, + "application/vnd.aether.imp": { + source: "iana" + }, + "application/vnd.afpc.afplinedata": { + source: "iana" + }, + "application/vnd.afpc.afplinedata-pagedef": { + source: "iana" + }, + "application/vnd.afpc.cmoca-cmresource": { + source: "iana" + }, + "application/vnd.afpc.foca-charset": { + source: "iana" + }, + "application/vnd.afpc.foca-codedfont": { + source: "iana" + }, + "application/vnd.afpc.foca-codepage": { + source: "iana" + }, + "application/vnd.afpc.modca": { + source: "iana" + }, + "application/vnd.afpc.modca-cmtable": { + source: "iana" + }, + "application/vnd.afpc.modca-formdef": { + source: "iana" + }, + "application/vnd.afpc.modca-mediummap": { + source: "iana" + }, + "application/vnd.afpc.modca-objectcontainer": { + source: "iana" + }, + "application/vnd.afpc.modca-overlay": { + source: "iana" + }, + "application/vnd.afpc.modca-pagesegment": { + source: "iana" + }, + "application/vnd.age": { + source: "iana", + extensions: ["age"] + }, + "application/vnd.ah-barcode": { + source: "apache" + }, + "application/vnd.ahead.space": { + source: "iana", + extensions: ["ahead"] + }, + "application/vnd.airzip.filesecure.azf": { + source: "iana", + extensions: ["azf"] + }, + "application/vnd.airzip.filesecure.azs": { + source: "iana", + extensions: ["azs"] + }, + "application/vnd.amadeus+json": { + source: "iana", + compressible: true + }, + "application/vnd.amazon.ebook": { + source: "apache", + extensions: ["azw"] + }, + "application/vnd.amazon.mobi8-ebook": { + source: "iana" + }, + "application/vnd.americandynamics.acc": { + source: "iana", + extensions: ["acc"] + }, + "application/vnd.amiga.ami": { + source: "iana", + extensions: ["ami"] + }, + "application/vnd.amundsen.maze+xml": { + source: "iana", + compressible: true + }, + "application/vnd.android.ota": { + source: "iana" + }, + "application/vnd.android.package-archive": { + source: "apache", + compressible: false, + extensions: ["apk"] + }, + "application/vnd.anki": { + source: "iana" + }, + "application/vnd.anser-web-certificate-issue-initiation": { + source: "iana", + extensions: ["cii"] + }, + "application/vnd.anser-web-funds-transfer-initiation": { + source: "apache", + extensions: ["fti"] + }, + "application/vnd.antix.game-component": { + source: "iana", + extensions: ["atx"] + }, + "application/vnd.apache.arrow.file": { + source: "iana" + }, + "application/vnd.apache.arrow.stream": { + source: "iana" + }, + "application/vnd.apache.parquet": { + source: "iana" + }, + "application/vnd.apache.thrift.binary": { + source: "iana" + }, + "application/vnd.apache.thrift.compact": { + source: "iana" + }, + "application/vnd.apache.thrift.json": { + source: "iana" + }, + "application/vnd.apexlang": { + source: "iana" + }, + "application/vnd.api+json": { + source: "iana", + compressible: true + }, + "application/vnd.aplextor.warrp+json": { + source: "iana", + compressible: true + }, + "application/vnd.apothekende.reservation+json": { + source: "iana", + compressible: true + }, + "application/vnd.apple.installer+xml": { + source: "iana", + compressible: true, + extensions: ["mpkg"] + }, + "application/vnd.apple.keynote": { + source: "iana", + extensions: ["key"] + }, + "application/vnd.apple.mpegurl": { + source: "iana", + extensions: ["m3u8"] + }, + "application/vnd.apple.numbers": { + source: "iana", + extensions: ["numbers"] + }, + "application/vnd.apple.pages": { + source: "iana", + extensions: ["pages"] + }, + "application/vnd.apple.pkpass": { + compressible: false, + extensions: ["pkpass"] + }, + "application/vnd.arastra.swi": { + source: "apache" + }, + "application/vnd.aristanetworks.swi": { + source: "iana", + extensions: ["swi"] + }, + "application/vnd.artisan+json": { + source: "iana", + compressible: true + }, + "application/vnd.artsquare": { + source: "iana" + }, + "application/vnd.astraea-software.iota": { + source: "iana", + extensions: ["iota"] + }, + "application/vnd.audiograph": { + source: "iana", + extensions: ["aep"] + }, + "application/vnd.autodesk.fbx": { + extensions: ["fbx"] + }, + "application/vnd.autopackage": { + source: "iana" + }, + "application/vnd.avalon+json": { + source: "iana", + compressible: true + }, + "application/vnd.avistar+xml": { + source: "iana", + compressible: true + }, + "application/vnd.balsamiq.bmml+xml": { + source: "iana", + compressible: true, + extensions: ["bmml"] + }, + "application/vnd.balsamiq.bmpr": { + source: "iana" + }, + "application/vnd.banana-accounting": { + source: "iana" + }, + "application/vnd.bbf.usp.error": { + source: "iana" + }, + "application/vnd.bbf.usp.msg": { + source: "iana" + }, + "application/vnd.bbf.usp.msg+json": { + source: "iana", + compressible: true + }, + "application/vnd.bekitzur-stech+json": { + source: "iana", + compressible: true + }, + "application/vnd.belightsoft.lhzd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.belightsoft.lhzl+zip": { + source: "iana", + compressible: false + }, + "application/vnd.bint.med-content": { + source: "iana" + }, + "application/vnd.biopax.rdf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.blink-idb-value-wrapper": { + source: "iana" + }, + "application/vnd.blueice.multipass": { + source: "iana", + extensions: ["mpm"] + }, + "application/vnd.bluetooth.ep.oob": { + source: "iana" + }, + "application/vnd.bluetooth.le.oob": { + source: "iana" + }, + "application/vnd.bmi": { + source: "iana", + extensions: ["bmi"] + }, + "application/vnd.bpf": { + source: "iana" + }, + "application/vnd.bpf3": { + source: "iana" + }, + "application/vnd.businessobjects": { + source: "iana", + extensions: ["rep"] + }, + "application/vnd.byu.uapi+json": { + source: "iana", + compressible: true + }, + "application/vnd.bzip3": { + source: "iana" + }, + "application/vnd.c3voc.schedule+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cab-jscript": { + source: "iana" + }, + "application/vnd.canon-cpdl": { + source: "iana" + }, + "application/vnd.canon-lips": { + source: "iana" + }, + "application/vnd.capasystems-pg+json": { + source: "iana", + compressible: true + }, + "application/vnd.cendio.thinlinc.clientconf": { + source: "iana" + }, + "application/vnd.century-systems.tcp_stream": { + source: "iana" + }, + "application/vnd.chemdraw+xml": { + source: "iana", + compressible: true, + extensions: ["cdxml"] + }, + "application/vnd.chess-pgn": { + source: "iana" + }, + "application/vnd.chipnuts.karaoke-mmd": { + source: "iana", + extensions: ["mmd"] + }, + "application/vnd.ciedi": { + source: "iana" + }, + "application/vnd.cinderella": { + source: "iana", + extensions: ["cdy"] + }, + "application/vnd.cirpack.isdn-ext": { + source: "iana" + }, + "application/vnd.citationstyles.style+xml": { + source: "iana", + compressible: true, + extensions: ["csl"] + }, + "application/vnd.claymore": { + source: "iana", + extensions: ["cla"] + }, + "application/vnd.cloanto.rp9": { + source: "iana", + extensions: ["rp9"] + }, + "application/vnd.clonk.c4group": { + source: "iana", + extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"] + }, + "application/vnd.cluetrust.cartomobile-config": { + source: "iana", + extensions: ["c11amc"] + }, + "application/vnd.cluetrust.cartomobile-config-pkg": { + source: "iana", + extensions: ["c11amz"] + }, + "application/vnd.cncf.helm.chart.content.v1.tar+gzip": { + source: "iana" + }, + "application/vnd.cncf.helm.chart.provenance.v1.prov": { + source: "iana" + }, + "application/vnd.cncf.helm.config.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.coffeescript": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet-template": { + source: "iana" + }, + "application/vnd.collection+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.doc+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.next+json": { + source: "iana", + compressible: true + }, + "application/vnd.comicbook+zip": { + source: "iana", + compressible: false + }, + "application/vnd.comicbook-rar": { + source: "iana" + }, + "application/vnd.commerce-battelle": { + source: "iana" + }, + "application/vnd.commonspace": { + source: "iana", + extensions: ["csp"] + }, + "application/vnd.contact.cmsg": { + source: "iana", + extensions: ["cdbcmsg"] + }, + "application/vnd.coreos.ignition+json": { + source: "iana", + compressible: true + }, + "application/vnd.cosmocaller": { + source: "iana", + extensions: ["cmc"] + }, + "application/vnd.crick.clicker": { + source: "iana", + extensions: ["clkx"] + }, + "application/vnd.crick.clicker.keyboard": { + source: "iana", + extensions: ["clkk"] + }, + "application/vnd.crick.clicker.palette": { + source: "iana", + extensions: ["clkp"] + }, + "application/vnd.crick.clicker.template": { + source: "iana", + extensions: ["clkt"] + }, + "application/vnd.crick.clicker.wordbank": { + source: "iana", + extensions: ["clkw"] + }, + "application/vnd.criticaltools.wbs+xml": { + source: "iana", + compressible: true, + extensions: ["wbs"] + }, + "application/vnd.cryptii.pipe+json": { + source: "iana", + compressible: true + }, + "application/vnd.crypto-shade-file": { + source: "iana" + }, + "application/vnd.cryptomator.encrypted": { + source: "iana" + }, + "application/vnd.cryptomator.vault": { + source: "iana" + }, + "application/vnd.ctc-posml": { + source: "iana", + extensions: ["pml"] + }, + "application/vnd.ctct.ws+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cups-pdf": { + source: "iana" + }, + "application/vnd.cups-postscript": { + source: "iana" + }, + "application/vnd.cups-ppd": { + source: "iana", + extensions: ["ppd"] + }, + "application/vnd.cups-raster": { + source: "iana" + }, + "application/vnd.cups-raw": { + source: "iana" + }, + "application/vnd.curl": { + source: "iana" + }, + "application/vnd.curl.car": { + source: "apache", + extensions: ["car"] + }, + "application/vnd.curl.pcurl": { + source: "apache", + extensions: ["pcurl"] + }, + "application/vnd.cyan.dean.root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cybank": { + source: "iana" + }, + "application/vnd.cyclonedx+json": { + source: "iana", + compressible: true + }, + "application/vnd.cyclonedx+xml": { + source: "iana", + compressible: true + }, + "application/vnd.d2l.coursepackage1p0+zip": { + source: "iana", + compressible: false + }, + "application/vnd.d3m-dataset": { + source: "iana" + }, + "application/vnd.d3m-problem": { + source: "iana" + }, + "application/vnd.dart": { + source: "iana", + compressible: true, + extensions: ["dart"] + }, + "application/vnd.data-vision.rdz": { + source: "iana", + extensions: ["rdz"] + }, + "application/vnd.datalog": { + source: "iana" + }, + "application/vnd.datapackage+json": { + source: "iana", + compressible: true + }, + "application/vnd.dataresource+json": { + source: "iana", + compressible: true + }, + "application/vnd.dbf": { + source: "iana", + extensions: ["dbf"] + }, + "application/vnd.dcmp+xml": { + source: "iana", + compressible: true, + extensions: ["dcmp"] + }, + "application/vnd.debian.binary-package": { + source: "iana" + }, + "application/vnd.dece.data": { + source: "iana", + extensions: ["uvf", "uvvf", "uvd", "uvvd"] + }, + "application/vnd.dece.ttml+xml": { + source: "iana", + compressible: true, + extensions: ["uvt", "uvvt"] + }, + "application/vnd.dece.unspecified": { + source: "iana", + extensions: ["uvx", "uvvx"] + }, + "application/vnd.dece.zip": { + source: "iana", + extensions: ["uvz", "uvvz"] + }, + "application/vnd.denovo.fcselayout-link": { + source: "iana", + extensions: ["fe_launch"] + }, + "application/vnd.desmume.movie": { + source: "iana" + }, + "application/vnd.dir-bi.plate-dl-nosuffix": { + source: "iana" + }, + "application/vnd.dm.delegation+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dna": { + source: "iana", + extensions: ["dna"] + }, + "application/vnd.document+json": { + source: "iana", + compressible: true + }, + "application/vnd.dolby.mlp": { + source: "apache", + extensions: ["mlp"] + }, + "application/vnd.dolby.mobile.1": { + source: "iana" + }, + "application/vnd.dolby.mobile.2": { + source: "iana" + }, + "application/vnd.doremir.scorecloud-binary-document": { + source: "iana" + }, + "application/vnd.dpgraph": { + source: "iana", + extensions: ["dpg"] + }, + "application/vnd.dreamfactory": { + source: "iana", + extensions: ["dfac"] + }, + "application/vnd.drive+json": { + source: "iana", + compressible: true + }, + "application/vnd.ds-keypoint": { + source: "apache", + extensions: ["kpxx"] + }, + "application/vnd.dtg.local": { + source: "iana" + }, + "application/vnd.dtg.local.flash": { + source: "iana" + }, + "application/vnd.dtg.local.html": { + source: "iana" + }, + "application/vnd.dvb.ait": { + source: "iana", + extensions: ["ait"] + }, + "application/vnd.dvb.dvbisl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.dvbj": { + source: "iana" + }, + "application/vnd.dvb.esgcontainer": { + source: "iana" + }, + "application/vnd.dvb.ipdcdftnotifaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess2": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgpdd": { + source: "iana" + }, + "application/vnd.dvb.ipdcroaming": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-base": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-enhancement": { + source: "iana" + }, + "application/vnd.dvb.notif-aggregate-root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-container+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-generic+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-msglist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-response+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-init+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.pfr": { + source: "iana" + }, + "application/vnd.dvb.service": { + source: "iana", + extensions: ["svc"] + }, + "application/vnd.dxr": { + source: "iana" + }, + "application/vnd.dynageo": { + source: "iana", + extensions: ["geo"] + }, + "application/vnd.dzr": { + source: "iana" + }, + "application/vnd.easykaraoke.cdgdownload": { + source: "iana" + }, + "application/vnd.ecdis-update": { + source: "iana" + }, + "application/vnd.ecip.rlp": { + source: "iana" + }, + "application/vnd.eclipse.ditto+json": { + source: "iana", + compressible: true + }, + "application/vnd.ecowin.chart": { + source: "iana", + extensions: ["mag"] + }, + "application/vnd.ecowin.filerequest": { + source: "iana" + }, + "application/vnd.ecowin.fileupdate": { + source: "iana" + }, + "application/vnd.ecowin.series": { + source: "iana" + }, + "application/vnd.ecowin.seriesrequest": { + source: "iana" + }, + "application/vnd.ecowin.seriesupdate": { + source: "iana" + }, + "application/vnd.efi.img": { + source: "iana" + }, + "application/vnd.efi.iso": { + source: "iana" + }, + "application/vnd.eln+zip": { + source: "iana", + compressible: false + }, + "application/vnd.emclient.accessrequest+xml": { + source: "iana", + compressible: true + }, + "application/vnd.enliven": { + source: "iana", + extensions: ["nml"] + }, + "application/vnd.enphase.envoy": { + source: "iana" + }, + "application/vnd.eprints.data+xml": { + source: "iana", + compressible: true + }, + "application/vnd.epson.esf": { + source: "iana", + extensions: ["esf"] + }, + "application/vnd.epson.msf": { + source: "iana", + extensions: ["msf"] + }, + "application/vnd.epson.quickanime": { + source: "iana", + extensions: ["qam"] + }, + "application/vnd.epson.salt": { + source: "iana", + extensions: ["slt"] + }, + "application/vnd.epson.ssf": { + source: "iana", + extensions: ["ssf"] + }, + "application/vnd.ericsson.quickcall": { + source: "iana" + }, + "application/vnd.erofs": { + source: "iana" + }, + "application/vnd.espass-espass+zip": { + source: "iana", + compressible: false + }, + "application/vnd.eszigno3+xml": { + source: "iana", + compressible: true, + extensions: ["es3", "et3"] + }, + "application/vnd.etsi.aoc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.asic-e+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.asic-s+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.cug+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvcommand+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-bc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-cod+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-npvr+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvservice+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsync+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mcid+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mheg5": { + source: "iana" + }, + "application/vnd.etsi.overload-control-policy-dataset+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.pstn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.sci+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.simservs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.timestamp-token": { + source: "iana" + }, + "application/vnd.etsi.tsl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.tsl.der": { + source: "iana" + }, + "application/vnd.eu.kasparian.car+json": { + source: "iana", + compressible: true + }, + "application/vnd.eudora.data": { + source: "iana" + }, + "application/vnd.evolv.ecig.profile": { + source: "iana" + }, + "application/vnd.evolv.ecig.settings": { + source: "iana" + }, + "application/vnd.evolv.ecig.theme": { + source: "iana" + }, + "application/vnd.exstream-empower+zip": { + source: "iana", + compressible: false + }, + "application/vnd.exstream-package": { + source: "iana" + }, + "application/vnd.ezpix-album": { + source: "iana", + extensions: ["ez2"] + }, + "application/vnd.ezpix-package": { + source: "iana", + extensions: ["ez3"] + }, + "application/vnd.f-secure.mobile": { + source: "iana" + }, + "application/vnd.familysearch.gedcom+zip": { + source: "iana", + compressible: false + }, + "application/vnd.fastcopy-disk-image": { + source: "iana" + }, + "application/vnd.fdf": { + source: "apache", + extensions: ["fdf"] + }, + "application/vnd.fdsn.mseed": { + source: "iana", + extensions: ["mseed"] + }, + "application/vnd.fdsn.seed": { + source: "iana", + extensions: ["seed", "dataless"] + }, + "application/vnd.fdsn.stationxml+xml": { + source: "iana", + charset: "XML-BASED", + compressible: true + }, + "application/vnd.ffsns": { + source: "iana" + }, + "application/vnd.ficlab.flb+zip": { + source: "iana", + compressible: false + }, + "application/vnd.filmit.zfc": { + source: "iana" + }, + "application/vnd.fints": { + source: "iana" + }, + "application/vnd.firemonkeys.cloudcell": { + source: "iana" + }, + "application/vnd.flographit": { + source: "iana", + extensions: ["gph"] + }, + "application/vnd.fluxtime.clip": { + source: "iana", + extensions: ["ftc"] + }, + "application/vnd.font-fontforge-sfd": { + source: "iana" + }, + "application/vnd.framemaker": { + source: "iana", + extensions: ["fm", "frame", "maker", "book"] + }, + "application/vnd.freelog.comic": { + source: "iana" + }, + "application/vnd.frogans.fnc": { + source: "apache", + extensions: ["fnc"] + }, + "application/vnd.frogans.ltf": { + source: "apache", + extensions: ["ltf"] + }, + "application/vnd.fsc.weblaunch": { + source: "iana", + extensions: ["fsc"] + }, + "application/vnd.fujifilm.fb.docuworks": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.binder": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.container": { + source: "iana" + }, + "application/vnd.fujifilm.fb.jfi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.fujitsu.oasys": { + source: "iana", + extensions: ["oas"] + }, + "application/vnd.fujitsu.oasys2": { + source: "iana", + extensions: ["oa2"] + }, + "application/vnd.fujitsu.oasys3": { + source: "iana", + extensions: ["oa3"] + }, + "application/vnd.fujitsu.oasysgp": { + source: "iana", + extensions: ["fg5"] + }, + "application/vnd.fujitsu.oasysprs": { + source: "iana", + extensions: ["bh2"] + }, + "application/vnd.fujixerox.art-ex": { + source: "iana" + }, + "application/vnd.fujixerox.art4": { + source: "iana" + }, + "application/vnd.fujixerox.ddd": { + source: "iana", + extensions: ["ddd"] + }, + "application/vnd.fujixerox.docuworks": { + source: "iana", + extensions: ["xdw"] + }, + "application/vnd.fujixerox.docuworks.binder": { + source: "iana", + extensions: ["xbd"] + }, + "application/vnd.fujixerox.docuworks.container": { + source: "iana" + }, + "application/vnd.fujixerox.hbpl": { + source: "iana" + }, + "application/vnd.fut-misnet": { + source: "iana" + }, + "application/vnd.futoin+cbor": { + source: "iana" + }, + "application/vnd.futoin+json": { + source: "iana", + compressible: true + }, + "application/vnd.fuzzysheet": { + source: "iana", + extensions: ["fzs"] + }, + "application/vnd.ga4gh.passport+jwt": { + source: "iana" + }, + "application/vnd.genomatix.tuxedo": { + source: "iana", + extensions: ["txd"] + }, + "application/vnd.genozip": { + source: "iana" + }, + "application/vnd.gentics.grd+json": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.catmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.ebuild": { + source: "iana" + }, + "application/vnd.gentoo.eclass": { + source: "iana" + }, + "application/vnd.gentoo.gpkg": { + source: "iana" + }, + "application/vnd.gentoo.manifest": { + source: "iana" + }, + "application/vnd.gentoo.pkgmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.xpak": { + source: "iana" + }, + "application/vnd.geo+json": { + source: "apache", + compressible: true + }, + "application/vnd.geocube+xml": { + source: "apache", + compressible: true + }, + "application/vnd.geogebra.file": { + source: "iana", + extensions: ["ggb"] + }, + "application/vnd.geogebra.pinboard": { + source: "iana" + }, + "application/vnd.geogebra.slides": { + source: "iana", + extensions: ["ggs"] + }, + "application/vnd.geogebra.tool": { + source: "iana", + extensions: ["ggt"] + }, + "application/vnd.geometry-explorer": { + source: "iana", + extensions: ["gex", "gre"] + }, + "application/vnd.geonext": { + source: "iana", + extensions: ["gxt"] + }, + "application/vnd.geoplan": { + source: "iana", + extensions: ["g2w"] + }, + "application/vnd.geospace": { + source: "iana", + extensions: ["g3w"] + }, + "application/vnd.gerber": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt-response": { + source: "iana" + }, + "application/vnd.gmx": { + source: "iana", + extensions: ["gmx"] + }, + "application/vnd.gnu.taler.exchange+json": { + source: "iana", + compressible: true + }, + "application/vnd.gnu.taler.merchant+json": { + source: "iana", + compressible: true + }, + "application/vnd.google-apps.audio": {}, + "application/vnd.google-apps.document": { + compressible: false, + extensions: ["gdoc"] + }, + "application/vnd.google-apps.drawing": { + compressible: false, + extensions: ["gdraw"] + }, + "application/vnd.google-apps.drive-sdk": { + compressible: false + }, + "application/vnd.google-apps.file": {}, + "application/vnd.google-apps.folder": { + compressible: false + }, + "application/vnd.google-apps.form": { + compressible: false, + extensions: ["gform"] + }, + "application/vnd.google-apps.fusiontable": {}, + "application/vnd.google-apps.jam": { + compressible: false, + extensions: ["gjam"] + }, + "application/vnd.google-apps.mail-layout": {}, + "application/vnd.google-apps.map": { + compressible: false, + extensions: ["gmap"] + }, + "application/vnd.google-apps.photo": {}, + "application/vnd.google-apps.presentation": { + compressible: false, + extensions: ["gslides"] + }, + "application/vnd.google-apps.script": { + compressible: false, + extensions: ["gscript"] + }, + "application/vnd.google-apps.shortcut": {}, + "application/vnd.google-apps.site": { + compressible: false, + extensions: ["gsite"] + }, + "application/vnd.google-apps.spreadsheet": { + compressible: false, + extensions: ["gsheet"] + }, + "application/vnd.google-apps.unknown": {}, + "application/vnd.google-apps.video": {}, + "application/vnd.google-earth.kml+xml": { + source: "iana", + compressible: true, + extensions: ["kml"] + }, + "application/vnd.google-earth.kmz": { + source: "iana", + compressible: false, + extensions: ["kmz"] + }, + "application/vnd.gov.sk.e-form+xml": { + source: "apache", + compressible: true + }, + "application/vnd.gov.sk.e-form+zip": { + source: "iana", + compressible: false + }, + "application/vnd.gov.sk.xmldatacontainer+xml": { + source: "iana", + compressible: true, + extensions: ["xdcf"] + }, + "application/vnd.gpxsee.map+xml": { + source: "iana", + compressible: true + }, + "application/vnd.grafeq": { + source: "iana", + extensions: ["gqf", "gqs"] + }, + "application/vnd.gridmp": { + source: "iana" + }, + "application/vnd.groove-account": { + source: "iana", + extensions: ["gac"] + }, + "application/vnd.groove-help": { + source: "iana", + extensions: ["ghf"] + }, + "application/vnd.groove-identity-message": { + source: "iana", + extensions: ["gim"] + }, + "application/vnd.groove-injector": { + source: "iana", + extensions: ["grv"] + }, + "application/vnd.groove-tool-message": { + source: "iana", + extensions: ["gtm"] + }, + "application/vnd.groove-tool-template": { + source: "iana", + extensions: ["tpl"] + }, + "application/vnd.groove-vcard": { + source: "iana", + extensions: ["vcg"] + }, + "application/vnd.hal+json": { + source: "iana", + compressible: true + }, + "application/vnd.hal+xml": { + source: "iana", + compressible: true, + extensions: ["hal"] + }, + "application/vnd.handheld-entertainment+xml": { + source: "iana", + compressible: true, + extensions: ["zmm"] + }, + "application/vnd.hbci": { + source: "iana", + extensions: ["hbci"] + }, + "application/vnd.hc+json": { + source: "iana", + compressible: true + }, + "application/vnd.hcl-bireports": { + source: "iana" + }, + "application/vnd.hdt": { + source: "iana" + }, + "application/vnd.heroku+json": { + source: "iana", + compressible: true + }, + "application/vnd.hhe.lesson-player": { + source: "iana", + extensions: ["les"] + }, + "application/vnd.hp-hpgl": { + source: "iana", + extensions: ["hpgl"] + }, + "application/vnd.hp-hpid": { + source: "iana", + extensions: ["hpid"] + }, + "application/vnd.hp-hps": { + source: "iana", + extensions: ["hps"] + }, + "application/vnd.hp-jlyt": { + source: "iana", + extensions: ["jlt"] + }, + "application/vnd.hp-pcl": { + source: "iana", + extensions: ["pcl"] + }, + "application/vnd.hp-pclxl": { + source: "iana", + extensions: ["pclxl"] + }, + "application/vnd.hsl": { + source: "iana" + }, + "application/vnd.httphone": { + source: "iana" + }, + "application/vnd.hydrostatix.sof-data": { + source: "iana", + extensions: ["sfd-hdstx"] + }, + "application/vnd.hyper+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyper-item+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyperdrive+json": { + source: "iana", + compressible: true + }, + "application/vnd.hzn-3d-crossword": { + source: "iana" + }, + "application/vnd.ibm.afplinedata": { + source: "apache" + }, + "application/vnd.ibm.electronic-media": { + source: "iana" + }, + "application/vnd.ibm.minipay": { + source: "iana", + extensions: ["mpy"] + }, + "application/vnd.ibm.modcap": { + source: "apache", + extensions: ["afp", "listafp", "list3820"] + }, + "application/vnd.ibm.rights-management": { + source: "iana", + extensions: ["irm"] + }, + "application/vnd.ibm.secure-container": { + source: "iana", + extensions: ["sc"] + }, + "application/vnd.iccprofile": { + source: "iana", + extensions: ["icc", "icm"] + }, + "application/vnd.ieee.1905": { + source: "iana" + }, + "application/vnd.igloader": { + source: "iana", + extensions: ["igl"] + }, + "application/vnd.imagemeter.folder+zip": { + source: "iana", + compressible: false + }, + "application/vnd.imagemeter.image+zip": { + source: "iana", + compressible: false + }, + "application/vnd.immervision-ivp": { + source: "iana", + extensions: ["ivp"] + }, + "application/vnd.immervision-ivu": { + source: "iana", + extensions: ["ivu"] + }, + "application/vnd.ims.imsccv1p1": { + source: "iana" + }, + "application/vnd.ims.imsccv1p2": { + source: "iana" + }, + "application/vnd.ims.imsccv1p3": { + source: "iana" + }, + "application/vnd.ims.lis.v2.result+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolconsumerprofile+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy.id+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings.simple+json": { + source: "iana", + compressible: true + }, + "application/vnd.informedcontrol.rms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.informix-visionary": { + source: "apache" + }, + "application/vnd.infotech.project": { + source: "iana" + }, + "application/vnd.infotech.project+xml": { + source: "iana", + compressible: true + }, + "application/vnd.innopath.wamp.notification": { + source: "iana" + }, + "application/vnd.insors.igm": { + source: "iana", + extensions: ["igm"] + }, + "application/vnd.intercon.formnet": { + source: "iana", + extensions: ["xpw", "xpx"] + }, + "application/vnd.intergeo": { + source: "iana", + extensions: ["i2g"] + }, + "application/vnd.intertrust.digibox": { + source: "iana" + }, + "application/vnd.intertrust.nncp": { + source: "iana" + }, + "application/vnd.intu.qbo": { + source: "iana", + extensions: ["qbo"] + }, + "application/vnd.intu.qfx": { + source: "iana", + extensions: ["qfx"] + }, + "application/vnd.ipfs.ipns-record": { + source: "iana" + }, + "application/vnd.ipld.car": { + source: "iana" + }, + "application/vnd.ipld.dag-cbor": { + source: "iana" + }, + "application/vnd.ipld.dag-json": { + source: "iana" + }, + "application/vnd.ipld.raw": { + source: "iana" + }, + "application/vnd.iptc.g2.catalogitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.conceptitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.knowledgeitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.packageitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.planningitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ipunplugged.rcprofile": { + source: "iana", + extensions: ["rcprofile"] + }, + "application/vnd.irepository.package+xml": { + source: "iana", + compressible: true, + extensions: ["irp"] + }, + "application/vnd.is-xpr": { + source: "iana", + extensions: ["xpr"] + }, + "application/vnd.isac.fcs": { + source: "iana", + extensions: ["fcs"] + }, + "application/vnd.iso11783-10+zip": { + source: "iana", + compressible: false + }, + "application/vnd.jam": { + source: "iana", + extensions: ["jam"] + }, + "application/vnd.japannet-directory-service": { + source: "iana" + }, + "application/vnd.japannet-jpnstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-payment-wakeup": { + source: "iana" + }, + "application/vnd.japannet-registration": { + source: "iana" + }, + "application/vnd.japannet-registration-wakeup": { + source: "iana" + }, + "application/vnd.japannet-setstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-verification": { + source: "iana" + }, + "application/vnd.japannet-verification-wakeup": { + source: "iana" + }, + "application/vnd.jcp.javame.midlet-rms": { + source: "iana", + extensions: ["rms"] + }, + "application/vnd.jisp": { + source: "iana", + extensions: ["jisp"] + }, + "application/vnd.joost.joda-archive": { + source: "iana", + extensions: ["joda"] + }, + "application/vnd.jsk.isdn-ngn": { + source: "iana" + }, + "application/vnd.kahootz": { + source: "iana", + extensions: ["ktz", "ktr"] + }, + "application/vnd.kde.karbon": { + source: "iana", + extensions: ["karbon"] + }, + "application/vnd.kde.kchart": { + source: "iana", + extensions: ["chrt"] + }, + "application/vnd.kde.kformula": { + source: "iana", + extensions: ["kfo"] + }, + "application/vnd.kde.kivio": { + source: "iana", + extensions: ["flw"] + }, + "application/vnd.kde.kontour": { + source: "iana", + extensions: ["kon"] + }, + "application/vnd.kde.kpresenter": { + source: "iana", + extensions: ["kpr", "kpt"] + }, + "application/vnd.kde.kspread": { + source: "iana", + extensions: ["ksp"] + }, + "application/vnd.kde.kword": { + source: "iana", + extensions: ["kwd", "kwt"] + }, + "application/vnd.kdl": { + source: "iana" + }, + "application/vnd.kenameaapp": { + source: "iana", + extensions: ["htke"] + }, + "application/vnd.keyman.kmp+zip": { + source: "iana", + compressible: false + }, + "application/vnd.keyman.kmx": { + source: "iana" + }, + "application/vnd.kidspiration": { + source: "iana", + extensions: ["kia"] + }, + "application/vnd.kinar": { + source: "iana", + extensions: ["kne", "knp"] + }, + "application/vnd.koan": { + source: "iana", + extensions: ["skp", "skd", "skt", "skm"] + }, + "application/vnd.kodak-descriptor": { + source: "iana", + extensions: ["sse"] + }, + "application/vnd.las": { + source: "iana" + }, + "application/vnd.las.las+json": { + source: "iana", + compressible: true + }, + "application/vnd.las.las+xml": { + source: "iana", + compressible: true, + extensions: ["lasxml"] + }, + "application/vnd.laszip": { + source: "iana" + }, + "application/vnd.ldev.productlicensing": { + source: "iana" + }, + "application/vnd.leap+json": { + source: "iana", + compressible: true + }, + "application/vnd.liberty-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.llamagraphics.life-balance.desktop": { + source: "iana", + extensions: ["lbd"] + }, + "application/vnd.llamagraphics.life-balance.exchange+xml": { + source: "iana", + compressible: true, + extensions: ["lbe"] + }, + "application/vnd.logipipe.circuit+zip": { + source: "iana", + compressible: false + }, + "application/vnd.loom": { + source: "iana" + }, + "application/vnd.lotus-1-2-3": { + source: "iana", + extensions: ["123"] + }, + "application/vnd.lotus-approach": { + source: "iana", + extensions: ["apr"] + }, + "application/vnd.lotus-freelance": { + source: "iana", + extensions: ["pre"] + }, + "application/vnd.lotus-notes": { + source: "iana", + extensions: ["nsf"] + }, + "application/vnd.lotus-organizer": { + source: "iana", + extensions: ["org"] + }, + "application/vnd.lotus-screencam": { + source: "iana", + extensions: ["scm"] + }, + "application/vnd.lotus-wordpro": { + source: "iana", + extensions: ["lwp"] + }, + "application/vnd.macports.portpkg": { + source: "iana", + extensions: ["portpkg"] + }, + "application/vnd.mapbox-vector-tile": { + source: "iana", + extensions: ["mvt"] + }, + "application/vnd.marlin.drm.actiontoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.conftoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.license+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.mdcf": { + source: "iana" + }, + "application/vnd.mason+json": { + source: "iana", + compressible: true + }, + "application/vnd.maxar.archive.3tz+zip": { + source: "iana", + compressible: false + }, + "application/vnd.maxmind.maxmind-db": { + source: "iana" + }, + "application/vnd.mcd": { + source: "iana", + extensions: ["mcd"] + }, + "application/vnd.mdl": { + source: "iana" + }, + "application/vnd.mdl-mbsdf": { + source: "iana" + }, + "application/vnd.medcalcdata": { + source: "iana", + extensions: ["mc1"] + }, + "application/vnd.mediastation.cdkey": { + source: "iana", + extensions: ["cdkey"] + }, + "application/vnd.medicalholodeck.recordxr": { + source: "iana" + }, + "application/vnd.meridian-slingshot": { + source: "iana" + }, + "application/vnd.mermaid": { + source: "iana" + }, + "application/vnd.mfer": { + source: "iana", + extensions: ["mwf"] + }, + "application/vnd.mfmp": { + source: "iana", + extensions: ["mfm"] + }, + "application/vnd.micro+json": { + source: "iana", + compressible: true + }, + "application/vnd.micrografx.flo": { + source: "iana", + extensions: ["flo"] + }, + "application/vnd.micrografx.igx": { + source: "iana", + extensions: ["igx"] + }, + "application/vnd.microsoft.portable-executable": { + source: "iana" + }, + "application/vnd.microsoft.windows.thumbnail-cache": { + source: "iana" + }, + "application/vnd.miele+json": { + source: "iana", + compressible: true + }, + "application/vnd.mif": { + source: "iana", + extensions: ["mif"] + }, + "application/vnd.minisoft-hp3000-save": { + source: "iana" + }, + "application/vnd.mitsubishi.misty-guard.trustweb": { + source: "iana" + }, + "application/vnd.mobius.daf": { + source: "iana", + extensions: ["daf"] + }, + "application/vnd.mobius.dis": { + source: "iana", + extensions: ["dis"] + }, + "application/vnd.mobius.mbk": { + source: "iana", + extensions: ["mbk"] + }, + "application/vnd.mobius.mqy": { + source: "iana", + extensions: ["mqy"] + }, + "application/vnd.mobius.msl": { + source: "iana", + extensions: ["msl"] + }, + "application/vnd.mobius.plc": { + source: "iana", + extensions: ["plc"] + }, + "application/vnd.mobius.txf": { + source: "iana", + extensions: ["txf"] + }, + "application/vnd.modl": { + source: "iana" + }, + "application/vnd.mophun.application": { + source: "iana", + extensions: ["mpn"] + }, + "application/vnd.mophun.certificate": { + source: "iana", + extensions: ["mpc"] + }, + "application/vnd.motorola.flexsuite": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.adsi": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.fis": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.gotap": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.kmr": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.ttc": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.wem": { + source: "iana" + }, + "application/vnd.motorola.iprm": { + source: "iana" + }, + "application/vnd.mozilla.xul+xml": { + source: "iana", + compressible: true, + extensions: ["xul"] + }, + "application/vnd.ms-3mfdocument": { + source: "iana" + }, + "application/vnd.ms-artgalry": { + source: "iana", + extensions: ["cil"] + }, + "application/vnd.ms-asf": { + source: "iana" + }, + "application/vnd.ms-cab-compressed": { + source: "iana", + extensions: ["cab"] + }, + "application/vnd.ms-color.iccprofile": { + source: "apache" + }, + "application/vnd.ms-excel": { + source: "iana", + compressible: false, + extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] + }, + "application/vnd.ms-excel.addin.macroenabled.12": { + source: "iana", + extensions: ["xlam"] + }, + "application/vnd.ms-excel.sheet.binary.macroenabled.12": { + source: "iana", + extensions: ["xlsb"] + }, + "application/vnd.ms-excel.sheet.macroenabled.12": { + source: "iana", + extensions: ["xlsm"] + }, + "application/vnd.ms-excel.template.macroenabled.12": { + source: "iana", + extensions: ["xltm"] + }, + "application/vnd.ms-fontobject": { + source: "iana", + compressible: true, + extensions: ["eot"] + }, + "application/vnd.ms-htmlhelp": { + source: "iana", + extensions: ["chm"] + }, + "application/vnd.ms-ims": { + source: "iana", + extensions: ["ims"] + }, + "application/vnd.ms-lrm": { + source: "iana", + extensions: ["lrm"] + }, + "application/vnd.ms-office.activex+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-officetheme": { + source: "iana", + extensions: ["thmx"] + }, + "application/vnd.ms-opentype": { + source: "apache", + compressible: true + }, + "application/vnd.ms-outlook": { + compressible: false, + extensions: ["msg"] + }, + "application/vnd.ms-package.obfuscated-opentype": { + source: "apache" + }, + "application/vnd.ms-pki.seccat": { + source: "apache", + extensions: ["cat"] + }, + "application/vnd.ms-pki.stl": { + source: "apache", + extensions: ["stl"] + }, + "application/vnd.ms-playready.initiator+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-powerpoint": { + source: "iana", + compressible: false, + extensions: ["ppt", "pps", "pot"] + }, + "application/vnd.ms-powerpoint.addin.macroenabled.12": { + source: "iana", + extensions: ["ppam"] + }, + "application/vnd.ms-powerpoint.presentation.macroenabled.12": { + source: "iana", + extensions: ["pptm"] + }, + "application/vnd.ms-powerpoint.slide.macroenabled.12": { + source: "iana", + extensions: ["sldm"] + }, + "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { + source: "iana", + extensions: ["ppsm"] + }, + "application/vnd.ms-powerpoint.template.macroenabled.12": { + source: "iana", + extensions: ["potm"] + }, + "application/vnd.ms-printdevicecapabilities+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-printing.printticket+xml": { + source: "apache", + compressible: true + }, + "application/vnd.ms-printschematicket+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-project": { + source: "iana", + extensions: ["mpp", "mpt"] + }, + "application/vnd.ms-tnef": { + source: "iana" + }, + "application/vnd.ms-visio.viewer": { + extensions: ["vdx"] + }, + "application/vnd.ms-windows.devicepairing": { + source: "iana" + }, + "application/vnd.ms-windows.nwprinting.oob": { + source: "iana" + }, + "application/vnd.ms-windows.printerpairing": { + source: "iana" + }, + "application/vnd.ms-windows.wsd.oob": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-resp": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-resp": { + source: "iana" + }, + "application/vnd.ms-word.document.macroenabled.12": { + source: "iana", + extensions: ["docm"] + }, + "application/vnd.ms-word.template.macroenabled.12": { + source: "iana", + extensions: ["dotm"] + }, + "application/vnd.ms-works": { + source: "iana", + extensions: ["wps", "wks", "wcm", "wdb"] + }, + "application/vnd.ms-wpl": { + source: "iana", + extensions: ["wpl"] + }, + "application/vnd.ms-xpsdocument": { + source: "iana", + compressible: false, + extensions: ["xps"] + }, + "application/vnd.msa-disk-image": { + source: "iana" + }, + "application/vnd.mseq": { + source: "iana", + extensions: ["mseq"] + }, + "application/vnd.msgpack": { + source: "iana" + }, + "application/vnd.msign": { + source: "iana" + }, + "application/vnd.multiad.creator": { + source: "iana" + }, + "application/vnd.multiad.creator.cif": { + source: "iana" + }, + "application/vnd.music-niff": { + source: "iana" + }, + "application/vnd.musician": { + source: "iana", + extensions: ["mus"] + }, + "application/vnd.muvee.style": { + source: "iana", + extensions: ["msty"] + }, + "application/vnd.mynfc": { + source: "iana", + extensions: ["taglet"] + }, + "application/vnd.nacamar.ybrid+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+cbor": { + source: "iana" + }, + "application/vnd.nato.bindingdataobject+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+xml": { + source: "iana", + compressible: true, + extensions: ["bdo"] + }, + "application/vnd.nato.openxmlformats-package.iepd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.ncd.control": { + source: "iana" + }, + "application/vnd.ncd.reference": { + source: "iana" + }, + "application/vnd.nearst.inv+json": { + source: "iana", + compressible: true + }, + "application/vnd.nebumind.line": { + source: "iana" + }, + "application/vnd.nervana": { + source: "iana" + }, + "application/vnd.netfpx": { + source: "iana" + }, + "application/vnd.neurolanguage.nlu": { + source: "iana", + extensions: ["nlu"] + }, + "application/vnd.nimn": { + source: "iana" + }, + "application/vnd.nintendo.nitro.rom": { + source: "iana" + }, + "application/vnd.nintendo.snes.rom": { + source: "iana" + }, + "application/vnd.nitf": { + source: "iana", + extensions: ["ntf", "nitf"] + }, + "application/vnd.noblenet-directory": { + source: "iana", + extensions: ["nnd"] + }, + "application/vnd.noblenet-sealer": { + source: "iana", + extensions: ["nns"] + }, + "application/vnd.noblenet-web": { + source: "iana", + extensions: ["nnw"] + }, + "application/vnd.nokia.catalogs": { + source: "iana" + }, + "application/vnd.nokia.conml+wbxml": { + source: "iana" + }, + "application/vnd.nokia.conml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.iptv.config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.isds-radio-presets": { + source: "iana" + }, + "application/vnd.nokia.landmark+wbxml": { + source: "iana" + }, + "application/vnd.nokia.landmark+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.landmarkcollection+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.n-gage.ac+xml": { + source: "iana", + compressible: true, + extensions: ["ac"] + }, + "application/vnd.nokia.n-gage.data": { + source: "iana", + extensions: ["ngdat"] + }, + "application/vnd.nokia.n-gage.symbian.install": { + source: "apache", + extensions: ["n-gage"] + }, + "application/vnd.nokia.ncd": { + source: "iana" + }, + "application/vnd.nokia.pcd+wbxml": { + source: "iana" + }, + "application/vnd.nokia.pcd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.radio-preset": { + source: "iana", + extensions: ["rpst"] + }, + "application/vnd.nokia.radio-presets": { + source: "iana", + extensions: ["rpss"] + }, + "application/vnd.novadigm.edm": { + source: "iana", + extensions: ["edm"] + }, + "application/vnd.novadigm.edx": { + source: "iana", + extensions: ["edx"] + }, + "application/vnd.novadigm.ext": { + source: "iana", + extensions: ["ext"] + }, + "application/vnd.ntt-local.content-share": { + source: "iana" + }, + "application/vnd.ntt-local.file-transfer": { + source: "iana" + }, + "application/vnd.ntt-local.ogw_remote-access": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_remote": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_tcp_stream": { + source: "iana" + }, + "application/vnd.oai.workflows": { + source: "iana" + }, + "application/vnd.oai.workflows+json": { + source: "iana", + compressible: true + }, + "application/vnd.oai.workflows+yaml": { + source: "iana" + }, + "application/vnd.oasis.opendocument.base": { + source: "iana" + }, + "application/vnd.oasis.opendocument.chart": { + source: "iana", + extensions: ["odc"] + }, + "application/vnd.oasis.opendocument.chart-template": { + source: "iana", + extensions: ["otc"] + }, + "application/vnd.oasis.opendocument.database": { + source: "apache", + extensions: ["odb"] + }, + "application/vnd.oasis.opendocument.formula": { + source: "iana", + extensions: ["odf"] + }, + "application/vnd.oasis.opendocument.formula-template": { + source: "iana", + extensions: ["odft"] + }, + "application/vnd.oasis.opendocument.graphics": { + source: "iana", + compressible: false, + extensions: ["odg"] + }, + "application/vnd.oasis.opendocument.graphics-template": { + source: "iana", + extensions: ["otg"] + }, + "application/vnd.oasis.opendocument.image": { + source: "iana", + extensions: ["odi"] + }, + "application/vnd.oasis.opendocument.image-template": { + source: "iana", + extensions: ["oti"] + }, + "application/vnd.oasis.opendocument.presentation": { + source: "iana", + compressible: false, + extensions: ["odp"] + }, + "application/vnd.oasis.opendocument.presentation-template": { + source: "iana", + extensions: ["otp"] + }, + "application/vnd.oasis.opendocument.spreadsheet": { + source: "iana", + compressible: false, + extensions: ["ods"] + }, + "application/vnd.oasis.opendocument.spreadsheet-template": { + source: "iana", + extensions: ["ots"] + }, + "application/vnd.oasis.opendocument.text": { + source: "iana", + compressible: false, + extensions: ["odt"] + }, + "application/vnd.oasis.opendocument.text-master": { + source: "iana", + extensions: ["odm"] + }, + "application/vnd.oasis.opendocument.text-master-template": { + source: "iana" + }, + "application/vnd.oasis.opendocument.text-template": { + source: "iana", + extensions: ["ott"] + }, + "application/vnd.oasis.opendocument.text-web": { + source: "iana", + extensions: ["oth"] + }, + "application/vnd.obn": { + source: "iana" + }, + "application/vnd.ocf+cbor": { + source: "iana" + }, + "application/vnd.oci.image.manifest.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.oftn.l10n+json": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessdownload+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessstreaming+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.cspg-hexbinary": { + source: "iana" + }, + "application/vnd.oipf.dae.svg+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.dae.xhtml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.mippvcontrolmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.pae.gem": { + source: "iana" + }, + "application/vnd.oipf.spdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.spdlist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.ueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.userprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.olpc-sugar": { + source: "iana", + extensions: ["xo"] + }, + "application/vnd.oma-scws-config": { + source: "iana" + }, + "application/vnd.oma-scws-http-request": { + source: "iana" + }, + "application/vnd.oma-scws-http-response": { + source: "iana" + }, + "application/vnd.oma.bcast.associated-procedure-parameter+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.drm-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.imd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.ltkm": { + source: "iana" + }, + "application/vnd.oma.bcast.notification+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.provisioningtrigger": { + source: "iana" + }, + "application/vnd.oma.bcast.sgboot": { + source: "iana" + }, + "application/vnd.oma.bcast.sgdd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sgdu": { + source: "iana" + }, + "application/vnd.oma.bcast.simple-symbol-container": { + source: "iana" + }, + "application/vnd.oma.bcast.smartcard-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.sprov+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.stkm": { + source: "iana" + }, + "application/vnd.oma.cab-address-book+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-feature-handler+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-pcc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-subs-invite+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-user-prefs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.dcd": { + source: "iana" + }, + "application/vnd.oma.dcdc": { + source: "iana" + }, + "application/vnd.oma.dd2+xml": { + source: "iana", + compressible: true, + extensions: ["dd2"] + }, + "application/vnd.oma.drm.risd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.group-usage-list+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+cbor": { + source: "iana" + }, + "application/vnd.oma.lwm2m+json": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+tlv": { + source: "iana" + }, + "application/vnd.oma.pal+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.detailed-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.final-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.groups+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.invocation-descriptor+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.optimized-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.push": { + source: "iana" + }, + "application/vnd.oma.scidm.messages+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.xcap-directory+xml": { + source: "iana", + compressible: true + }, + "application/vnd.omads-email+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-file+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-folder+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omaloc-supl-init": { + source: "iana" + }, + "application/vnd.onepager": { + source: "iana" + }, + "application/vnd.onepagertamp": { + source: "iana" + }, + "application/vnd.onepagertamx": { + source: "iana" + }, + "application/vnd.onepagertat": { + source: "iana" + }, + "application/vnd.onepagertatp": { + source: "iana" + }, + "application/vnd.onepagertatx": { + source: "iana" + }, + "application/vnd.onvif.metadata": { + source: "iana" + }, + "application/vnd.openblox.game+xml": { + source: "iana", + compressible: true, + extensions: ["obgx"] + }, + "application/vnd.openblox.game-binary": { + source: "iana" + }, + "application/vnd.openeye.oeb": { + source: "iana" + }, + "application/vnd.openofficeorg.extension": { + source: "apache", + extensions: ["oxt"] + }, + "application/vnd.openstreetmap.data+xml": { + source: "iana", + compressible: true, + extensions: ["osm"] + }, + "application/vnd.opentimestamps.ots": { + source: "iana" + }, + "application/vnd.openvpi.dspx+json": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.custom-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawing+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.extended-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation": { + source: "iana", + compressible: false, + extensions: ["pptx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide": { + source: "iana", + extensions: ["sldx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { + source: "iana", + extensions: ["ppsx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.template": { + source: "iana", + extensions: ["potx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { + source: "iana", + compressible: false, + extensions: ["xlsx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { + source: "iana", + extensions: ["xltx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.theme+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.themeoverride+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.vmldrawing": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { + source: "iana", + compressible: false, + extensions: ["docx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { + source: "iana", + extensions: ["dotx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.core-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.relationships+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oracle.resource+json": { + source: "iana", + compressible: true + }, + "application/vnd.orange.indata": { + source: "iana" + }, + "application/vnd.osa.netdeploy": { + source: "iana" + }, + "application/vnd.osgeo.mapguide.package": { + source: "iana", + extensions: ["mgp"] + }, + "application/vnd.osgi.bundle": { + source: "iana" + }, + "application/vnd.osgi.dp": { + source: "iana", + extensions: ["dp"] + }, + "application/vnd.osgi.subsystem": { + source: "iana", + extensions: ["esa"] + }, + "application/vnd.otps.ct-kip+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oxli.countgraph": { + source: "iana" + }, + "application/vnd.pagerduty+json": { + source: "iana", + compressible: true + }, + "application/vnd.palm": { + source: "iana", + extensions: ["pdb", "pqa", "oprc"] + }, + "application/vnd.panoply": { + source: "iana" + }, + "application/vnd.paos.xml": { + source: "iana" + }, + "application/vnd.patentdive": { + source: "iana" + }, + "application/vnd.patientecommsdoc": { + source: "iana" + }, + "application/vnd.pawaafile": { + source: "iana", + extensions: ["paw"] + }, + "application/vnd.pcos": { + source: "iana" + }, + "application/vnd.pg.format": { + source: "iana", + extensions: ["str"] + }, + "application/vnd.pg.osasli": { + source: "iana", + extensions: ["ei6"] + }, + "application/vnd.piaccess.application-licence": { + source: "iana" + }, + "application/vnd.picsel": { + source: "iana", + extensions: ["efif"] + }, + "application/vnd.pmi.widget": { + source: "iana", + extensions: ["wg"] + }, + "application/vnd.poc.group-advertisement+xml": { + source: "iana", + compressible: true + }, + "application/vnd.pocketlearn": { + source: "iana", + extensions: ["plf"] + }, + "application/vnd.powerbuilder6": { + source: "iana", + extensions: ["pbd"] + }, + "application/vnd.powerbuilder6-s": { + source: "iana" + }, + "application/vnd.powerbuilder7": { + source: "iana" + }, + "application/vnd.powerbuilder7-s": { + source: "iana" + }, + "application/vnd.powerbuilder75": { + source: "iana" + }, + "application/vnd.powerbuilder75-s": { + source: "iana" + }, + "application/vnd.preminet": { + source: "iana" + }, + "application/vnd.previewsystems.box": { + source: "iana", + extensions: ["box"] + }, + "application/vnd.procrate.brushset": { + extensions: ["brushset"] + }, + "application/vnd.procreate.brush": { + extensions: ["brush"] + }, + "application/vnd.procreate.dream": { + extensions: ["drm"] + }, + "application/vnd.proteus.magazine": { + source: "iana", + extensions: ["mgz"] + }, + "application/vnd.psfs": { + source: "iana" + }, + "application/vnd.pt.mundusmundi": { + source: "iana" + }, + "application/vnd.publishare-delta-tree": { + source: "iana", + extensions: ["qps"] + }, + "application/vnd.pvi.ptid1": { + source: "iana", + extensions: ["ptid"] + }, + "application/vnd.pwg-multiplexed": { + source: "iana" + }, + "application/vnd.pwg-xhtml-print+xml": { + source: "iana", + compressible: true, + extensions: ["xhtm"] + }, + "application/vnd.qualcomm.brew-app-res": { + source: "iana" + }, + "application/vnd.quarantainenet": { + source: "iana" + }, + "application/vnd.quark.quarkxpress": { + source: "iana", + extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] + }, + "application/vnd.quobject-quoxdocument": { + source: "iana" + }, + "application/vnd.radisys.moml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-stream+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-base+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-detect+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-group+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-speech+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-transform+xml": { + source: "iana", + compressible: true + }, + "application/vnd.rainstor.data": { + source: "iana" + }, + "application/vnd.rapid": { + source: "iana" + }, + "application/vnd.rar": { + source: "iana", + extensions: ["rar"] + }, + "application/vnd.realvnc.bed": { + source: "iana", + extensions: ["bed"] + }, + "application/vnd.recordare.musicxml": { + source: "iana", + extensions: ["mxl"] + }, + "application/vnd.recordare.musicxml+xml": { + source: "iana", + compressible: true, + extensions: ["musicxml"] + }, + "application/vnd.relpipe": { + source: "iana" + }, + "application/vnd.renlearn.rlprint": { + source: "iana" + }, + "application/vnd.resilient.logic": { + source: "iana" + }, + "application/vnd.restful+json": { + source: "iana", + compressible: true + }, + "application/vnd.rig.cryptonote": { + source: "iana", + extensions: ["cryptonote"] + }, + "application/vnd.rim.cod": { + source: "apache", + extensions: ["cod"] + }, + "application/vnd.rn-realmedia": { + source: "apache", + extensions: ["rm"] + }, + "application/vnd.rn-realmedia-vbr": { + source: "apache", + extensions: ["rmvb"] + }, + "application/vnd.route66.link66+xml": { + source: "iana", + compressible: true, + extensions: ["link66"] + }, + "application/vnd.rs-274x": { + source: "iana" + }, + "application/vnd.ruckus.download": { + source: "iana" + }, + "application/vnd.s3sms": { + source: "iana" + }, + "application/vnd.sailingtracker.track": { + source: "iana", + extensions: ["st"] + }, + "application/vnd.sar": { + source: "iana" + }, + "application/vnd.sbm.cid": { + source: "iana" + }, + "application/vnd.sbm.mid2": { + source: "iana" + }, + "application/vnd.scribus": { + source: "iana" + }, + "application/vnd.sealed.3df": { + source: "iana" + }, + "application/vnd.sealed.csf": { + source: "iana" + }, + "application/vnd.sealed.doc": { + source: "iana" + }, + "application/vnd.sealed.eml": { + source: "iana" + }, + "application/vnd.sealed.mht": { + source: "iana" + }, + "application/vnd.sealed.net": { + source: "iana" + }, + "application/vnd.sealed.ppt": { + source: "iana" + }, + "application/vnd.sealed.tiff": { + source: "iana" + }, + "application/vnd.sealed.xls": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.html": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.pdf": { + source: "iana" + }, + "application/vnd.seemail": { + source: "iana", + extensions: ["see"] + }, + "application/vnd.seis+json": { + source: "iana", + compressible: true + }, + "application/vnd.sema": { + source: "iana", + extensions: ["sema"] + }, + "application/vnd.semd": { + source: "iana", + extensions: ["semd"] + }, + "application/vnd.semf": { + source: "iana", + extensions: ["semf"] + }, + "application/vnd.shade-save-file": { + source: "iana" + }, + "application/vnd.shana.informed.formdata": { + source: "iana", + extensions: ["ifm"] + }, + "application/vnd.shana.informed.formtemplate": { + source: "iana", + extensions: ["itp"] + }, + "application/vnd.shana.informed.interchange": { + source: "iana", + extensions: ["iif"] + }, + "application/vnd.shana.informed.package": { + source: "iana", + extensions: ["ipk"] + }, + "application/vnd.shootproof+json": { + source: "iana", + compressible: true + }, + "application/vnd.shopkick+json": { + source: "iana", + compressible: true + }, + "application/vnd.shp": { + source: "iana" + }, + "application/vnd.shx": { + source: "iana" + }, + "application/vnd.sigrok.session": { + source: "iana" + }, + "application/vnd.simtech-mindmapper": { + source: "iana", + extensions: ["twd", "twds"] + }, + "application/vnd.siren+json": { + source: "iana", + compressible: true + }, + "application/vnd.sketchometry": { + source: "iana" + }, + "application/vnd.smaf": { + source: "iana", + extensions: ["mmf"] + }, + "application/vnd.smart.notebook": { + source: "iana" + }, + "application/vnd.smart.teacher": { + source: "iana", + extensions: ["teacher"] + }, + "application/vnd.smintio.portals.archive": { + source: "iana" + }, + "application/vnd.snesdev-page-table": { + source: "iana" + }, + "application/vnd.software602.filler.form+xml": { + source: "iana", + compressible: true, + extensions: ["fo"] + }, + "application/vnd.software602.filler.form-xml-zip": { + source: "iana" + }, + "application/vnd.solent.sdkm+xml": { + source: "iana", + compressible: true, + extensions: ["sdkm", "sdkd"] + }, + "application/vnd.spotfire.dxp": { + source: "iana", + extensions: ["dxp"] + }, + "application/vnd.spotfire.sfs": { + source: "iana", + extensions: ["sfs"] + }, + "application/vnd.sqlite3": { + source: "iana" + }, + "application/vnd.sss-cod": { + source: "iana" + }, + "application/vnd.sss-dtf": { + source: "iana" + }, + "application/vnd.sss-ntf": { + source: "iana" + }, + "application/vnd.stardivision.calc": { + source: "apache", + extensions: ["sdc"] + }, + "application/vnd.stardivision.draw": { + source: "apache", + extensions: ["sda"] + }, + "application/vnd.stardivision.impress": { + source: "apache", + extensions: ["sdd"] + }, + "application/vnd.stardivision.math": { + source: "apache", + extensions: ["smf"] + }, + "application/vnd.stardivision.writer": { + source: "apache", + extensions: ["sdw", "vor"] + }, + "application/vnd.stardivision.writer-global": { + source: "apache", + extensions: ["sgl"] + }, + "application/vnd.stepmania.package": { + source: "iana", + extensions: ["smzip"] + }, + "application/vnd.stepmania.stepchart": { + source: "iana", + extensions: ["sm"] + }, + "application/vnd.street-stream": { + source: "iana" + }, + "application/vnd.sun.wadl+xml": { + source: "iana", + compressible: true, + extensions: ["wadl"] + }, + "application/vnd.sun.xml.calc": { + source: "apache", + extensions: ["sxc"] + }, + "application/vnd.sun.xml.calc.template": { + source: "apache", + extensions: ["stc"] + }, + "application/vnd.sun.xml.draw": { + source: "apache", + extensions: ["sxd"] + }, + "application/vnd.sun.xml.draw.template": { + source: "apache", + extensions: ["std"] + }, + "application/vnd.sun.xml.impress": { + source: "apache", + extensions: ["sxi"] + }, + "application/vnd.sun.xml.impress.template": { + source: "apache", + extensions: ["sti"] + }, + "application/vnd.sun.xml.math": { + source: "apache", + extensions: ["sxm"] + }, + "application/vnd.sun.xml.writer": { + source: "apache", + extensions: ["sxw"] + }, + "application/vnd.sun.xml.writer.global": { + source: "apache", + extensions: ["sxg"] + }, + "application/vnd.sun.xml.writer.template": { + source: "apache", + extensions: ["stw"] + }, + "application/vnd.sus-calendar": { + source: "iana", + extensions: ["sus", "susp"] + }, + "application/vnd.svd": { + source: "iana", + extensions: ["svd"] + }, + "application/vnd.swiftview-ics": { + source: "iana" + }, + "application/vnd.sybyl.mol2": { + source: "iana" + }, + "application/vnd.sycle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.syft+json": { + source: "iana", + compressible: true + }, + "application/vnd.symbian.install": { + source: "apache", + extensions: ["sis", "sisx"] + }, + "application/vnd.syncml+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xsm"] + }, + "application/vnd.syncml.dm+wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["bdm"] + }, + "application/vnd.syncml.dm+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xdm"] + }, + "application/vnd.syncml.dm.notification": { + source: "iana" + }, + "application/vnd.syncml.dmddf+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmddf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["ddf"] + }, + "application/vnd.syncml.dmtnds+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmtnds+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.syncml.ds.notification": { + source: "iana" + }, + "application/vnd.tableschema+json": { + source: "iana", + compressible: true + }, + "application/vnd.tao.intent-module-archive": { + source: "iana", + extensions: ["tao"] + }, + "application/vnd.tcpdump.pcap": { + source: "iana", + extensions: ["pcap", "cap", "dmp"] + }, + "application/vnd.think-cell.ppttc+json": { + source: "iana", + compressible: true + }, + "application/vnd.tmd.mediaflex.api+xml": { + source: "iana", + compressible: true + }, + "application/vnd.tml": { + source: "iana" + }, + "application/vnd.tmobile-livetv": { + source: "iana", + extensions: ["tmo"] + }, + "application/vnd.tri.onesource": { + source: "iana" + }, + "application/vnd.trid.tpt": { + source: "iana", + extensions: ["tpt"] + }, + "application/vnd.triscape.mxs": { + source: "iana", + extensions: ["mxs"] + }, + "application/vnd.trueapp": { + source: "iana", + extensions: ["tra"] + }, + "application/vnd.truedoc": { + source: "iana" + }, + "application/vnd.ubisoft.webplayer": { + source: "iana" + }, + "application/vnd.ufdl": { + source: "iana", + extensions: ["ufd", "ufdl"] + }, + "application/vnd.uic.osdm+json": { + source: "iana", + compressible: true + }, + "application/vnd.uiq.theme": { + source: "iana", + extensions: ["utz"] + }, + "application/vnd.umajin": { + source: "iana", + extensions: ["umj"] + }, + "application/vnd.unity": { + source: "iana", + extensions: ["unityweb"] + }, + "application/vnd.uoml+xml": { + source: "iana", + compressible: true, + extensions: ["uoml", "uo"] + }, + "application/vnd.uplanet.alert": { + source: "iana" + }, + "application/vnd.uplanet.alert-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.cacheop": { + source: "iana" + }, + "application/vnd.uplanet.cacheop-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.channel": { + source: "iana" + }, + "application/vnd.uplanet.channel-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.list": { + source: "iana" + }, + "application/vnd.uplanet.list-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.listcmd": { + source: "iana" + }, + "application/vnd.uplanet.listcmd-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.signal": { + source: "iana" + }, + "application/vnd.uri-map": { + source: "iana" + }, + "application/vnd.valve.source.material": { + source: "iana" + }, + "application/vnd.vcx": { + source: "iana", + extensions: ["vcx"] + }, + "application/vnd.vd-study": { + source: "iana" + }, + "application/vnd.vectorworks": { + source: "iana" + }, + "application/vnd.vel+json": { + source: "iana", + compressible: true + }, + "application/vnd.veraison.tsm-report+cbor": { + source: "iana" + }, + "application/vnd.veraison.tsm-report+json": { + source: "iana", + compressible: true + }, + "application/vnd.verimatrix.vcas": { + source: "iana" + }, + "application/vnd.veritone.aion+json": { + source: "iana", + compressible: true + }, + "application/vnd.veryant.thin": { + source: "iana" + }, + "application/vnd.ves.encrypted": { + source: "iana" + }, + "application/vnd.vidsoft.vidconference": { + source: "iana" + }, + "application/vnd.visio": { + source: "iana", + extensions: ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"] + }, + "application/vnd.visionary": { + source: "iana", + extensions: ["vis"] + }, + "application/vnd.vividence.scriptfile": { + source: "iana" + }, + "application/vnd.vocalshaper.vsp4": { + source: "iana" + }, + "application/vnd.vsf": { + source: "iana", + extensions: ["vsf"] + }, + "application/vnd.wap.sic": { + source: "iana" + }, + "application/vnd.wap.slc": { + source: "iana" + }, + "application/vnd.wap.wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["wbxml"] + }, + "application/vnd.wap.wmlc": { + source: "iana", + extensions: ["wmlc"] + }, + "application/vnd.wap.wmlscriptc": { + source: "iana", + extensions: ["wmlsc"] + }, + "application/vnd.wasmflow.wafl": { + source: "iana" + }, + "application/vnd.webturbo": { + source: "iana", + extensions: ["wtb"] + }, + "application/vnd.wfa.dpp": { + source: "iana" + }, + "application/vnd.wfa.p2p": { + source: "iana" + }, + "application/vnd.wfa.wsc": { + source: "iana" + }, + "application/vnd.windows.devicepairing": { + source: "iana" + }, + "application/vnd.wmc": { + source: "iana" + }, + "application/vnd.wmf.bootstrap": { + source: "iana" + }, + "application/vnd.wolfram.mathematica": { + source: "iana" + }, + "application/vnd.wolfram.mathematica.package": { + source: "iana" + }, + "application/vnd.wolfram.player": { + source: "iana", + extensions: ["nbp"] + }, + "application/vnd.wordlift": { + source: "iana" + }, + "application/vnd.wordperfect": { + source: "iana", + extensions: ["wpd"] + }, + "application/vnd.wqd": { + source: "iana", + extensions: ["wqd"] + }, + "application/vnd.wrq-hp3000-labelled": { + source: "iana" + }, + "application/vnd.wt.stf": { + source: "iana", + extensions: ["stf"] + }, + "application/vnd.wv.csp+wbxml": { + source: "iana" + }, + "application/vnd.wv.csp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.wv.ssp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xacml+json": { + source: "iana", + compressible: true + }, + "application/vnd.xara": { + source: "iana", + extensions: ["xar"] + }, + "application/vnd.xarin.cpj": { + source: "iana" + }, + "application/vnd.xecrets-encrypted": { + source: "iana" + }, + "application/vnd.xfdl": { + source: "iana", + extensions: ["xfdl"] + }, + "application/vnd.xfdl.webform": { + source: "iana" + }, + "application/vnd.xmi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xmpie.cpkg": { + source: "iana" + }, + "application/vnd.xmpie.dpkg": { + source: "iana" + }, + "application/vnd.xmpie.plan": { + source: "iana" + }, + "application/vnd.xmpie.ppkg": { + source: "iana" + }, + "application/vnd.xmpie.xlim": { + source: "iana" + }, + "application/vnd.yamaha.hv-dic": { + source: "iana", + extensions: ["hvd"] + }, + "application/vnd.yamaha.hv-script": { + source: "iana", + extensions: ["hvs"] + }, + "application/vnd.yamaha.hv-voice": { + source: "iana", + extensions: ["hvp"] + }, + "application/vnd.yamaha.openscoreformat": { + source: "iana", + extensions: ["osf"] + }, + "application/vnd.yamaha.openscoreformat.osfpvg+xml": { + source: "iana", + compressible: true, + extensions: ["osfpvg"] + }, + "application/vnd.yamaha.remote-setup": { + source: "iana" + }, + "application/vnd.yamaha.smaf-audio": { + source: "iana", + extensions: ["saf"] + }, + "application/vnd.yamaha.smaf-phrase": { + source: "iana", + extensions: ["spf"] + }, + "application/vnd.yamaha.through-ngn": { + source: "iana" + }, + "application/vnd.yamaha.tunnel-udpencap": { + source: "iana" + }, + "application/vnd.yaoweme": { + source: "iana" + }, + "application/vnd.yellowriver-custom-menu": { + source: "iana", + extensions: ["cmp"] + }, + "application/vnd.zul": { + source: "iana", + extensions: ["zir", "zirz"] + }, + "application/vnd.zzazz.deck+xml": { + source: "iana", + compressible: true, + extensions: ["zaz"] + }, + "application/voicexml+xml": { + source: "iana", + compressible: true, + extensions: ["vxml"] + }, + "application/voucher-cms+json": { + source: "iana", + compressible: true + }, + "application/voucher-jws+json": { + source: "iana", + compressible: true + }, + "application/vp": { + source: "iana" + }, + "application/vp+cose": { + source: "iana" + }, + "application/vp+jwt": { + source: "iana" + }, + "application/vq-rtcpxr": { + source: "iana" + }, + "application/wasm": { + source: "iana", + compressible: true, + extensions: ["wasm"] + }, + "application/watcherinfo+xml": { + source: "iana", + compressible: true, + extensions: ["wif"] + }, + "application/webpush-options+json": { + source: "iana", + compressible: true + }, + "application/whoispp-query": { + source: "iana" + }, + "application/whoispp-response": { + source: "iana" + }, + "application/widget": { + source: "iana", + extensions: ["wgt"] + }, + "application/winhlp": { + source: "apache", + extensions: ["hlp"] + }, + "application/wita": { + source: "iana" + }, + "application/wordperfect5.1": { + source: "iana" + }, + "application/wsdl+xml": { + source: "iana", + compressible: true, + extensions: ["wsdl"] + }, + "application/wspolicy+xml": { + source: "iana", + compressible: true, + extensions: ["wspolicy"] + }, + "application/x-7z-compressed": { + source: "apache", + compressible: false, + extensions: ["7z"] + }, + "application/x-abiword": { + source: "apache", + extensions: ["abw"] + }, + "application/x-ace-compressed": { + source: "apache", + extensions: ["ace"] + }, + "application/x-amf": { + source: "apache" + }, + "application/x-apple-diskimage": { + source: "apache", + extensions: ["dmg"] + }, + "application/x-arj": { + compressible: false, + extensions: ["arj"] + }, + "application/x-authorware-bin": { + source: "apache", + extensions: ["aab", "x32", "u32", "vox"] + }, + "application/x-authorware-map": { + source: "apache", + extensions: ["aam"] + }, + "application/x-authorware-seg": { + source: "apache", + extensions: ["aas"] + }, + "application/x-bcpio": { + source: "apache", + extensions: ["bcpio"] + }, + "application/x-bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/x-bittorrent": { + source: "apache", + extensions: ["torrent"] + }, + "application/x-blender": { + extensions: ["blend"] + }, + "application/x-blorb": { + source: "apache", + extensions: ["blb", "blorb"] + }, + "application/x-bzip": { + source: "apache", + compressible: false, + extensions: ["bz"] + }, + "application/x-bzip2": { + source: "apache", + compressible: false, + extensions: ["bz2", "boz"] + }, + "application/x-cbr": { + source: "apache", + extensions: ["cbr", "cba", "cbt", "cbz", "cb7"] + }, + "application/x-cdlink": { + source: "apache", + extensions: ["vcd"] + }, + "application/x-cfs-compressed": { + source: "apache", + extensions: ["cfs"] + }, + "application/x-chat": { + source: "apache", + extensions: ["chat"] + }, + "application/x-chess-pgn": { + source: "apache", + extensions: ["pgn"] + }, + "application/x-chrome-extension": { + extensions: ["crx"] + }, + "application/x-cocoa": { + source: "nginx", + extensions: ["cco"] + }, + "application/x-compress": { + source: "apache" + }, + "application/x-compressed": { + extensions: ["rar"] + }, + "application/x-conference": { + source: "apache", + extensions: ["nsc"] + }, + "application/x-cpio": { + source: "apache", + extensions: ["cpio"] + }, + "application/x-csh": { + source: "apache", + extensions: ["csh"] + }, + "application/x-deb": { + compressible: false + }, + "application/x-debian-package": { + source: "apache", + extensions: ["deb", "udeb"] + }, + "application/x-dgc-compressed": { + source: "apache", + extensions: ["dgc"] + }, + "application/x-director": { + source: "apache", + extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] + }, + "application/x-doom": { + source: "apache", + extensions: ["wad"] + }, + "application/x-dtbncx+xml": { + source: "apache", + compressible: true, + extensions: ["ncx"] + }, + "application/x-dtbook+xml": { + source: "apache", + compressible: true, + extensions: ["dtb"] + }, + "application/x-dtbresource+xml": { + source: "apache", + compressible: true, + extensions: ["res"] + }, + "application/x-dvi": { + source: "apache", + compressible: false, + extensions: ["dvi"] + }, + "application/x-envoy": { + source: "apache", + extensions: ["evy"] + }, + "application/x-eva": { + source: "apache", + extensions: ["eva"] + }, + "application/x-font-bdf": { + source: "apache", + extensions: ["bdf"] + }, + "application/x-font-dos": { + source: "apache" + }, + "application/x-font-framemaker": { + source: "apache" + }, + "application/x-font-ghostscript": { + source: "apache", + extensions: ["gsf"] + }, + "application/x-font-libgrx": { + source: "apache" + }, + "application/x-font-linux-psf": { + source: "apache", + extensions: ["psf"] + }, + "application/x-font-pcf": { + source: "apache", + extensions: ["pcf"] + }, + "application/x-font-snf": { + source: "apache", + extensions: ["snf"] + }, + "application/x-font-speedo": { + source: "apache" + }, + "application/x-font-sunos-news": { + source: "apache" + }, + "application/x-font-type1": { + source: "apache", + extensions: ["pfa", "pfb", "pfm", "afm"] + }, + "application/x-font-vfont": { + source: "apache" + }, + "application/x-freearc": { + source: "apache", + extensions: ["arc"] + }, + "application/x-futuresplash": { + source: "apache", + extensions: ["spl"] + }, + "application/x-gca-compressed": { + source: "apache", + extensions: ["gca"] + }, + "application/x-glulx": { + source: "apache", + extensions: ["ulx"] + }, + "application/x-gnumeric": { + source: "apache", + extensions: ["gnumeric"] + }, + "application/x-gramps-xml": { + source: "apache", + extensions: ["gramps"] + }, + "application/x-gtar": { + source: "apache", + extensions: ["gtar"] + }, + "application/x-gzip": { + source: "apache" + }, + "application/x-hdf": { + source: "apache", + extensions: ["hdf"] + }, + "application/x-httpd-php": { + compressible: true, + extensions: ["php"] + }, + "application/x-install-instructions": { + source: "apache", + extensions: ["install"] + }, + "application/x-ipynb+json": { + compressible: true, + extensions: ["ipynb"] + }, + "application/x-iso9660-image": { + source: "apache", + extensions: ["iso"] + }, + "application/x-iwork-keynote-sffkey": { + extensions: ["key"] + }, + "application/x-iwork-numbers-sffnumbers": { + extensions: ["numbers"] + }, + "application/x-iwork-pages-sffpages": { + extensions: ["pages"] + }, + "application/x-java-archive-diff": { + source: "nginx", + extensions: ["jardiff"] + }, + "application/x-java-jnlp-file": { + source: "apache", + compressible: false, + extensions: ["jnlp"] + }, + "application/x-javascript": { + compressible: true + }, + "application/x-keepass2": { + extensions: ["kdbx"] + }, + "application/x-latex": { + source: "apache", + compressible: false, + extensions: ["latex"] + }, + "application/x-lua-bytecode": { + extensions: ["luac"] + }, + "application/x-lzh-compressed": { + source: "apache", + extensions: ["lzh", "lha"] + }, + "application/x-makeself": { + source: "nginx", + extensions: ["run"] + }, + "application/x-mie": { + source: "apache", + extensions: ["mie"] + }, + "application/x-mobipocket-ebook": { + source: "apache", + extensions: ["prc", "mobi"] + }, + "application/x-mpegurl": { + compressible: false + }, + "application/x-ms-application": { + source: "apache", + extensions: ["application"] + }, + "application/x-ms-shortcut": { + source: "apache", + extensions: ["lnk"] + }, + "application/x-ms-wmd": { + source: "apache", + extensions: ["wmd"] + }, + "application/x-ms-wmz": { + source: "apache", + extensions: ["wmz"] + }, + "application/x-ms-xbap": { + source: "apache", + extensions: ["xbap"] + }, + "application/x-msaccess": { + source: "apache", + extensions: ["mdb"] + }, + "application/x-msbinder": { + source: "apache", + extensions: ["obd"] + }, + "application/x-mscardfile": { + source: "apache", + extensions: ["crd"] + }, + "application/x-msclip": { + source: "apache", + extensions: ["clp"] + }, + "application/x-msdos-program": { + extensions: ["exe"] + }, + "application/x-msdownload": { + source: "apache", + extensions: ["exe", "dll", "com", "bat", "msi"] + }, + "application/x-msmediaview": { + source: "apache", + extensions: ["mvb", "m13", "m14"] + }, + "application/x-msmetafile": { + source: "apache", + extensions: ["wmf", "wmz", "emf", "emz"] + }, + "application/x-msmoney": { + source: "apache", + extensions: ["mny"] + }, + "application/x-mspublisher": { + source: "apache", + extensions: ["pub"] + }, + "application/x-msschedule": { + source: "apache", + extensions: ["scd"] + }, + "application/x-msterminal": { + source: "apache", + extensions: ["trm"] + }, + "application/x-mswrite": { + source: "apache", + extensions: ["wri"] + }, + "application/x-netcdf": { + source: "apache", + extensions: ["nc", "cdf"] + }, + "application/x-ns-proxy-autoconfig": { + compressible: true, + extensions: ["pac"] + }, + "application/x-nzb": { + source: "apache", + extensions: ["nzb"] + }, + "application/x-perl": { + source: "nginx", + extensions: ["pl", "pm"] + }, + "application/x-pilot": { + source: "nginx", + extensions: ["prc", "pdb"] + }, + "application/x-pkcs12": { + source: "apache", + compressible: false, + extensions: ["p12", "pfx"] + }, + "application/x-pkcs7-certificates": { + source: "apache", + extensions: ["p7b", "spc"] + }, + "application/x-pkcs7-certreqresp": { + source: "apache", + extensions: ["p7r"] + }, + "application/x-pki-message": { + source: "iana" + }, + "application/x-rar-compressed": { + source: "apache", + compressible: false, + extensions: ["rar"] + }, + "application/x-redhat-package-manager": { + source: "nginx", + extensions: ["rpm"] + }, + "application/x-research-info-systems": { + source: "apache", + extensions: ["ris"] + }, + "application/x-sea": { + source: "nginx", + extensions: ["sea"] + }, + "application/x-sh": { + source: "apache", + compressible: true, + extensions: ["sh"] + }, + "application/x-shar": { + source: "apache", + extensions: ["shar"] + }, + "application/x-shockwave-flash": { + source: "apache", + compressible: false, + extensions: ["swf"] + }, + "application/x-silverlight-app": { + source: "apache", + extensions: ["xap"] + }, + "application/x-sql": { + source: "apache", + extensions: ["sql"] + }, + "application/x-stuffit": { + source: "apache", + compressible: false, + extensions: ["sit"] + }, + "application/x-stuffitx": { + source: "apache", + extensions: ["sitx"] + }, + "application/x-subrip": { + source: "apache", + extensions: ["srt"] + }, + "application/x-sv4cpio": { + source: "apache", + extensions: ["sv4cpio"] + }, + "application/x-sv4crc": { + source: "apache", + extensions: ["sv4crc"] + }, + "application/x-t3vm-image": { + source: "apache", + extensions: ["t3"] + }, + "application/x-tads": { + source: "apache", + extensions: ["gam"] + }, + "application/x-tar": { + source: "apache", + compressible: true, + extensions: ["tar"] + }, + "application/x-tcl": { + source: "apache", + extensions: ["tcl", "tk"] + }, + "application/x-tex": { + source: "apache", + extensions: ["tex"] + }, + "application/x-tex-tfm": { + source: "apache", + extensions: ["tfm"] + }, + "application/x-texinfo": { + source: "apache", + extensions: ["texinfo", "texi"] + }, + "application/x-tgif": { + source: "apache", + extensions: ["obj"] + }, + "application/x-ustar": { + source: "apache", + extensions: ["ustar"] + }, + "application/x-virtualbox-hdd": { + compressible: true, + extensions: ["hdd"] + }, + "application/x-virtualbox-ova": { + compressible: true, + extensions: ["ova"] + }, + "application/x-virtualbox-ovf": { + compressible: true, + extensions: ["ovf"] + }, + "application/x-virtualbox-vbox": { + compressible: true, + extensions: ["vbox"] + }, + "application/x-virtualbox-vbox-extpack": { + compressible: false, + extensions: ["vbox-extpack"] + }, + "application/x-virtualbox-vdi": { + compressible: true, + extensions: ["vdi"] + }, + "application/x-virtualbox-vhd": { + compressible: true, + extensions: ["vhd"] + }, + "application/x-virtualbox-vmdk": { + compressible: true, + extensions: ["vmdk"] + }, + "application/x-wais-source": { + source: "apache", + extensions: ["src"] + }, + "application/x-web-app-manifest+json": { + compressible: true, + extensions: ["webapp"] + }, + "application/x-www-form-urlencoded": { + source: "iana", + compressible: true + }, + "application/x-x509-ca-cert": { + source: "iana", + extensions: ["der", "crt", "pem"] + }, + "application/x-x509-ca-ra-cert": { + source: "iana" + }, + "application/x-x509-next-ca-cert": { + source: "iana" + }, + "application/x-xfig": { + source: "apache", + extensions: ["fig"] + }, + "application/x-xliff+xml": { + source: "apache", + compressible: true, + extensions: ["xlf"] + }, + "application/x-xpinstall": { + source: "apache", + compressible: false, + extensions: ["xpi"] + }, + "application/x-xz": { + source: "apache", + extensions: ["xz"] + }, + "application/x-zip-compressed": { + extensions: ["zip"] + }, + "application/x-zmachine": { + source: "apache", + extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] + }, + "application/x400-bp": { + source: "iana" + }, + "application/xacml+xml": { + source: "iana", + compressible: true + }, + "application/xaml+xml": { + source: "apache", + compressible: true, + extensions: ["xaml"] + }, + "application/xcap-att+xml": { + source: "iana", + compressible: true, + extensions: ["xav"] + }, + "application/xcap-caps+xml": { + source: "iana", + compressible: true, + extensions: ["xca"] + }, + "application/xcap-diff+xml": { + source: "iana", + compressible: true, + extensions: ["xdf"] + }, + "application/xcap-el+xml": { + source: "iana", + compressible: true, + extensions: ["xel"] + }, + "application/xcap-error+xml": { + source: "iana", + compressible: true + }, + "application/xcap-ns+xml": { + source: "iana", + compressible: true, + extensions: ["xns"] + }, + "application/xcon-conference-info+xml": { + source: "iana", + compressible: true + }, + "application/xcon-conference-info-diff+xml": { + source: "iana", + compressible: true + }, + "application/xenc+xml": { + source: "iana", + compressible: true, + extensions: ["xenc"] + }, + "application/xfdf": { + source: "iana", + extensions: ["xfdf"] + }, + "application/xhtml+xml": { + source: "iana", + compressible: true, + extensions: ["xhtml", "xht"] + }, + "application/xhtml-voice+xml": { + source: "apache", + compressible: true + }, + "application/xliff+xml": { + source: "iana", + compressible: true, + extensions: ["xlf"] + }, + "application/xml": { + source: "iana", + compressible: true, + extensions: ["xml", "xsl", "xsd", "rng"] + }, + "application/xml-dtd": { + source: "iana", + compressible: true, + extensions: ["dtd"] + }, + "application/xml-external-parsed-entity": { + source: "iana" + }, + "application/xml-patch+xml": { + source: "iana", + compressible: true + }, + "application/xmpp+xml": { + source: "iana", + compressible: true + }, + "application/xop+xml": { + source: "iana", + compressible: true, + extensions: ["xop"] + }, + "application/xproc+xml": { + source: "apache", + compressible: true, + extensions: ["xpl"] + }, + "application/xslt+xml": { + source: "iana", + compressible: true, + extensions: ["xsl", "xslt"] + }, + "application/xspf+xml": { + source: "apache", + compressible: true, + extensions: ["xspf"] + }, + "application/xv+xml": { + source: "iana", + compressible: true, + extensions: ["mxml", "xhvml", "xvml", "xvm"] + }, + "application/yaml": { + source: "iana" + }, + "application/yang": { + source: "iana", + extensions: ["yang"] + }, + "application/yang-data+cbor": { + source: "iana" + }, + "application/yang-data+json": { + source: "iana", + compressible: true + }, + "application/yang-data+xml": { + source: "iana", + compressible: true + }, + "application/yang-patch+json": { + source: "iana", + compressible: true + }, + "application/yang-patch+xml": { + source: "iana", + compressible: true + }, + "application/yang-sid+json": { + source: "iana", + compressible: true + }, + "application/yin+xml": { + source: "iana", + compressible: true, + extensions: ["yin"] + }, + "application/zip": { + source: "iana", + compressible: false, + extensions: ["zip"] + }, + "application/zip+dotlottie": { + extensions: ["lottie"] + }, + "application/zlib": { + source: "iana" + }, + "application/zstd": { + source: "iana" + }, + "audio/1d-interleaved-parityfec": { + source: "iana" + }, + "audio/32kadpcm": { + source: "iana" + }, + "audio/3gpp": { + source: "iana", + compressible: false, + extensions: ["3gpp"] + }, + "audio/3gpp2": { + source: "iana" + }, + "audio/aac": { + source: "iana", + extensions: ["adts", "aac"] + }, + "audio/ac3": { + source: "iana" + }, + "audio/adpcm": { + source: "apache", + extensions: ["adp"] + }, + "audio/amr": { + source: "iana", + extensions: ["amr"] + }, + "audio/amr-wb": { + source: "iana" + }, + "audio/amr-wb+": { + source: "iana" + }, + "audio/aptx": { + source: "iana" + }, + "audio/asc": { + source: "iana" + }, + "audio/atrac-advanced-lossless": { + source: "iana" + }, + "audio/atrac-x": { + source: "iana" + }, + "audio/atrac3": { + source: "iana" + }, + "audio/basic": { + source: "iana", + compressible: false, + extensions: ["au", "snd"] + }, + "audio/bv16": { + source: "iana" + }, + "audio/bv32": { + source: "iana" + }, + "audio/clearmode": { + source: "iana" + }, + "audio/cn": { + source: "iana" + }, + "audio/dat12": { + source: "iana" + }, + "audio/dls": { + source: "iana" + }, + "audio/dsr-es201108": { + source: "iana" + }, + "audio/dsr-es202050": { + source: "iana" + }, + "audio/dsr-es202211": { + source: "iana" + }, + "audio/dsr-es202212": { + source: "iana" + }, + "audio/dv": { + source: "iana" + }, + "audio/dvi4": { + source: "iana" + }, + "audio/eac3": { + source: "iana" + }, + "audio/encaprtp": { + source: "iana" + }, + "audio/evrc": { + source: "iana" + }, + "audio/evrc-qcp": { + source: "iana" + }, + "audio/evrc0": { + source: "iana" + }, + "audio/evrc1": { + source: "iana" + }, + "audio/evrcb": { + source: "iana" + }, + "audio/evrcb0": { + source: "iana" + }, + "audio/evrcb1": { + source: "iana" + }, + "audio/evrcnw": { + source: "iana" + }, + "audio/evrcnw0": { + source: "iana" + }, + "audio/evrcnw1": { + source: "iana" + }, + "audio/evrcwb": { + source: "iana" + }, + "audio/evrcwb0": { + source: "iana" + }, + "audio/evrcwb1": { + source: "iana" + }, + "audio/evs": { + source: "iana" + }, + "audio/flac": { + source: "iana" + }, + "audio/flexfec": { + source: "iana" + }, + "audio/fwdred": { + source: "iana" + }, + "audio/g711-0": { + source: "iana" + }, + "audio/g719": { + source: "iana" + }, + "audio/g722": { + source: "iana" + }, + "audio/g7221": { + source: "iana" + }, + "audio/g723": { + source: "iana" + }, + "audio/g726-16": { + source: "iana" + }, + "audio/g726-24": { + source: "iana" + }, + "audio/g726-32": { + source: "iana" + }, + "audio/g726-40": { + source: "iana" + }, + "audio/g728": { + source: "iana" + }, + "audio/g729": { + source: "iana" + }, + "audio/g7291": { + source: "iana" + }, + "audio/g729d": { + source: "iana" + }, + "audio/g729e": { + source: "iana" + }, + "audio/gsm": { + source: "iana" + }, + "audio/gsm-efr": { + source: "iana" + }, + "audio/gsm-hr-08": { + source: "iana" + }, + "audio/ilbc": { + source: "iana" + }, + "audio/ip-mr_v2.5": { + source: "iana" + }, + "audio/isac": { + source: "apache" + }, + "audio/l16": { + source: "iana" + }, + "audio/l20": { + source: "iana" + }, + "audio/l24": { + source: "iana", + compressible: false + }, + "audio/l8": { + source: "iana" + }, + "audio/lpc": { + source: "iana" + }, + "audio/matroska": { + source: "iana" + }, + "audio/melp": { + source: "iana" + }, + "audio/melp1200": { + source: "iana" + }, + "audio/melp2400": { + source: "iana" + }, + "audio/melp600": { + source: "iana" + }, + "audio/mhas": { + source: "iana" + }, + "audio/midi": { + source: "apache", + extensions: ["mid", "midi", "kar", "rmi"] + }, + "audio/midi-clip": { + source: "iana" + }, + "audio/mobile-xmf": { + source: "iana", + extensions: ["mxmf"] + }, + "audio/mp3": { + compressible: false, + extensions: ["mp3"] + }, + "audio/mp4": { + source: "iana", + compressible: false, + extensions: ["m4a", "mp4a", "m4b"] + }, + "audio/mp4a-latm": { + source: "iana" + }, + "audio/mpa": { + source: "iana" + }, + "audio/mpa-robust": { + source: "iana" + }, + "audio/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] + }, + "audio/mpeg4-generic": { + source: "iana" + }, + "audio/musepack": { + source: "apache" + }, + "audio/ogg": { + source: "iana", + compressible: false, + extensions: ["oga", "ogg", "spx", "opus"] + }, + "audio/opus": { + source: "iana" + }, + "audio/parityfec": { + source: "iana" + }, + "audio/pcma": { + source: "iana" + }, + "audio/pcma-wb": { + source: "iana" + }, + "audio/pcmu": { + source: "iana" + }, + "audio/pcmu-wb": { + source: "iana" + }, + "audio/prs.sid": { + source: "iana" + }, + "audio/qcelp": { + source: "iana" + }, + "audio/raptorfec": { + source: "iana" + }, + "audio/red": { + source: "iana" + }, + "audio/rtp-enc-aescm128": { + source: "iana" + }, + "audio/rtp-midi": { + source: "iana" + }, + "audio/rtploopback": { + source: "iana" + }, + "audio/rtx": { + source: "iana" + }, + "audio/s3m": { + source: "apache", + extensions: ["s3m"] + }, + "audio/scip": { + source: "iana" + }, + "audio/silk": { + source: "apache", + extensions: ["sil"] + }, + "audio/smv": { + source: "iana" + }, + "audio/smv-qcp": { + source: "iana" + }, + "audio/smv0": { + source: "iana" + }, + "audio/sofa": { + source: "iana" + }, + "audio/sp-midi": { + source: "iana" + }, + "audio/speex": { + source: "iana" + }, + "audio/t140c": { + source: "iana" + }, + "audio/t38": { + source: "iana" + }, + "audio/telephone-event": { + source: "iana" + }, + "audio/tetra_acelp": { + source: "iana" + }, + "audio/tetra_acelp_bb": { + source: "iana" + }, + "audio/tone": { + source: "iana" + }, + "audio/tsvcis": { + source: "iana" + }, + "audio/uemclip": { + source: "iana" + }, + "audio/ulpfec": { + source: "iana" + }, + "audio/usac": { + source: "iana" + }, + "audio/vdvi": { + source: "iana" + }, + "audio/vmr-wb": { + source: "iana" + }, + "audio/vnd.3gpp.iufp": { + source: "iana" + }, + "audio/vnd.4sb": { + source: "iana" + }, + "audio/vnd.audiokoz": { + source: "iana" + }, + "audio/vnd.celp": { + source: "iana" + }, + "audio/vnd.cisco.nse": { + source: "iana" + }, + "audio/vnd.cmles.radio-events": { + source: "iana" + }, + "audio/vnd.cns.anp1": { + source: "iana" + }, + "audio/vnd.cns.inf1": { + source: "iana" + }, + "audio/vnd.dece.audio": { + source: "iana", + extensions: ["uva", "uvva"] + }, + "audio/vnd.digital-winds": { + source: "iana", + extensions: ["eol"] + }, + "audio/vnd.dlna.adts": { + source: "iana" + }, + "audio/vnd.dolby.heaac.1": { + source: "iana" + }, + "audio/vnd.dolby.heaac.2": { + source: "iana" + }, + "audio/vnd.dolby.mlp": { + source: "iana" + }, + "audio/vnd.dolby.mps": { + source: "iana" + }, + "audio/vnd.dolby.pl2": { + source: "iana" + }, + "audio/vnd.dolby.pl2x": { + source: "iana" + }, + "audio/vnd.dolby.pl2z": { + source: "iana" + }, + "audio/vnd.dolby.pulse.1": { + source: "iana" + }, + "audio/vnd.dra": { + source: "iana", + extensions: ["dra"] + }, + "audio/vnd.dts": { + source: "iana", + extensions: ["dts"] + }, + "audio/vnd.dts.hd": { + source: "iana", + extensions: ["dtshd"] + }, + "audio/vnd.dts.uhd": { + source: "iana" + }, + "audio/vnd.dvb.file": { + source: "iana" + }, + "audio/vnd.everad.plj": { + source: "iana" + }, + "audio/vnd.hns.audio": { + source: "iana" + }, + "audio/vnd.lucent.voice": { + source: "iana", + extensions: ["lvp"] + }, + "audio/vnd.ms-playready.media.pya": { + source: "iana", + extensions: ["pya"] + }, + "audio/vnd.nokia.mobile-xmf": { + source: "iana" + }, + "audio/vnd.nortel.vbk": { + source: "iana" + }, + "audio/vnd.nuera.ecelp4800": { + source: "iana", + extensions: ["ecelp4800"] + }, + "audio/vnd.nuera.ecelp7470": { + source: "iana", + extensions: ["ecelp7470"] + }, + "audio/vnd.nuera.ecelp9600": { + source: "iana", + extensions: ["ecelp9600"] + }, + "audio/vnd.octel.sbc": { + source: "iana" + }, + "audio/vnd.presonus.multitrack": { + source: "iana" + }, + "audio/vnd.qcelp": { + source: "apache" + }, + "audio/vnd.rhetorex.32kadpcm": { + source: "iana" + }, + "audio/vnd.rip": { + source: "iana", + extensions: ["rip"] + }, + "audio/vnd.rn-realaudio": { + compressible: false + }, + "audio/vnd.sealedmedia.softseal.mpeg": { + source: "iana" + }, + "audio/vnd.vmx.cvsd": { + source: "iana" + }, + "audio/vnd.wave": { + compressible: false + }, + "audio/vorbis": { + source: "iana", + compressible: false + }, + "audio/vorbis-config": { + source: "iana" + }, + "audio/wav": { + compressible: false, + extensions: ["wav"] + }, + "audio/wave": { + compressible: false, + extensions: ["wav"] + }, + "audio/webm": { + source: "apache", + compressible: false, + extensions: ["weba"] + }, + "audio/x-aac": { + source: "apache", + compressible: false, + extensions: ["aac"] + }, + "audio/x-aiff": { + source: "apache", + extensions: ["aif", "aiff", "aifc"] + }, + "audio/x-caf": { + source: "apache", + compressible: false, + extensions: ["caf"] + }, + "audio/x-flac": { + source: "apache", + extensions: ["flac"] + }, + "audio/x-m4a": { + source: "nginx", + extensions: ["m4a"] + }, + "audio/x-matroska": { + source: "apache", + extensions: ["mka"] + }, + "audio/x-mpegurl": { + source: "apache", + extensions: ["m3u"] + }, + "audio/x-ms-wax": { + source: "apache", + extensions: ["wax"] + }, + "audio/x-ms-wma": { + source: "apache", + extensions: ["wma"] + }, + "audio/x-pn-realaudio": { + source: "apache", + extensions: ["ram", "ra"] + }, + "audio/x-pn-realaudio-plugin": { + source: "apache", + extensions: ["rmp"] + }, + "audio/x-realaudio": { + source: "nginx", + extensions: ["ra"] + }, + "audio/x-tta": { + source: "apache" + }, + "audio/x-wav": { + source: "apache", + extensions: ["wav"] + }, + "audio/xm": { + source: "apache", + extensions: ["xm"] + }, + "chemical/x-cdx": { + source: "apache", + extensions: ["cdx"] + }, + "chemical/x-cif": { + source: "apache", + extensions: ["cif"] + }, + "chemical/x-cmdf": { + source: "apache", + extensions: ["cmdf"] + }, + "chemical/x-cml": { + source: "apache", + extensions: ["cml"] + }, + "chemical/x-csml": { + source: "apache", + extensions: ["csml"] + }, + "chemical/x-pdb": { + source: "apache" + }, + "chemical/x-xyz": { + source: "apache", + extensions: ["xyz"] + }, + "font/collection": { + source: "iana", + extensions: ["ttc"] + }, + "font/otf": { + source: "iana", + compressible: true, + extensions: ["otf"] + }, + "font/sfnt": { + source: "iana" + }, + "font/ttf": { + source: "iana", + compressible: true, + extensions: ["ttf"] + }, + "font/woff": { + source: "iana", + extensions: ["woff"] + }, + "font/woff2": { + source: "iana", + extensions: ["woff2"] + }, + "image/aces": { + source: "iana", + extensions: ["exr"] + }, + "image/apng": { + source: "iana", + compressible: false, + extensions: ["apng"] + }, + "image/avci": { + source: "iana", + extensions: ["avci"] + }, + "image/avcs": { + source: "iana", + extensions: ["avcs"] + }, + "image/avif": { + source: "iana", + compressible: false, + extensions: ["avif"] + }, + "image/bmp": { + source: "iana", + compressible: true, + extensions: ["bmp", "dib"] + }, + "image/cgm": { + source: "iana", + extensions: ["cgm"] + }, + "image/dicom-rle": { + source: "iana", + extensions: ["drle"] + }, + "image/dpx": { + source: "iana", + extensions: ["dpx"] + }, + "image/emf": { + source: "iana", + extensions: ["emf"] + }, + "image/fits": { + source: "iana", + extensions: ["fits"] + }, + "image/g3fax": { + source: "iana", + extensions: ["g3"] + }, + "image/gif": { + source: "iana", + compressible: false, + extensions: ["gif"] + }, + "image/heic": { + source: "iana", + extensions: ["heic"] + }, + "image/heic-sequence": { + source: "iana", + extensions: ["heics"] + }, + "image/heif": { + source: "iana", + extensions: ["heif"] + }, + "image/heif-sequence": { + source: "iana", + extensions: ["heifs"] + }, + "image/hej2k": { + source: "iana", + extensions: ["hej2"] + }, + "image/ief": { + source: "iana", + extensions: ["ief"] + }, + "image/j2c": { + source: "iana" + }, + "image/jaii": { + source: "iana", + extensions: ["jaii"] + }, + "image/jais": { + source: "iana", + extensions: ["jais"] + }, + "image/jls": { + source: "iana", + extensions: ["jls"] + }, + "image/jp2": { + source: "iana", + compressible: false, + extensions: ["jp2", "jpg2"] + }, + "image/jpeg": { + source: "iana", + compressible: false, + extensions: ["jpg", "jpeg", "jpe"] + }, + "image/jph": { + source: "iana", + extensions: ["jph"] + }, + "image/jphc": { + source: "iana", + extensions: ["jhc"] + }, + "image/jpm": { + source: "iana", + compressible: false, + extensions: ["jpm", "jpgm"] + }, + "image/jpx": { + source: "iana", + compressible: false, + extensions: ["jpx", "jpf"] + }, + "image/jxl": { + source: "iana", + extensions: ["jxl"] + }, + "image/jxr": { + source: "iana", + extensions: ["jxr"] + }, + "image/jxra": { + source: "iana", + extensions: ["jxra"] + }, + "image/jxrs": { + source: "iana", + extensions: ["jxrs"] + }, + "image/jxs": { + source: "iana", + extensions: ["jxs"] + }, + "image/jxsc": { + source: "iana", + extensions: ["jxsc"] + }, + "image/jxsi": { + source: "iana", + extensions: ["jxsi"] + }, + "image/jxss": { + source: "iana", + extensions: ["jxss"] + }, + "image/ktx": { + source: "iana", + extensions: ["ktx"] + }, + "image/ktx2": { + source: "iana", + extensions: ["ktx2"] + }, + "image/naplps": { + source: "iana" + }, + "image/pjpeg": { + compressible: false, + extensions: ["jfif"] + }, + "image/png": { + source: "iana", + compressible: false, + extensions: ["png"] + }, + "image/prs.btif": { + source: "iana", + extensions: ["btif", "btf"] + }, + "image/prs.pti": { + source: "iana", + extensions: ["pti"] + }, + "image/pwg-raster": { + source: "iana" + }, + "image/sgi": { + source: "apache", + extensions: ["sgi"] + }, + "image/svg+xml": { + source: "iana", + compressible: true, + extensions: ["svg", "svgz"] + }, + "image/t38": { + source: "iana", + extensions: ["t38"] + }, + "image/tiff": { + source: "iana", + compressible: false, + extensions: ["tif", "tiff"] + }, + "image/tiff-fx": { + source: "iana", + extensions: ["tfx"] + }, + "image/vnd.adobe.photoshop": { + source: "iana", + compressible: true, + extensions: ["psd"] + }, + "image/vnd.airzip.accelerator.azv": { + source: "iana", + extensions: ["azv"] + }, + "image/vnd.clip": { + source: "iana" + }, + "image/vnd.cns.inf2": { + source: "iana" + }, + "image/vnd.dece.graphic": { + source: "iana", + extensions: ["uvi", "uvvi", "uvg", "uvvg"] + }, + "image/vnd.djvu": { + source: "iana", + extensions: ["djvu", "djv"] + }, + "image/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "image/vnd.dwg": { + source: "iana", + extensions: ["dwg"] + }, + "image/vnd.dxf": { + source: "iana", + extensions: ["dxf"] + }, + "image/vnd.fastbidsheet": { + source: "iana", + extensions: ["fbs"] + }, + "image/vnd.fpx": { + source: "iana", + extensions: ["fpx"] + }, + "image/vnd.fst": { + source: "iana", + extensions: ["fst"] + }, + "image/vnd.fujixerox.edmics-mmr": { + source: "iana", + extensions: ["mmr"] + }, + "image/vnd.fujixerox.edmics-rlc": { + source: "iana", + extensions: ["rlc"] + }, + "image/vnd.globalgraphics.pgb": { + source: "iana" + }, + "image/vnd.microsoft.icon": { + source: "iana", + compressible: true, + extensions: ["ico"] + }, + "image/vnd.mix": { + source: "iana" + }, + "image/vnd.mozilla.apng": { + source: "iana" + }, + "image/vnd.ms-dds": { + compressible: true, + extensions: ["dds"] + }, + "image/vnd.ms-modi": { + source: "iana", + extensions: ["mdi"] + }, + "image/vnd.ms-photo": { + source: "apache", + extensions: ["wdp"] + }, + "image/vnd.net-fpx": { + source: "iana", + extensions: ["npx"] + }, + "image/vnd.pco.b16": { + source: "iana", + extensions: ["b16"] + }, + "image/vnd.radiance": { + source: "iana" + }, + "image/vnd.sealed.png": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.gif": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.jpg": { + source: "iana" + }, + "image/vnd.svf": { + source: "iana" + }, + "image/vnd.tencent.tap": { + source: "iana", + extensions: ["tap"] + }, + "image/vnd.valve.source.texture": { + source: "iana", + extensions: ["vtf"] + }, + "image/vnd.wap.wbmp": { + source: "iana", + extensions: ["wbmp"] + }, + "image/vnd.xiff": { + source: "iana", + extensions: ["xif"] + }, + "image/vnd.zbrush.pcx": { + source: "iana", + extensions: ["pcx"] + }, + "image/webp": { + source: "iana", + extensions: ["webp"] + }, + "image/wmf": { + source: "iana", + extensions: ["wmf"] + }, + "image/x-3ds": { + source: "apache", + extensions: ["3ds"] + }, + "image/x-adobe-dng": { + extensions: ["dng"] + }, + "image/x-cmu-raster": { + source: "apache", + extensions: ["ras"] + }, + "image/x-cmx": { + source: "apache", + extensions: ["cmx"] + }, + "image/x-emf": { + source: "iana" + }, + "image/x-freehand": { + source: "apache", + extensions: ["fh", "fhc", "fh4", "fh5", "fh7"] + }, + "image/x-icon": { + source: "apache", + compressible: true, + extensions: ["ico"] + }, + "image/x-jng": { + source: "nginx", + extensions: ["jng"] + }, + "image/x-mrsid-image": { + source: "apache", + extensions: ["sid"] + }, + "image/x-ms-bmp": { + source: "nginx", + compressible: true, + extensions: ["bmp"] + }, + "image/x-pcx": { + source: "apache", + extensions: ["pcx"] + }, + "image/x-pict": { + source: "apache", + extensions: ["pic", "pct"] + }, + "image/x-portable-anymap": { + source: "apache", + extensions: ["pnm"] + }, + "image/x-portable-bitmap": { + source: "apache", + extensions: ["pbm"] + }, + "image/x-portable-graymap": { + source: "apache", + extensions: ["pgm"] + }, + "image/x-portable-pixmap": { + source: "apache", + extensions: ["ppm"] + }, + "image/x-rgb": { + source: "apache", + extensions: ["rgb"] + }, + "image/x-tga": { + source: "apache", + extensions: ["tga"] + }, + "image/x-wmf": { + source: "iana" + }, + "image/x-xbitmap": { + source: "apache", + extensions: ["xbm"] + }, + "image/x-xcf": { + compressible: false + }, + "image/x-xpixmap": { + source: "apache", + extensions: ["xpm"] + }, + "image/x-xwindowdump": { + source: "apache", + extensions: ["xwd"] + }, + "message/bhttp": { + source: "iana" + }, + "message/cpim": { + source: "iana" + }, + "message/delivery-status": { + source: "iana" + }, + "message/disposition-notification": { + source: "iana", + extensions: [ + "disposition-notification" + ] + }, + "message/external-body": { + source: "iana" + }, + "message/feedback-report": { + source: "iana" + }, + "message/global": { + source: "iana", + extensions: ["u8msg"] + }, + "message/global-delivery-status": { + source: "iana", + extensions: ["u8dsn"] + }, + "message/global-disposition-notification": { + source: "iana", + extensions: ["u8mdn"] + }, + "message/global-headers": { + source: "iana", + extensions: ["u8hdr"] + }, + "message/http": { + source: "iana", + compressible: false + }, + "message/imdn+xml": { + source: "iana", + compressible: true + }, + "message/mls": { + source: "iana" + }, + "message/news": { + source: "apache" + }, + "message/ohttp-req": { + source: "iana" + }, + "message/ohttp-res": { + source: "iana" + }, + "message/partial": { + source: "iana", + compressible: false + }, + "message/rfc822": { + source: "iana", + compressible: true, + extensions: ["eml", "mime", "mht", "mhtml"] + }, + "message/s-http": { + source: "apache" + }, + "message/sip": { + source: "iana" + }, + "message/sipfrag": { + source: "iana" + }, + "message/tracking-status": { + source: "iana" + }, + "message/vnd.si.simp": { + source: "apache" + }, + "message/vnd.wfa.wsc": { + source: "iana", + extensions: ["wsc"] + }, + "model/3mf": { + source: "iana", + extensions: ["3mf"] + }, + "model/e57": { + source: "iana" + }, + "model/gltf+json": { + source: "iana", + compressible: true, + extensions: ["gltf"] + }, + "model/gltf-binary": { + source: "iana", + compressible: true, + extensions: ["glb"] + }, + "model/iges": { + source: "iana", + compressible: false, + extensions: ["igs", "iges"] + }, + "model/jt": { + source: "iana", + extensions: ["jt"] + }, + "model/mesh": { + source: "iana", + compressible: false, + extensions: ["msh", "mesh", "silo"] + }, + "model/mtl": { + source: "iana", + extensions: ["mtl"] + }, + "model/obj": { + source: "iana", + extensions: ["obj"] + }, + "model/prc": { + source: "iana", + extensions: ["prc"] + }, + "model/step": { + source: "iana", + extensions: ["step", "stp", "stpnc", "p21", "210"] + }, + "model/step+xml": { + source: "iana", + compressible: true, + extensions: ["stpx"] + }, + "model/step+zip": { + source: "iana", + compressible: false, + extensions: ["stpz"] + }, + "model/step-xml+zip": { + source: "iana", + compressible: false, + extensions: ["stpxz"] + }, + "model/stl": { + source: "iana", + extensions: ["stl"] + }, + "model/u3d": { + source: "iana", + extensions: ["u3d"] + }, + "model/vnd.bary": { + source: "iana", + extensions: ["bary"] + }, + "model/vnd.cld": { + source: "iana", + extensions: ["cld"] + }, + "model/vnd.collada+xml": { + source: "iana", + compressible: true, + extensions: ["dae"] + }, + "model/vnd.dwf": { + source: "iana", + extensions: ["dwf"] + }, + "model/vnd.flatland.3dml": { + source: "iana" + }, + "model/vnd.gdl": { + source: "iana", + extensions: ["gdl"] + }, + "model/vnd.gs-gdl": { + source: "apache" + }, + "model/vnd.gs.gdl": { + source: "iana" + }, + "model/vnd.gtw": { + source: "iana", + extensions: ["gtw"] + }, + "model/vnd.moml+xml": { + source: "iana", + compressible: true + }, + "model/vnd.mts": { + source: "iana", + extensions: ["mts"] + }, + "model/vnd.opengex": { + source: "iana", + extensions: ["ogex"] + }, + "model/vnd.parasolid.transmit.binary": { + source: "iana", + extensions: ["x_b"] + }, + "model/vnd.parasolid.transmit.text": { + source: "iana", + extensions: ["x_t"] + }, + "model/vnd.pytha.pyox": { + source: "iana", + extensions: ["pyo", "pyox"] + }, + "model/vnd.rosette.annotated-data-model": { + source: "iana" + }, + "model/vnd.sap.vds": { + source: "iana", + extensions: ["vds"] + }, + "model/vnd.usda": { + source: "iana", + extensions: ["usda"] + }, + "model/vnd.usdz+zip": { + source: "iana", + compressible: false, + extensions: ["usdz"] + }, + "model/vnd.valve.source.compiled-map": { + source: "iana", + extensions: ["bsp"] + }, + "model/vnd.vtu": { + source: "iana", + extensions: ["vtu"] + }, + "model/vrml": { + source: "iana", + compressible: false, + extensions: ["wrl", "vrml"] + }, + "model/x3d+binary": { + source: "apache", + compressible: false, + extensions: ["x3db", "x3dbz"] + }, + "model/x3d+fastinfoset": { + source: "iana", + extensions: ["x3db"] + }, + "model/x3d+vrml": { + source: "apache", + compressible: false, + extensions: ["x3dv", "x3dvz"] + }, + "model/x3d+xml": { + source: "iana", + compressible: true, + extensions: ["x3d", "x3dz"] + }, + "model/x3d-vrml": { + source: "iana", + extensions: ["x3dv"] + }, + "multipart/alternative": { + source: "iana", + compressible: false + }, + "multipart/appledouble": { + source: "iana" + }, + "multipart/byteranges": { + source: "iana" + }, + "multipart/digest": { + source: "iana" + }, + "multipart/encrypted": { + source: "iana", + compressible: false + }, + "multipart/form-data": { + source: "iana", + compressible: false + }, + "multipart/header-set": { + source: "iana" + }, + "multipart/mixed": { + source: "iana" + }, + "multipart/multilingual": { + source: "iana" + }, + "multipart/parallel": { + source: "iana" + }, + "multipart/related": { + source: "iana", + compressible: false + }, + "multipart/report": { + source: "iana" + }, + "multipart/signed": { + source: "iana", + compressible: false + }, + "multipart/vnd.bint.med-plus": { + source: "iana" + }, + "multipart/voice-message": { + source: "iana" + }, + "multipart/x-mixed-replace": { + source: "iana" + }, + "text/1d-interleaved-parityfec": { + source: "iana" + }, + "text/cache-manifest": { + source: "iana", + compressible: true, + extensions: ["appcache", "manifest"] + }, + "text/calendar": { + source: "iana", + extensions: ["ics", "ifb"] + }, + "text/calender": { + compressible: true + }, + "text/cmd": { + compressible: true + }, + "text/coffeescript": { + extensions: ["coffee", "litcoffee"] + }, + "text/cql": { + source: "iana" + }, + "text/cql-expression": { + source: "iana" + }, + "text/cql-identifier": { + source: "iana" + }, + "text/css": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["css"] + }, + "text/csv": { + source: "iana", + compressible: true, + extensions: ["csv"] + }, + "text/csv-schema": { + source: "iana" + }, + "text/directory": { + source: "iana" + }, + "text/dns": { + source: "iana" + }, + "text/ecmascript": { + source: "apache" + }, + "text/encaprtp": { + source: "iana" + }, + "text/enriched": { + source: "iana" + }, + "text/fhirpath": { + source: "iana" + }, + "text/flexfec": { + source: "iana" + }, + "text/fwdred": { + source: "iana" + }, + "text/gff3": { + source: "iana" + }, + "text/grammar-ref-list": { + source: "iana" + }, + "text/hl7v2": { + source: "iana" + }, + "text/html": { + source: "iana", + compressible: true, + extensions: ["html", "htm", "shtml"] + }, + "text/jade": { + extensions: ["jade"] + }, + "text/javascript": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["js", "mjs"] + }, + "text/jcr-cnd": { + source: "iana" + }, + "text/jsx": { + compressible: true, + extensions: ["jsx"] + }, + "text/less": { + compressible: true, + extensions: ["less"] + }, + "text/markdown": { + source: "iana", + compressible: true, + extensions: ["md", "markdown"] + }, + "text/mathml": { + source: "nginx", + extensions: ["mml"] + }, + "text/mdx": { + compressible: true, + extensions: ["mdx"] + }, + "text/mizar": { + source: "iana" + }, + "text/n3": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["n3"] + }, + "text/parameters": { + source: "iana", + charset: "UTF-8" + }, + "text/parityfec": { + source: "iana" + }, + "text/plain": { + source: "iana", + compressible: true, + extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"] + }, + "text/provenance-notation": { + source: "iana", + charset: "UTF-8" + }, + "text/prs.fallenstein.rst": { + source: "iana" + }, + "text/prs.lines.tag": { + source: "iana", + extensions: ["dsc"] + }, + "text/prs.prop.logic": { + source: "iana" + }, + "text/prs.texi": { + source: "iana" + }, + "text/raptorfec": { + source: "iana" + }, + "text/red": { + source: "iana" + }, + "text/rfc822-headers": { + source: "iana" + }, + "text/richtext": { + source: "iana", + compressible: true, + extensions: ["rtx"] + }, + "text/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "text/rtp-enc-aescm128": { + source: "iana" + }, + "text/rtploopback": { + source: "iana" + }, + "text/rtx": { + source: "iana" + }, + "text/sgml": { + source: "iana", + extensions: ["sgml", "sgm"] + }, + "text/shaclc": { + source: "iana" + }, + "text/shex": { + source: "iana", + extensions: ["shex"] + }, + "text/slim": { + extensions: ["slim", "slm"] + }, + "text/spdx": { + source: "iana", + extensions: ["spdx"] + }, + "text/strings": { + source: "iana" + }, + "text/stylus": { + extensions: ["stylus", "styl"] + }, + "text/t140": { + source: "iana" + }, + "text/tab-separated-values": { + source: "iana", + compressible: true, + extensions: ["tsv"] + }, + "text/troff": { + source: "iana", + extensions: ["t", "tr", "roff", "man", "me", "ms"] + }, + "text/turtle": { + source: "iana", + charset: "UTF-8", + extensions: ["ttl"] + }, + "text/ulpfec": { + source: "iana" + }, + "text/uri-list": { + source: "iana", + compressible: true, + extensions: ["uri", "uris", "urls"] + }, + "text/vcard": { + source: "iana", + compressible: true, + extensions: ["vcard"] + }, + "text/vnd.a": { + source: "iana" + }, + "text/vnd.abc": { + source: "iana" + }, + "text/vnd.ascii-art": { + source: "iana" + }, + "text/vnd.curl": { + source: "iana", + extensions: ["curl"] + }, + "text/vnd.curl.dcurl": { + source: "apache", + extensions: ["dcurl"] + }, + "text/vnd.curl.mcurl": { + source: "apache", + extensions: ["mcurl"] + }, + "text/vnd.curl.scurl": { + source: "apache", + extensions: ["scurl"] + }, + "text/vnd.debian.copyright": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.dmclientscript": { + source: "iana" + }, + "text/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "text/vnd.esmertec.theme-descriptor": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.exchangeable": { + source: "iana" + }, + "text/vnd.familysearch.gedcom": { + source: "iana", + extensions: ["ged"] + }, + "text/vnd.ficlab.flt": { + source: "iana" + }, + "text/vnd.fly": { + source: "iana", + extensions: ["fly"] + }, + "text/vnd.fmi.flexstor": { + source: "iana", + extensions: ["flx"] + }, + "text/vnd.gml": { + source: "iana" + }, + "text/vnd.graphviz": { + source: "iana", + extensions: ["gv"] + }, + "text/vnd.hans": { + source: "iana" + }, + "text/vnd.hgl": { + source: "iana" + }, + "text/vnd.in3d.3dml": { + source: "iana", + extensions: ["3dml"] + }, + "text/vnd.in3d.spot": { + source: "iana", + extensions: ["spot"] + }, + "text/vnd.iptc.newsml": { + source: "iana" + }, + "text/vnd.iptc.nitf": { + source: "iana" + }, + "text/vnd.latex-z": { + source: "iana" + }, + "text/vnd.motorola.reflex": { + source: "iana" + }, + "text/vnd.ms-mediapackage": { + source: "iana" + }, + "text/vnd.net2phone.commcenter.command": { + source: "iana" + }, + "text/vnd.radisys.msml-basic-layout": { + source: "iana" + }, + "text/vnd.senx.warpscript": { + source: "iana" + }, + "text/vnd.si.uricatalogue": { + source: "apache" + }, + "text/vnd.sosi": { + source: "iana" + }, + "text/vnd.sun.j2me.app-descriptor": { + source: "iana", + charset: "UTF-8", + extensions: ["jad"] + }, + "text/vnd.trolltech.linguist": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.vcf": { + source: "iana" + }, + "text/vnd.wap.si": { + source: "iana" + }, + "text/vnd.wap.sl": { + source: "iana" + }, + "text/vnd.wap.wml": { + source: "iana", + extensions: ["wml"] + }, + "text/vnd.wap.wmlscript": { + source: "iana", + extensions: ["wmls"] + }, + "text/vnd.zoo.kcl": { + source: "iana" + }, + "text/vtt": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["vtt"] + }, + "text/wgsl": { + source: "iana", + extensions: ["wgsl"] + }, + "text/x-asm": { + source: "apache", + extensions: ["s", "asm"] + }, + "text/x-c": { + source: "apache", + extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] + }, + "text/x-component": { + source: "nginx", + extensions: ["htc"] + }, + "text/x-fortran": { + source: "apache", + extensions: ["f", "for", "f77", "f90"] + }, + "text/x-gwt-rpc": { + compressible: true + }, + "text/x-handlebars-template": { + extensions: ["hbs"] + }, + "text/x-java-source": { + source: "apache", + extensions: ["java"] + }, + "text/x-jquery-tmpl": { + compressible: true + }, + "text/x-lua": { + extensions: ["lua"] + }, + "text/x-markdown": { + compressible: true, + extensions: ["mkd"] + }, + "text/x-nfo": { + source: "apache", + extensions: ["nfo"] + }, + "text/x-opml": { + source: "apache", + extensions: ["opml"] + }, + "text/x-org": { + compressible: true, + extensions: ["org"] + }, + "text/x-pascal": { + source: "apache", + extensions: ["p", "pas"] + }, + "text/x-processing": { + compressible: true, + extensions: ["pde"] + }, + "text/x-sass": { + extensions: ["sass"] + }, + "text/x-scss": { + extensions: ["scss"] + }, + "text/x-setext": { + source: "apache", + extensions: ["etx"] + }, + "text/x-sfv": { + source: "apache", + extensions: ["sfv"] + }, + "text/x-suse-ymp": { + compressible: true, + extensions: ["ymp"] + }, + "text/x-uuencode": { + source: "apache", + extensions: ["uu"] + }, + "text/x-vcalendar": { + source: "apache", + extensions: ["vcs"] + }, + "text/x-vcard": { + source: "apache", + extensions: ["vcf"] + }, + "text/xml": { + source: "iana", + compressible: true, + extensions: ["xml"] + }, + "text/xml-external-parsed-entity": { + source: "iana" + }, + "text/yaml": { + compressible: true, + extensions: ["yaml", "yml"] + }, + "video/1d-interleaved-parityfec": { + source: "iana" + }, + "video/3gpp": { + source: "iana", + extensions: ["3gp", "3gpp"] + }, + "video/3gpp-tt": { + source: "iana" + }, + "video/3gpp2": { + source: "iana", + extensions: ["3g2"] + }, + "video/av1": { + source: "iana" + }, + "video/bmpeg": { + source: "iana" + }, + "video/bt656": { + source: "iana" + }, + "video/celb": { + source: "iana" + }, + "video/dv": { + source: "iana" + }, + "video/encaprtp": { + source: "iana" + }, + "video/evc": { + source: "iana" + }, + "video/ffv1": { + source: "iana" + }, + "video/flexfec": { + source: "iana" + }, + "video/h261": { + source: "iana", + extensions: ["h261"] + }, + "video/h263": { + source: "iana", + extensions: ["h263"] + }, + "video/h263-1998": { + source: "iana" + }, + "video/h263-2000": { + source: "iana" + }, + "video/h264": { + source: "iana", + extensions: ["h264"] + }, + "video/h264-rcdo": { + source: "iana" + }, + "video/h264-svc": { + source: "iana" + }, + "video/h265": { + source: "iana" + }, + "video/h266": { + source: "iana" + }, + "video/iso.segment": { + source: "iana", + extensions: ["m4s"] + }, + "video/jpeg": { + source: "iana", + extensions: ["jpgv"] + }, + "video/jpeg2000": { + source: "iana" + }, + "video/jpm": { + source: "apache", + extensions: ["jpm", "jpgm"] + }, + "video/jxsv": { + source: "iana" + }, + "video/lottie+json": { + source: "iana", + compressible: true + }, + "video/matroska": { + source: "iana" + }, + "video/matroska-3d": { + source: "iana" + }, + "video/mj2": { + source: "iana", + extensions: ["mj2", "mjp2"] + }, + "video/mp1s": { + source: "iana" + }, + "video/mp2p": { + source: "iana" + }, + "video/mp2t": { + source: "iana", + extensions: ["ts", "m2t", "m2ts", "mts"] + }, + "video/mp4": { + source: "iana", + compressible: false, + extensions: ["mp4", "mp4v", "mpg4"] + }, + "video/mp4v-es": { + source: "iana" + }, + "video/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"] + }, + "video/mpeg4-generic": { + source: "iana" + }, + "video/mpv": { + source: "iana" + }, + "video/nv": { + source: "iana" + }, + "video/ogg": { + source: "iana", + compressible: false, + extensions: ["ogv"] + }, + "video/parityfec": { + source: "iana" + }, + "video/pointer": { + source: "iana" + }, + "video/quicktime": { + source: "iana", + compressible: false, + extensions: ["qt", "mov"] + }, + "video/raptorfec": { + source: "iana" + }, + "video/raw": { + source: "iana" + }, + "video/rtp-enc-aescm128": { + source: "iana" + }, + "video/rtploopback": { + source: "iana" + }, + "video/rtx": { + source: "iana" + }, + "video/scip": { + source: "iana" + }, + "video/smpte291": { + source: "iana" + }, + "video/smpte292m": { + source: "iana" + }, + "video/ulpfec": { + source: "iana" + }, + "video/vc1": { + source: "iana" + }, + "video/vc2": { + source: "iana" + }, + "video/vnd.cctv": { + source: "iana" + }, + "video/vnd.dece.hd": { + source: "iana", + extensions: ["uvh", "uvvh"] + }, + "video/vnd.dece.mobile": { + source: "iana", + extensions: ["uvm", "uvvm"] + }, + "video/vnd.dece.mp4": { + source: "iana" + }, + "video/vnd.dece.pd": { + source: "iana", + extensions: ["uvp", "uvvp"] + }, + "video/vnd.dece.sd": { + source: "iana", + extensions: ["uvs", "uvvs"] + }, + "video/vnd.dece.video": { + source: "iana", + extensions: ["uvv", "uvvv"] + }, + "video/vnd.directv.mpeg": { + source: "iana" + }, + "video/vnd.directv.mpeg-tts": { + source: "iana" + }, + "video/vnd.dlna.mpeg-tts": { + source: "iana" + }, + "video/vnd.dvb.file": { + source: "iana", + extensions: ["dvb"] + }, + "video/vnd.fvt": { + source: "iana", + extensions: ["fvt"] + }, + "video/vnd.hns.video": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.ttsavc": { + source: "iana" + }, + "video/vnd.iptvforum.ttsmpeg2": { + source: "iana" + }, + "video/vnd.motorola.video": { + source: "iana" + }, + "video/vnd.motorola.videop": { + source: "iana" + }, + "video/vnd.mpegurl": { + source: "iana", + extensions: ["mxu", "m4u"] + }, + "video/vnd.ms-playready.media.pyv": { + source: "iana", + extensions: ["pyv"] + }, + "video/vnd.nokia.interleaved-multimedia": { + source: "iana" + }, + "video/vnd.nokia.mp4vr": { + source: "iana" + }, + "video/vnd.nokia.videovoip": { + source: "iana" + }, + "video/vnd.objectvideo": { + source: "iana" + }, + "video/vnd.planar": { + source: "iana" + }, + "video/vnd.radgamettools.bink": { + source: "iana" + }, + "video/vnd.radgamettools.smacker": { + source: "apache" + }, + "video/vnd.sealed.mpeg1": { + source: "iana" + }, + "video/vnd.sealed.mpeg4": { + source: "iana" + }, + "video/vnd.sealed.swf": { + source: "iana" + }, + "video/vnd.sealedmedia.softseal.mov": { + source: "iana" + }, + "video/vnd.uvvu.mp4": { + source: "iana", + extensions: ["uvu", "uvvu"] + }, + "video/vnd.vivo": { + source: "iana", + extensions: ["viv"] + }, + "video/vnd.youtube.yt": { + source: "iana" + }, + "video/vp8": { + source: "iana" + }, + "video/vp9": { + source: "iana" + }, + "video/webm": { + source: "apache", + compressible: false, + extensions: ["webm"] + }, + "video/x-f4v": { + source: "apache", + extensions: ["f4v"] + }, + "video/x-fli": { + source: "apache", + extensions: ["fli"] + }, + "video/x-flv": { + source: "apache", + compressible: false, + extensions: ["flv"] + }, + "video/x-m4v": { + source: "apache", + extensions: ["m4v"] + }, + "video/x-matroska": { + source: "apache", + compressible: false, + extensions: ["mkv", "mk3d", "mks"] + }, + "video/x-mng": { + source: "apache", + extensions: ["mng"] + }, + "video/x-ms-asf": { + source: "apache", + extensions: ["asf", "asx"] + }, + "video/x-ms-vob": { + source: "apache", + extensions: ["vob"] + }, + "video/x-ms-wm": { + source: "apache", + extensions: ["wm"] + }, + "video/x-ms-wmv": { + source: "apache", + compressible: false, + extensions: ["wmv"] + }, + "video/x-ms-wmx": { + source: "apache", + extensions: ["wmx"] + }, + "video/x-ms-wvx": { + source: "apache", + extensions: ["wvx"] + }, + "video/x-msvideo": { + source: "apache", + extensions: ["avi"] + }, + "video/x-sgi-movie": { + source: "apache", + extensions: ["movie"] + }, + "video/x-smv": { + source: "apache", + extensions: ["smv"] + }, + "x-conference/x-cooltalk": { + source: "apache", + extensions: ["ice"] + }, + "x-shader/x-fragment": { + compressible: true + }, + "x-shader/x-vertex": { + compressible: true + } + }; + } +}); +var require_mime_db3 = __commonJS2({ + "node_modules/accepts/node_modules/mime-db/index.js"(exports2, module2) { + module2.exports = require_db3(); + } +}); +var require_mimeScore3 = __commonJS2({ + "node_modules/accepts/node_modules/mime-types/mimeScore.js"(exports2, module2) { + var FACET_SCORES = { + "prs.": 100, + "x-": 200, + "x.": 300, + "vnd.": 400, + default: 900 + }; + var SOURCE_SCORES = { + nginx: 10, + apache: 20, + iana: 40, + default: 30 + // definitions added by `jshttp/mime-db` project? + }; + var TYPE_SCORES = { + // prefer application/xml over text/xml + // prefer application/rtf over text/rtf + application: 1, + // prefer font/woff over application/font-woff + font: 2, + default: 0 + }; + module2.exports = function mimeScore(mimeType, source = "default") { + if (mimeType === "application/octet-stream") { + return 0; + } + const [type, subtype] = mimeType.split("/"); + const facet = subtype.replace(/(\.|x-).*/, "$1"); + const facetScore = FACET_SCORES[facet] || FACET_SCORES.default; + const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default; + const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default; + const lengthScore = 1 - mimeType.length / 100; + return facetScore + sourceScore + typeScore + lengthScore; + }; + } +}); +var require_mime_types3 = __commonJS2({ + "node_modules/accepts/node_modules/mime-types/index.js"(exports2) { + "use strict"; + var db = require_mime_db3(); + var extname = require("path").extname; + var mimeScore = require_mimeScore3(); + var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/; + var TEXT_TYPE_REGEXP = /^text\//i; + exports2.charset = charset; + exports2.charsets = { lookup: charset }; + exports2.contentType = contentType2; + exports2.extension = extension; + exports2.extensions = /* @__PURE__ */ Object.create(null); + exports2.lookup = lookup; + exports2.types = /* @__PURE__ */ Object.create(null); + exports2._extensionConflicts = []; + populateMaps(exports2.extensions, exports2.types); + function charset(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var mime = match && db[match[1].toLowerCase()]; + if (mime && mime.charset) { + return mime.charset; + } + if (match && TEXT_TYPE_REGEXP.test(match[1])) { + return "UTF-8"; + } + return false; + } + function contentType2(str) { + if (!str || typeof str !== "string") { + return false; + } + var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str; + if (!mime) { + return false; + } + if (mime.indexOf("charset") === -1) { + var charset2 = exports2.charset(mime); + if (charset2) mime += "; charset=" + charset2.toLowerCase(); + } + return mime; + } + function extension(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var exts = match && exports2.extensions[match[1].toLowerCase()]; + if (!exts || !exts.length) { + return false; + } + return exts[0]; + } + function lookup(path) { + if (!path || typeof path !== "string") { + return false; + } + var extension2 = extname("x." + path).toLowerCase().slice(1); + if (!extension2) { + return false; + } + return exports2.types[extension2] || false; + } + function populateMaps(extensions, types) { + Object.keys(db).forEach(function forEachMimeType(type) { + var mime = db[type]; + var exts = mime.extensions; + if (!exts || !exts.length) { + return; + } + extensions[type] = exts; + for (var i = 0; i < exts.length; i++) { + var extension2 = exts[i]; + types[extension2] = _preferredType(extension2, types[extension2], type); + const legacyType = _preferredTypeLegacy( + extension2, + types[extension2], + type + ); + if (legacyType !== types[extension2]) { + exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]); + } + } + }); + } + function _preferredType(ext, type0, type1) { + var score0 = type0 ? mimeScore(type0, db[type0].source) : 0; + var score1 = type1 ? mimeScore(type1, db[type1].source) : 0; + return score0 > score1 ? type0 : type1; + } + function _preferredTypeLegacy(ext, type0, type1) { + var SOURCE_RANK = ["nginx", "apache", void 0, "iana"]; + var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0; + var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0; + if (exports2.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === "application/")) { + return type0; + } + return score0 > score1 ? type0 : type1; + } + } +}); +var require_accepts = __commonJS2({ + "node_modules/accepts/index.js"(exports2, module2) { + "use strict"; + var Negotiator = require_negotiator(); + var mime = require_mime_types3(); + module2.exports = Accepts; + function Accepts(req) { + if (!(this instanceof Accepts)) { + return new Accepts(req); + } + this.headers = req.headers; + this.negotiator = new Negotiator(req); + } + Accepts.prototype.type = Accepts.prototype.types = function(types_) { + var types = types_; + if (types && !Array.isArray(types)) { + types = new Array(arguments.length); + for (var i = 0; i < types.length; i++) { + types[i] = arguments[i]; + } + } + if (!types || types.length === 0) { + return this.negotiator.mediaTypes(); + } + if (!this.headers.accept) { + return types[0]; + } + var mimes = types.map(extToMime); + var accepts = this.negotiator.mediaTypes(mimes.filter(validMime)); + var first = accepts[0]; + return first ? types[mimes.indexOf(first)] : false; + }; + Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) { + var encodings = encodings_; + if (encodings && !Array.isArray(encodings)) { + encodings = new Array(arguments.length); + for (var i = 0; i < encodings.length; i++) { + encodings[i] = arguments[i]; + } + } + if (!encodings || encodings.length === 0) { + return this.negotiator.encodings(); + } + return this.negotiator.encodings(encodings)[0] || false; + }; + Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) { + var charsets = charsets_; + if (charsets && !Array.isArray(charsets)) { + charsets = new Array(arguments.length); + for (var i = 0; i < charsets.length; i++) { + charsets[i] = arguments[i]; + } + } + if (!charsets || charsets.length === 0) { + return this.negotiator.charsets(); + } + return this.negotiator.charsets(charsets)[0] || false; + }; + Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) { + var languages = languages_; + if (languages && !Array.isArray(languages)) { + languages = new Array(arguments.length); + for (var i = 0; i < languages.length; i++) { + languages[i] = arguments[i]; + } + } + if (!languages || languages.length === 0) { + return this.negotiator.languages(); + } + return this.negotiator.languages(languages)[0] || false; + }; + function extToMime(type) { + return type.indexOf("/") === -1 ? mime.lookup(type) : type; + } + function validMime(type) { + return typeof type === "string"; + } + } +}); +var require_fresh = __commonJS2({ + "node_modules/fresh/index.js"(exports2, module2) { + "use strict"; + var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/; + module2.exports = fresh; + function fresh(reqHeaders, resHeaders) { + var modifiedSince = reqHeaders["if-modified-since"]; + var noneMatch = reqHeaders["if-none-match"]; + if (!modifiedSince && !noneMatch) { + return false; + } + var cacheControl = reqHeaders["cache-control"]; + if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) { + return false; + } + if (noneMatch) { + if (noneMatch === "*") { + return true; + } + var etag = resHeaders.etag; + if (!etag) { + return false; + } + var matches = parseTokenList(noneMatch); + for (var i = 0; i < matches.length; i++) { + var match = matches[i]; + if (match === etag || match === "W/" + etag || "W/" + match === etag) { + return true; + } + } + return false; + } + if (modifiedSince) { + var lastModified = resHeaders["last-modified"]; + var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince)); + if (modifiedStale) { + return false; + } + } + return true; + } + function parseHttpDate(date) { + var timestamp = date && Date.parse(date); + return typeof timestamp === "number" ? timestamp : NaN; + } + function parseTokenList(str) { + var end = 0; + var list = []; + var start = 0; + for (var i = 0, len = str.length; i < len; i++) { + switch (str.charCodeAt(i)) { + case 32: + if (start === end) { + start = end = i + 1; + } + break; + case 44: + list.push(str.substring(start, end)); + start = end = i + 1; + break; + default: + end = i + 1; + break; + } + } + list.push(str.substring(start, end)); + return list; + } + } +}); +var require_range_parser = __commonJS2({ + "node_modules/range-parser/index.js"(exports2, module2) { + "use strict"; + module2.exports = rangeParser; + function rangeParser(size, str, options) { + if (typeof str !== "string") { + throw new TypeError("argument str must be a string"); + } + var index = str.indexOf("="); + if (index === -1) { + return -2; + } + var arr = str.slice(index + 1).split(","); + var ranges = []; + ranges.type = str.slice(0, index); + for (var i = 0; i < arr.length; i++) { + var range = arr[i].split("-"); + var start = parseInt(range[0], 10); + var end = parseInt(range[1], 10); + if (isNaN(start)) { + start = size - end; + end = size - 1; + } else if (isNaN(end)) { + end = size - 1; + } + if (end > size - 1) { + end = size - 1; + } + if (isNaN(start) || isNaN(end) || start > end || start < 0) { + continue; + } + ranges.push({ + start, + end + }); + } + if (ranges.length < 1) { + return -1; + } + return options && options.combine ? combineRanges(ranges) : ranges; + } + function combineRanges(ranges) { + var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart); + for (var j = 0, i = 1; i < ordered.length; i++) { + var range = ordered[i]; + var current = ordered[j]; + if (range.start > current.end + 1) { + ordered[++j] = range; + } else if (range.end > current.end) { + current.end = range.end; + current.index = Math.min(current.index, range.index); + } + } + ordered.length = j + 1; + var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex); + combined.type = ranges.type; + return combined; + } + function mapWithIndex(range, index) { + return { + start: range.start, + end: range.end, + index + }; + } + function mapWithoutIndex(range) { + return { + start: range.start, + end: range.end + }; + } + function sortByRangeIndex(a, b) { + return a.index - b.index; + } + function sortByRangeStart(a, b) { + return a.start - b.start; + } + } +}); +var require_request = __commonJS2({ + "node_modules/express/lib/request.js"(exports2, module2) { + "use strict"; + var accepts = require_accepts(); + var isIP = require("node:net").isIP; + var typeis = require_type_is(); + var http = require("node:http"); + var fresh = require_fresh(); + var parseRange = require_range_parser(); + var parse = require_parseurl(); + var proxyaddr = require_proxy_addr(); + var req = Object.create(http.IncomingMessage.prototype); + module2.exports = req; + req.get = req.header = function header(name) { + if (!name) { + throw new TypeError("name argument is required to req.get"); + } + if (typeof name !== "string") { + throw new TypeError("name must be a string to req.get"); + } + var lc = name.toLowerCase(); + switch (lc) { + case "referer": + case "referrer": + return this.headers.referrer || this.headers.referer; + default: + return this.headers[lc]; + } + }; + req.accepts = function() { + var accept = accepts(this); + return accept.types.apply(accept, arguments); + }; + req.acceptsEncodings = function() { + var accept = accepts(this); + return accept.encodings.apply(accept, arguments); + }; + req.acceptsCharsets = function() { + var accept = accepts(this); + return accept.charsets.apply(accept, arguments); + }; + req.acceptsLanguages = function() { + var accept = accepts(this); + return accept.languages.apply(accept, arguments); + }; + req.range = function range(size, options) { + var range2 = this.get("Range"); + if (!range2) return; + return parseRange(size, range2, options); + }; + defineGetter(req, "query", function query() { + var queryparse = this.app.get("query parser fn"); + if (!queryparse) { + return /* @__PURE__ */ Object.create(null); + } + var querystring = parse(this).query; + return queryparse(querystring); + }); + req.is = function is(types) { + var arr = types; + if (!Array.isArray(types)) { + arr = new Array(arguments.length); + for (var i = 0; i < arr.length; i++) { + arr[i] = arguments[i]; + } + } + return typeis(this, arr); + }; + defineGetter(req, "protocol", function protocol() { + var proto2 = this.connection.encrypted ? "https" : "http"; + var trust = this.app.get("trust proxy fn"); + if (!trust(this.connection.remoteAddress, 0)) { + return proto2; + } + var header = this.get("X-Forwarded-Proto") || proto2; + var index = header.indexOf(","); + return index !== -1 ? header.substring(0, index).trim() : header.trim(); + }); + defineGetter(req, "secure", function secure() { + return this.protocol === "https"; + }); + defineGetter(req, "ip", function ip() { + var trust = this.app.get("trust proxy fn"); + return proxyaddr(this, trust); + }); + defineGetter(req, "ips", function ips() { + var trust = this.app.get("trust proxy fn"); + var addrs = proxyaddr.all(this, trust); + addrs.reverse().pop(); + return addrs; + }); + defineGetter(req, "subdomains", function subdomains() { + var hostname = this.hostname; + if (!hostname) return []; + var offset = this.app.get("subdomain offset"); + var subdomains2 = !isIP(hostname) ? hostname.split(".").reverse() : [hostname]; + return subdomains2.slice(offset); + }); + defineGetter(req, "path", function path() { + return parse(this).pathname; + }); + defineGetter(req, "host", function host() { + var trust = this.app.get("trust proxy fn"); + var val = this.get("X-Forwarded-Host"); + if (!val || !trust(this.connection.remoteAddress, 0)) { + val = this.get("Host"); + } else if (val.indexOf(",") !== -1) { + val = val.substring(0, val.indexOf(",")).trimRight(); + } + return val || void 0; + }); + defineGetter(req, "hostname", function hostname() { + var host = this.host; + if (!host) return; + var offset = host[0] === "[" ? host.indexOf("]") + 1 : 0; + var index = host.indexOf(":", offset); + return index !== -1 ? host.substring(0, index) : host; + }); + defineGetter(req, "fresh", function() { + var method = this.method; + var res = this.res; + var status = res.statusCode; + if ("GET" !== method && "HEAD" !== method) return false; + if (status >= 200 && status < 300 || 304 === status) { + return fresh(this.headers, { + "etag": res.get("ETag"), + "last-modified": res.get("Last-Modified") + }); + } + return false; + }); + defineGetter(req, "stale", function stale() { + return !this.fresh; + }); + defineGetter(req, "xhr", function xhr() { + var val = this.get("X-Requested-With") || ""; + return val.toLowerCase() === "xmlhttprequest"; + }); + function defineGetter(obj, name, getter) { + Object.defineProperty(obj, name, { + configurable: true, + enumerable: true, + get: getter + }); + } + } +}); +var require_safe_buffer = __commonJS2({ + "node_modules/safe-buffer/index.js"(exports2, module2) { + var buffer = require("buffer"); + var Buffer2 = buffer.Buffer; + function copyProps(src, dst) { + for (var key in src) { + dst[key] = src[key]; + } + } + if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) { + module2.exports = buffer; + } else { + copyProps(buffer, exports2); + exports2.Buffer = SafeBuffer; + } + function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer2(arg, encodingOrOffset, length); + } + SafeBuffer.prototype = Object.create(Buffer2.prototype); + copyProps(Buffer2, SafeBuffer); + SafeBuffer.from = function(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + throw new TypeError("Argument must not be a number"); + } + return Buffer2(arg, encodingOrOffset, length); + }; + SafeBuffer.alloc = function(size, fill, encoding) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + var buf = Buffer2(size); + if (fill !== void 0) { + if (typeof encoding === "string") { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; + }; + SafeBuffer.allocUnsafe = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return Buffer2(size); + }; + SafeBuffer.allocUnsafeSlow = function(size) { + if (typeof size !== "number") { + throw new TypeError("Argument must be a number"); + } + return buffer.SlowBuffer(size); + }; + } +}); +var require_content_disposition = __commonJS2({ + "node_modules/content-disposition/index.js"(exports2, module2) { + "use strict"; + module2.exports = contentDisposition; + module2.exports.parse = parse; + var basename = require("path").basename; + var Buffer2 = require_safe_buffer().Buffer; + var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g; + var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/; + var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g; + var NON_LATIN1_REGEXP = /[^\x20-\x7e\xa0-\xff]/g; + var QESC_REGEXP = /\\([\u0000-\u007f])/g; + var QUOTE_REGEXP = /([\\"])/g; + var PARAM_REGEXP = /;[\x09\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*=[\x09\x20]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*/g; + var TEXT_REGEXP = /^[\x20-\x7e\x80-\xff]+$/; + var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/; + var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/; + var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*(?:$|;)/; + function contentDisposition(filename, options) { + var opts = options || {}; + var type = opts.type || "attachment"; + var params = createparams(filename, opts.fallback); + return format(new ContentDisposition(type, params)); + } + function createparams(filename, fallback) { + if (filename === void 0) { + return; + } + var params = {}; + if (typeof filename !== "string") { + throw new TypeError("filename must be a string"); + } + if (fallback === void 0) { + fallback = true; + } + if (typeof fallback !== "string" && typeof fallback !== "boolean") { + throw new TypeError("fallback must be a string or boolean"); + } + if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) { + throw new TypeError("fallback must be ISO-8859-1 string"); + } + var name = basename(filename); + var isQuotedString = TEXT_REGEXP.test(name); + var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename(fallback); + var hasFallback = typeof fallbackName === "string" && fallbackName !== name; + if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) { + params["filename*"] = name; + } + if (isQuotedString || hasFallback) { + params.filename = hasFallback ? fallbackName : name; + } + return params; + } + function format(obj) { + var parameters = obj.parameters; + var type = obj.type; + if (!type || typeof type !== "string" || !TOKEN_REGEXP.test(type)) { + throw new TypeError("invalid type"); + } + var string = String(type).toLowerCase(); + if (parameters && typeof parameters === "object") { + var param; + var params = Object.keys(parameters).sort(); + for (var i = 0; i < params.length; i++) { + param = params[i]; + var val = param.slice(-1) === "*" ? ustring(parameters[param]) : qstring(parameters[param]); + string += "; " + param + "=" + val; + } + } + return string; + } + function decodefield(str) { + var match = EXT_VALUE_REGEXP.exec(str); + if (!match) { + throw new TypeError("invalid extended field value"); + } + var charset = match[1].toLowerCase(); + var encoded = match[2]; + var value; + var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode); + switch (charset) { + case "iso-8859-1": + value = getlatin1(binary); + break; + case "utf-8": + case "utf8": + value = Buffer2.from(binary, "binary").toString("utf8"); + break; + default: + throw new TypeError("unsupported charset in extended field"); + } + return value; + } + function getlatin1(val) { + return String(val).replace(NON_LATIN1_REGEXP, "?"); + } + function parse(string) { + if (!string || typeof string !== "string") { + throw new TypeError("argument string is required"); + } + var match = DISPOSITION_TYPE_REGEXP.exec(string); + if (!match) { + throw new TypeError("invalid type format"); + } + var index = match[0].length; + var type = match[1].toLowerCase(); + var key; + var names = []; + var params = {}; + var value; + index = PARAM_REGEXP.lastIndex = match[0].slice(-1) === ";" ? index - 1 : index; + while (match = PARAM_REGEXP.exec(string)) { + if (match.index !== index) { + throw new TypeError("invalid parameter format"); + } + index += match[0].length; + key = match[1].toLowerCase(); + value = match[2]; + if (names.indexOf(key) !== -1) { + throw new TypeError("invalid duplicate parameter"); + } + names.push(key); + if (key.indexOf("*") + 1 === key.length) { + key = key.slice(0, -1); + value = decodefield(value); + params[key] = value; + continue; + } + if (typeof params[key] === "string") { + continue; + } + if (value[0] === '"') { + value = value.slice(1, -1).replace(QESC_REGEXP, "$1"); + } + params[key] = value; + } + if (index !== -1 && index !== string.length) { + throw new TypeError("invalid parameter format"); + } + return new ContentDisposition(type, params); + } + function pdecode(str, hex) { + return String.fromCharCode(parseInt(hex, 16)); + } + function pencode(char) { + return "%" + String(char).charCodeAt(0).toString(16).toUpperCase(); + } + function qstring(val) { + var str = String(val); + return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"'; + } + function ustring(val) { + var str = String(val); + var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode); + return "UTF-8''" + encoded; + } + function ContentDisposition(type, parameters) { + this.type = type; + this.parameters = parameters; + } + } +}); +var require_cookie_signature = __commonJS2({ + "node_modules/cookie-signature/index.js"(exports2) { + var crypto = require("crypto"); + exports2.sign = function(val, secret) { + if ("string" != typeof val) throw new TypeError("Cookie value must be provided as a string."); + if (null == secret) throw new TypeError("Secret key must be provided."); + return val + "." + crypto.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, ""); + }; + exports2.unsign = function(input, secret) { + if ("string" != typeof input) throw new TypeError("Signed cookie string must be provided."); + if (null == secret) throw new TypeError("Secret key must be provided."); + var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports2.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input); + return expectedBuffer.length === inputBuffer.length && crypto.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false; + }; + } +}); +var require_cookie = __commonJS2({ + "node_modules/cookie/index.js"(exports2) { + "use strict"; + exports2.parse = parse; + exports2.serialize = serialize; + var __toString = Object.prototype.toString; + var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; + var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/; + var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i; + var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/; + function parse(str, opt) { + if (typeof str !== "string") { + throw new TypeError("argument str must be a string"); + } + var obj = {}; + var len = str.length; + if (len < 2) return obj; + var dec = opt && opt.decode || decode; + var index = 0; + var eqIdx = 0; + var endIdx = 0; + do { + eqIdx = str.indexOf("=", index); + if (eqIdx === -1) break; + endIdx = str.indexOf(";", index); + if (endIdx === -1) { + endIdx = len; + } else if (eqIdx > endIdx) { + index = str.lastIndexOf(";", eqIdx - 1) + 1; + continue; + } + var keyStartIdx = startIndex(str, index, eqIdx); + var keyEndIdx = endIndex(str, eqIdx, keyStartIdx); + var key = str.slice(keyStartIdx, keyEndIdx); + if (!obj.hasOwnProperty(key)) { + var valStartIdx = startIndex(str, eqIdx + 1, endIdx); + var valEndIdx = endIndex(str, endIdx, valStartIdx); + if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) { + valStartIdx++; + valEndIdx--; + } + var val = str.slice(valStartIdx, valEndIdx); + obj[key] = tryDecode(val, dec); + } + index = endIdx + 1; + } while (index < len); + return obj; + } + function startIndex(str, index, max) { + do { + var code = str.charCodeAt(index); + if (code !== 32 && code !== 9) return index; + } while (++index < max); + return max; + } + function endIndex(str, index, min) { + while (index > min) { + var code = str.charCodeAt(--index); + if (code !== 32 && code !== 9) return index + 1; + } + return min; + } + function serialize(name, val, opt) { + var enc = opt && opt.encode || encodeURIComponent; + if (typeof enc !== "function") { + throw new TypeError("option encode is invalid"); + } + if (!cookieNameRegExp.test(name)) { + throw new TypeError("argument name is invalid"); + } + var value = enc(val); + if (!cookieValueRegExp.test(value)) { + throw new TypeError("argument val is invalid"); + } + var str = name + "=" + value; + if (!opt) return str; + if (null != opt.maxAge) { + var maxAge = Math.floor(opt.maxAge); + if (!isFinite(maxAge)) { + throw new TypeError("option maxAge is invalid"); + } + str += "; Max-Age=" + maxAge; + } + if (opt.domain) { + if (!domainValueRegExp.test(opt.domain)) { + throw new TypeError("option domain is invalid"); + } + str += "; Domain=" + opt.domain; + } + if (opt.path) { + if (!pathValueRegExp.test(opt.path)) { + throw new TypeError("option path is invalid"); + } + str += "; Path=" + opt.path; + } + if (opt.expires) { + var expires = opt.expires; + if (!isDate(expires) || isNaN(expires.valueOf())) { + throw new TypeError("option expires is invalid"); + } + str += "; Expires=" + expires.toUTCString(); + } + if (opt.httpOnly) { + str += "; HttpOnly"; + } + if (opt.secure) { + str += "; Secure"; + } + if (opt.partitioned) { + str += "; Partitioned"; + } + if (opt.priority) { + var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority; + switch (priority) { + case "low": + str += "; Priority=Low"; + break; + case "medium": + str += "; Priority=Medium"; + break; + case "high": + str += "; Priority=High"; + break; + default: + throw new TypeError("option priority is invalid"); + } + } + if (opt.sameSite) { + var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite; + switch (sameSite) { + case true: + str += "; SameSite=Strict"; + break; + case "lax": + str += "; SameSite=Lax"; + break; + case "strict": + str += "; SameSite=Strict"; + break; + case "none": + str += "; SameSite=None"; + break; + default: + throw new TypeError("option sameSite is invalid"); + } + } + return str; + } + function decode(str) { + return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str; + } + function isDate(val) { + return __toString.call(val) === "[object Date]"; + } + function tryDecode(str, decode2) { + try { + return decode2(str); + } catch (e) { + return str; + } + } + } +}); +var require_db4 = __commonJS2({ + "node_modules/send/node_modules/mime-db/db.json"(exports2, module2) { + module2.exports = { + "application/1d-interleaved-parityfec": { + source: "iana" + }, + "application/3gpdash-qoe-report+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/3gpp-ims+xml": { + source: "iana", + compressible: true + }, + "application/3gpphal+json": { + source: "iana", + compressible: true + }, + "application/3gpphalforms+json": { + source: "iana", + compressible: true + }, + "application/a2l": { + source: "iana" + }, + "application/ace+cbor": { + source: "iana" + }, + "application/ace+json": { + source: "iana", + compressible: true + }, + "application/ace-groupcomm+cbor": { + source: "iana" + }, + "application/ace-trl+cbor": { + source: "iana" + }, + "application/activemessage": { + source: "iana" + }, + "application/activity+json": { + source: "iana", + compressible: true + }, + "application/aif+cbor": { + source: "iana" + }, + "application/aif+json": { + source: "iana", + compressible: true + }, + "application/alto-cdni+json": { + source: "iana", + compressible: true + }, + "application/alto-cdnifilter+json": { + source: "iana", + compressible: true + }, + "application/alto-costmap+json": { + source: "iana", + compressible: true + }, + "application/alto-costmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-directory+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcost+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcostparams+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointprop+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointpropparams+json": { + source: "iana", + compressible: true + }, + "application/alto-error+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmap+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-propmap+json": { + source: "iana", + compressible: true + }, + "application/alto-propmapparams+json": { + source: "iana", + compressible: true + }, + "application/alto-tips+json": { + source: "iana", + compressible: true + }, + "application/alto-tipsparams+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamcontrol+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamparams+json": { + source: "iana", + compressible: true + }, + "application/aml": { + source: "iana" + }, + "application/andrew-inset": { + source: "iana", + extensions: ["ez"] + }, + "application/appinstaller": { + compressible: false, + extensions: ["appinstaller"] + }, + "application/applefile": { + source: "iana" + }, + "application/applixware": { + source: "apache", + extensions: ["aw"] + }, + "application/appx": { + compressible: false, + extensions: ["appx"] + }, + "application/appxbundle": { + compressible: false, + extensions: ["appxbundle"] + }, + "application/at+jwt": { + source: "iana" + }, + "application/atf": { + source: "iana" + }, + "application/atfx": { + source: "iana" + }, + "application/atom+xml": { + source: "iana", + compressible: true, + extensions: ["atom"] + }, + "application/atomcat+xml": { + source: "iana", + compressible: true, + extensions: ["atomcat"] + }, + "application/atomdeleted+xml": { + source: "iana", + compressible: true, + extensions: ["atomdeleted"] + }, + "application/atomicmail": { + source: "iana" + }, + "application/atomsvc+xml": { + source: "iana", + compressible: true, + extensions: ["atomsvc"] + }, + "application/atsc-dwd+xml": { + source: "iana", + compressible: true, + extensions: ["dwd"] + }, + "application/atsc-dynamic-event-message": { + source: "iana" + }, + "application/atsc-held+xml": { + source: "iana", + compressible: true, + extensions: ["held"] + }, + "application/atsc-rdt+json": { + source: "iana", + compressible: true + }, + "application/atsc-rsat+xml": { + source: "iana", + compressible: true, + extensions: ["rsat"] + }, + "application/atxml": { + source: "iana" + }, + "application/auth-policy+xml": { + source: "iana", + compressible: true + }, + "application/automationml-aml+xml": { + source: "iana", + compressible: true, + extensions: ["aml"] + }, + "application/automationml-amlx+zip": { + source: "iana", + compressible: false, + extensions: ["amlx"] + }, + "application/bacnet-xdd+zip": { + source: "iana", + compressible: false + }, + "application/batch-smtp": { + source: "iana" + }, + "application/bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/beep+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/bufr": { + source: "iana" + }, + "application/c2pa": { + source: "iana" + }, + "application/calendar+json": { + source: "iana", + compressible: true + }, + "application/calendar+xml": { + source: "iana", + compressible: true, + extensions: ["xcs"] + }, + "application/call-completion": { + source: "iana" + }, + "application/cals-1840": { + source: "iana" + }, + "application/captive+json": { + source: "iana", + compressible: true + }, + "application/cbor": { + source: "iana" + }, + "application/cbor-seq": { + source: "iana" + }, + "application/cccex": { + source: "iana" + }, + "application/ccmp+xml": { + source: "iana", + compressible: true + }, + "application/ccxml+xml": { + source: "iana", + compressible: true, + extensions: ["ccxml"] + }, + "application/cda+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/cdfx+xml": { + source: "iana", + compressible: true, + extensions: ["cdfx"] + }, + "application/cdmi-capability": { + source: "iana", + extensions: ["cdmia"] + }, + "application/cdmi-container": { + source: "iana", + extensions: ["cdmic"] + }, + "application/cdmi-domain": { + source: "iana", + extensions: ["cdmid"] + }, + "application/cdmi-object": { + source: "iana", + extensions: ["cdmio"] + }, + "application/cdmi-queue": { + source: "iana", + extensions: ["cdmiq"] + }, + "application/cdni": { + source: "iana" + }, + "application/ce+cbor": { + source: "iana" + }, + "application/cea": { + source: "iana" + }, + "application/cea-2018+xml": { + source: "iana", + compressible: true + }, + "application/cellml+xml": { + source: "iana", + compressible: true + }, + "application/cfw": { + source: "iana" + }, + "application/cid-edhoc+cbor-seq": { + source: "iana" + }, + "application/city+json": { + source: "iana", + compressible: true + }, + "application/city+json-seq": { + source: "iana" + }, + "application/clr": { + source: "iana" + }, + "application/clue+xml": { + source: "iana", + compressible: true + }, + "application/clue_info+xml": { + source: "iana", + compressible: true + }, + "application/cms": { + source: "iana" + }, + "application/cnrp+xml": { + source: "iana", + compressible: true + }, + "application/coap-eap": { + source: "iana" + }, + "application/coap-group+json": { + source: "iana", + compressible: true + }, + "application/coap-payload": { + source: "iana" + }, + "application/commonground": { + source: "iana" + }, + "application/concise-problem-details+cbor": { + source: "iana" + }, + "application/conference-info+xml": { + source: "iana", + compressible: true + }, + "application/cose": { + source: "iana" + }, + "application/cose-key": { + source: "iana" + }, + "application/cose-key-set": { + source: "iana" + }, + "application/cose-x509": { + source: "iana" + }, + "application/cpl+xml": { + source: "iana", + compressible: true, + extensions: ["cpl"] + }, + "application/csrattrs": { + source: "iana" + }, + "application/csta+xml": { + source: "iana", + compressible: true + }, + "application/cstadata+xml": { + source: "iana", + compressible: true + }, + "application/csvm+json": { + source: "iana", + compressible: true + }, + "application/cu-seeme": { + source: "apache", + extensions: ["cu"] + }, + "application/cwl": { + source: "iana", + extensions: ["cwl"] + }, + "application/cwl+json": { + source: "iana", + compressible: true + }, + "application/cwl+yaml": { + source: "iana" + }, + "application/cwt": { + source: "iana" + }, + "application/cybercash": { + source: "iana" + }, + "application/dart": { + compressible: true + }, + "application/dash+xml": { + source: "iana", + compressible: true, + extensions: ["mpd"] + }, + "application/dash-patch+xml": { + source: "iana", + compressible: true, + extensions: ["mpp"] + }, + "application/dashdelta": { + source: "iana" + }, + "application/davmount+xml": { + source: "iana", + compressible: true, + extensions: ["davmount"] + }, + "application/dca-rft": { + source: "iana" + }, + "application/dcd": { + source: "iana" + }, + "application/dec-dx": { + source: "iana" + }, + "application/dialog-info+xml": { + source: "iana", + compressible: true + }, + "application/dicom": { + source: "iana", + extensions: ["dcm"] + }, + "application/dicom+json": { + source: "iana", + compressible: true + }, + "application/dicom+xml": { + source: "iana", + compressible: true + }, + "application/dii": { + source: "iana" + }, + "application/dit": { + source: "iana" + }, + "application/dns": { + source: "iana" + }, + "application/dns+json": { + source: "iana", + compressible: true + }, + "application/dns-message": { + source: "iana" + }, + "application/docbook+xml": { + source: "apache", + compressible: true, + extensions: ["dbk"] + }, + "application/dots+cbor": { + source: "iana" + }, + "application/dpop+jwt": { + source: "iana" + }, + "application/dskpp+xml": { + source: "iana", + compressible: true + }, + "application/dssc+der": { + source: "iana", + extensions: ["dssc"] + }, + "application/dssc+xml": { + source: "iana", + compressible: true, + extensions: ["xdssc"] + }, + "application/dvcs": { + source: "iana" + }, + "application/eat+cwt": { + source: "iana" + }, + "application/eat+jwt": { + source: "iana" + }, + "application/eat-bun+cbor": { + source: "iana" + }, + "application/eat-bun+json": { + source: "iana", + compressible: true + }, + "application/eat-ucs+cbor": { + source: "iana" + }, + "application/eat-ucs+json": { + source: "iana", + compressible: true + }, + "application/ecmascript": { + source: "apache", + compressible: true, + extensions: ["ecma"] + }, + "application/edhoc+cbor-seq": { + source: "iana" + }, + "application/edi-consent": { + source: "iana" + }, + "application/edi-x12": { + source: "iana", + compressible: false + }, + "application/edifact": { + source: "iana", + compressible: false + }, + "application/efi": { + source: "iana" + }, + "application/elm+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/elm+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.cap+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/emergencycalldata.comment+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.control+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.deviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.ecall.msd": { + source: "iana" + }, + "application/emergencycalldata.legacyesn+json": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.providerinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.serviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.subscriberinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.veds+xml": { + source: "iana", + compressible: true + }, + "application/emma+xml": { + source: "iana", + compressible: true, + extensions: ["emma"] + }, + "application/emotionml+xml": { + source: "iana", + compressible: true, + extensions: ["emotionml"] + }, + "application/encaprtp": { + source: "iana" + }, + "application/entity-statement+jwt": { + source: "iana" + }, + "application/epp+xml": { + source: "iana", + compressible: true + }, + "application/epub+zip": { + source: "iana", + compressible: false, + extensions: ["epub"] + }, + "application/eshop": { + source: "iana" + }, + "application/exi": { + source: "iana", + extensions: ["exi"] + }, + "application/expect-ct-report+json": { + source: "iana", + compressible: true + }, + "application/express": { + source: "iana", + extensions: ["exp"] + }, + "application/fastinfoset": { + source: "iana" + }, + "application/fastsoap": { + source: "iana" + }, + "application/fdf": { + source: "iana", + extensions: ["fdf"] + }, + "application/fdt+xml": { + source: "iana", + compressible: true, + extensions: ["fdt"] + }, + "application/fhir+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fhir+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fido.trusted-apps+json": { + compressible: true + }, + "application/fits": { + source: "iana" + }, + "application/flexfec": { + source: "iana" + }, + "application/font-sfnt": { + source: "iana" + }, + "application/font-tdpfr": { + source: "iana", + extensions: ["pfr"] + }, + "application/font-woff": { + source: "iana", + compressible: false + }, + "application/framework-attributes+xml": { + source: "iana", + compressible: true + }, + "application/geo+json": { + source: "iana", + compressible: true, + extensions: ["geojson"] + }, + "application/geo+json-seq": { + source: "iana" + }, + "application/geopackage+sqlite3": { + source: "iana" + }, + "application/geopose+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+json": { + source: "iana", + compressible: true + }, + "application/geoxacml+xml": { + source: "iana", + compressible: true + }, + "application/gltf-buffer": { + source: "iana" + }, + "application/gml+xml": { + source: "iana", + compressible: true, + extensions: ["gml"] + }, + "application/gnap-binding-jws": { + source: "iana" + }, + "application/gnap-binding-jwsd": { + source: "iana" + }, + "application/gnap-binding-rotation-jws": { + source: "iana" + }, + "application/gnap-binding-rotation-jwsd": { + source: "iana" + }, + "application/gpx+xml": { + source: "apache", + compressible: true, + extensions: ["gpx"] + }, + "application/grib": { + source: "iana" + }, + "application/gxf": { + source: "apache", + extensions: ["gxf"] + }, + "application/gzip": { + source: "iana", + compressible: false, + extensions: ["gz"] + }, + "application/h224": { + source: "iana" + }, + "application/held+xml": { + source: "iana", + compressible: true + }, + "application/hjson": { + extensions: ["hjson"] + }, + "application/hl7v2+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/http": { + source: "iana" + }, + "application/hyperstudio": { + source: "iana", + extensions: ["stk"] + }, + "application/ibe-key-request+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pkg-reply+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pp-data": { + source: "iana" + }, + "application/iges": { + source: "iana" + }, + "application/im-iscomposing+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/index": { + source: "iana" + }, + "application/index.cmd": { + source: "iana" + }, + "application/index.obj": { + source: "iana" + }, + "application/index.response": { + source: "iana" + }, + "application/index.vnd": { + source: "iana" + }, + "application/inkml+xml": { + source: "iana", + compressible: true, + extensions: ["ink", "inkml"] + }, + "application/iotp": { + source: "iana" + }, + "application/ipfix": { + source: "iana", + extensions: ["ipfix"] + }, + "application/ipp": { + source: "iana" + }, + "application/isup": { + source: "iana" + }, + "application/its+xml": { + source: "iana", + compressible: true, + extensions: ["its"] + }, + "application/java-archive": { + source: "iana", + compressible: false, + extensions: ["jar", "war", "ear"] + }, + "application/java-serialized-object": { + source: "apache", + compressible: false, + extensions: ["ser"] + }, + "application/java-vm": { + source: "apache", + compressible: false, + extensions: ["class"] + }, + "application/javascript": { + source: "apache", + charset: "UTF-8", + compressible: true, + extensions: ["js"] + }, + "application/jf2feed+json": { + source: "iana", + compressible: true + }, + "application/jose": { + source: "iana" + }, + "application/jose+json": { + source: "iana", + compressible: true + }, + "application/jrd+json": { + source: "iana", + compressible: true + }, + "application/jscalendar+json": { + source: "iana", + compressible: true + }, + "application/jscontact+json": { + source: "iana", + compressible: true + }, + "application/json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["json", "map"] + }, + "application/json-patch+json": { + source: "iana", + compressible: true + }, + "application/json-seq": { + source: "iana" + }, + "application/json5": { + extensions: ["json5"] + }, + "application/jsonml+json": { + source: "apache", + compressible: true, + extensions: ["jsonml"] + }, + "application/jsonpath": { + source: "iana" + }, + "application/jwk+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+jwt": { + source: "iana" + }, + "application/jwt": { + source: "iana" + }, + "application/kpml-request+xml": { + source: "iana", + compressible: true + }, + "application/kpml-response+xml": { + source: "iana", + compressible: true + }, + "application/ld+json": { + source: "iana", + compressible: true, + extensions: ["jsonld"] + }, + "application/lgr+xml": { + source: "iana", + compressible: true, + extensions: ["lgr"] + }, + "application/link-format": { + source: "iana" + }, + "application/linkset": { + source: "iana" + }, + "application/linkset+json": { + source: "iana", + compressible: true + }, + "application/load-control+xml": { + source: "iana", + compressible: true + }, + "application/logout+jwt": { + source: "iana" + }, + "application/lost+xml": { + source: "iana", + compressible: true, + extensions: ["lostxml"] + }, + "application/lostsync+xml": { + source: "iana", + compressible: true + }, + "application/lpf+zip": { + source: "iana", + compressible: false + }, + "application/lxf": { + source: "iana" + }, + "application/mac-binhex40": { + source: "iana", + extensions: ["hqx"] + }, + "application/mac-compactpro": { + source: "apache", + extensions: ["cpt"] + }, + "application/macwriteii": { + source: "iana" + }, + "application/mads+xml": { + source: "iana", + compressible: true, + extensions: ["mads"] + }, + "application/manifest+json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["webmanifest"] + }, + "application/marc": { + source: "iana", + extensions: ["mrc"] + }, + "application/marcxml+xml": { + source: "iana", + compressible: true, + extensions: ["mrcx"] + }, + "application/mathematica": { + source: "iana", + extensions: ["ma", "nb", "mb"] + }, + "application/mathml+xml": { + source: "iana", + compressible: true, + extensions: ["mathml"] + }, + "application/mathml-content+xml": { + source: "iana", + compressible: true + }, + "application/mathml-presentation+xml": { + source: "iana", + compressible: true + }, + "application/mbms-associated-procedure-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-deregister+xml": { + source: "iana", + compressible: true + }, + "application/mbms-envelope+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-protection-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-reception-report+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-schedule+xml": { + source: "iana", + compressible: true + }, + "application/mbms-user-service-description+xml": { + source: "iana", + compressible: true + }, + "application/mbox": { + source: "iana", + extensions: ["mbox"] + }, + "application/media-policy-dataset+xml": { + source: "iana", + compressible: true, + extensions: ["mpf"] + }, + "application/media_control+xml": { + source: "iana", + compressible: true + }, + "application/mediaservercontrol+xml": { + source: "iana", + compressible: true, + extensions: ["mscml"] + }, + "application/merge-patch+json": { + source: "iana", + compressible: true + }, + "application/metalink+xml": { + source: "apache", + compressible: true, + extensions: ["metalink"] + }, + "application/metalink4+xml": { + source: "iana", + compressible: true, + extensions: ["meta4"] + }, + "application/mets+xml": { + source: "iana", + compressible: true, + extensions: ["mets"] + }, + "application/mf4": { + source: "iana" + }, + "application/mikey": { + source: "iana" + }, + "application/mipc": { + source: "iana" + }, + "application/missing-blocks+cbor-seq": { + source: "iana" + }, + "application/mmt-aei+xml": { + source: "iana", + compressible: true, + extensions: ["maei"] + }, + "application/mmt-usd+xml": { + source: "iana", + compressible: true, + extensions: ["musd"] + }, + "application/mods+xml": { + source: "iana", + compressible: true, + extensions: ["mods"] + }, + "application/moss-keys": { + source: "iana" + }, + "application/moss-signature": { + source: "iana" + }, + "application/mosskey-data": { + source: "iana" + }, + "application/mosskey-request": { + source: "iana" + }, + "application/mp21": { + source: "iana", + extensions: ["m21", "mp21"] + }, + "application/mp4": { + source: "iana", + extensions: ["mp4", "mpg4", "mp4s", "m4p"] + }, + "application/mpeg4-generic": { + source: "iana" + }, + "application/mpeg4-iod": { + source: "iana" + }, + "application/mpeg4-iod-xmt": { + source: "iana" + }, + "application/mrb-consumer+xml": { + source: "iana", + compressible: true + }, + "application/mrb-publish+xml": { + source: "iana", + compressible: true + }, + "application/msc-ivr+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msc-mixer+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msix": { + compressible: false, + extensions: ["msix"] + }, + "application/msixbundle": { + compressible: false, + extensions: ["msixbundle"] + }, + "application/msword": { + source: "iana", + compressible: false, + extensions: ["doc", "dot"] + }, + "application/mud+json": { + source: "iana", + compressible: true + }, + "application/multipart-core": { + source: "iana" + }, + "application/mxf": { + source: "iana", + extensions: ["mxf"] + }, + "application/n-quads": { + source: "iana", + extensions: ["nq"] + }, + "application/n-triples": { + source: "iana", + extensions: ["nt"] + }, + "application/nasdata": { + source: "iana" + }, + "application/news-checkgroups": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-groupinfo": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-transmission": { + source: "iana" + }, + "application/nlsml+xml": { + source: "iana", + compressible: true + }, + "application/node": { + source: "iana", + extensions: ["cjs"] + }, + "application/nss": { + source: "iana" + }, + "application/oauth-authz-req+jwt": { + source: "iana" + }, + "application/oblivious-dns-message": { + source: "iana" + }, + "application/ocsp-request": { + source: "iana" + }, + "application/ocsp-response": { + source: "iana" + }, + "application/octet-stream": { + source: "iana", + compressible: true, + extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] + }, + "application/oda": { + source: "iana", + extensions: ["oda"] + }, + "application/odm+xml": { + source: "iana", + compressible: true + }, + "application/odx": { + source: "iana" + }, + "application/oebps-package+xml": { + source: "iana", + compressible: true, + extensions: ["opf"] + }, + "application/ogg": { + source: "iana", + compressible: false, + extensions: ["ogx"] + }, + "application/ohttp-keys": { + source: "iana" + }, + "application/omdoc+xml": { + source: "apache", + compressible: true, + extensions: ["omdoc"] + }, + "application/onenote": { + source: "apache", + extensions: ["onetoc", "onetoc2", "onetmp", "onepkg", "one", "onea"] + }, + "application/opc-nodeset+xml": { + source: "iana", + compressible: true + }, + "application/oscore": { + source: "iana" + }, + "application/oxps": { + source: "iana", + extensions: ["oxps"] + }, + "application/p21": { + source: "iana" + }, + "application/p21+zip": { + source: "iana", + compressible: false + }, + "application/p2p-overlay+xml": { + source: "iana", + compressible: true, + extensions: ["relo"] + }, + "application/parityfec": { + source: "iana" + }, + "application/passport": { + source: "iana" + }, + "application/patch-ops-error+xml": { + source: "iana", + compressible: true, + extensions: ["xer"] + }, + "application/pdf": { + source: "iana", + compressible: false, + extensions: ["pdf"] + }, + "application/pdx": { + source: "iana" + }, + "application/pem-certificate-chain": { + source: "iana" + }, + "application/pgp-encrypted": { + source: "iana", + compressible: false, + extensions: ["pgp"] + }, + "application/pgp-keys": { + source: "iana", + extensions: ["asc"] + }, + "application/pgp-signature": { + source: "iana", + extensions: ["sig", "asc"] + }, + "application/pics-rules": { + source: "apache", + extensions: ["prf"] + }, + "application/pidf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pidf-diff+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pkcs10": { + source: "iana", + extensions: ["p10"] + }, + "application/pkcs12": { + source: "iana" + }, + "application/pkcs7-mime": { + source: "iana", + extensions: ["p7m", "p7c"] + }, + "application/pkcs7-signature": { + source: "iana", + extensions: ["p7s"] + }, + "application/pkcs8": { + source: "iana", + extensions: ["p8"] + }, + "application/pkcs8-encrypted": { + source: "iana" + }, + "application/pkix-attr-cert": { + source: "iana", + extensions: ["ac"] + }, + "application/pkix-cert": { + source: "iana", + extensions: ["cer"] + }, + "application/pkix-crl": { + source: "iana", + extensions: ["crl"] + }, + "application/pkix-pkipath": { + source: "iana", + extensions: ["pkipath"] + }, + "application/pkixcmp": { + source: "iana", + extensions: ["pki"] + }, + "application/pls+xml": { + source: "iana", + compressible: true, + extensions: ["pls"] + }, + "application/poc-settings+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/postscript": { + source: "iana", + compressible: true, + extensions: ["ai", "eps", "ps"] + }, + "application/ppsp-tracker+json": { + source: "iana", + compressible: true + }, + "application/private-token-issuer-directory": { + source: "iana" + }, + "application/private-token-request": { + source: "iana" + }, + "application/private-token-response": { + source: "iana" + }, + "application/problem+json": { + source: "iana", + compressible: true + }, + "application/problem+xml": { + source: "iana", + compressible: true + }, + "application/provenance+xml": { + source: "iana", + compressible: true, + extensions: ["provx"] + }, + "application/provided-claims+jwt": { + source: "iana" + }, + "application/prs.alvestrand.titrax-sheet": { + source: "iana" + }, + "application/prs.cww": { + source: "iana", + extensions: ["cww"] + }, + "application/prs.cyn": { + source: "iana", + charset: "7-BIT" + }, + "application/prs.hpub+zip": { + source: "iana", + compressible: false + }, + "application/prs.implied-document+xml": { + source: "iana", + compressible: true + }, + "application/prs.implied-executable": { + source: "iana" + }, + "application/prs.implied-object+json": { + source: "iana", + compressible: true + }, + "application/prs.implied-object+json-seq": { + source: "iana" + }, + "application/prs.implied-object+yaml": { + source: "iana" + }, + "application/prs.implied-structure": { + source: "iana" + }, + "application/prs.mayfile": { + source: "iana" + }, + "application/prs.nprend": { + source: "iana" + }, + "application/prs.plucker": { + source: "iana" + }, + "application/prs.rdf-xml-crypt": { + source: "iana" + }, + "application/prs.vcfbzip2": { + source: "iana" + }, + "application/prs.xsf+xml": { + source: "iana", + compressible: true, + extensions: ["xsf"] + }, + "application/pskc+xml": { + source: "iana", + compressible: true, + extensions: ["pskcxml"] + }, + "application/pvd+json": { + source: "iana", + compressible: true + }, + "application/qsig": { + source: "iana" + }, + "application/raml+yaml": { + compressible: true, + extensions: ["raml"] + }, + "application/raptorfec": { + source: "iana" + }, + "application/rdap+json": { + source: "iana", + compressible: true + }, + "application/rdf+xml": { + source: "iana", + compressible: true, + extensions: ["rdf", "owl"] + }, + "application/reginfo+xml": { + source: "iana", + compressible: true, + extensions: ["rif"] + }, + "application/relax-ng-compact-syntax": { + source: "iana", + extensions: ["rnc"] + }, + "application/remote-printing": { + source: "apache" + }, + "application/reputon+json": { + source: "iana", + compressible: true + }, + "application/resolve-response+jwt": { + source: "iana" + }, + "application/resource-lists+xml": { + source: "iana", + compressible: true, + extensions: ["rl"] + }, + "application/resource-lists-diff+xml": { + source: "iana", + compressible: true, + extensions: ["rld"] + }, + "application/rfc+xml": { + source: "iana", + compressible: true + }, + "application/riscos": { + source: "iana" + }, + "application/rlmi+xml": { + source: "iana", + compressible: true + }, + "application/rls-services+xml": { + source: "iana", + compressible: true, + extensions: ["rs"] + }, + "application/route-apd+xml": { + source: "iana", + compressible: true, + extensions: ["rapd"] + }, + "application/route-s-tsid+xml": { + source: "iana", + compressible: true, + extensions: ["sls"] + }, + "application/route-usd+xml": { + source: "iana", + compressible: true, + extensions: ["rusd"] + }, + "application/rpki-checklist": { + source: "iana" + }, + "application/rpki-ghostbusters": { + source: "iana", + extensions: ["gbr"] + }, + "application/rpki-manifest": { + source: "iana", + extensions: ["mft"] + }, + "application/rpki-publication": { + source: "iana" + }, + "application/rpki-roa": { + source: "iana", + extensions: ["roa"] + }, + "application/rpki-signed-tal": { + source: "iana" + }, + "application/rpki-updown": { + source: "iana" + }, + "application/rsd+xml": { + source: "apache", + compressible: true, + extensions: ["rsd"] + }, + "application/rss+xml": { + source: "apache", + compressible: true, + extensions: ["rss"] + }, + "application/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "application/rtploopback": { + source: "iana" + }, + "application/rtx": { + source: "iana" + }, + "application/samlassertion+xml": { + source: "iana", + compressible: true + }, + "application/samlmetadata+xml": { + source: "iana", + compressible: true + }, + "application/sarif+json": { + source: "iana", + compressible: true + }, + "application/sarif-external-properties+json": { + source: "iana", + compressible: true + }, + "application/sbe": { + source: "iana" + }, + "application/sbml+xml": { + source: "iana", + compressible: true, + extensions: ["sbml"] + }, + "application/scaip+xml": { + source: "iana", + compressible: true + }, + "application/scim+json": { + source: "iana", + compressible: true + }, + "application/scvp-cv-request": { + source: "iana", + extensions: ["scq"] + }, + "application/scvp-cv-response": { + source: "iana", + extensions: ["scs"] + }, + "application/scvp-vp-request": { + source: "iana", + extensions: ["spq"] + }, + "application/scvp-vp-response": { + source: "iana", + extensions: ["spp"] + }, + "application/sdp": { + source: "iana", + extensions: ["sdp"] + }, + "application/secevent+jwt": { + source: "iana" + }, + "application/senml+cbor": { + source: "iana" + }, + "application/senml+json": { + source: "iana", + compressible: true + }, + "application/senml+xml": { + source: "iana", + compressible: true, + extensions: ["senmlx"] + }, + "application/senml-etch+cbor": { + source: "iana" + }, + "application/senml-etch+json": { + source: "iana", + compressible: true + }, + "application/senml-exi": { + source: "iana" + }, + "application/sensml+cbor": { + source: "iana" + }, + "application/sensml+json": { + source: "iana", + compressible: true + }, + "application/sensml+xml": { + source: "iana", + compressible: true, + extensions: ["sensmlx"] + }, + "application/sensml-exi": { + source: "iana" + }, + "application/sep+xml": { + source: "iana", + compressible: true + }, + "application/sep-exi": { + source: "iana" + }, + "application/session-info": { + source: "iana" + }, + "application/set-payment": { + source: "iana" + }, + "application/set-payment-initiation": { + source: "iana", + extensions: ["setpay"] + }, + "application/set-registration": { + source: "iana" + }, + "application/set-registration-initiation": { + source: "iana", + extensions: ["setreg"] + }, + "application/sgml": { + source: "iana" + }, + "application/sgml-open-catalog": { + source: "iana" + }, + "application/shf+xml": { + source: "iana", + compressible: true, + extensions: ["shf"] + }, + "application/sieve": { + source: "iana", + extensions: ["siv", "sieve"] + }, + "application/simple-filter+xml": { + source: "iana", + compressible: true + }, + "application/simple-message-summary": { + source: "iana" + }, + "application/simplesymbolcontainer": { + source: "iana" + }, + "application/sipc": { + source: "iana" + }, + "application/slate": { + source: "iana" + }, + "application/smil": { + source: "apache" + }, + "application/smil+xml": { + source: "iana", + compressible: true, + extensions: ["smi", "smil"] + }, + "application/smpte336m": { + source: "iana" + }, + "application/soap+fastinfoset": { + source: "iana" + }, + "application/soap+xml": { + source: "iana", + compressible: true + }, + "application/sparql-query": { + source: "iana", + extensions: ["rq"] + }, + "application/sparql-results+xml": { + source: "iana", + compressible: true, + extensions: ["srx"] + }, + "application/spdx+json": { + source: "iana", + compressible: true + }, + "application/spirits-event+xml": { + source: "iana", + compressible: true + }, + "application/sql": { + source: "iana", + extensions: ["sql"] + }, + "application/srgs": { + source: "iana", + extensions: ["gram"] + }, + "application/srgs+xml": { + source: "iana", + compressible: true, + extensions: ["grxml"] + }, + "application/sru+xml": { + source: "iana", + compressible: true, + extensions: ["sru"] + }, + "application/ssdl+xml": { + source: "apache", + compressible: true, + extensions: ["ssdl"] + }, + "application/sslkeylogfile": { + source: "iana" + }, + "application/ssml+xml": { + source: "iana", + compressible: true, + extensions: ["ssml"] + }, + "application/st2110-41": { + source: "iana" + }, + "application/stix+json": { + source: "iana", + compressible: true + }, + "application/stratum": { + source: "iana" + }, + "application/swid+cbor": { + source: "iana" + }, + "application/swid+xml": { + source: "iana", + compressible: true, + extensions: ["swidtag"] + }, + "application/tamp-apex-update": { + source: "iana" + }, + "application/tamp-apex-update-confirm": { + source: "iana" + }, + "application/tamp-community-update": { + source: "iana" + }, + "application/tamp-community-update-confirm": { + source: "iana" + }, + "application/tamp-error": { + source: "iana" + }, + "application/tamp-sequence-adjust": { + source: "iana" + }, + "application/tamp-sequence-adjust-confirm": { + source: "iana" + }, + "application/tamp-status-query": { + source: "iana" + }, + "application/tamp-status-response": { + source: "iana" + }, + "application/tamp-update": { + source: "iana" + }, + "application/tamp-update-confirm": { + source: "iana" + }, + "application/tar": { + compressible: true + }, + "application/taxii+json": { + source: "iana", + compressible: true + }, + "application/td+json": { + source: "iana", + compressible: true + }, + "application/tei+xml": { + source: "iana", + compressible: true, + extensions: ["tei", "teicorpus"] + }, + "application/tetra_isi": { + source: "iana" + }, + "application/thraud+xml": { + source: "iana", + compressible: true, + extensions: ["tfi"] + }, + "application/timestamp-query": { + source: "iana" + }, + "application/timestamp-reply": { + source: "iana" + }, + "application/timestamped-data": { + source: "iana", + extensions: ["tsd"] + }, + "application/tlsrpt+gzip": { + source: "iana" + }, + "application/tlsrpt+json": { + source: "iana", + compressible: true + }, + "application/tm+json": { + source: "iana", + compressible: true + }, + "application/tnauthlist": { + source: "iana" + }, + "application/toc+cbor": { + source: "iana" + }, + "application/token-introspection+jwt": { + source: "iana" + }, + "application/toml": { + source: "iana", + compressible: true, + extensions: ["toml"] + }, + "application/trickle-ice-sdpfrag": { + source: "iana" + }, + "application/trig": { + source: "iana", + extensions: ["trig"] + }, + "application/trust-chain+json": { + source: "iana", + compressible: true + }, + "application/trust-mark+jwt": { + source: "iana" + }, + "application/trust-mark-delegation+jwt": { + source: "iana" + }, + "application/ttml+xml": { + source: "iana", + compressible: true, + extensions: ["ttml"] + }, + "application/tve-trigger": { + source: "iana" + }, + "application/tzif": { + source: "iana" + }, + "application/tzif-leap": { + source: "iana" + }, + "application/ubjson": { + compressible: false, + extensions: ["ubj"] + }, + "application/uccs+cbor": { + source: "iana" + }, + "application/ujcs+json": { + source: "iana", + compressible: true + }, + "application/ulpfec": { + source: "iana" + }, + "application/urc-grpsheet+xml": { + source: "iana", + compressible: true + }, + "application/urc-ressheet+xml": { + source: "iana", + compressible: true, + extensions: ["rsheet"] + }, + "application/urc-targetdesc+xml": { + source: "iana", + compressible: true, + extensions: ["td"] + }, + "application/urc-uisocketdesc+xml": { + source: "iana", + compressible: true + }, + "application/vc": { + source: "iana" + }, + "application/vc+cose": { + source: "iana" + }, + "application/vc+jwt": { + source: "iana" + }, + "application/vcard+json": { + source: "iana", + compressible: true + }, + "application/vcard+xml": { + source: "iana", + compressible: true + }, + "application/vemmi": { + source: "iana" + }, + "application/vividence.scriptfile": { + source: "apache" + }, + "application/vnd.1000minds.decision-model+xml": { + source: "iana", + compressible: true, + extensions: ["1km"] + }, + "application/vnd.1ob": { + source: "iana" + }, + "application/vnd.3gpp-prose+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3a+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ach+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ch+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc8+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-v2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gnas": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsa2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x": { + source: "iana" + }, + "application/vnd.3gpp.5gsv2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.access-transfer-events+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.bsf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.crs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.current-location-discovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gmop+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gtpc": { + source: "iana" + }, + "application/vnd.3gpp.interworking-data": { + source: "iana" + }, + "application/vnd.3gpp.lpp": { + source: "iana" + }, + "application/vnd.3gpp.mc-signalling-ear": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-payload": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-signalling": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-floor-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-signed+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-init-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-regroup+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-transmission-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mid-call+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ngap": { + source: "iana" + }, + "application/vnd.3gpp.pfcp": { + source: "iana" + }, + "application/vnd.3gpp.pic-bw-large": { + source: "iana", + extensions: ["plb"] + }, + "application/vnd.3gpp.pic-bw-small": { + source: "iana", + extensions: ["psb"] + }, + "application/vnd.3gpp.pic-bw-var": { + source: "iana", + extensions: ["pvb"] + }, + "application/vnd.3gpp.pinapp-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.s1ap": { + source: "iana" + }, + "application/vnd.3gpp.seal-group-doc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-network-qos-management-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-ue-config-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-unicast-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.seal-user-profile-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.sms": { + source: "iana" + }, + "application/vnd.3gpp.sms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-ext+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.state-and-event-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ussd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.v2x": { + source: "iana" + }, + "application/vnd.3gpp.vae-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.bcmcsinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.sms": { + source: "iana" + }, + "application/vnd.3gpp2.tcap": { + source: "iana", + extensions: ["tcap"] + }, + "application/vnd.3lightssoftware.imagescal": { + source: "iana" + }, + "application/vnd.3m.post-it-notes": { + source: "iana", + extensions: ["pwn"] + }, + "application/vnd.accpac.simply.aso": { + source: "iana", + extensions: ["aso"] + }, + "application/vnd.accpac.simply.imp": { + source: "iana", + extensions: ["imp"] + }, + "application/vnd.acm.addressxfer+json": { + source: "iana", + compressible: true + }, + "application/vnd.acm.chatbot+json": { + source: "iana", + compressible: true + }, + "application/vnd.acucobol": { + source: "iana", + extensions: ["acu"] + }, + "application/vnd.acucorp": { + source: "iana", + extensions: ["atc", "acutc"] + }, + "application/vnd.adobe.air-application-installer-package+zip": { + source: "apache", + compressible: false, + extensions: ["air"] + }, + "application/vnd.adobe.flash.movie": { + source: "iana" + }, + "application/vnd.adobe.formscentral.fcdt": { + source: "iana", + extensions: ["fcdt"] + }, + "application/vnd.adobe.fxp": { + source: "iana", + extensions: ["fxp", "fxpl"] + }, + "application/vnd.adobe.partial-upload": { + source: "iana" + }, + "application/vnd.adobe.xdp+xml": { + source: "iana", + compressible: true, + extensions: ["xdp"] + }, + "application/vnd.adobe.xfdf": { + source: "apache", + extensions: ["xfdf"] + }, + "application/vnd.aether.imp": { + source: "iana" + }, + "application/vnd.afpc.afplinedata": { + source: "iana" + }, + "application/vnd.afpc.afplinedata-pagedef": { + source: "iana" + }, + "application/vnd.afpc.cmoca-cmresource": { + source: "iana" + }, + "application/vnd.afpc.foca-charset": { + source: "iana" + }, + "application/vnd.afpc.foca-codedfont": { + source: "iana" + }, + "application/vnd.afpc.foca-codepage": { + source: "iana" + }, + "application/vnd.afpc.modca": { + source: "iana" + }, + "application/vnd.afpc.modca-cmtable": { + source: "iana" + }, + "application/vnd.afpc.modca-formdef": { + source: "iana" + }, + "application/vnd.afpc.modca-mediummap": { + source: "iana" + }, + "application/vnd.afpc.modca-objectcontainer": { + source: "iana" + }, + "application/vnd.afpc.modca-overlay": { + source: "iana" + }, + "application/vnd.afpc.modca-pagesegment": { + source: "iana" + }, + "application/vnd.age": { + source: "iana", + extensions: ["age"] + }, + "application/vnd.ah-barcode": { + source: "apache" + }, + "application/vnd.ahead.space": { + source: "iana", + extensions: ["ahead"] + }, + "application/vnd.airzip.filesecure.azf": { + source: "iana", + extensions: ["azf"] + }, + "application/vnd.airzip.filesecure.azs": { + source: "iana", + extensions: ["azs"] + }, + "application/vnd.amadeus+json": { + source: "iana", + compressible: true + }, + "application/vnd.amazon.ebook": { + source: "apache", + extensions: ["azw"] + }, + "application/vnd.amazon.mobi8-ebook": { + source: "iana" + }, + "application/vnd.americandynamics.acc": { + source: "iana", + extensions: ["acc"] + }, + "application/vnd.amiga.ami": { + source: "iana", + extensions: ["ami"] + }, + "application/vnd.amundsen.maze+xml": { + source: "iana", + compressible: true + }, + "application/vnd.android.ota": { + source: "iana" + }, + "application/vnd.android.package-archive": { + source: "apache", + compressible: false, + extensions: ["apk"] + }, + "application/vnd.anki": { + source: "iana" + }, + "application/vnd.anser-web-certificate-issue-initiation": { + source: "iana", + extensions: ["cii"] + }, + "application/vnd.anser-web-funds-transfer-initiation": { + source: "apache", + extensions: ["fti"] + }, + "application/vnd.antix.game-component": { + source: "iana", + extensions: ["atx"] + }, + "application/vnd.apache.arrow.file": { + source: "iana" + }, + "application/vnd.apache.arrow.stream": { + source: "iana" + }, + "application/vnd.apache.parquet": { + source: "iana" + }, + "application/vnd.apache.thrift.binary": { + source: "iana" + }, + "application/vnd.apache.thrift.compact": { + source: "iana" + }, + "application/vnd.apache.thrift.json": { + source: "iana" + }, + "application/vnd.apexlang": { + source: "iana" + }, + "application/vnd.api+json": { + source: "iana", + compressible: true + }, + "application/vnd.aplextor.warrp+json": { + source: "iana", + compressible: true + }, + "application/vnd.apothekende.reservation+json": { + source: "iana", + compressible: true + }, + "application/vnd.apple.installer+xml": { + source: "iana", + compressible: true, + extensions: ["mpkg"] + }, + "application/vnd.apple.keynote": { + source: "iana", + extensions: ["key"] + }, + "application/vnd.apple.mpegurl": { + source: "iana", + extensions: ["m3u8"] + }, + "application/vnd.apple.numbers": { + source: "iana", + extensions: ["numbers"] + }, + "application/vnd.apple.pages": { + source: "iana", + extensions: ["pages"] + }, + "application/vnd.apple.pkpass": { + compressible: false, + extensions: ["pkpass"] + }, + "application/vnd.arastra.swi": { + source: "apache" + }, + "application/vnd.aristanetworks.swi": { + source: "iana", + extensions: ["swi"] + }, + "application/vnd.artisan+json": { + source: "iana", + compressible: true + }, + "application/vnd.artsquare": { + source: "iana" + }, + "application/vnd.astraea-software.iota": { + source: "iana", + extensions: ["iota"] + }, + "application/vnd.audiograph": { + source: "iana", + extensions: ["aep"] + }, + "application/vnd.autodesk.fbx": { + extensions: ["fbx"] + }, + "application/vnd.autopackage": { + source: "iana" + }, + "application/vnd.avalon+json": { + source: "iana", + compressible: true + }, + "application/vnd.avistar+xml": { + source: "iana", + compressible: true + }, + "application/vnd.balsamiq.bmml+xml": { + source: "iana", + compressible: true, + extensions: ["bmml"] + }, + "application/vnd.balsamiq.bmpr": { + source: "iana" + }, + "application/vnd.banana-accounting": { + source: "iana" + }, + "application/vnd.bbf.usp.error": { + source: "iana" + }, + "application/vnd.bbf.usp.msg": { + source: "iana" + }, + "application/vnd.bbf.usp.msg+json": { + source: "iana", + compressible: true + }, + "application/vnd.bekitzur-stech+json": { + source: "iana", + compressible: true + }, + "application/vnd.belightsoft.lhzd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.belightsoft.lhzl+zip": { + source: "iana", + compressible: false + }, + "application/vnd.bint.med-content": { + source: "iana" + }, + "application/vnd.biopax.rdf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.blink-idb-value-wrapper": { + source: "iana" + }, + "application/vnd.blueice.multipass": { + source: "iana", + extensions: ["mpm"] + }, + "application/vnd.bluetooth.ep.oob": { + source: "iana" + }, + "application/vnd.bluetooth.le.oob": { + source: "iana" + }, + "application/vnd.bmi": { + source: "iana", + extensions: ["bmi"] + }, + "application/vnd.bpf": { + source: "iana" + }, + "application/vnd.bpf3": { + source: "iana" + }, + "application/vnd.businessobjects": { + source: "iana", + extensions: ["rep"] + }, + "application/vnd.byu.uapi+json": { + source: "iana", + compressible: true + }, + "application/vnd.bzip3": { + source: "iana" + }, + "application/vnd.c3voc.schedule+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cab-jscript": { + source: "iana" + }, + "application/vnd.canon-cpdl": { + source: "iana" + }, + "application/vnd.canon-lips": { + source: "iana" + }, + "application/vnd.capasystems-pg+json": { + source: "iana", + compressible: true + }, + "application/vnd.cendio.thinlinc.clientconf": { + source: "iana" + }, + "application/vnd.century-systems.tcp_stream": { + source: "iana" + }, + "application/vnd.chemdraw+xml": { + source: "iana", + compressible: true, + extensions: ["cdxml"] + }, + "application/vnd.chess-pgn": { + source: "iana" + }, + "application/vnd.chipnuts.karaoke-mmd": { + source: "iana", + extensions: ["mmd"] + }, + "application/vnd.ciedi": { + source: "iana" + }, + "application/vnd.cinderella": { + source: "iana", + extensions: ["cdy"] + }, + "application/vnd.cirpack.isdn-ext": { + source: "iana" + }, + "application/vnd.citationstyles.style+xml": { + source: "iana", + compressible: true, + extensions: ["csl"] + }, + "application/vnd.claymore": { + source: "iana", + extensions: ["cla"] + }, + "application/vnd.cloanto.rp9": { + source: "iana", + extensions: ["rp9"] + }, + "application/vnd.clonk.c4group": { + source: "iana", + extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"] + }, + "application/vnd.cluetrust.cartomobile-config": { + source: "iana", + extensions: ["c11amc"] + }, + "application/vnd.cluetrust.cartomobile-config-pkg": { + source: "iana", + extensions: ["c11amz"] + }, + "application/vnd.cncf.helm.chart.content.v1.tar+gzip": { + source: "iana" + }, + "application/vnd.cncf.helm.chart.provenance.v1.prov": { + source: "iana" + }, + "application/vnd.cncf.helm.config.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.coffeescript": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet-template": { + source: "iana" + }, + "application/vnd.collection+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.doc+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.next+json": { + source: "iana", + compressible: true + }, + "application/vnd.comicbook+zip": { + source: "iana", + compressible: false + }, + "application/vnd.comicbook-rar": { + source: "iana" + }, + "application/vnd.commerce-battelle": { + source: "iana" + }, + "application/vnd.commonspace": { + source: "iana", + extensions: ["csp"] + }, + "application/vnd.contact.cmsg": { + source: "iana", + extensions: ["cdbcmsg"] + }, + "application/vnd.coreos.ignition+json": { + source: "iana", + compressible: true + }, + "application/vnd.cosmocaller": { + source: "iana", + extensions: ["cmc"] + }, + "application/vnd.crick.clicker": { + source: "iana", + extensions: ["clkx"] + }, + "application/vnd.crick.clicker.keyboard": { + source: "iana", + extensions: ["clkk"] + }, + "application/vnd.crick.clicker.palette": { + source: "iana", + extensions: ["clkp"] + }, + "application/vnd.crick.clicker.template": { + source: "iana", + extensions: ["clkt"] + }, + "application/vnd.crick.clicker.wordbank": { + source: "iana", + extensions: ["clkw"] + }, + "application/vnd.criticaltools.wbs+xml": { + source: "iana", + compressible: true, + extensions: ["wbs"] + }, + "application/vnd.cryptii.pipe+json": { + source: "iana", + compressible: true + }, + "application/vnd.crypto-shade-file": { + source: "iana" + }, + "application/vnd.cryptomator.encrypted": { + source: "iana" + }, + "application/vnd.cryptomator.vault": { + source: "iana" + }, + "application/vnd.ctc-posml": { + source: "iana", + extensions: ["pml"] + }, + "application/vnd.ctct.ws+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cups-pdf": { + source: "iana" + }, + "application/vnd.cups-postscript": { + source: "iana" + }, + "application/vnd.cups-ppd": { + source: "iana", + extensions: ["ppd"] + }, + "application/vnd.cups-raster": { + source: "iana" + }, + "application/vnd.cups-raw": { + source: "iana" + }, + "application/vnd.curl": { + source: "iana" + }, + "application/vnd.curl.car": { + source: "apache", + extensions: ["car"] + }, + "application/vnd.curl.pcurl": { + source: "apache", + extensions: ["pcurl"] + }, + "application/vnd.cyan.dean.root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cybank": { + source: "iana" + }, + "application/vnd.cyclonedx+json": { + source: "iana", + compressible: true + }, + "application/vnd.cyclonedx+xml": { + source: "iana", + compressible: true + }, + "application/vnd.d2l.coursepackage1p0+zip": { + source: "iana", + compressible: false + }, + "application/vnd.d3m-dataset": { + source: "iana" + }, + "application/vnd.d3m-problem": { + source: "iana" + }, + "application/vnd.dart": { + source: "iana", + compressible: true, + extensions: ["dart"] + }, + "application/vnd.data-vision.rdz": { + source: "iana", + extensions: ["rdz"] + }, + "application/vnd.datalog": { + source: "iana" + }, + "application/vnd.datapackage+json": { + source: "iana", + compressible: true + }, + "application/vnd.dataresource+json": { + source: "iana", + compressible: true + }, + "application/vnd.dbf": { + source: "iana", + extensions: ["dbf"] + }, + "application/vnd.dcmp+xml": { + source: "iana", + compressible: true, + extensions: ["dcmp"] + }, + "application/vnd.debian.binary-package": { + source: "iana" + }, + "application/vnd.dece.data": { + source: "iana", + extensions: ["uvf", "uvvf", "uvd", "uvvd"] + }, + "application/vnd.dece.ttml+xml": { + source: "iana", + compressible: true, + extensions: ["uvt", "uvvt"] + }, + "application/vnd.dece.unspecified": { + source: "iana", + extensions: ["uvx", "uvvx"] + }, + "application/vnd.dece.zip": { + source: "iana", + extensions: ["uvz", "uvvz"] + }, + "application/vnd.denovo.fcselayout-link": { + source: "iana", + extensions: ["fe_launch"] + }, + "application/vnd.desmume.movie": { + source: "iana" + }, + "application/vnd.dir-bi.plate-dl-nosuffix": { + source: "iana" + }, + "application/vnd.dm.delegation+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dna": { + source: "iana", + extensions: ["dna"] + }, + "application/vnd.document+json": { + source: "iana", + compressible: true + }, + "application/vnd.dolby.mlp": { + source: "apache", + extensions: ["mlp"] + }, + "application/vnd.dolby.mobile.1": { + source: "iana" + }, + "application/vnd.dolby.mobile.2": { + source: "iana" + }, + "application/vnd.doremir.scorecloud-binary-document": { + source: "iana" + }, + "application/vnd.dpgraph": { + source: "iana", + extensions: ["dpg"] + }, + "application/vnd.dreamfactory": { + source: "iana", + extensions: ["dfac"] + }, + "application/vnd.drive+json": { + source: "iana", + compressible: true + }, + "application/vnd.ds-keypoint": { + source: "apache", + extensions: ["kpxx"] + }, + "application/vnd.dtg.local": { + source: "iana" + }, + "application/vnd.dtg.local.flash": { + source: "iana" + }, + "application/vnd.dtg.local.html": { + source: "iana" + }, + "application/vnd.dvb.ait": { + source: "iana", + extensions: ["ait"] + }, + "application/vnd.dvb.dvbisl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.dvbj": { + source: "iana" + }, + "application/vnd.dvb.esgcontainer": { + source: "iana" + }, + "application/vnd.dvb.ipdcdftnotifaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess2": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgpdd": { + source: "iana" + }, + "application/vnd.dvb.ipdcroaming": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-base": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-enhancement": { + source: "iana" + }, + "application/vnd.dvb.notif-aggregate-root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-container+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-generic+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-msglist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-response+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-init+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.pfr": { + source: "iana" + }, + "application/vnd.dvb.service": { + source: "iana", + extensions: ["svc"] + }, + "application/vnd.dxr": { + source: "iana" + }, + "application/vnd.dynageo": { + source: "iana", + extensions: ["geo"] + }, + "application/vnd.dzr": { + source: "iana" + }, + "application/vnd.easykaraoke.cdgdownload": { + source: "iana" + }, + "application/vnd.ecdis-update": { + source: "iana" + }, + "application/vnd.ecip.rlp": { + source: "iana" + }, + "application/vnd.eclipse.ditto+json": { + source: "iana", + compressible: true + }, + "application/vnd.ecowin.chart": { + source: "iana", + extensions: ["mag"] + }, + "application/vnd.ecowin.filerequest": { + source: "iana" + }, + "application/vnd.ecowin.fileupdate": { + source: "iana" + }, + "application/vnd.ecowin.series": { + source: "iana" + }, + "application/vnd.ecowin.seriesrequest": { + source: "iana" + }, + "application/vnd.ecowin.seriesupdate": { + source: "iana" + }, + "application/vnd.efi.img": { + source: "iana" + }, + "application/vnd.efi.iso": { + source: "iana" + }, + "application/vnd.eln+zip": { + source: "iana", + compressible: false + }, + "application/vnd.emclient.accessrequest+xml": { + source: "iana", + compressible: true + }, + "application/vnd.enliven": { + source: "iana", + extensions: ["nml"] + }, + "application/vnd.enphase.envoy": { + source: "iana" + }, + "application/vnd.eprints.data+xml": { + source: "iana", + compressible: true + }, + "application/vnd.epson.esf": { + source: "iana", + extensions: ["esf"] + }, + "application/vnd.epson.msf": { + source: "iana", + extensions: ["msf"] + }, + "application/vnd.epson.quickanime": { + source: "iana", + extensions: ["qam"] + }, + "application/vnd.epson.salt": { + source: "iana", + extensions: ["slt"] + }, + "application/vnd.epson.ssf": { + source: "iana", + extensions: ["ssf"] + }, + "application/vnd.ericsson.quickcall": { + source: "iana" + }, + "application/vnd.erofs": { + source: "iana" + }, + "application/vnd.espass-espass+zip": { + source: "iana", + compressible: false + }, + "application/vnd.eszigno3+xml": { + source: "iana", + compressible: true, + extensions: ["es3", "et3"] + }, + "application/vnd.etsi.aoc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.asic-e+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.asic-s+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.cug+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvcommand+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-bc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-cod+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-npvr+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvservice+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsync+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mcid+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mheg5": { + source: "iana" + }, + "application/vnd.etsi.overload-control-policy-dataset+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.pstn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.sci+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.simservs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.timestamp-token": { + source: "iana" + }, + "application/vnd.etsi.tsl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.tsl.der": { + source: "iana" + }, + "application/vnd.eu.kasparian.car+json": { + source: "iana", + compressible: true + }, + "application/vnd.eudora.data": { + source: "iana" + }, + "application/vnd.evolv.ecig.profile": { + source: "iana" + }, + "application/vnd.evolv.ecig.settings": { + source: "iana" + }, + "application/vnd.evolv.ecig.theme": { + source: "iana" + }, + "application/vnd.exstream-empower+zip": { + source: "iana", + compressible: false + }, + "application/vnd.exstream-package": { + source: "iana" + }, + "application/vnd.ezpix-album": { + source: "iana", + extensions: ["ez2"] + }, + "application/vnd.ezpix-package": { + source: "iana", + extensions: ["ez3"] + }, + "application/vnd.f-secure.mobile": { + source: "iana" + }, + "application/vnd.familysearch.gedcom+zip": { + source: "iana", + compressible: false + }, + "application/vnd.fastcopy-disk-image": { + source: "iana" + }, + "application/vnd.fdf": { + source: "apache", + extensions: ["fdf"] + }, + "application/vnd.fdsn.mseed": { + source: "iana", + extensions: ["mseed"] + }, + "application/vnd.fdsn.seed": { + source: "iana", + extensions: ["seed", "dataless"] + }, + "application/vnd.fdsn.stationxml+xml": { + source: "iana", + charset: "XML-BASED", + compressible: true + }, + "application/vnd.ffsns": { + source: "iana" + }, + "application/vnd.ficlab.flb+zip": { + source: "iana", + compressible: false + }, + "application/vnd.filmit.zfc": { + source: "iana" + }, + "application/vnd.fints": { + source: "iana" + }, + "application/vnd.firemonkeys.cloudcell": { + source: "iana" + }, + "application/vnd.flographit": { + source: "iana", + extensions: ["gph"] + }, + "application/vnd.fluxtime.clip": { + source: "iana", + extensions: ["ftc"] + }, + "application/vnd.font-fontforge-sfd": { + source: "iana" + }, + "application/vnd.framemaker": { + source: "iana", + extensions: ["fm", "frame", "maker", "book"] + }, + "application/vnd.freelog.comic": { + source: "iana" + }, + "application/vnd.frogans.fnc": { + source: "apache", + extensions: ["fnc"] + }, + "application/vnd.frogans.ltf": { + source: "apache", + extensions: ["ltf"] + }, + "application/vnd.fsc.weblaunch": { + source: "iana", + extensions: ["fsc"] + }, + "application/vnd.fujifilm.fb.docuworks": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.binder": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.container": { + source: "iana" + }, + "application/vnd.fujifilm.fb.jfi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.fujitsu.oasys": { + source: "iana", + extensions: ["oas"] + }, + "application/vnd.fujitsu.oasys2": { + source: "iana", + extensions: ["oa2"] + }, + "application/vnd.fujitsu.oasys3": { + source: "iana", + extensions: ["oa3"] + }, + "application/vnd.fujitsu.oasysgp": { + source: "iana", + extensions: ["fg5"] + }, + "application/vnd.fujitsu.oasysprs": { + source: "iana", + extensions: ["bh2"] + }, + "application/vnd.fujixerox.art-ex": { + source: "iana" + }, + "application/vnd.fujixerox.art4": { + source: "iana" + }, + "application/vnd.fujixerox.ddd": { + source: "iana", + extensions: ["ddd"] + }, + "application/vnd.fujixerox.docuworks": { + source: "iana", + extensions: ["xdw"] + }, + "application/vnd.fujixerox.docuworks.binder": { + source: "iana", + extensions: ["xbd"] + }, + "application/vnd.fujixerox.docuworks.container": { + source: "iana" + }, + "application/vnd.fujixerox.hbpl": { + source: "iana" + }, + "application/vnd.fut-misnet": { + source: "iana" + }, + "application/vnd.futoin+cbor": { + source: "iana" + }, + "application/vnd.futoin+json": { + source: "iana", + compressible: true + }, + "application/vnd.fuzzysheet": { + source: "iana", + extensions: ["fzs"] + }, + "application/vnd.ga4gh.passport+jwt": { + source: "iana" + }, + "application/vnd.genomatix.tuxedo": { + source: "iana", + extensions: ["txd"] + }, + "application/vnd.genozip": { + source: "iana" + }, + "application/vnd.gentics.grd+json": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.catmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.ebuild": { + source: "iana" + }, + "application/vnd.gentoo.eclass": { + source: "iana" + }, + "application/vnd.gentoo.gpkg": { + source: "iana" + }, + "application/vnd.gentoo.manifest": { + source: "iana" + }, + "application/vnd.gentoo.pkgmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gentoo.xpak": { + source: "iana" + }, + "application/vnd.geo+json": { + source: "apache", + compressible: true + }, + "application/vnd.geocube+xml": { + source: "apache", + compressible: true + }, + "application/vnd.geogebra.file": { + source: "iana", + extensions: ["ggb"] + }, + "application/vnd.geogebra.pinboard": { + source: "iana" + }, + "application/vnd.geogebra.slides": { + source: "iana", + extensions: ["ggs"] + }, + "application/vnd.geogebra.tool": { + source: "iana", + extensions: ["ggt"] + }, + "application/vnd.geometry-explorer": { + source: "iana", + extensions: ["gex", "gre"] + }, + "application/vnd.geonext": { + source: "iana", + extensions: ["gxt"] + }, + "application/vnd.geoplan": { + source: "iana", + extensions: ["g2w"] + }, + "application/vnd.geospace": { + source: "iana", + extensions: ["g3w"] + }, + "application/vnd.gerber": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt-response": { + source: "iana" + }, + "application/vnd.gmx": { + source: "iana", + extensions: ["gmx"] + }, + "application/vnd.gnu.taler.exchange+json": { + source: "iana", + compressible: true + }, + "application/vnd.gnu.taler.merchant+json": { + source: "iana", + compressible: true + }, + "application/vnd.google-apps.audio": {}, + "application/vnd.google-apps.document": { + compressible: false, + extensions: ["gdoc"] + }, + "application/vnd.google-apps.drawing": { + compressible: false, + extensions: ["gdraw"] + }, + "application/vnd.google-apps.drive-sdk": { + compressible: false + }, + "application/vnd.google-apps.file": {}, + "application/vnd.google-apps.folder": { + compressible: false + }, + "application/vnd.google-apps.form": { + compressible: false, + extensions: ["gform"] + }, + "application/vnd.google-apps.fusiontable": {}, + "application/vnd.google-apps.jam": { + compressible: false, + extensions: ["gjam"] + }, + "application/vnd.google-apps.mail-layout": {}, + "application/vnd.google-apps.map": { + compressible: false, + extensions: ["gmap"] + }, + "application/vnd.google-apps.photo": {}, + "application/vnd.google-apps.presentation": { + compressible: false, + extensions: ["gslides"] + }, + "application/vnd.google-apps.script": { + compressible: false, + extensions: ["gscript"] + }, + "application/vnd.google-apps.shortcut": {}, + "application/vnd.google-apps.site": { + compressible: false, + extensions: ["gsite"] + }, + "application/vnd.google-apps.spreadsheet": { + compressible: false, + extensions: ["gsheet"] + }, + "application/vnd.google-apps.unknown": {}, + "application/vnd.google-apps.video": {}, + "application/vnd.google-earth.kml+xml": { + source: "iana", + compressible: true, + extensions: ["kml"] + }, + "application/vnd.google-earth.kmz": { + source: "iana", + compressible: false, + extensions: ["kmz"] + }, + "application/vnd.gov.sk.e-form+xml": { + source: "apache", + compressible: true + }, + "application/vnd.gov.sk.e-form+zip": { + source: "iana", + compressible: false + }, + "application/vnd.gov.sk.xmldatacontainer+xml": { + source: "iana", + compressible: true, + extensions: ["xdcf"] + }, + "application/vnd.gpxsee.map+xml": { + source: "iana", + compressible: true + }, + "application/vnd.grafeq": { + source: "iana", + extensions: ["gqf", "gqs"] + }, + "application/vnd.gridmp": { + source: "iana" + }, + "application/vnd.groove-account": { + source: "iana", + extensions: ["gac"] + }, + "application/vnd.groove-help": { + source: "iana", + extensions: ["ghf"] + }, + "application/vnd.groove-identity-message": { + source: "iana", + extensions: ["gim"] + }, + "application/vnd.groove-injector": { + source: "iana", + extensions: ["grv"] + }, + "application/vnd.groove-tool-message": { + source: "iana", + extensions: ["gtm"] + }, + "application/vnd.groove-tool-template": { + source: "iana", + extensions: ["tpl"] + }, + "application/vnd.groove-vcard": { + source: "iana", + extensions: ["vcg"] + }, + "application/vnd.hal+json": { + source: "iana", + compressible: true + }, + "application/vnd.hal+xml": { + source: "iana", + compressible: true, + extensions: ["hal"] + }, + "application/vnd.handheld-entertainment+xml": { + source: "iana", + compressible: true, + extensions: ["zmm"] + }, + "application/vnd.hbci": { + source: "iana", + extensions: ["hbci"] + }, + "application/vnd.hc+json": { + source: "iana", + compressible: true + }, + "application/vnd.hcl-bireports": { + source: "iana" + }, + "application/vnd.hdt": { + source: "iana" + }, + "application/vnd.heroku+json": { + source: "iana", + compressible: true + }, + "application/vnd.hhe.lesson-player": { + source: "iana", + extensions: ["les"] + }, + "application/vnd.hp-hpgl": { + source: "iana", + extensions: ["hpgl"] + }, + "application/vnd.hp-hpid": { + source: "iana", + extensions: ["hpid"] + }, + "application/vnd.hp-hps": { + source: "iana", + extensions: ["hps"] + }, + "application/vnd.hp-jlyt": { + source: "iana", + extensions: ["jlt"] + }, + "application/vnd.hp-pcl": { + source: "iana", + extensions: ["pcl"] + }, + "application/vnd.hp-pclxl": { + source: "iana", + extensions: ["pclxl"] + }, + "application/vnd.hsl": { + source: "iana" + }, + "application/vnd.httphone": { + source: "iana" + }, + "application/vnd.hydrostatix.sof-data": { + source: "iana", + extensions: ["sfd-hdstx"] + }, + "application/vnd.hyper+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyper-item+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyperdrive+json": { + source: "iana", + compressible: true + }, + "application/vnd.hzn-3d-crossword": { + source: "iana" + }, + "application/vnd.ibm.afplinedata": { + source: "apache" + }, + "application/vnd.ibm.electronic-media": { + source: "iana" + }, + "application/vnd.ibm.minipay": { + source: "iana", + extensions: ["mpy"] + }, + "application/vnd.ibm.modcap": { + source: "apache", + extensions: ["afp", "listafp", "list3820"] + }, + "application/vnd.ibm.rights-management": { + source: "iana", + extensions: ["irm"] + }, + "application/vnd.ibm.secure-container": { + source: "iana", + extensions: ["sc"] + }, + "application/vnd.iccprofile": { + source: "iana", + extensions: ["icc", "icm"] + }, + "application/vnd.ieee.1905": { + source: "iana" + }, + "application/vnd.igloader": { + source: "iana", + extensions: ["igl"] + }, + "application/vnd.imagemeter.folder+zip": { + source: "iana", + compressible: false + }, + "application/vnd.imagemeter.image+zip": { + source: "iana", + compressible: false + }, + "application/vnd.immervision-ivp": { + source: "iana", + extensions: ["ivp"] + }, + "application/vnd.immervision-ivu": { + source: "iana", + extensions: ["ivu"] + }, + "application/vnd.ims.imsccv1p1": { + source: "iana" + }, + "application/vnd.ims.imsccv1p2": { + source: "iana" + }, + "application/vnd.ims.imsccv1p3": { + source: "iana" + }, + "application/vnd.ims.lis.v2.result+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolconsumerprofile+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy.id+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings.simple+json": { + source: "iana", + compressible: true + }, + "application/vnd.informedcontrol.rms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.informix-visionary": { + source: "apache" + }, + "application/vnd.infotech.project": { + source: "iana" + }, + "application/vnd.infotech.project+xml": { + source: "iana", + compressible: true + }, + "application/vnd.innopath.wamp.notification": { + source: "iana" + }, + "application/vnd.insors.igm": { + source: "iana", + extensions: ["igm"] + }, + "application/vnd.intercon.formnet": { + source: "iana", + extensions: ["xpw", "xpx"] + }, + "application/vnd.intergeo": { + source: "iana", + extensions: ["i2g"] + }, + "application/vnd.intertrust.digibox": { + source: "iana" + }, + "application/vnd.intertrust.nncp": { + source: "iana" + }, + "application/vnd.intu.qbo": { + source: "iana", + extensions: ["qbo"] + }, + "application/vnd.intu.qfx": { + source: "iana", + extensions: ["qfx"] + }, + "application/vnd.ipfs.ipns-record": { + source: "iana" + }, + "application/vnd.ipld.car": { + source: "iana" + }, + "application/vnd.ipld.dag-cbor": { + source: "iana" + }, + "application/vnd.ipld.dag-json": { + source: "iana" + }, + "application/vnd.ipld.raw": { + source: "iana" + }, + "application/vnd.iptc.g2.catalogitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.conceptitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.knowledgeitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.packageitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.planningitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ipunplugged.rcprofile": { + source: "iana", + extensions: ["rcprofile"] + }, + "application/vnd.irepository.package+xml": { + source: "iana", + compressible: true, + extensions: ["irp"] + }, + "application/vnd.is-xpr": { + source: "iana", + extensions: ["xpr"] + }, + "application/vnd.isac.fcs": { + source: "iana", + extensions: ["fcs"] + }, + "application/vnd.iso11783-10+zip": { + source: "iana", + compressible: false + }, + "application/vnd.jam": { + source: "iana", + extensions: ["jam"] + }, + "application/vnd.japannet-directory-service": { + source: "iana" + }, + "application/vnd.japannet-jpnstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-payment-wakeup": { + source: "iana" + }, + "application/vnd.japannet-registration": { + source: "iana" + }, + "application/vnd.japannet-registration-wakeup": { + source: "iana" + }, + "application/vnd.japannet-setstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-verification": { + source: "iana" + }, + "application/vnd.japannet-verification-wakeup": { + source: "iana" + }, + "application/vnd.jcp.javame.midlet-rms": { + source: "iana", + extensions: ["rms"] + }, + "application/vnd.jisp": { + source: "iana", + extensions: ["jisp"] + }, + "application/vnd.joost.joda-archive": { + source: "iana", + extensions: ["joda"] + }, + "application/vnd.jsk.isdn-ngn": { + source: "iana" + }, + "application/vnd.kahootz": { + source: "iana", + extensions: ["ktz", "ktr"] + }, + "application/vnd.kde.karbon": { + source: "iana", + extensions: ["karbon"] + }, + "application/vnd.kde.kchart": { + source: "iana", + extensions: ["chrt"] + }, + "application/vnd.kde.kformula": { + source: "iana", + extensions: ["kfo"] + }, + "application/vnd.kde.kivio": { + source: "iana", + extensions: ["flw"] + }, + "application/vnd.kde.kontour": { + source: "iana", + extensions: ["kon"] + }, + "application/vnd.kde.kpresenter": { + source: "iana", + extensions: ["kpr", "kpt"] + }, + "application/vnd.kde.kspread": { + source: "iana", + extensions: ["ksp"] + }, + "application/vnd.kde.kword": { + source: "iana", + extensions: ["kwd", "kwt"] + }, + "application/vnd.kdl": { + source: "iana" + }, + "application/vnd.kenameaapp": { + source: "iana", + extensions: ["htke"] + }, + "application/vnd.keyman.kmp+zip": { + source: "iana", + compressible: false + }, + "application/vnd.keyman.kmx": { + source: "iana" + }, + "application/vnd.kidspiration": { + source: "iana", + extensions: ["kia"] + }, + "application/vnd.kinar": { + source: "iana", + extensions: ["kne", "knp"] + }, + "application/vnd.koan": { + source: "iana", + extensions: ["skp", "skd", "skt", "skm"] + }, + "application/vnd.kodak-descriptor": { + source: "iana", + extensions: ["sse"] + }, + "application/vnd.las": { + source: "iana" + }, + "application/vnd.las.las+json": { + source: "iana", + compressible: true + }, + "application/vnd.las.las+xml": { + source: "iana", + compressible: true, + extensions: ["lasxml"] + }, + "application/vnd.laszip": { + source: "iana" + }, + "application/vnd.ldev.productlicensing": { + source: "iana" + }, + "application/vnd.leap+json": { + source: "iana", + compressible: true + }, + "application/vnd.liberty-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.llamagraphics.life-balance.desktop": { + source: "iana", + extensions: ["lbd"] + }, + "application/vnd.llamagraphics.life-balance.exchange+xml": { + source: "iana", + compressible: true, + extensions: ["lbe"] + }, + "application/vnd.logipipe.circuit+zip": { + source: "iana", + compressible: false + }, + "application/vnd.loom": { + source: "iana" + }, + "application/vnd.lotus-1-2-3": { + source: "iana", + extensions: ["123"] + }, + "application/vnd.lotus-approach": { + source: "iana", + extensions: ["apr"] + }, + "application/vnd.lotus-freelance": { + source: "iana", + extensions: ["pre"] + }, + "application/vnd.lotus-notes": { + source: "iana", + extensions: ["nsf"] + }, + "application/vnd.lotus-organizer": { + source: "iana", + extensions: ["org"] + }, + "application/vnd.lotus-screencam": { + source: "iana", + extensions: ["scm"] + }, + "application/vnd.lotus-wordpro": { + source: "iana", + extensions: ["lwp"] + }, + "application/vnd.macports.portpkg": { + source: "iana", + extensions: ["portpkg"] + }, + "application/vnd.mapbox-vector-tile": { + source: "iana", + extensions: ["mvt"] + }, + "application/vnd.marlin.drm.actiontoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.conftoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.license+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.mdcf": { + source: "iana" + }, + "application/vnd.mason+json": { + source: "iana", + compressible: true + }, + "application/vnd.maxar.archive.3tz+zip": { + source: "iana", + compressible: false + }, + "application/vnd.maxmind.maxmind-db": { + source: "iana" + }, + "application/vnd.mcd": { + source: "iana", + extensions: ["mcd"] + }, + "application/vnd.mdl": { + source: "iana" + }, + "application/vnd.mdl-mbsdf": { + source: "iana" + }, + "application/vnd.medcalcdata": { + source: "iana", + extensions: ["mc1"] + }, + "application/vnd.mediastation.cdkey": { + source: "iana", + extensions: ["cdkey"] + }, + "application/vnd.medicalholodeck.recordxr": { + source: "iana" + }, + "application/vnd.meridian-slingshot": { + source: "iana" + }, + "application/vnd.mermaid": { + source: "iana" + }, + "application/vnd.mfer": { + source: "iana", + extensions: ["mwf"] + }, + "application/vnd.mfmp": { + source: "iana", + extensions: ["mfm"] + }, + "application/vnd.micro+json": { + source: "iana", + compressible: true + }, + "application/vnd.micrografx.flo": { + source: "iana", + extensions: ["flo"] + }, + "application/vnd.micrografx.igx": { + source: "iana", + extensions: ["igx"] + }, + "application/vnd.microsoft.portable-executable": { + source: "iana" + }, + "application/vnd.microsoft.windows.thumbnail-cache": { + source: "iana" + }, + "application/vnd.miele+json": { + source: "iana", + compressible: true + }, + "application/vnd.mif": { + source: "iana", + extensions: ["mif"] + }, + "application/vnd.minisoft-hp3000-save": { + source: "iana" + }, + "application/vnd.mitsubishi.misty-guard.trustweb": { + source: "iana" + }, + "application/vnd.mobius.daf": { + source: "iana", + extensions: ["daf"] + }, + "application/vnd.mobius.dis": { + source: "iana", + extensions: ["dis"] + }, + "application/vnd.mobius.mbk": { + source: "iana", + extensions: ["mbk"] + }, + "application/vnd.mobius.mqy": { + source: "iana", + extensions: ["mqy"] + }, + "application/vnd.mobius.msl": { + source: "iana", + extensions: ["msl"] + }, + "application/vnd.mobius.plc": { + source: "iana", + extensions: ["plc"] + }, + "application/vnd.mobius.txf": { + source: "iana", + extensions: ["txf"] + }, + "application/vnd.modl": { + source: "iana" + }, + "application/vnd.mophun.application": { + source: "iana", + extensions: ["mpn"] + }, + "application/vnd.mophun.certificate": { + source: "iana", + extensions: ["mpc"] + }, + "application/vnd.motorola.flexsuite": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.adsi": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.fis": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.gotap": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.kmr": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.ttc": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.wem": { + source: "iana" + }, + "application/vnd.motorola.iprm": { + source: "iana" + }, + "application/vnd.mozilla.xul+xml": { + source: "iana", + compressible: true, + extensions: ["xul"] + }, + "application/vnd.ms-3mfdocument": { + source: "iana" + }, + "application/vnd.ms-artgalry": { + source: "iana", + extensions: ["cil"] + }, + "application/vnd.ms-asf": { + source: "iana" + }, + "application/vnd.ms-cab-compressed": { + source: "iana", + extensions: ["cab"] + }, + "application/vnd.ms-color.iccprofile": { + source: "apache" + }, + "application/vnd.ms-excel": { + source: "iana", + compressible: false, + extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] + }, + "application/vnd.ms-excel.addin.macroenabled.12": { + source: "iana", + extensions: ["xlam"] + }, + "application/vnd.ms-excel.sheet.binary.macroenabled.12": { + source: "iana", + extensions: ["xlsb"] + }, + "application/vnd.ms-excel.sheet.macroenabled.12": { + source: "iana", + extensions: ["xlsm"] + }, + "application/vnd.ms-excel.template.macroenabled.12": { + source: "iana", + extensions: ["xltm"] + }, + "application/vnd.ms-fontobject": { + source: "iana", + compressible: true, + extensions: ["eot"] + }, + "application/vnd.ms-htmlhelp": { + source: "iana", + extensions: ["chm"] + }, + "application/vnd.ms-ims": { + source: "iana", + extensions: ["ims"] + }, + "application/vnd.ms-lrm": { + source: "iana", + extensions: ["lrm"] + }, + "application/vnd.ms-office.activex+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-officetheme": { + source: "iana", + extensions: ["thmx"] + }, + "application/vnd.ms-opentype": { + source: "apache", + compressible: true + }, + "application/vnd.ms-outlook": { + compressible: false, + extensions: ["msg"] + }, + "application/vnd.ms-package.obfuscated-opentype": { + source: "apache" + }, + "application/vnd.ms-pki.seccat": { + source: "apache", + extensions: ["cat"] + }, + "application/vnd.ms-pki.stl": { + source: "apache", + extensions: ["stl"] + }, + "application/vnd.ms-playready.initiator+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-powerpoint": { + source: "iana", + compressible: false, + extensions: ["ppt", "pps", "pot"] + }, + "application/vnd.ms-powerpoint.addin.macroenabled.12": { + source: "iana", + extensions: ["ppam"] + }, + "application/vnd.ms-powerpoint.presentation.macroenabled.12": { + source: "iana", + extensions: ["pptm"] + }, + "application/vnd.ms-powerpoint.slide.macroenabled.12": { + source: "iana", + extensions: ["sldm"] + }, + "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { + source: "iana", + extensions: ["ppsm"] + }, + "application/vnd.ms-powerpoint.template.macroenabled.12": { + source: "iana", + extensions: ["potm"] + }, + "application/vnd.ms-printdevicecapabilities+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-printing.printticket+xml": { + source: "apache", + compressible: true + }, + "application/vnd.ms-printschematicket+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-project": { + source: "iana", + extensions: ["mpp", "mpt"] + }, + "application/vnd.ms-tnef": { + source: "iana" + }, + "application/vnd.ms-visio.viewer": { + extensions: ["vdx"] + }, + "application/vnd.ms-windows.devicepairing": { + source: "iana" + }, + "application/vnd.ms-windows.nwprinting.oob": { + source: "iana" + }, + "application/vnd.ms-windows.printerpairing": { + source: "iana" + }, + "application/vnd.ms-windows.wsd.oob": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-resp": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-resp": { + source: "iana" + }, + "application/vnd.ms-word.document.macroenabled.12": { + source: "iana", + extensions: ["docm"] + }, + "application/vnd.ms-word.template.macroenabled.12": { + source: "iana", + extensions: ["dotm"] + }, + "application/vnd.ms-works": { + source: "iana", + extensions: ["wps", "wks", "wcm", "wdb"] + }, + "application/vnd.ms-wpl": { + source: "iana", + extensions: ["wpl"] + }, + "application/vnd.ms-xpsdocument": { + source: "iana", + compressible: false, + extensions: ["xps"] + }, + "application/vnd.msa-disk-image": { + source: "iana" + }, + "application/vnd.mseq": { + source: "iana", + extensions: ["mseq"] + }, + "application/vnd.msgpack": { + source: "iana" + }, + "application/vnd.msign": { + source: "iana" + }, + "application/vnd.multiad.creator": { + source: "iana" + }, + "application/vnd.multiad.creator.cif": { + source: "iana" + }, + "application/vnd.music-niff": { + source: "iana" + }, + "application/vnd.musician": { + source: "iana", + extensions: ["mus"] + }, + "application/vnd.muvee.style": { + source: "iana", + extensions: ["msty"] + }, + "application/vnd.mynfc": { + source: "iana", + extensions: ["taglet"] + }, + "application/vnd.nacamar.ybrid+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+cbor": { + source: "iana" + }, + "application/vnd.nato.bindingdataobject+json": { + source: "iana", + compressible: true + }, + "application/vnd.nato.bindingdataobject+xml": { + source: "iana", + compressible: true, + extensions: ["bdo"] + }, + "application/vnd.nato.openxmlformats-package.iepd+zip": { + source: "iana", + compressible: false + }, + "application/vnd.ncd.control": { + source: "iana" + }, + "application/vnd.ncd.reference": { + source: "iana" + }, + "application/vnd.nearst.inv+json": { + source: "iana", + compressible: true + }, + "application/vnd.nebumind.line": { + source: "iana" + }, + "application/vnd.nervana": { + source: "iana" + }, + "application/vnd.netfpx": { + source: "iana" + }, + "application/vnd.neurolanguage.nlu": { + source: "iana", + extensions: ["nlu"] + }, + "application/vnd.nimn": { + source: "iana" + }, + "application/vnd.nintendo.nitro.rom": { + source: "iana" + }, + "application/vnd.nintendo.snes.rom": { + source: "iana" + }, + "application/vnd.nitf": { + source: "iana", + extensions: ["ntf", "nitf"] + }, + "application/vnd.noblenet-directory": { + source: "iana", + extensions: ["nnd"] + }, + "application/vnd.noblenet-sealer": { + source: "iana", + extensions: ["nns"] + }, + "application/vnd.noblenet-web": { + source: "iana", + extensions: ["nnw"] + }, + "application/vnd.nokia.catalogs": { + source: "iana" + }, + "application/vnd.nokia.conml+wbxml": { + source: "iana" + }, + "application/vnd.nokia.conml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.iptv.config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.isds-radio-presets": { + source: "iana" + }, + "application/vnd.nokia.landmark+wbxml": { + source: "iana" + }, + "application/vnd.nokia.landmark+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.landmarkcollection+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.n-gage.ac+xml": { + source: "iana", + compressible: true, + extensions: ["ac"] + }, + "application/vnd.nokia.n-gage.data": { + source: "iana", + extensions: ["ngdat"] + }, + "application/vnd.nokia.n-gage.symbian.install": { + source: "apache", + extensions: ["n-gage"] + }, + "application/vnd.nokia.ncd": { + source: "iana" + }, + "application/vnd.nokia.pcd+wbxml": { + source: "iana" + }, + "application/vnd.nokia.pcd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.radio-preset": { + source: "iana", + extensions: ["rpst"] + }, + "application/vnd.nokia.radio-presets": { + source: "iana", + extensions: ["rpss"] + }, + "application/vnd.novadigm.edm": { + source: "iana", + extensions: ["edm"] + }, + "application/vnd.novadigm.edx": { + source: "iana", + extensions: ["edx"] + }, + "application/vnd.novadigm.ext": { + source: "iana", + extensions: ["ext"] + }, + "application/vnd.ntt-local.content-share": { + source: "iana" + }, + "application/vnd.ntt-local.file-transfer": { + source: "iana" + }, + "application/vnd.ntt-local.ogw_remote-access": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_remote": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_tcp_stream": { + source: "iana" + }, + "application/vnd.oai.workflows": { + source: "iana" + }, + "application/vnd.oai.workflows+json": { + source: "iana", + compressible: true + }, + "application/vnd.oai.workflows+yaml": { + source: "iana" + }, + "application/vnd.oasis.opendocument.base": { + source: "iana" + }, + "application/vnd.oasis.opendocument.chart": { + source: "iana", + extensions: ["odc"] + }, + "application/vnd.oasis.opendocument.chart-template": { + source: "iana", + extensions: ["otc"] + }, + "application/vnd.oasis.opendocument.database": { + source: "apache", + extensions: ["odb"] + }, + "application/vnd.oasis.opendocument.formula": { + source: "iana", + extensions: ["odf"] + }, + "application/vnd.oasis.opendocument.formula-template": { + source: "iana", + extensions: ["odft"] + }, + "application/vnd.oasis.opendocument.graphics": { + source: "iana", + compressible: false, + extensions: ["odg"] + }, + "application/vnd.oasis.opendocument.graphics-template": { + source: "iana", + extensions: ["otg"] + }, + "application/vnd.oasis.opendocument.image": { + source: "iana", + extensions: ["odi"] + }, + "application/vnd.oasis.opendocument.image-template": { + source: "iana", + extensions: ["oti"] + }, + "application/vnd.oasis.opendocument.presentation": { + source: "iana", + compressible: false, + extensions: ["odp"] + }, + "application/vnd.oasis.opendocument.presentation-template": { + source: "iana", + extensions: ["otp"] + }, + "application/vnd.oasis.opendocument.spreadsheet": { + source: "iana", + compressible: false, + extensions: ["ods"] + }, + "application/vnd.oasis.opendocument.spreadsheet-template": { + source: "iana", + extensions: ["ots"] + }, + "application/vnd.oasis.opendocument.text": { + source: "iana", + compressible: false, + extensions: ["odt"] + }, + "application/vnd.oasis.opendocument.text-master": { + source: "iana", + extensions: ["odm"] + }, + "application/vnd.oasis.opendocument.text-master-template": { + source: "iana" + }, + "application/vnd.oasis.opendocument.text-template": { + source: "iana", + extensions: ["ott"] + }, + "application/vnd.oasis.opendocument.text-web": { + source: "iana", + extensions: ["oth"] + }, + "application/vnd.obn": { + source: "iana" + }, + "application/vnd.ocf+cbor": { + source: "iana" + }, + "application/vnd.oci.image.manifest.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.oftn.l10n+json": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessdownload+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessstreaming+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.cspg-hexbinary": { + source: "iana" + }, + "application/vnd.oipf.dae.svg+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.dae.xhtml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.mippvcontrolmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.pae.gem": { + source: "iana" + }, + "application/vnd.oipf.spdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.spdlist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.ueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.userprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.olpc-sugar": { + source: "iana", + extensions: ["xo"] + }, + "application/vnd.oma-scws-config": { + source: "iana" + }, + "application/vnd.oma-scws-http-request": { + source: "iana" + }, + "application/vnd.oma-scws-http-response": { + source: "iana" + }, + "application/vnd.oma.bcast.associated-procedure-parameter+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.drm-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.imd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.ltkm": { + source: "iana" + }, + "application/vnd.oma.bcast.notification+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.provisioningtrigger": { + source: "iana" + }, + "application/vnd.oma.bcast.sgboot": { + source: "iana" + }, + "application/vnd.oma.bcast.sgdd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sgdu": { + source: "iana" + }, + "application/vnd.oma.bcast.simple-symbol-container": { + source: "iana" + }, + "application/vnd.oma.bcast.smartcard-trigger+xml": { + source: "apache", + compressible: true + }, + "application/vnd.oma.bcast.sprov+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.stkm": { + source: "iana" + }, + "application/vnd.oma.cab-address-book+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-feature-handler+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-pcc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-subs-invite+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-user-prefs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.dcd": { + source: "iana" + }, + "application/vnd.oma.dcdc": { + source: "iana" + }, + "application/vnd.oma.dd2+xml": { + source: "iana", + compressible: true, + extensions: ["dd2"] + }, + "application/vnd.oma.drm.risd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.group-usage-list+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+cbor": { + source: "iana" + }, + "application/vnd.oma.lwm2m+json": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+tlv": { + source: "iana" + }, + "application/vnd.oma.pal+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.detailed-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.final-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.groups+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.invocation-descriptor+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.optimized-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.push": { + source: "iana" + }, + "application/vnd.oma.scidm.messages+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.xcap-directory+xml": { + source: "iana", + compressible: true + }, + "application/vnd.omads-email+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-file+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-folder+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omaloc-supl-init": { + source: "iana" + }, + "application/vnd.onepager": { + source: "iana" + }, + "application/vnd.onepagertamp": { + source: "iana" + }, + "application/vnd.onepagertamx": { + source: "iana" + }, + "application/vnd.onepagertat": { + source: "iana" + }, + "application/vnd.onepagertatp": { + source: "iana" + }, + "application/vnd.onepagertatx": { + source: "iana" + }, + "application/vnd.onvif.metadata": { + source: "iana" + }, + "application/vnd.openblox.game+xml": { + source: "iana", + compressible: true, + extensions: ["obgx"] + }, + "application/vnd.openblox.game-binary": { + source: "iana" + }, + "application/vnd.openeye.oeb": { + source: "iana" + }, + "application/vnd.openofficeorg.extension": { + source: "apache", + extensions: ["oxt"] + }, + "application/vnd.openstreetmap.data+xml": { + source: "iana", + compressible: true, + extensions: ["osm"] + }, + "application/vnd.opentimestamps.ots": { + source: "iana" + }, + "application/vnd.openvpi.dspx+json": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.custom-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawing+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.extended-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation": { + source: "iana", + compressible: false, + extensions: ["pptx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide": { + source: "iana", + extensions: ["sldx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { + source: "iana", + extensions: ["ppsx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.template": { + source: "iana", + extensions: ["potx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { + source: "iana", + compressible: false, + extensions: ["xlsx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { + source: "iana", + extensions: ["xltx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.theme+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.themeoverride+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.vmldrawing": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { + source: "iana", + compressible: false, + extensions: ["docx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { + source: "iana", + extensions: ["dotx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.core-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.relationships+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oracle.resource+json": { + source: "iana", + compressible: true + }, + "application/vnd.orange.indata": { + source: "iana" + }, + "application/vnd.osa.netdeploy": { + source: "iana" + }, + "application/vnd.osgeo.mapguide.package": { + source: "iana", + extensions: ["mgp"] + }, + "application/vnd.osgi.bundle": { + source: "iana" + }, + "application/vnd.osgi.dp": { + source: "iana", + extensions: ["dp"] + }, + "application/vnd.osgi.subsystem": { + source: "iana", + extensions: ["esa"] + }, + "application/vnd.otps.ct-kip+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oxli.countgraph": { + source: "iana" + }, + "application/vnd.pagerduty+json": { + source: "iana", + compressible: true + }, + "application/vnd.palm": { + source: "iana", + extensions: ["pdb", "pqa", "oprc"] + }, + "application/vnd.panoply": { + source: "iana" + }, + "application/vnd.paos.xml": { + source: "iana" + }, + "application/vnd.patentdive": { + source: "iana" + }, + "application/vnd.patientecommsdoc": { + source: "iana" + }, + "application/vnd.pawaafile": { + source: "iana", + extensions: ["paw"] + }, + "application/vnd.pcos": { + source: "iana" + }, + "application/vnd.pg.format": { + source: "iana", + extensions: ["str"] + }, + "application/vnd.pg.osasli": { + source: "iana", + extensions: ["ei6"] + }, + "application/vnd.piaccess.application-licence": { + source: "iana" + }, + "application/vnd.picsel": { + source: "iana", + extensions: ["efif"] + }, + "application/vnd.pmi.widget": { + source: "iana", + extensions: ["wg"] + }, + "application/vnd.poc.group-advertisement+xml": { + source: "iana", + compressible: true + }, + "application/vnd.pocketlearn": { + source: "iana", + extensions: ["plf"] + }, + "application/vnd.powerbuilder6": { + source: "iana", + extensions: ["pbd"] + }, + "application/vnd.powerbuilder6-s": { + source: "iana" + }, + "application/vnd.powerbuilder7": { + source: "iana" + }, + "application/vnd.powerbuilder7-s": { + source: "iana" + }, + "application/vnd.powerbuilder75": { + source: "iana" + }, + "application/vnd.powerbuilder75-s": { + source: "iana" + }, + "application/vnd.preminet": { + source: "iana" + }, + "application/vnd.previewsystems.box": { + source: "iana", + extensions: ["box"] + }, + "application/vnd.procrate.brushset": { + extensions: ["brushset"] + }, + "application/vnd.procreate.brush": { + extensions: ["brush"] + }, + "application/vnd.procreate.dream": { + extensions: ["drm"] + }, + "application/vnd.proteus.magazine": { + source: "iana", + extensions: ["mgz"] + }, + "application/vnd.psfs": { + source: "iana" + }, + "application/vnd.pt.mundusmundi": { + source: "iana" + }, + "application/vnd.publishare-delta-tree": { + source: "iana", + extensions: ["qps"] + }, + "application/vnd.pvi.ptid1": { + source: "iana", + extensions: ["ptid"] + }, + "application/vnd.pwg-multiplexed": { + source: "iana" + }, + "application/vnd.pwg-xhtml-print+xml": { + source: "iana", + compressible: true, + extensions: ["xhtm"] + }, + "application/vnd.qualcomm.brew-app-res": { + source: "iana" + }, + "application/vnd.quarantainenet": { + source: "iana" + }, + "application/vnd.quark.quarkxpress": { + source: "iana", + extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] + }, + "application/vnd.quobject-quoxdocument": { + source: "iana" + }, + "application/vnd.radisys.moml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-stream+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-base+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-detect+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-group+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-speech+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-transform+xml": { + source: "iana", + compressible: true + }, + "application/vnd.rainstor.data": { + source: "iana" + }, + "application/vnd.rapid": { + source: "iana" + }, + "application/vnd.rar": { + source: "iana", + extensions: ["rar"] + }, + "application/vnd.realvnc.bed": { + source: "iana", + extensions: ["bed"] + }, + "application/vnd.recordare.musicxml": { + source: "iana", + extensions: ["mxl"] + }, + "application/vnd.recordare.musicxml+xml": { + source: "iana", + compressible: true, + extensions: ["musicxml"] + }, + "application/vnd.relpipe": { + source: "iana" + }, + "application/vnd.renlearn.rlprint": { + source: "iana" + }, + "application/vnd.resilient.logic": { + source: "iana" + }, + "application/vnd.restful+json": { + source: "iana", + compressible: true + }, + "application/vnd.rig.cryptonote": { + source: "iana", + extensions: ["cryptonote"] + }, + "application/vnd.rim.cod": { + source: "apache", + extensions: ["cod"] + }, + "application/vnd.rn-realmedia": { + source: "apache", + extensions: ["rm"] + }, + "application/vnd.rn-realmedia-vbr": { + source: "apache", + extensions: ["rmvb"] + }, + "application/vnd.route66.link66+xml": { + source: "iana", + compressible: true, + extensions: ["link66"] + }, + "application/vnd.rs-274x": { + source: "iana" + }, + "application/vnd.ruckus.download": { + source: "iana" + }, + "application/vnd.s3sms": { + source: "iana" + }, + "application/vnd.sailingtracker.track": { + source: "iana", + extensions: ["st"] + }, + "application/vnd.sar": { + source: "iana" + }, + "application/vnd.sbm.cid": { + source: "iana" + }, + "application/vnd.sbm.mid2": { + source: "iana" + }, + "application/vnd.scribus": { + source: "iana" + }, + "application/vnd.sealed.3df": { + source: "iana" + }, + "application/vnd.sealed.csf": { + source: "iana" + }, + "application/vnd.sealed.doc": { + source: "iana" + }, + "application/vnd.sealed.eml": { + source: "iana" + }, + "application/vnd.sealed.mht": { + source: "iana" + }, + "application/vnd.sealed.net": { + source: "iana" + }, + "application/vnd.sealed.ppt": { + source: "iana" + }, + "application/vnd.sealed.tiff": { + source: "iana" + }, + "application/vnd.sealed.xls": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.html": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.pdf": { + source: "iana" + }, + "application/vnd.seemail": { + source: "iana", + extensions: ["see"] + }, + "application/vnd.seis+json": { + source: "iana", + compressible: true + }, + "application/vnd.sema": { + source: "iana", + extensions: ["sema"] + }, + "application/vnd.semd": { + source: "iana", + extensions: ["semd"] + }, + "application/vnd.semf": { + source: "iana", + extensions: ["semf"] + }, + "application/vnd.shade-save-file": { + source: "iana" + }, + "application/vnd.shana.informed.formdata": { + source: "iana", + extensions: ["ifm"] + }, + "application/vnd.shana.informed.formtemplate": { + source: "iana", + extensions: ["itp"] + }, + "application/vnd.shana.informed.interchange": { + source: "iana", + extensions: ["iif"] + }, + "application/vnd.shana.informed.package": { + source: "iana", + extensions: ["ipk"] + }, + "application/vnd.shootproof+json": { + source: "iana", + compressible: true + }, + "application/vnd.shopkick+json": { + source: "iana", + compressible: true + }, + "application/vnd.shp": { + source: "iana" + }, + "application/vnd.shx": { + source: "iana" + }, + "application/vnd.sigrok.session": { + source: "iana" + }, + "application/vnd.simtech-mindmapper": { + source: "iana", + extensions: ["twd", "twds"] + }, + "application/vnd.siren+json": { + source: "iana", + compressible: true + }, + "application/vnd.sketchometry": { + source: "iana" + }, + "application/vnd.smaf": { + source: "iana", + extensions: ["mmf"] + }, + "application/vnd.smart.notebook": { + source: "iana" + }, + "application/vnd.smart.teacher": { + source: "iana", + extensions: ["teacher"] + }, + "application/vnd.smintio.portals.archive": { + source: "iana" + }, + "application/vnd.snesdev-page-table": { + source: "iana" + }, + "application/vnd.software602.filler.form+xml": { + source: "iana", + compressible: true, + extensions: ["fo"] + }, + "application/vnd.software602.filler.form-xml-zip": { + source: "iana" + }, + "application/vnd.solent.sdkm+xml": { + source: "iana", + compressible: true, + extensions: ["sdkm", "sdkd"] + }, + "application/vnd.spotfire.dxp": { + source: "iana", + extensions: ["dxp"] + }, + "application/vnd.spotfire.sfs": { + source: "iana", + extensions: ["sfs"] + }, + "application/vnd.sqlite3": { + source: "iana" + }, + "application/vnd.sss-cod": { + source: "iana" + }, + "application/vnd.sss-dtf": { + source: "iana" + }, + "application/vnd.sss-ntf": { + source: "iana" + }, + "application/vnd.stardivision.calc": { + source: "apache", + extensions: ["sdc"] + }, + "application/vnd.stardivision.draw": { + source: "apache", + extensions: ["sda"] + }, + "application/vnd.stardivision.impress": { + source: "apache", + extensions: ["sdd"] + }, + "application/vnd.stardivision.math": { + source: "apache", + extensions: ["smf"] + }, + "application/vnd.stardivision.writer": { + source: "apache", + extensions: ["sdw", "vor"] + }, + "application/vnd.stardivision.writer-global": { + source: "apache", + extensions: ["sgl"] + }, + "application/vnd.stepmania.package": { + source: "iana", + extensions: ["smzip"] + }, + "application/vnd.stepmania.stepchart": { + source: "iana", + extensions: ["sm"] + }, + "application/vnd.street-stream": { + source: "iana" + }, + "application/vnd.sun.wadl+xml": { + source: "iana", + compressible: true, + extensions: ["wadl"] + }, + "application/vnd.sun.xml.calc": { + source: "apache", + extensions: ["sxc"] + }, + "application/vnd.sun.xml.calc.template": { + source: "apache", + extensions: ["stc"] + }, + "application/vnd.sun.xml.draw": { + source: "apache", + extensions: ["sxd"] + }, + "application/vnd.sun.xml.draw.template": { + source: "apache", + extensions: ["std"] + }, + "application/vnd.sun.xml.impress": { + source: "apache", + extensions: ["sxi"] + }, + "application/vnd.sun.xml.impress.template": { + source: "apache", + extensions: ["sti"] + }, + "application/vnd.sun.xml.math": { + source: "apache", + extensions: ["sxm"] + }, + "application/vnd.sun.xml.writer": { + source: "apache", + extensions: ["sxw"] + }, + "application/vnd.sun.xml.writer.global": { + source: "apache", + extensions: ["sxg"] + }, + "application/vnd.sun.xml.writer.template": { + source: "apache", + extensions: ["stw"] + }, + "application/vnd.sus-calendar": { + source: "iana", + extensions: ["sus", "susp"] + }, + "application/vnd.svd": { + source: "iana", + extensions: ["svd"] + }, + "application/vnd.swiftview-ics": { + source: "iana" + }, + "application/vnd.sybyl.mol2": { + source: "iana" + }, + "application/vnd.sycle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.syft+json": { + source: "iana", + compressible: true + }, + "application/vnd.symbian.install": { + source: "apache", + extensions: ["sis", "sisx"] + }, + "application/vnd.syncml+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xsm"] + }, + "application/vnd.syncml.dm+wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["bdm"] + }, + "application/vnd.syncml.dm+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xdm"] + }, + "application/vnd.syncml.dm.notification": { + source: "iana" + }, + "application/vnd.syncml.dmddf+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmddf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["ddf"] + }, + "application/vnd.syncml.dmtnds+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmtnds+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.syncml.ds.notification": { + source: "iana" + }, + "application/vnd.tableschema+json": { + source: "iana", + compressible: true + }, + "application/vnd.tao.intent-module-archive": { + source: "iana", + extensions: ["tao"] + }, + "application/vnd.tcpdump.pcap": { + source: "iana", + extensions: ["pcap", "cap", "dmp"] + }, + "application/vnd.think-cell.ppttc+json": { + source: "iana", + compressible: true + }, + "application/vnd.tmd.mediaflex.api+xml": { + source: "iana", + compressible: true + }, + "application/vnd.tml": { + source: "iana" + }, + "application/vnd.tmobile-livetv": { + source: "iana", + extensions: ["tmo"] + }, + "application/vnd.tri.onesource": { + source: "iana" + }, + "application/vnd.trid.tpt": { + source: "iana", + extensions: ["tpt"] + }, + "application/vnd.triscape.mxs": { + source: "iana", + extensions: ["mxs"] + }, + "application/vnd.trueapp": { + source: "iana", + extensions: ["tra"] + }, + "application/vnd.truedoc": { + source: "iana" + }, + "application/vnd.ubisoft.webplayer": { + source: "iana" + }, + "application/vnd.ufdl": { + source: "iana", + extensions: ["ufd", "ufdl"] + }, + "application/vnd.uic.osdm+json": { + source: "iana", + compressible: true + }, + "application/vnd.uiq.theme": { + source: "iana", + extensions: ["utz"] + }, + "application/vnd.umajin": { + source: "iana", + extensions: ["umj"] + }, + "application/vnd.unity": { + source: "iana", + extensions: ["unityweb"] + }, + "application/vnd.uoml+xml": { + source: "iana", + compressible: true, + extensions: ["uoml", "uo"] + }, + "application/vnd.uplanet.alert": { + source: "iana" + }, + "application/vnd.uplanet.alert-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.cacheop": { + source: "iana" + }, + "application/vnd.uplanet.cacheop-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.channel": { + source: "iana" + }, + "application/vnd.uplanet.channel-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.list": { + source: "iana" + }, + "application/vnd.uplanet.list-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.listcmd": { + source: "iana" + }, + "application/vnd.uplanet.listcmd-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.signal": { + source: "iana" + }, + "application/vnd.uri-map": { + source: "iana" + }, + "application/vnd.valve.source.material": { + source: "iana" + }, + "application/vnd.vcx": { + source: "iana", + extensions: ["vcx"] + }, + "application/vnd.vd-study": { + source: "iana" + }, + "application/vnd.vectorworks": { + source: "iana" + }, + "application/vnd.vel+json": { + source: "iana", + compressible: true + }, + "application/vnd.veraison.tsm-report+cbor": { + source: "iana" + }, + "application/vnd.veraison.tsm-report+json": { + source: "iana", + compressible: true + }, + "application/vnd.verimatrix.vcas": { + source: "iana" + }, + "application/vnd.veritone.aion+json": { + source: "iana", + compressible: true + }, + "application/vnd.veryant.thin": { + source: "iana" + }, + "application/vnd.ves.encrypted": { + source: "iana" + }, + "application/vnd.vidsoft.vidconference": { + source: "iana" + }, + "application/vnd.visio": { + source: "iana", + extensions: ["vsd", "vst", "vss", "vsw", "vsdx", "vtx"] + }, + "application/vnd.visionary": { + source: "iana", + extensions: ["vis"] + }, + "application/vnd.vividence.scriptfile": { + source: "iana" + }, + "application/vnd.vocalshaper.vsp4": { + source: "iana" + }, + "application/vnd.vsf": { + source: "iana", + extensions: ["vsf"] + }, + "application/vnd.wap.sic": { + source: "iana" + }, + "application/vnd.wap.slc": { + source: "iana" + }, + "application/vnd.wap.wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["wbxml"] + }, + "application/vnd.wap.wmlc": { + source: "iana", + extensions: ["wmlc"] + }, + "application/vnd.wap.wmlscriptc": { + source: "iana", + extensions: ["wmlsc"] + }, + "application/vnd.wasmflow.wafl": { + source: "iana" + }, + "application/vnd.webturbo": { + source: "iana", + extensions: ["wtb"] + }, + "application/vnd.wfa.dpp": { + source: "iana" + }, + "application/vnd.wfa.p2p": { + source: "iana" + }, + "application/vnd.wfa.wsc": { + source: "iana" + }, + "application/vnd.windows.devicepairing": { + source: "iana" + }, + "application/vnd.wmc": { + source: "iana" + }, + "application/vnd.wmf.bootstrap": { + source: "iana" + }, + "application/vnd.wolfram.mathematica": { + source: "iana" + }, + "application/vnd.wolfram.mathematica.package": { + source: "iana" + }, + "application/vnd.wolfram.player": { + source: "iana", + extensions: ["nbp"] + }, + "application/vnd.wordlift": { + source: "iana" + }, + "application/vnd.wordperfect": { + source: "iana", + extensions: ["wpd"] + }, + "application/vnd.wqd": { + source: "iana", + extensions: ["wqd"] + }, + "application/vnd.wrq-hp3000-labelled": { + source: "iana" + }, + "application/vnd.wt.stf": { + source: "iana", + extensions: ["stf"] + }, + "application/vnd.wv.csp+wbxml": { + source: "iana" + }, + "application/vnd.wv.csp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.wv.ssp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xacml+json": { + source: "iana", + compressible: true + }, + "application/vnd.xara": { + source: "iana", + extensions: ["xar"] + }, + "application/vnd.xarin.cpj": { + source: "iana" + }, + "application/vnd.xecrets-encrypted": { + source: "iana" + }, + "application/vnd.xfdl": { + source: "iana", + extensions: ["xfdl"] + }, + "application/vnd.xfdl.webform": { + source: "iana" + }, + "application/vnd.xmi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xmpie.cpkg": { + source: "iana" + }, + "application/vnd.xmpie.dpkg": { + source: "iana" + }, + "application/vnd.xmpie.plan": { + source: "iana" + }, + "application/vnd.xmpie.ppkg": { + source: "iana" + }, + "application/vnd.xmpie.xlim": { + source: "iana" + }, + "application/vnd.yamaha.hv-dic": { + source: "iana", + extensions: ["hvd"] + }, + "application/vnd.yamaha.hv-script": { + source: "iana", + extensions: ["hvs"] + }, + "application/vnd.yamaha.hv-voice": { + source: "iana", + extensions: ["hvp"] + }, + "application/vnd.yamaha.openscoreformat": { + source: "iana", + extensions: ["osf"] + }, + "application/vnd.yamaha.openscoreformat.osfpvg+xml": { + source: "iana", + compressible: true, + extensions: ["osfpvg"] + }, + "application/vnd.yamaha.remote-setup": { + source: "iana" + }, + "application/vnd.yamaha.smaf-audio": { + source: "iana", + extensions: ["saf"] + }, + "application/vnd.yamaha.smaf-phrase": { + source: "iana", + extensions: ["spf"] + }, + "application/vnd.yamaha.through-ngn": { + source: "iana" + }, + "application/vnd.yamaha.tunnel-udpencap": { + source: "iana" + }, + "application/vnd.yaoweme": { + source: "iana" + }, + "application/vnd.yellowriver-custom-menu": { + source: "iana", + extensions: ["cmp"] + }, + "application/vnd.zul": { + source: "iana", + extensions: ["zir", "zirz"] + }, + "application/vnd.zzazz.deck+xml": { + source: "iana", + compressible: true, + extensions: ["zaz"] + }, + "application/voicexml+xml": { + source: "iana", + compressible: true, + extensions: ["vxml"] + }, + "application/voucher-cms+json": { + source: "iana", + compressible: true + }, + "application/voucher-jws+json": { + source: "iana", + compressible: true + }, + "application/vp": { + source: "iana" + }, + "application/vp+cose": { + source: "iana" + }, + "application/vp+jwt": { + source: "iana" + }, + "application/vq-rtcpxr": { + source: "iana" + }, + "application/wasm": { + source: "iana", + compressible: true, + extensions: ["wasm"] + }, + "application/watcherinfo+xml": { + source: "iana", + compressible: true, + extensions: ["wif"] + }, + "application/webpush-options+json": { + source: "iana", + compressible: true + }, + "application/whoispp-query": { + source: "iana" + }, + "application/whoispp-response": { + source: "iana" + }, + "application/widget": { + source: "iana", + extensions: ["wgt"] + }, + "application/winhlp": { + source: "apache", + extensions: ["hlp"] + }, + "application/wita": { + source: "iana" + }, + "application/wordperfect5.1": { + source: "iana" + }, + "application/wsdl+xml": { + source: "iana", + compressible: true, + extensions: ["wsdl"] + }, + "application/wspolicy+xml": { + source: "iana", + compressible: true, + extensions: ["wspolicy"] + }, + "application/x-7z-compressed": { + source: "apache", + compressible: false, + extensions: ["7z"] + }, + "application/x-abiword": { + source: "apache", + extensions: ["abw"] + }, + "application/x-ace-compressed": { + source: "apache", + extensions: ["ace"] + }, + "application/x-amf": { + source: "apache" + }, + "application/x-apple-diskimage": { + source: "apache", + extensions: ["dmg"] + }, + "application/x-arj": { + compressible: false, + extensions: ["arj"] + }, + "application/x-authorware-bin": { + source: "apache", + extensions: ["aab", "x32", "u32", "vox"] + }, + "application/x-authorware-map": { + source: "apache", + extensions: ["aam"] + }, + "application/x-authorware-seg": { + source: "apache", + extensions: ["aas"] + }, + "application/x-bcpio": { + source: "apache", + extensions: ["bcpio"] + }, + "application/x-bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/x-bittorrent": { + source: "apache", + extensions: ["torrent"] + }, + "application/x-blender": { + extensions: ["blend"] + }, + "application/x-blorb": { + source: "apache", + extensions: ["blb", "blorb"] + }, + "application/x-bzip": { + source: "apache", + compressible: false, + extensions: ["bz"] + }, + "application/x-bzip2": { + source: "apache", + compressible: false, + extensions: ["bz2", "boz"] + }, + "application/x-cbr": { + source: "apache", + extensions: ["cbr", "cba", "cbt", "cbz", "cb7"] + }, + "application/x-cdlink": { + source: "apache", + extensions: ["vcd"] + }, + "application/x-cfs-compressed": { + source: "apache", + extensions: ["cfs"] + }, + "application/x-chat": { + source: "apache", + extensions: ["chat"] + }, + "application/x-chess-pgn": { + source: "apache", + extensions: ["pgn"] + }, + "application/x-chrome-extension": { + extensions: ["crx"] + }, + "application/x-cocoa": { + source: "nginx", + extensions: ["cco"] + }, + "application/x-compress": { + source: "apache" + }, + "application/x-compressed": { + extensions: ["rar"] + }, + "application/x-conference": { + source: "apache", + extensions: ["nsc"] + }, + "application/x-cpio": { + source: "apache", + extensions: ["cpio"] + }, + "application/x-csh": { + source: "apache", + extensions: ["csh"] + }, + "application/x-deb": { + compressible: false + }, + "application/x-debian-package": { + source: "apache", + extensions: ["deb", "udeb"] + }, + "application/x-dgc-compressed": { + source: "apache", + extensions: ["dgc"] + }, + "application/x-director": { + source: "apache", + extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] + }, + "application/x-doom": { + source: "apache", + extensions: ["wad"] + }, + "application/x-dtbncx+xml": { + source: "apache", + compressible: true, + extensions: ["ncx"] + }, + "application/x-dtbook+xml": { + source: "apache", + compressible: true, + extensions: ["dtb"] + }, + "application/x-dtbresource+xml": { + source: "apache", + compressible: true, + extensions: ["res"] + }, + "application/x-dvi": { + source: "apache", + compressible: false, + extensions: ["dvi"] + }, + "application/x-envoy": { + source: "apache", + extensions: ["evy"] + }, + "application/x-eva": { + source: "apache", + extensions: ["eva"] + }, + "application/x-font-bdf": { + source: "apache", + extensions: ["bdf"] + }, + "application/x-font-dos": { + source: "apache" + }, + "application/x-font-framemaker": { + source: "apache" + }, + "application/x-font-ghostscript": { + source: "apache", + extensions: ["gsf"] + }, + "application/x-font-libgrx": { + source: "apache" + }, + "application/x-font-linux-psf": { + source: "apache", + extensions: ["psf"] + }, + "application/x-font-pcf": { + source: "apache", + extensions: ["pcf"] + }, + "application/x-font-snf": { + source: "apache", + extensions: ["snf"] + }, + "application/x-font-speedo": { + source: "apache" + }, + "application/x-font-sunos-news": { + source: "apache" + }, + "application/x-font-type1": { + source: "apache", + extensions: ["pfa", "pfb", "pfm", "afm"] + }, + "application/x-font-vfont": { + source: "apache" + }, + "application/x-freearc": { + source: "apache", + extensions: ["arc"] + }, + "application/x-futuresplash": { + source: "apache", + extensions: ["spl"] + }, + "application/x-gca-compressed": { + source: "apache", + extensions: ["gca"] + }, + "application/x-glulx": { + source: "apache", + extensions: ["ulx"] + }, + "application/x-gnumeric": { + source: "apache", + extensions: ["gnumeric"] + }, + "application/x-gramps-xml": { + source: "apache", + extensions: ["gramps"] + }, + "application/x-gtar": { + source: "apache", + extensions: ["gtar"] + }, + "application/x-gzip": { + source: "apache" + }, + "application/x-hdf": { + source: "apache", + extensions: ["hdf"] + }, + "application/x-httpd-php": { + compressible: true, + extensions: ["php"] + }, + "application/x-install-instructions": { + source: "apache", + extensions: ["install"] + }, + "application/x-ipynb+json": { + compressible: true, + extensions: ["ipynb"] + }, + "application/x-iso9660-image": { + source: "apache", + extensions: ["iso"] + }, + "application/x-iwork-keynote-sffkey": { + extensions: ["key"] + }, + "application/x-iwork-numbers-sffnumbers": { + extensions: ["numbers"] + }, + "application/x-iwork-pages-sffpages": { + extensions: ["pages"] + }, + "application/x-java-archive-diff": { + source: "nginx", + extensions: ["jardiff"] + }, + "application/x-java-jnlp-file": { + source: "apache", + compressible: false, + extensions: ["jnlp"] + }, + "application/x-javascript": { + compressible: true + }, + "application/x-keepass2": { + extensions: ["kdbx"] + }, + "application/x-latex": { + source: "apache", + compressible: false, + extensions: ["latex"] + }, + "application/x-lua-bytecode": { + extensions: ["luac"] + }, + "application/x-lzh-compressed": { + source: "apache", + extensions: ["lzh", "lha"] + }, + "application/x-makeself": { + source: "nginx", + extensions: ["run"] + }, + "application/x-mie": { + source: "apache", + extensions: ["mie"] + }, + "application/x-mobipocket-ebook": { + source: "apache", + extensions: ["prc", "mobi"] + }, + "application/x-mpegurl": { + compressible: false + }, + "application/x-ms-application": { + source: "apache", + extensions: ["application"] + }, + "application/x-ms-shortcut": { + source: "apache", + extensions: ["lnk"] + }, + "application/x-ms-wmd": { + source: "apache", + extensions: ["wmd"] + }, + "application/x-ms-wmz": { + source: "apache", + extensions: ["wmz"] + }, + "application/x-ms-xbap": { + source: "apache", + extensions: ["xbap"] + }, + "application/x-msaccess": { + source: "apache", + extensions: ["mdb"] + }, + "application/x-msbinder": { + source: "apache", + extensions: ["obd"] + }, + "application/x-mscardfile": { + source: "apache", + extensions: ["crd"] + }, + "application/x-msclip": { + source: "apache", + extensions: ["clp"] + }, + "application/x-msdos-program": { + extensions: ["exe"] + }, + "application/x-msdownload": { + source: "apache", + extensions: ["exe", "dll", "com", "bat", "msi"] + }, + "application/x-msmediaview": { + source: "apache", + extensions: ["mvb", "m13", "m14"] + }, + "application/x-msmetafile": { + source: "apache", + extensions: ["wmf", "wmz", "emf", "emz"] + }, + "application/x-msmoney": { + source: "apache", + extensions: ["mny"] + }, + "application/x-mspublisher": { + source: "apache", + extensions: ["pub"] + }, + "application/x-msschedule": { + source: "apache", + extensions: ["scd"] + }, + "application/x-msterminal": { + source: "apache", + extensions: ["trm"] + }, + "application/x-mswrite": { + source: "apache", + extensions: ["wri"] + }, + "application/x-netcdf": { + source: "apache", + extensions: ["nc", "cdf"] + }, + "application/x-ns-proxy-autoconfig": { + compressible: true, + extensions: ["pac"] + }, + "application/x-nzb": { + source: "apache", + extensions: ["nzb"] + }, + "application/x-perl": { + source: "nginx", + extensions: ["pl", "pm"] + }, + "application/x-pilot": { + source: "nginx", + extensions: ["prc", "pdb"] + }, + "application/x-pkcs12": { + source: "apache", + compressible: false, + extensions: ["p12", "pfx"] + }, + "application/x-pkcs7-certificates": { + source: "apache", + extensions: ["p7b", "spc"] + }, + "application/x-pkcs7-certreqresp": { + source: "apache", + extensions: ["p7r"] + }, + "application/x-pki-message": { + source: "iana" + }, + "application/x-rar-compressed": { + source: "apache", + compressible: false, + extensions: ["rar"] + }, + "application/x-redhat-package-manager": { + source: "nginx", + extensions: ["rpm"] + }, + "application/x-research-info-systems": { + source: "apache", + extensions: ["ris"] + }, + "application/x-sea": { + source: "nginx", + extensions: ["sea"] + }, + "application/x-sh": { + source: "apache", + compressible: true, + extensions: ["sh"] + }, + "application/x-shar": { + source: "apache", + extensions: ["shar"] + }, + "application/x-shockwave-flash": { + source: "apache", + compressible: false, + extensions: ["swf"] + }, + "application/x-silverlight-app": { + source: "apache", + extensions: ["xap"] + }, + "application/x-sql": { + source: "apache", + extensions: ["sql"] + }, + "application/x-stuffit": { + source: "apache", + compressible: false, + extensions: ["sit"] + }, + "application/x-stuffitx": { + source: "apache", + extensions: ["sitx"] + }, + "application/x-subrip": { + source: "apache", + extensions: ["srt"] + }, + "application/x-sv4cpio": { + source: "apache", + extensions: ["sv4cpio"] + }, + "application/x-sv4crc": { + source: "apache", + extensions: ["sv4crc"] + }, + "application/x-t3vm-image": { + source: "apache", + extensions: ["t3"] + }, + "application/x-tads": { + source: "apache", + extensions: ["gam"] + }, + "application/x-tar": { + source: "apache", + compressible: true, + extensions: ["tar"] + }, + "application/x-tcl": { + source: "apache", + extensions: ["tcl", "tk"] + }, + "application/x-tex": { + source: "apache", + extensions: ["tex"] + }, + "application/x-tex-tfm": { + source: "apache", + extensions: ["tfm"] + }, + "application/x-texinfo": { + source: "apache", + extensions: ["texinfo", "texi"] + }, + "application/x-tgif": { + source: "apache", + extensions: ["obj"] + }, + "application/x-ustar": { + source: "apache", + extensions: ["ustar"] + }, + "application/x-virtualbox-hdd": { + compressible: true, + extensions: ["hdd"] + }, + "application/x-virtualbox-ova": { + compressible: true, + extensions: ["ova"] + }, + "application/x-virtualbox-ovf": { + compressible: true, + extensions: ["ovf"] + }, + "application/x-virtualbox-vbox": { + compressible: true, + extensions: ["vbox"] + }, + "application/x-virtualbox-vbox-extpack": { + compressible: false, + extensions: ["vbox-extpack"] + }, + "application/x-virtualbox-vdi": { + compressible: true, + extensions: ["vdi"] + }, + "application/x-virtualbox-vhd": { + compressible: true, + extensions: ["vhd"] + }, + "application/x-virtualbox-vmdk": { + compressible: true, + extensions: ["vmdk"] + }, + "application/x-wais-source": { + source: "apache", + extensions: ["src"] + }, + "application/x-web-app-manifest+json": { + compressible: true, + extensions: ["webapp"] + }, + "application/x-www-form-urlencoded": { + source: "iana", + compressible: true + }, + "application/x-x509-ca-cert": { + source: "iana", + extensions: ["der", "crt", "pem"] + }, + "application/x-x509-ca-ra-cert": { + source: "iana" + }, + "application/x-x509-next-ca-cert": { + source: "iana" + }, + "application/x-xfig": { + source: "apache", + extensions: ["fig"] + }, + "application/x-xliff+xml": { + source: "apache", + compressible: true, + extensions: ["xlf"] + }, + "application/x-xpinstall": { + source: "apache", + compressible: false, + extensions: ["xpi"] + }, + "application/x-xz": { + source: "apache", + extensions: ["xz"] + }, + "application/x-zip-compressed": { + extensions: ["zip"] + }, + "application/x-zmachine": { + source: "apache", + extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] + }, + "application/x400-bp": { + source: "iana" + }, + "application/xacml+xml": { + source: "iana", + compressible: true + }, + "application/xaml+xml": { + source: "apache", + compressible: true, + extensions: ["xaml"] + }, + "application/xcap-att+xml": { + source: "iana", + compressible: true, + extensions: ["xav"] + }, + "application/xcap-caps+xml": { + source: "iana", + compressible: true, + extensions: ["xca"] + }, + "application/xcap-diff+xml": { + source: "iana", + compressible: true, + extensions: ["xdf"] + }, + "application/xcap-el+xml": { + source: "iana", + compressible: true, + extensions: ["xel"] + }, + "application/xcap-error+xml": { + source: "iana", + compressible: true + }, + "application/xcap-ns+xml": { + source: "iana", + compressible: true, + extensions: ["xns"] + }, + "application/xcon-conference-info+xml": { + source: "iana", + compressible: true + }, + "application/xcon-conference-info-diff+xml": { + source: "iana", + compressible: true + }, + "application/xenc+xml": { + source: "iana", + compressible: true, + extensions: ["xenc"] + }, + "application/xfdf": { + source: "iana", + extensions: ["xfdf"] + }, + "application/xhtml+xml": { + source: "iana", + compressible: true, + extensions: ["xhtml", "xht"] + }, + "application/xhtml-voice+xml": { + source: "apache", + compressible: true + }, + "application/xliff+xml": { + source: "iana", + compressible: true, + extensions: ["xlf"] + }, + "application/xml": { + source: "iana", + compressible: true, + extensions: ["xml", "xsl", "xsd", "rng"] + }, + "application/xml-dtd": { + source: "iana", + compressible: true, + extensions: ["dtd"] + }, + "application/xml-external-parsed-entity": { + source: "iana" + }, + "application/xml-patch+xml": { + source: "iana", + compressible: true + }, + "application/xmpp+xml": { + source: "iana", + compressible: true + }, + "application/xop+xml": { + source: "iana", + compressible: true, + extensions: ["xop"] + }, + "application/xproc+xml": { + source: "apache", + compressible: true, + extensions: ["xpl"] + }, + "application/xslt+xml": { + source: "iana", + compressible: true, + extensions: ["xsl", "xslt"] + }, + "application/xspf+xml": { + source: "apache", + compressible: true, + extensions: ["xspf"] + }, + "application/xv+xml": { + source: "iana", + compressible: true, + extensions: ["mxml", "xhvml", "xvml", "xvm"] + }, + "application/yaml": { + source: "iana" + }, + "application/yang": { + source: "iana", + extensions: ["yang"] + }, + "application/yang-data+cbor": { + source: "iana" + }, + "application/yang-data+json": { + source: "iana", + compressible: true + }, + "application/yang-data+xml": { + source: "iana", + compressible: true + }, + "application/yang-patch+json": { + source: "iana", + compressible: true + }, + "application/yang-patch+xml": { + source: "iana", + compressible: true + }, + "application/yang-sid+json": { + source: "iana", + compressible: true + }, + "application/yin+xml": { + source: "iana", + compressible: true, + extensions: ["yin"] + }, + "application/zip": { + source: "iana", + compressible: false, + extensions: ["zip"] + }, + "application/zip+dotlottie": { + extensions: ["lottie"] + }, + "application/zlib": { + source: "iana" + }, + "application/zstd": { + source: "iana" + }, + "audio/1d-interleaved-parityfec": { + source: "iana" + }, + "audio/32kadpcm": { + source: "iana" + }, + "audio/3gpp": { + source: "iana", + compressible: false, + extensions: ["3gpp"] + }, + "audio/3gpp2": { + source: "iana" + }, + "audio/aac": { + source: "iana", + extensions: ["adts", "aac"] + }, + "audio/ac3": { + source: "iana" + }, + "audio/adpcm": { + source: "apache", + extensions: ["adp"] + }, + "audio/amr": { + source: "iana", + extensions: ["amr"] + }, + "audio/amr-wb": { + source: "iana" + }, + "audio/amr-wb+": { + source: "iana" + }, + "audio/aptx": { + source: "iana" + }, + "audio/asc": { + source: "iana" + }, + "audio/atrac-advanced-lossless": { + source: "iana" + }, + "audio/atrac-x": { + source: "iana" + }, + "audio/atrac3": { + source: "iana" + }, + "audio/basic": { + source: "iana", + compressible: false, + extensions: ["au", "snd"] + }, + "audio/bv16": { + source: "iana" + }, + "audio/bv32": { + source: "iana" + }, + "audio/clearmode": { + source: "iana" + }, + "audio/cn": { + source: "iana" + }, + "audio/dat12": { + source: "iana" + }, + "audio/dls": { + source: "iana" + }, + "audio/dsr-es201108": { + source: "iana" + }, + "audio/dsr-es202050": { + source: "iana" + }, + "audio/dsr-es202211": { + source: "iana" + }, + "audio/dsr-es202212": { + source: "iana" + }, + "audio/dv": { + source: "iana" + }, + "audio/dvi4": { + source: "iana" + }, + "audio/eac3": { + source: "iana" + }, + "audio/encaprtp": { + source: "iana" + }, + "audio/evrc": { + source: "iana" + }, + "audio/evrc-qcp": { + source: "iana" + }, + "audio/evrc0": { + source: "iana" + }, + "audio/evrc1": { + source: "iana" + }, + "audio/evrcb": { + source: "iana" + }, + "audio/evrcb0": { + source: "iana" + }, + "audio/evrcb1": { + source: "iana" + }, + "audio/evrcnw": { + source: "iana" + }, + "audio/evrcnw0": { + source: "iana" + }, + "audio/evrcnw1": { + source: "iana" + }, + "audio/evrcwb": { + source: "iana" + }, + "audio/evrcwb0": { + source: "iana" + }, + "audio/evrcwb1": { + source: "iana" + }, + "audio/evs": { + source: "iana" + }, + "audio/flac": { + source: "iana" + }, + "audio/flexfec": { + source: "iana" + }, + "audio/fwdred": { + source: "iana" + }, + "audio/g711-0": { + source: "iana" + }, + "audio/g719": { + source: "iana" + }, + "audio/g722": { + source: "iana" + }, + "audio/g7221": { + source: "iana" + }, + "audio/g723": { + source: "iana" + }, + "audio/g726-16": { + source: "iana" + }, + "audio/g726-24": { + source: "iana" + }, + "audio/g726-32": { + source: "iana" + }, + "audio/g726-40": { + source: "iana" + }, + "audio/g728": { + source: "iana" + }, + "audio/g729": { + source: "iana" + }, + "audio/g7291": { + source: "iana" + }, + "audio/g729d": { + source: "iana" + }, + "audio/g729e": { + source: "iana" + }, + "audio/gsm": { + source: "iana" + }, + "audio/gsm-efr": { + source: "iana" + }, + "audio/gsm-hr-08": { + source: "iana" + }, + "audio/ilbc": { + source: "iana" + }, + "audio/ip-mr_v2.5": { + source: "iana" + }, + "audio/isac": { + source: "apache" + }, + "audio/l16": { + source: "iana" + }, + "audio/l20": { + source: "iana" + }, + "audio/l24": { + source: "iana", + compressible: false + }, + "audio/l8": { + source: "iana" + }, + "audio/lpc": { + source: "iana" + }, + "audio/matroska": { + source: "iana" + }, + "audio/melp": { + source: "iana" + }, + "audio/melp1200": { + source: "iana" + }, + "audio/melp2400": { + source: "iana" + }, + "audio/melp600": { + source: "iana" + }, + "audio/mhas": { + source: "iana" + }, + "audio/midi": { + source: "apache", + extensions: ["mid", "midi", "kar", "rmi"] + }, + "audio/midi-clip": { + source: "iana" + }, + "audio/mobile-xmf": { + source: "iana", + extensions: ["mxmf"] + }, + "audio/mp3": { + compressible: false, + extensions: ["mp3"] + }, + "audio/mp4": { + source: "iana", + compressible: false, + extensions: ["m4a", "mp4a", "m4b"] + }, + "audio/mp4a-latm": { + source: "iana" + }, + "audio/mpa": { + source: "iana" + }, + "audio/mpa-robust": { + source: "iana" + }, + "audio/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] + }, + "audio/mpeg4-generic": { + source: "iana" + }, + "audio/musepack": { + source: "apache" + }, + "audio/ogg": { + source: "iana", + compressible: false, + extensions: ["oga", "ogg", "spx", "opus"] + }, + "audio/opus": { + source: "iana" + }, + "audio/parityfec": { + source: "iana" + }, + "audio/pcma": { + source: "iana" + }, + "audio/pcma-wb": { + source: "iana" + }, + "audio/pcmu": { + source: "iana" + }, + "audio/pcmu-wb": { + source: "iana" + }, + "audio/prs.sid": { + source: "iana" + }, + "audio/qcelp": { + source: "iana" + }, + "audio/raptorfec": { + source: "iana" + }, + "audio/red": { + source: "iana" + }, + "audio/rtp-enc-aescm128": { + source: "iana" + }, + "audio/rtp-midi": { + source: "iana" + }, + "audio/rtploopback": { + source: "iana" + }, + "audio/rtx": { + source: "iana" + }, + "audio/s3m": { + source: "apache", + extensions: ["s3m"] + }, + "audio/scip": { + source: "iana" + }, + "audio/silk": { + source: "apache", + extensions: ["sil"] + }, + "audio/smv": { + source: "iana" + }, + "audio/smv-qcp": { + source: "iana" + }, + "audio/smv0": { + source: "iana" + }, + "audio/sofa": { + source: "iana" + }, + "audio/sp-midi": { + source: "iana" + }, + "audio/speex": { + source: "iana" + }, + "audio/t140c": { + source: "iana" + }, + "audio/t38": { + source: "iana" + }, + "audio/telephone-event": { + source: "iana" + }, + "audio/tetra_acelp": { + source: "iana" + }, + "audio/tetra_acelp_bb": { + source: "iana" + }, + "audio/tone": { + source: "iana" + }, + "audio/tsvcis": { + source: "iana" + }, + "audio/uemclip": { + source: "iana" + }, + "audio/ulpfec": { + source: "iana" + }, + "audio/usac": { + source: "iana" + }, + "audio/vdvi": { + source: "iana" + }, + "audio/vmr-wb": { + source: "iana" + }, + "audio/vnd.3gpp.iufp": { + source: "iana" + }, + "audio/vnd.4sb": { + source: "iana" + }, + "audio/vnd.audiokoz": { + source: "iana" + }, + "audio/vnd.celp": { + source: "iana" + }, + "audio/vnd.cisco.nse": { + source: "iana" + }, + "audio/vnd.cmles.radio-events": { + source: "iana" + }, + "audio/vnd.cns.anp1": { + source: "iana" + }, + "audio/vnd.cns.inf1": { + source: "iana" + }, + "audio/vnd.dece.audio": { + source: "iana", + extensions: ["uva", "uvva"] + }, + "audio/vnd.digital-winds": { + source: "iana", + extensions: ["eol"] + }, + "audio/vnd.dlna.adts": { + source: "iana" + }, + "audio/vnd.dolby.heaac.1": { + source: "iana" + }, + "audio/vnd.dolby.heaac.2": { + source: "iana" + }, + "audio/vnd.dolby.mlp": { + source: "iana" + }, + "audio/vnd.dolby.mps": { + source: "iana" + }, + "audio/vnd.dolby.pl2": { + source: "iana" + }, + "audio/vnd.dolby.pl2x": { + source: "iana" + }, + "audio/vnd.dolby.pl2z": { + source: "iana" + }, + "audio/vnd.dolby.pulse.1": { + source: "iana" + }, + "audio/vnd.dra": { + source: "iana", + extensions: ["dra"] + }, + "audio/vnd.dts": { + source: "iana", + extensions: ["dts"] + }, + "audio/vnd.dts.hd": { + source: "iana", + extensions: ["dtshd"] + }, + "audio/vnd.dts.uhd": { + source: "iana" + }, + "audio/vnd.dvb.file": { + source: "iana" + }, + "audio/vnd.everad.plj": { + source: "iana" + }, + "audio/vnd.hns.audio": { + source: "iana" + }, + "audio/vnd.lucent.voice": { + source: "iana", + extensions: ["lvp"] + }, + "audio/vnd.ms-playready.media.pya": { + source: "iana", + extensions: ["pya"] + }, + "audio/vnd.nokia.mobile-xmf": { + source: "iana" + }, + "audio/vnd.nortel.vbk": { + source: "iana" + }, + "audio/vnd.nuera.ecelp4800": { + source: "iana", + extensions: ["ecelp4800"] + }, + "audio/vnd.nuera.ecelp7470": { + source: "iana", + extensions: ["ecelp7470"] + }, + "audio/vnd.nuera.ecelp9600": { + source: "iana", + extensions: ["ecelp9600"] + }, + "audio/vnd.octel.sbc": { + source: "iana" + }, + "audio/vnd.presonus.multitrack": { + source: "iana" + }, + "audio/vnd.qcelp": { + source: "apache" + }, + "audio/vnd.rhetorex.32kadpcm": { + source: "iana" + }, + "audio/vnd.rip": { + source: "iana", + extensions: ["rip"] + }, + "audio/vnd.rn-realaudio": { + compressible: false + }, + "audio/vnd.sealedmedia.softseal.mpeg": { + source: "iana" + }, + "audio/vnd.vmx.cvsd": { + source: "iana" + }, + "audio/vnd.wave": { + compressible: false + }, + "audio/vorbis": { + source: "iana", + compressible: false + }, + "audio/vorbis-config": { + source: "iana" + }, + "audio/wav": { + compressible: false, + extensions: ["wav"] + }, + "audio/wave": { + compressible: false, + extensions: ["wav"] + }, + "audio/webm": { + source: "apache", + compressible: false, + extensions: ["weba"] + }, + "audio/x-aac": { + source: "apache", + compressible: false, + extensions: ["aac"] + }, + "audio/x-aiff": { + source: "apache", + extensions: ["aif", "aiff", "aifc"] + }, + "audio/x-caf": { + source: "apache", + compressible: false, + extensions: ["caf"] + }, + "audio/x-flac": { + source: "apache", + extensions: ["flac"] + }, + "audio/x-m4a": { + source: "nginx", + extensions: ["m4a"] + }, + "audio/x-matroska": { + source: "apache", + extensions: ["mka"] + }, + "audio/x-mpegurl": { + source: "apache", + extensions: ["m3u"] + }, + "audio/x-ms-wax": { + source: "apache", + extensions: ["wax"] + }, + "audio/x-ms-wma": { + source: "apache", + extensions: ["wma"] + }, + "audio/x-pn-realaudio": { + source: "apache", + extensions: ["ram", "ra"] + }, + "audio/x-pn-realaudio-plugin": { + source: "apache", + extensions: ["rmp"] + }, + "audio/x-realaudio": { + source: "nginx", + extensions: ["ra"] + }, + "audio/x-tta": { + source: "apache" + }, + "audio/x-wav": { + source: "apache", + extensions: ["wav"] + }, + "audio/xm": { + source: "apache", + extensions: ["xm"] + }, + "chemical/x-cdx": { + source: "apache", + extensions: ["cdx"] + }, + "chemical/x-cif": { + source: "apache", + extensions: ["cif"] + }, + "chemical/x-cmdf": { + source: "apache", + extensions: ["cmdf"] + }, + "chemical/x-cml": { + source: "apache", + extensions: ["cml"] + }, + "chemical/x-csml": { + source: "apache", + extensions: ["csml"] + }, + "chemical/x-pdb": { + source: "apache" + }, + "chemical/x-xyz": { + source: "apache", + extensions: ["xyz"] + }, + "font/collection": { + source: "iana", + extensions: ["ttc"] + }, + "font/otf": { + source: "iana", + compressible: true, + extensions: ["otf"] + }, + "font/sfnt": { + source: "iana" + }, + "font/ttf": { + source: "iana", + compressible: true, + extensions: ["ttf"] + }, + "font/woff": { + source: "iana", + extensions: ["woff"] + }, + "font/woff2": { + source: "iana", + extensions: ["woff2"] + }, + "image/aces": { + source: "iana", + extensions: ["exr"] + }, + "image/apng": { + source: "iana", + compressible: false, + extensions: ["apng"] + }, + "image/avci": { + source: "iana", + extensions: ["avci"] + }, + "image/avcs": { + source: "iana", + extensions: ["avcs"] + }, + "image/avif": { + source: "iana", + compressible: false, + extensions: ["avif"] + }, + "image/bmp": { + source: "iana", + compressible: true, + extensions: ["bmp", "dib"] + }, + "image/cgm": { + source: "iana", + extensions: ["cgm"] + }, + "image/dicom-rle": { + source: "iana", + extensions: ["drle"] + }, + "image/dpx": { + source: "iana", + extensions: ["dpx"] + }, + "image/emf": { + source: "iana", + extensions: ["emf"] + }, + "image/fits": { + source: "iana", + extensions: ["fits"] + }, + "image/g3fax": { + source: "iana", + extensions: ["g3"] + }, + "image/gif": { + source: "iana", + compressible: false, + extensions: ["gif"] + }, + "image/heic": { + source: "iana", + extensions: ["heic"] + }, + "image/heic-sequence": { + source: "iana", + extensions: ["heics"] + }, + "image/heif": { + source: "iana", + extensions: ["heif"] + }, + "image/heif-sequence": { + source: "iana", + extensions: ["heifs"] + }, + "image/hej2k": { + source: "iana", + extensions: ["hej2"] + }, + "image/ief": { + source: "iana", + extensions: ["ief"] + }, + "image/j2c": { + source: "iana" + }, + "image/jaii": { + source: "iana", + extensions: ["jaii"] + }, + "image/jais": { + source: "iana", + extensions: ["jais"] + }, + "image/jls": { + source: "iana", + extensions: ["jls"] + }, + "image/jp2": { + source: "iana", + compressible: false, + extensions: ["jp2", "jpg2"] + }, + "image/jpeg": { + source: "iana", + compressible: false, + extensions: ["jpg", "jpeg", "jpe"] + }, + "image/jph": { + source: "iana", + extensions: ["jph"] + }, + "image/jphc": { + source: "iana", + extensions: ["jhc"] + }, + "image/jpm": { + source: "iana", + compressible: false, + extensions: ["jpm", "jpgm"] + }, + "image/jpx": { + source: "iana", + compressible: false, + extensions: ["jpx", "jpf"] + }, + "image/jxl": { + source: "iana", + extensions: ["jxl"] + }, + "image/jxr": { + source: "iana", + extensions: ["jxr"] + }, + "image/jxra": { + source: "iana", + extensions: ["jxra"] + }, + "image/jxrs": { + source: "iana", + extensions: ["jxrs"] + }, + "image/jxs": { + source: "iana", + extensions: ["jxs"] + }, + "image/jxsc": { + source: "iana", + extensions: ["jxsc"] + }, + "image/jxsi": { + source: "iana", + extensions: ["jxsi"] + }, + "image/jxss": { + source: "iana", + extensions: ["jxss"] + }, + "image/ktx": { + source: "iana", + extensions: ["ktx"] + }, + "image/ktx2": { + source: "iana", + extensions: ["ktx2"] + }, + "image/naplps": { + source: "iana" + }, + "image/pjpeg": { + compressible: false, + extensions: ["jfif"] + }, + "image/png": { + source: "iana", + compressible: false, + extensions: ["png"] + }, + "image/prs.btif": { + source: "iana", + extensions: ["btif", "btf"] + }, + "image/prs.pti": { + source: "iana", + extensions: ["pti"] + }, + "image/pwg-raster": { + source: "iana" + }, + "image/sgi": { + source: "apache", + extensions: ["sgi"] + }, + "image/svg+xml": { + source: "iana", + compressible: true, + extensions: ["svg", "svgz"] + }, + "image/t38": { + source: "iana", + extensions: ["t38"] + }, + "image/tiff": { + source: "iana", + compressible: false, + extensions: ["tif", "tiff"] + }, + "image/tiff-fx": { + source: "iana", + extensions: ["tfx"] + }, + "image/vnd.adobe.photoshop": { + source: "iana", + compressible: true, + extensions: ["psd"] + }, + "image/vnd.airzip.accelerator.azv": { + source: "iana", + extensions: ["azv"] + }, + "image/vnd.clip": { + source: "iana" + }, + "image/vnd.cns.inf2": { + source: "iana" + }, + "image/vnd.dece.graphic": { + source: "iana", + extensions: ["uvi", "uvvi", "uvg", "uvvg"] + }, + "image/vnd.djvu": { + source: "iana", + extensions: ["djvu", "djv"] + }, + "image/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "image/vnd.dwg": { + source: "iana", + extensions: ["dwg"] + }, + "image/vnd.dxf": { + source: "iana", + extensions: ["dxf"] + }, + "image/vnd.fastbidsheet": { + source: "iana", + extensions: ["fbs"] + }, + "image/vnd.fpx": { + source: "iana", + extensions: ["fpx"] + }, + "image/vnd.fst": { + source: "iana", + extensions: ["fst"] + }, + "image/vnd.fujixerox.edmics-mmr": { + source: "iana", + extensions: ["mmr"] + }, + "image/vnd.fujixerox.edmics-rlc": { + source: "iana", + extensions: ["rlc"] + }, + "image/vnd.globalgraphics.pgb": { + source: "iana" + }, + "image/vnd.microsoft.icon": { + source: "iana", + compressible: true, + extensions: ["ico"] + }, + "image/vnd.mix": { + source: "iana" + }, + "image/vnd.mozilla.apng": { + source: "iana" + }, + "image/vnd.ms-dds": { + compressible: true, + extensions: ["dds"] + }, + "image/vnd.ms-modi": { + source: "iana", + extensions: ["mdi"] + }, + "image/vnd.ms-photo": { + source: "apache", + extensions: ["wdp"] + }, + "image/vnd.net-fpx": { + source: "iana", + extensions: ["npx"] + }, + "image/vnd.pco.b16": { + source: "iana", + extensions: ["b16"] + }, + "image/vnd.radiance": { + source: "iana" + }, + "image/vnd.sealed.png": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.gif": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.jpg": { + source: "iana" + }, + "image/vnd.svf": { + source: "iana" + }, + "image/vnd.tencent.tap": { + source: "iana", + extensions: ["tap"] + }, + "image/vnd.valve.source.texture": { + source: "iana", + extensions: ["vtf"] + }, + "image/vnd.wap.wbmp": { + source: "iana", + extensions: ["wbmp"] + }, + "image/vnd.xiff": { + source: "iana", + extensions: ["xif"] + }, + "image/vnd.zbrush.pcx": { + source: "iana", + extensions: ["pcx"] + }, + "image/webp": { + source: "iana", + extensions: ["webp"] + }, + "image/wmf": { + source: "iana", + extensions: ["wmf"] + }, + "image/x-3ds": { + source: "apache", + extensions: ["3ds"] + }, + "image/x-adobe-dng": { + extensions: ["dng"] + }, + "image/x-cmu-raster": { + source: "apache", + extensions: ["ras"] + }, + "image/x-cmx": { + source: "apache", + extensions: ["cmx"] + }, + "image/x-emf": { + source: "iana" + }, + "image/x-freehand": { + source: "apache", + extensions: ["fh", "fhc", "fh4", "fh5", "fh7"] + }, + "image/x-icon": { + source: "apache", + compressible: true, + extensions: ["ico"] + }, + "image/x-jng": { + source: "nginx", + extensions: ["jng"] + }, + "image/x-mrsid-image": { + source: "apache", + extensions: ["sid"] + }, + "image/x-ms-bmp": { + source: "nginx", + compressible: true, + extensions: ["bmp"] + }, + "image/x-pcx": { + source: "apache", + extensions: ["pcx"] + }, + "image/x-pict": { + source: "apache", + extensions: ["pic", "pct"] + }, + "image/x-portable-anymap": { + source: "apache", + extensions: ["pnm"] + }, + "image/x-portable-bitmap": { + source: "apache", + extensions: ["pbm"] + }, + "image/x-portable-graymap": { + source: "apache", + extensions: ["pgm"] + }, + "image/x-portable-pixmap": { + source: "apache", + extensions: ["ppm"] + }, + "image/x-rgb": { + source: "apache", + extensions: ["rgb"] + }, + "image/x-tga": { + source: "apache", + extensions: ["tga"] + }, + "image/x-wmf": { + source: "iana" + }, + "image/x-xbitmap": { + source: "apache", + extensions: ["xbm"] + }, + "image/x-xcf": { + compressible: false + }, + "image/x-xpixmap": { + source: "apache", + extensions: ["xpm"] + }, + "image/x-xwindowdump": { + source: "apache", + extensions: ["xwd"] + }, + "message/bhttp": { + source: "iana" + }, + "message/cpim": { + source: "iana" + }, + "message/delivery-status": { + source: "iana" + }, + "message/disposition-notification": { + source: "iana", + extensions: [ + "disposition-notification" + ] + }, + "message/external-body": { + source: "iana" + }, + "message/feedback-report": { + source: "iana" + }, + "message/global": { + source: "iana", + extensions: ["u8msg"] + }, + "message/global-delivery-status": { + source: "iana", + extensions: ["u8dsn"] + }, + "message/global-disposition-notification": { + source: "iana", + extensions: ["u8mdn"] + }, + "message/global-headers": { + source: "iana", + extensions: ["u8hdr"] + }, + "message/http": { + source: "iana", + compressible: false + }, + "message/imdn+xml": { + source: "iana", + compressible: true + }, + "message/mls": { + source: "iana" + }, + "message/news": { + source: "apache" + }, + "message/ohttp-req": { + source: "iana" + }, + "message/ohttp-res": { + source: "iana" + }, + "message/partial": { + source: "iana", + compressible: false + }, + "message/rfc822": { + source: "iana", + compressible: true, + extensions: ["eml", "mime", "mht", "mhtml"] + }, + "message/s-http": { + source: "apache" + }, + "message/sip": { + source: "iana" + }, + "message/sipfrag": { + source: "iana" + }, + "message/tracking-status": { + source: "iana" + }, + "message/vnd.si.simp": { + source: "apache" + }, + "message/vnd.wfa.wsc": { + source: "iana", + extensions: ["wsc"] + }, + "model/3mf": { + source: "iana", + extensions: ["3mf"] + }, + "model/e57": { + source: "iana" + }, + "model/gltf+json": { + source: "iana", + compressible: true, + extensions: ["gltf"] + }, + "model/gltf-binary": { + source: "iana", + compressible: true, + extensions: ["glb"] + }, + "model/iges": { + source: "iana", + compressible: false, + extensions: ["igs", "iges"] + }, + "model/jt": { + source: "iana", + extensions: ["jt"] + }, + "model/mesh": { + source: "iana", + compressible: false, + extensions: ["msh", "mesh", "silo"] + }, + "model/mtl": { + source: "iana", + extensions: ["mtl"] + }, + "model/obj": { + source: "iana", + extensions: ["obj"] + }, + "model/prc": { + source: "iana", + extensions: ["prc"] + }, + "model/step": { + source: "iana", + extensions: ["step", "stp", "stpnc", "p21", "210"] + }, + "model/step+xml": { + source: "iana", + compressible: true, + extensions: ["stpx"] + }, + "model/step+zip": { + source: "iana", + compressible: false, + extensions: ["stpz"] + }, + "model/step-xml+zip": { + source: "iana", + compressible: false, + extensions: ["stpxz"] + }, + "model/stl": { + source: "iana", + extensions: ["stl"] + }, + "model/u3d": { + source: "iana", + extensions: ["u3d"] + }, + "model/vnd.bary": { + source: "iana", + extensions: ["bary"] + }, + "model/vnd.cld": { + source: "iana", + extensions: ["cld"] + }, + "model/vnd.collada+xml": { + source: "iana", + compressible: true, + extensions: ["dae"] + }, + "model/vnd.dwf": { + source: "iana", + extensions: ["dwf"] + }, + "model/vnd.flatland.3dml": { + source: "iana" + }, + "model/vnd.gdl": { + source: "iana", + extensions: ["gdl"] + }, + "model/vnd.gs-gdl": { + source: "apache" + }, + "model/vnd.gs.gdl": { + source: "iana" + }, + "model/vnd.gtw": { + source: "iana", + extensions: ["gtw"] + }, + "model/vnd.moml+xml": { + source: "iana", + compressible: true + }, + "model/vnd.mts": { + source: "iana", + extensions: ["mts"] + }, + "model/vnd.opengex": { + source: "iana", + extensions: ["ogex"] + }, + "model/vnd.parasolid.transmit.binary": { + source: "iana", + extensions: ["x_b"] + }, + "model/vnd.parasolid.transmit.text": { + source: "iana", + extensions: ["x_t"] + }, + "model/vnd.pytha.pyox": { + source: "iana", + extensions: ["pyo", "pyox"] + }, + "model/vnd.rosette.annotated-data-model": { + source: "iana" + }, + "model/vnd.sap.vds": { + source: "iana", + extensions: ["vds"] + }, + "model/vnd.usda": { + source: "iana", + extensions: ["usda"] + }, + "model/vnd.usdz+zip": { + source: "iana", + compressible: false, + extensions: ["usdz"] + }, + "model/vnd.valve.source.compiled-map": { + source: "iana", + extensions: ["bsp"] + }, + "model/vnd.vtu": { + source: "iana", + extensions: ["vtu"] + }, + "model/vrml": { + source: "iana", + compressible: false, + extensions: ["wrl", "vrml"] + }, + "model/x3d+binary": { + source: "apache", + compressible: false, + extensions: ["x3db", "x3dbz"] + }, + "model/x3d+fastinfoset": { + source: "iana", + extensions: ["x3db"] + }, + "model/x3d+vrml": { + source: "apache", + compressible: false, + extensions: ["x3dv", "x3dvz"] + }, + "model/x3d+xml": { + source: "iana", + compressible: true, + extensions: ["x3d", "x3dz"] + }, + "model/x3d-vrml": { + source: "iana", + extensions: ["x3dv"] + }, + "multipart/alternative": { + source: "iana", + compressible: false + }, + "multipart/appledouble": { + source: "iana" + }, + "multipart/byteranges": { + source: "iana" + }, + "multipart/digest": { + source: "iana" + }, + "multipart/encrypted": { + source: "iana", + compressible: false + }, + "multipart/form-data": { + source: "iana", + compressible: false + }, + "multipart/header-set": { + source: "iana" + }, + "multipart/mixed": { + source: "iana" + }, + "multipart/multilingual": { + source: "iana" + }, + "multipart/parallel": { + source: "iana" + }, + "multipart/related": { + source: "iana", + compressible: false + }, + "multipart/report": { + source: "iana" + }, + "multipart/signed": { + source: "iana", + compressible: false + }, + "multipart/vnd.bint.med-plus": { + source: "iana" + }, + "multipart/voice-message": { + source: "iana" + }, + "multipart/x-mixed-replace": { + source: "iana" + }, + "text/1d-interleaved-parityfec": { + source: "iana" + }, + "text/cache-manifest": { + source: "iana", + compressible: true, + extensions: ["appcache", "manifest"] + }, + "text/calendar": { + source: "iana", + extensions: ["ics", "ifb"] + }, + "text/calender": { + compressible: true + }, + "text/cmd": { + compressible: true + }, + "text/coffeescript": { + extensions: ["coffee", "litcoffee"] + }, + "text/cql": { + source: "iana" + }, + "text/cql-expression": { + source: "iana" + }, + "text/cql-identifier": { + source: "iana" + }, + "text/css": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["css"] + }, + "text/csv": { + source: "iana", + compressible: true, + extensions: ["csv"] + }, + "text/csv-schema": { + source: "iana" + }, + "text/directory": { + source: "iana" + }, + "text/dns": { + source: "iana" + }, + "text/ecmascript": { + source: "apache" + }, + "text/encaprtp": { + source: "iana" + }, + "text/enriched": { + source: "iana" + }, + "text/fhirpath": { + source: "iana" + }, + "text/flexfec": { + source: "iana" + }, + "text/fwdred": { + source: "iana" + }, + "text/gff3": { + source: "iana" + }, + "text/grammar-ref-list": { + source: "iana" + }, + "text/hl7v2": { + source: "iana" + }, + "text/html": { + source: "iana", + compressible: true, + extensions: ["html", "htm", "shtml"] + }, + "text/jade": { + extensions: ["jade"] + }, + "text/javascript": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["js", "mjs"] + }, + "text/jcr-cnd": { + source: "iana" + }, + "text/jsx": { + compressible: true, + extensions: ["jsx"] + }, + "text/less": { + compressible: true, + extensions: ["less"] + }, + "text/markdown": { + source: "iana", + compressible: true, + extensions: ["md", "markdown"] + }, + "text/mathml": { + source: "nginx", + extensions: ["mml"] + }, + "text/mdx": { + compressible: true, + extensions: ["mdx"] + }, + "text/mizar": { + source: "iana" + }, + "text/n3": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["n3"] + }, + "text/parameters": { + source: "iana", + charset: "UTF-8" + }, + "text/parityfec": { + source: "iana" + }, + "text/plain": { + source: "iana", + compressible: true, + extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"] + }, + "text/provenance-notation": { + source: "iana", + charset: "UTF-8" + }, + "text/prs.fallenstein.rst": { + source: "iana" + }, + "text/prs.lines.tag": { + source: "iana", + extensions: ["dsc"] + }, + "text/prs.prop.logic": { + source: "iana" + }, + "text/prs.texi": { + source: "iana" + }, + "text/raptorfec": { + source: "iana" + }, + "text/red": { + source: "iana" + }, + "text/rfc822-headers": { + source: "iana" + }, + "text/richtext": { + source: "iana", + compressible: true, + extensions: ["rtx"] + }, + "text/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "text/rtp-enc-aescm128": { + source: "iana" + }, + "text/rtploopback": { + source: "iana" + }, + "text/rtx": { + source: "iana" + }, + "text/sgml": { + source: "iana", + extensions: ["sgml", "sgm"] + }, + "text/shaclc": { + source: "iana" + }, + "text/shex": { + source: "iana", + extensions: ["shex"] + }, + "text/slim": { + extensions: ["slim", "slm"] + }, + "text/spdx": { + source: "iana", + extensions: ["spdx"] + }, + "text/strings": { + source: "iana" + }, + "text/stylus": { + extensions: ["stylus", "styl"] + }, + "text/t140": { + source: "iana" + }, + "text/tab-separated-values": { + source: "iana", + compressible: true, + extensions: ["tsv"] + }, + "text/troff": { + source: "iana", + extensions: ["t", "tr", "roff", "man", "me", "ms"] + }, + "text/turtle": { + source: "iana", + charset: "UTF-8", + extensions: ["ttl"] + }, + "text/ulpfec": { + source: "iana" + }, + "text/uri-list": { + source: "iana", + compressible: true, + extensions: ["uri", "uris", "urls"] + }, + "text/vcard": { + source: "iana", + compressible: true, + extensions: ["vcard"] + }, + "text/vnd.a": { + source: "iana" + }, + "text/vnd.abc": { + source: "iana" + }, + "text/vnd.ascii-art": { + source: "iana" + }, + "text/vnd.curl": { + source: "iana", + extensions: ["curl"] + }, + "text/vnd.curl.dcurl": { + source: "apache", + extensions: ["dcurl"] + }, + "text/vnd.curl.mcurl": { + source: "apache", + extensions: ["mcurl"] + }, + "text/vnd.curl.scurl": { + source: "apache", + extensions: ["scurl"] + }, + "text/vnd.debian.copyright": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.dmclientscript": { + source: "iana" + }, + "text/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "text/vnd.esmertec.theme-descriptor": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.exchangeable": { + source: "iana" + }, + "text/vnd.familysearch.gedcom": { + source: "iana", + extensions: ["ged"] + }, + "text/vnd.ficlab.flt": { + source: "iana" + }, + "text/vnd.fly": { + source: "iana", + extensions: ["fly"] + }, + "text/vnd.fmi.flexstor": { + source: "iana", + extensions: ["flx"] + }, + "text/vnd.gml": { + source: "iana" + }, + "text/vnd.graphviz": { + source: "iana", + extensions: ["gv"] + }, + "text/vnd.hans": { + source: "iana" + }, + "text/vnd.hgl": { + source: "iana" + }, + "text/vnd.in3d.3dml": { + source: "iana", + extensions: ["3dml"] + }, + "text/vnd.in3d.spot": { + source: "iana", + extensions: ["spot"] + }, + "text/vnd.iptc.newsml": { + source: "iana" + }, + "text/vnd.iptc.nitf": { + source: "iana" + }, + "text/vnd.latex-z": { + source: "iana" + }, + "text/vnd.motorola.reflex": { + source: "iana" + }, + "text/vnd.ms-mediapackage": { + source: "iana" + }, + "text/vnd.net2phone.commcenter.command": { + source: "iana" + }, + "text/vnd.radisys.msml-basic-layout": { + source: "iana" + }, + "text/vnd.senx.warpscript": { + source: "iana" + }, + "text/vnd.si.uricatalogue": { + source: "apache" + }, + "text/vnd.sosi": { + source: "iana" + }, + "text/vnd.sun.j2me.app-descriptor": { + source: "iana", + charset: "UTF-8", + extensions: ["jad"] + }, + "text/vnd.trolltech.linguist": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.vcf": { + source: "iana" + }, + "text/vnd.wap.si": { + source: "iana" + }, + "text/vnd.wap.sl": { + source: "iana" + }, + "text/vnd.wap.wml": { + source: "iana", + extensions: ["wml"] + }, + "text/vnd.wap.wmlscript": { + source: "iana", + extensions: ["wmls"] + }, + "text/vnd.zoo.kcl": { + source: "iana" + }, + "text/vtt": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["vtt"] + }, + "text/wgsl": { + source: "iana", + extensions: ["wgsl"] + }, + "text/x-asm": { + source: "apache", + extensions: ["s", "asm"] + }, + "text/x-c": { + source: "apache", + extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] + }, + "text/x-component": { + source: "nginx", + extensions: ["htc"] + }, + "text/x-fortran": { + source: "apache", + extensions: ["f", "for", "f77", "f90"] + }, + "text/x-gwt-rpc": { + compressible: true + }, + "text/x-handlebars-template": { + extensions: ["hbs"] + }, + "text/x-java-source": { + source: "apache", + extensions: ["java"] + }, + "text/x-jquery-tmpl": { + compressible: true + }, + "text/x-lua": { + extensions: ["lua"] + }, + "text/x-markdown": { + compressible: true, + extensions: ["mkd"] + }, + "text/x-nfo": { + source: "apache", + extensions: ["nfo"] + }, + "text/x-opml": { + source: "apache", + extensions: ["opml"] + }, + "text/x-org": { + compressible: true, + extensions: ["org"] + }, + "text/x-pascal": { + source: "apache", + extensions: ["p", "pas"] + }, + "text/x-processing": { + compressible: true, + extensions: ["pde"] + }, + "text/x-sass": { + extensions: ["sass"] + }, + "text/x-scss": { + extensions: ["scss"] + }, + "text/x-setext": { + source: "apache", + extensions: ["etx"] + }, + "text/x-sfv": { + source: "apache", + extensions: ["sfv"] + }, + "text/x-suse-ymp": { + compressible: true, + extensions: ["ymp"] + }, + "text/x-uuencode": { + source: "apache", + extensions: ["uu"] + }, + "text/x-vcalendar": { + source: "apache", + extensions: ["vcs"] + }, + "text/x-vcard": { + source: "apache", + extensions: ["vcf"] + }, + "text/xml": { + source: "iana", + compressible: true, + extensions: ["xml"] + }, + "text/xml-external-parsed-entity": { + source: "iana" + }, + "text/yaml": { + compressible: true, + extensions: ["yaml", "yml"] + }, + "video/1d-interleaved-parityfec": { + source: "iana" + }, + "video/3gpp": { + source: "iana", + extensions: ["3gp", "3gpp"] + }, + "video/3gpp-tt": { + source: "iana" + }, + "video/3gpp2": { + source: "iana", + extensions: ["3g2"] + }, + "video/av1": { + source: "iana" + }, + "video/bmpeg": { + source: "iana" + }, + "video/bt656": { + source: "iana" + }, + "video/celb": { + source: "iana" + }, + "video/dv": { + source: "iana" + }, + "video/encaprtp": { + source: "iana" + }, + "video/evc": { + source: "iana" + }, + "video/ffv1": { + source: "iana" + }, + "video/flexfec": { + source: "iana" + }, + "video/h261": { + source: "iana", + extensions: ["h261"] + }, + "video/h263": { + source: "iana", + extensions: ["h263"] + }, + "video/h263-1998": { + source: "iana" + }, + "video/h263-2000": { + source: "iana" + }, + "video/h264": { + source: "iana", + extensions: ["h264"] + }, + "video/h264-rcdo": { + source: "iana" + }, + "video/h264-svc": { + source: "iana" + }, + "video/h265": { + source: "iana" + }, + "video/h266": { + source: "iana" + }, + "video/iso.segment": { + source: "iana", + extensions: ["m4s"] + }, + "video/jpeg": { + source: "iana", + extensions: ["jpgv"] + }, + "video/jpeg2000": { + source: "iana" + }, + "video/jpm": { + source: "apache", + extensions: ["jpm", "jpgm"] + }, + "video/jxsv": { + source: "iana" + }, + "video/lottie+json": { + source: "iana", + compressible: true + }, + "video/matroska": { + source: "iana" + }, + "video/matroska-3d": { + source: "iana" + }, + "video/mj2": { + source: "iana", + extensions: ["mj2", "mjp2"] + }, + "video/mp1s": { + source: "iana" + }, + "video/mp2p": { + source: "iana" + }, + "video/mp2t": { + source: "iana", + extensions: ["ts", "m2t", "m2ts", "mts"] + }, + "video/mp4": { + source: "iana", + compressible: false, + extensions: ["mp4", "mp4v", "mpg4"] + }, + "video/mp4v-es": { + source: "iana" + }, + "video/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"] + }, + "video/mpeg4-generic": { + source: "iana" + }, + "video/mpv": { + source: "iana" + }, + "video/nv": { + source: "iana" + }, + "video/ogg": { + source: "iana", + compressible: false, + extensions: ["ogv"] + }, + "video/parityfec": { + source: "iana" + }, + "video/pointer": { + source: "iana" + }, + "video/quicktime": { + source: "iana", + compressible: false, + extensions: ["qt", "mov"] + }, + "video/raptorfec": { + source: "iana" + }, + "video/raw": { + source: "iana" + }, + "video/rtp-enc-aescm128": { + source: "iana" + }, + "video/rtploopback": { + source: "iana" + }, + "video/rtx": { + source: "iana" + }, + "video/scip": { + source: "iana" + }, + "video/smpte291": { + source: "iana" + }, + "video/smpte292m": { + source: "iana" + }, + "video/ulpfec": { + source: "iana" + }, + "video/vc1": { + source: "iana" + }, + "video/vc2": { + source: "iana" + }, + "video/vnd.cctv": { + source: "iana" + }, + "video/vnd.dece.hd": { + source: "iana", + extensions: ["uvh", "uvvh"] + }, + "video/vnd.dece.mobile": { + source: "iana", + extensions: ["uvm", "uvvm"] + }, + "video/vnd.dece.mp4": { + source: "iana" + }, + "video/vnd.dece.pd": { + source: "iana", + extensions: ["uvp", "uvvp"] + }, + "video/vnd.dece.sd": { + source: "iana", + extensions: ["uvs", "uvvs"] + }, + "video/vnd.dece.video": { + source: "iana", + extensions: ["uvv", "uvvv"] + }, + "video/vnd.directv.mpeg": { + source: "iana" + }, + "video/vnd.directv.mpeg-tts": { + source: "iana" + }, + "video/vnd.dlna.mpeg-tts": { + source: "iana" + }, + "video/vnd.dvb.file": { + source: "iana", + extensions: ["dvb"] + }, + "video/vnd.fvt": { + source: "iana", + extensions: ["fvt"] + }, + "video/vnd.hns.video": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.ttsavc": { + source: "iana" + }, + "video/vnd.iptvforum.ttsmpeg2": { + source: "iana" + }, + "video/vnd.motorola.video": { + source: "iana" + }, + "video/vnd.motorola.videop": { + source: "iana" + }, + "video/vnd.mpegurl": { + source: "iana", + extensions: ["mxu", "m4u"] + }, + "video/vnd.ms-playready.media.pyv": { + source: "iana", + extensions: ["pyv"] + }, + "video/vnd.nokia.interleaved-multimedia": { + source: "iana" + }, + "video/vnd.nokia.mp4vr": { + source: "iana" + }, + "video/vnd.nokia.videovoip": { + source: "iana" + }, + "video/vnd.objectvideo": { + source: "iana" + }, + "video/vnd.planar": { + source: "iana" + }, + "video/vnd.radgamettools.bink": { + source: "iana" + }, + "video/vnd.radgamettools.smacker": { + source: "apache" + }, + "video/vnd.sealed.mpeg1": { + source: "iana" + }, + "video/vnd.sealed.mpeg4": { + source: "iana" + }, + "video/vnd.sealed.swf": { + source: "iana" + }, + "video/vnd.sealedmedia.softseal.mov": { + source: "iana" + }, + "video/vnd.uvvu.mp4": { + source: "iana", + extensions: ["uvu", "uvvu"] + }, + "video/vnd.vivo": { + source: "iana", + extensions: ["viv"] + }, + "video/vnd.youtube.yt": { + source: "iana" + }, + "video/vp8": { + source: "iana" + }, + "video/vp9": { + source: "iana" + }, + "video/webm": { + source: "apache", + compressible: false, + extensions: ["webm"] + }, + "video/x-f4v": { + source: "apache", + extensions: ["f4v"] + }, + "video/x-fli": { + source: "apache", + extensions: ["fli"] + }, + "video/x-flv": { + source: "apache", + compressible: false, + extensions: ["flv"] + }, + "video/x-m4v": { + source: "apache", + extensions: ["m4v"] + }, + "video/x-matroska": { + source: "apache", + compressible: false, + extensions: ["mkv", "mk3d", "mks"] + }, + "video/x-mng": { + source: "apache", + extensions: ["mng"] + }, + "video/x-ms-asf": { + source: "apache", + extensions: ["asf", "asx"] + }, + "video/x-ms-vob": { + source: "apache", + extensions: ["vob"] + }, + "video/x-ms-wm": { + source: "apache", + extensions: ["wm"] + }, + "video/x-ms-wmv": { + source: "apache", + compressible: false, + extensions: ["wmv"] + }, + "video/x-ms-wmx": { + source: "apache", + extensions: ["wmx"] + }, + "video/x-ms-wvx": { + source: "apache", + extensions: ["wvx"] + }, + "video/x-msvideo": { + source: "apache", + extensions: ["avi"] + }, + "video/x-sgi-movie": { + source: "apache", + extensions: ["movie"] + }, + "video/x-smv": { + source: "apache", + extensions: ["smv"] + }, + "x-conference/x-cooltalk": { + source: "apache", + extensions: ["ice"] + }, + "x-shader/x-fragment": { + compressible: true + }, + "x-shader/x-vertex": { + compressible: true + } + }; + } +}); +var require_mime_db4 = __commonJS2({ + "node_modules/send/node_modules/mime-db/index.js"(exports2, module2) { + module2.exports = require_db4(); + } +}); +var require_mimeScore4 = __commonJS2({ + "node_modules/send/node_modules/mime-types/mimeScore.js"(exports2, module2) { + var FACET_SCORES = { + "prs.": 100, + "x-": 200, + "x.": 300, + "vnd.": 400, + default: 900 + }; + var SOURCE_SCORES = { + nginx: 10, + apache: 20, + iana: 40, + default: 30 + // definitions added by `jshttp/mime-db` project? + }; + var TYPE_SCORES = { + // prefer application/xml over text/xml + // prefer application/rtf over text/rtf + application: 1, + // prefer font/woff over application/font-woff + font: 2, + default: 0 + }; + module2.exports = function mimeScore(mimeType, source = "default") { + if (mimeType === "application/octet-stream") { + return 0; + } + const [type, subtype] = mimeType.split("/"); + const facet = subtype.replace(/(\.|x-).*/, "$1"); + const facetScore = FACET_SCORES[facet] || FACET_SCORES.default; + const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default; + const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default; + const lengthScore = 1 - mimeType.length / 100; + return facetScore + sourceScore + typeScore + lengthScore; + }; + } +}); +var require_mime_types4 = __commonJS2({ + "node_modules/send/node_modules/mime-types/index.js"(exports2) { + "use strict"; + var db = require_mime_db4(); + var extname = require("path").extname; + var mimeScore = require_mimeScore4(); + var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/; + var TEXT_TYPE_REGEXP = /^text\//i; + exports2.charset = charset; + exports2.charsets = { lookup: charset }; + exports2.contentType = contentType2; + exports2.extension = extension; + exports2.extensions = /* @__PURE__ */ Object.create(null); + exports2.lookup = lookup; + exports2.types = /* @__PURE__ */ Object.create(null); + exports2._extensionConflicts = []; + populateMaps(exports2.extensions, exports2.types); + function charset(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var mime = match && db[match[1].toLowerCase()]; + if (mime && mime.charset) { + return mime.charset; + } + if (match && TEXT_TYPE_REGEXP.test(match[1])) { + return "UTF-8"; + } + return false; + } + function contentType2(str) { + if (!str || typeof str !== "string") { + return false; + } + var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str; + if (!mime) { + return false; + } + if (mime.indexOf("charset") === -1) { + var charset2 = exports2.charset(mime); + if (charset2) mime += "; charset=" + charset2.toLowerCase(); + } + return mime; + } + function extension(type) { + if (!type || typeof type !== "string") { + return false; + } + var match = EXTRACT_TYPE_REGEXP.exec(type); + var exts = match && exports2.extensions[match[1].toLowerCase()]; + if (!exts || !exts.length) { + return false; + } + return exts[0]; + } + function lookup(path) { + if (!path || typeof path !== "string") { + return false; + } + var extension2 = extname("x." + path).toLowerCase().slice(1); + if (!extension2) { + return false; + } + return exports2.types[extension2] || false; + } + function populateMaps(extensions, types) { + Object.keys(db).forEach(function forEachMimeType(type) { + var mime = db[type]; + var exts = mime.extensions; + if (!exts || !exts.length) { + return; + } + extensions[type] = exts; + for (var i = 0; i < exts.length; i++) { + var extension2 = exts[i]; + types[extension2] = _preferredType(extension2, types[extension2], type); + const legacyType = _preferredTypeLegacy( + extension2, + types[extension2], + type + ); + if (legacyType !== types[extension2]) { + exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]); + } + } + }); + } + function _preferredType(ext, type0, type1) { + var score0 = type0 ? mimeScore(type0, db[type0].source) : 0; + var score1 = type1 ? mimeScore(type1, db[type1].source) : 0; + return score0 > score1 ? type0 : type1; + } + function _preferredTypeLegacy(ext, type0, type1) { + var SOURCE_RANK = ["nginx", "apache", void 0, "iana"]; + var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0; + var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0; + if (exports2.types[extension] !== "application/octet-stream" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === "application/")) { + return type0; + } + return score0 > score1 ? type0 : type1; + } + } +}); +var require_send = __commonJS2({ + "node_modules/send/index.js"(exports2, module2) { + "use strict"; + var createError = require_http_errors(); + var debug = require_src()("send"); + var encodeUrl = require_encodeurl(); + var escapeHtml = require_escape_html(); + var etag = require_etag(); + var fresh = require_fresh(); + var fs = require("fs"); + var mime = require_mime_types4(); + var ms = require_ms(); + var onFinished = require_on_finished(); + var parseRange = require_range_parser(); + var path = require("path"); + var statuses = require_statuses(); + var Stream = require("stream"); + var util22 = require("util"); + var extname = path.extname; + var join = path.join; + var normalize = path.normalize; + var resolve = path.resolve; + var sep = path.sep; + var BYTES_RANGE_REGEXP = /^ *bytes=/; + var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3; + var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/; + module2.exports = send; + function send(req, path2, options) { + return new SendStream(req, path2, options); + } + function SendStream(req, path2, options) { + Stream.call(this); + var opts = options || {}; + this.options = opts; + this.path = path2; + this.req = req; + this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true; + this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true; + this._etag = opts.etag !== void 0 ? Boolean(opts.etag) : true; + this._dotfiles = opts.dotfiles !== void 0 ? opts.dotfiles : "ignore"; + if (this._dotfiles !== "ignore" && this._dotfiles !== "allow" && this._dotfiles !== "deny") { + throw new TypeError('dotfiles option must be "allow", "deny", or "ignore"'); + } + this._extensions = opts.extensions !== void 0 ? normalizeList(opts.extensions, "extensions option") : []; + this._immutable = opts.immutable !== void 0 ? Boolean(opts.immutable) : false; + this._index = opts.index !== void 0 ? normalizeList(opts.index, "index option") : ["index.html"]; + this._lastModified = opts.lastModified !== void 0 ? Boolean(opts.lastModified) : true; + this._maxage = opts.maxAge || opts.maxage; + this._maxage = typeof this._maxage === "string" ? ms(this._maxage) : Number(this._maxage); + this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0; + this._root = opts.root ? resolve(opts.root) : null; + } + util22.inherits(SendStream, Stream); + SendStream.prototype.error = function error(status, err2) { + if (hasListeners(this, "error")) { + return this.emit("error", createHttpError(status, err2)); + } + var res = this.res; + var msg = statuses.message[status] || String(status); + var doc = createHtmlDocument("Error", escapeHtml(msg)); + clearHeaders(res); + if (err2 && err2.headers) { + setHeaders(res, err2.headers); + } + res.statusCode = status; + res.setHeader("Content-Type", "text/html; charset=UTF-8"); + res.setHeader("Content-Length", Buffer.byteLength(doc)); + res.setHeader("Content-Security-Policy", "default-src 'none'"); + res.setHeader("X-Content-Type-Options", "nosniff"); + res.end(doc); + }; + SendStream.prototype.hasTrailingSlash = function hasTrailingSlash() { + return this.path[this.path.length - 1] === "/"; + }; + SendStream.prototype.isConditionalGET = function isConditionalGET() { + return this.req.headers["if-match"] || this.req.headers["if-unmodified-since"] || this.req.headers["if-none-match"] || this.req.headers["if-modified-since"]; + }; + SendStream.prototype.isPreconditionFailure = function isPreconditionFailure() { + var req = this.req; + var res = this.res; + var match = req.headers["if-match"]; + if (match) { + var etag2 = res.getHeader("ETag"); + return !etag2 || match !== "*" && parseTokenList(match).every(function(match2) { + return match2 !== etag2 && match2 !== "W/" + etag2 && "W/" + match2 !== etag2; + }); + } + var unmodifiedSince = parseHttpDate(req.headers["if-unmodified-since"]); + if (!isNaN(unmodifiedSince)) { + var lastModified = parseHttpDate(res.getHeader("Last-Modified")); + return isNaN(lastModified) || lastModified > unmodifiedSince; + } + return false; + }; + SendStream.prototype.removeContentHeaderFields = function removeContentHeaderFields() { + var res = this.res; + res.removeHeader("Content-Encoding"); + res.removeHeader("Content-Language"); + res.removeHeader("Content-Length"); + res.removeHeader("Content-Range"); + res.removeHeader("Content-Type"); + }; + SendStream.prototype.notModified = function notModified() { + var res = this.res; + debug("not modified"); + this.removeContentHeaderFields(); + res.statusCode = 304; + res.end(); + }; + SendStream.prototype.headersAlreadySent = function headersAlreadySent() { + var err2 = new Error("Can't set headers after they are sent."); + debug("headers already sent"); + this.error(500, err2); + }; + SendStream.prototype.isCachable = function isCachable() { + var statusCode = this.res.statusCode; + return statusCode >= 200 && statusCode < 300 || statusCode === 304; + }; + SendStream.prototype.onStatError = function onStatError(error) { + switch (error.code) { + case "ENAMETOOLONG": + case "ENOENT": + case "ENOTDIR": + this.error(404, error); + break; + default: + this.error(500, error); + break; + } + }; + SendStream.prototype.isFresh = function isFresh() { + return fresh(this.req.headers, { + etag: this.res.getHeader("ETag"), + "last-modified": this.res.getHeader("Last-Modified") + }); + }; + SendStream.prototype.isRangeFresh = function isRangeFresh() { + var ifRange = this.req.headers["if-range"]; + if (!ifRange) { + return true; + } + if (ifRange.indexOf('"') !== -1) { + var etag2 = this.res.getHeader("ETag"); + return Boolean(etag2 && ifRange.indexOf(etag2) !== -1); + } + var lastModified = this.res.getHeader("Last-Modified"); + return parseHttpDate(lastModified) <= parseHttpDate(ifRange); + }; + SendStream.prototype.redirect = function redirect(path2) { + var res = this.res; + if (hasListeners(this, "directory")) { + this.emit("directory", res, path2); + return; + } + if (this.hasTrailingSlash()) { + this.error(403); + return; + } + var loc = encodeUrl(collapseLeadingSlashes(this.path + "/")); + var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc)); + res.statusCode = 301; + res.setHeader("Content-Type", "text/html; charset=UTF-8"); + res.setHeader("Content-Length", Buffer.byteLength(doc)); + res.setHeader("Content-Security-Policy", "default-src 'none'"); + res.setHeader("X-Content-Type-Options", "nosniff"); + res.setHeader("Location", loc); + res.end(doc); + }; + SendStream.prototype.pipe = function pipe(res) { + var root = this._root; + this.res = res; + var path2 = decode(this.path); + if (path2 === -1) { + this.error(400); + return res; + } + if (~path2.indexOf("\0")) { + this.error(400); + return res; + } + var parts; + if (root !== null) { + if (path2) { + path2 = normalize("." + sep + path2); + } + if (UP_PATH_REGEXP.test(path2)) { + debug('malicious path "%s"', path2); + this.error(403); + return res; + } + parts = path2.split(sep); + path2 = normalize(join(root, path2)); + } else { + if (UP_PATH_REGEXP.test(path2)) { + debug('malicious path "%s"', path2); + this.error(403); + return res; + } + parts = normalize(path2).split(sep); + path2 = resolve(path2); + } + if (containsDotFile(parts)) { + debug('%s dotfile "%s"', this._dotfiles, path2); + switch (this._dotfiles) { + case "allow": + break; + case "deny": + this.error(403); + return res; + case "ignore": + default: + this.error(404); + return res; + } + } + if (this._index.length && this.hasTrailingSlash()) { + this.sendIndex(path2); + return res; + } + this.sendFile(path2); + return res; + }; + SendStream.prototype.send = function send2(path2, stat) { + var len = stat.size; + var options = this.options; + var opts = {}; + var res = this.res; + var req = this.req; + var ranges = req.headers.range; + var offset = options.start || 0; + if (res.headersSent) { + this.headersAlreadySent(); + return; + } + debug('pipe "%s"', path2); + this.setHeader(path2, stat); + this.type(path2); + if (this.isConditionalGET()) { + if (this.isPreconditionFailure()) { + this.error(412); + return; + } + if (this.isCachable() && this.isFresh()) { + this.notModified(); + return; + } + } + len = Math.max(0, len - offset); + if (options.end !== void 0) { + var bytes = options.end - offset + 1; + if (len > bytes) len = bytes; + } + if (this._acceptRanges && BYTES_RANGE_REGEXP.test(ranges)) { + ranges = parseRange(len, ranges, { + combine: true + }); + if (!this.isRangeFresh()) { + debug("range stale"); + ranges = -2; + } + if (ranges === -1) { + debug("range unsatisfiable"); + res.setHeader("Content-Range", contentRange("bytes", len)); + return this.error(416, { + headers: { "Content-Range": res.getHeader("Content-Range") } + }); + } + if (ranges !== -2 && ranges.length === 1) { + debug("range %j", ranges); + res.statusCode = 206; + res.setHeader("Content-Range", contentRange("bytes", len, ranges[0])); + offset += ranges[0].start; + len = ranges[0].end - ranges[0].start + 1; + } + } + for (var prop in options) { + opts[prop] = options[prop]; + } + opts.start = offset; + opts.end = Math.max(offset, offset + len - 1); + res.setHeader("Content-Length", len); + if (req.method === "HEAD") { + res.end(); + return; + } + this.stream(path2, opts); + }; + SendStream.prototype.sendFile = function sendFile(path2) { + var i = 0; + var self2 = this; + debug('stat "%s"', path2); + fs.stat(path2, function onstat(err2, stat) { + var pathEndsWithSep = path2[path2.length - 1] === sep; + if (err2 && err2.code === "ENOENT" && !extname(path2) && !pathEndsWithSep) { + return next(err2); + } + if (err2) return self2.onStatError(err2); + if (stat.isDirectory()) return self2.redirect(path2); + if (pathEndsWithSep) return self2.error(404); + self2.emit("file", path2, stat); + self2.send(path2, stat); + }); + function next(err2) { + if (self2._extensions.length <= i) { + return err2 ? self2.onStatError(err2) : self2.error(404); + } + var p = path2 + "." + self2._extensions[i++]; + debug('stat "%s"', p); + fs.stat(p, function(err3, stat) { + if (err3) return next(err3); + if (stat.isDirectory()) return next(); + self2.emit("file", p, stat); + self2.send(p, stat); + }); + } + }; + SendStream.prototype.sendIndex = function sendIndex(path2) { + var i = -1; + var self2 = this; + function next(err2) { + if (++i >= self2._index.length) { + if (err2) return self2.onStatError(err2); + return self2.error(404); + } + var p = join(path2, self2._index[i]); + debug('stat "%s"', p); + fs.stat(p, function(err3, stat) { + if (err3) return next(err3); + if (stat.isDirectory()) return next(); + self2.emit("file", p, stat); + self2.send(p, stat); + }); + } + next(); + }; + SendStream.prototype.stream = function stream(path2, options) { + var self2 = this; + var res = this.res; + var stream2 = fs.createReadStream(path2, options); + this.emit("stream", stream2); + stream2.pipe(res); + function cleanup() { + stream2.destroy(); + } + onFinished(res, cleanup); + stream2.on("error", function onerror(err2) { + cleanup(); + self2.onStatError(err2); + }); + stream2.on("end", function onend() { + self2.emit("end"); + }); + }; + SendStream.prototype.type = function type(path2) { + var res = this.res; + if (res.getHeader("Content-Type")) return; + var ext = extname(path2); + var type2 = mime.contentType(ext) || "application/octet-stream"; + debug("content-type %s", type2); + res.setHeader("Content-Type", type2); + }; + SendStream.prototype.setHeader = function setHeader(path2, stat) { + var res = this.res; + this.emit("headers", res, path2, stat); + if (this._acceptRanges && !res.getHeader("Accept-Ranges")) { + debug("accept ranges"); + res.setHeader("Accept-Ranges", "bytes"); + } + if (this._cacheControl && !res.getHeader("Cache-Control")) { + var cacheControl = "public, max-age=" + Math.floor(this._maxage / 1e3); + if (this._immutable) { + cacheControl += ", immutable"; + } + debug("cache-control %s", cacheControl); + res.setHeader("Cache-Control", cacheControl); + } + if (this._lastModified && !res.getHeader("Last-Modified")) { + var modified = stat.mtime.toUTCString(); + debug("modified %s", modified); + res.setHeader("Last-Modified", modified); + } + if (this._etag && !res.getHeader("ETag")) { + var val = etag(stat); + debug("etag %s", val); + res.setHeader("ETag", val); + } + }; + function clearHeaders(res) { + for (const header of res.getHeaderNames()) { + res.removeHeader(header); + } + } + function collapseLeadingSlashes(str) { + for (var i = 0; i < str.length; i++) { + if (str[i] !== "/") { + break; + } + } + return i > 1 ? "/" + str.substr(i) : str; + } + function containsDotFile(parts) { + for (var i = 0; i < parts.length; i++) { + var part = parts[i]; + if (part.length > 1 && part[0] === ".") { + return true; + } + } + return false; + } + function contentRange(type, size, range) { + return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size; + } + function createHtmlDocument(title, body) { + return '\n\n\n\n' + title + "\n\n\n
" + body + "
\n\n\n"; + } + function createHttpError(status, err2) { + if (!err2) { + return createError(status); + } + return err2 instanceof Error ? createError(status, err2, { expose: false }) : createError(status, err2); + } + function decode(path2) { + try { + return decodeURIComponent(path2); + } catch (err2) { + return -1; + } + } + function hasListeners(emitter, type) { + var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type); + return count > 0; + } + function normalizeList(val, name) { + var list = [].concat(val || []); + for (var i = 0; i < list.length; i++) { + if (typeof list[i] !== "string") { + throw new TypeError(name + " must be array of strings or false"); + } + } + return list; + } + function parseHttpDate(date) { + var timestamp = date && Date.parse(date); + return typeof timestamp === "number" ? timestamp : NaN; + } + function parseTokenList(str) { + var end = 0; + var list = []; + var start = 0; + for (var i = 0, len = str.length; i < len; i++) { + switch (str.charCodeAt(i)) { + case 32: + if (start === end) { + start = end = i + 1; + } + break; + case 44: + if (start !== end) { + list.push(str.substring(start, end)); + } + start = end = i + 1; + break; + default: + end = i + 1; + break; + } + } + if (start !== end) { + list.push(str.substring(start, end)); + } + return list; + } + function setHeaders(res, headers) { + var keys = Object.keys(headers); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + res.setHeader(key, headers[key]); + } + } + } +}); +var require_vary = __commonJS2({ + "node_modules/vary/index.js"(exports2, module2) { + "use strict"; + module2.exports = vary; + module2.exports.append = append; + var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; + function append(header, field) { + if (typeof header !== "string") { + throw new TypeError("header argument is required"); + } + if (!field) { + throw new TypeError("field argument is required"); + } + var fields = !Array.isArray(field) ? parse(String(field)) : field; + for (var j = 0; j < fields.length; j++) { + if (!FIELD_NAME_REGEXP.test(fields[j])) { + throw new TypeError("field argument contains an invalid header name"); + } + } + if (header === "*") { + return header; + } + var val = header; + var vals = parse(header.toLowerCase()); + if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) { + return "*"; + } + for (var i = 0; i < fields.length; i++) { + var fld = fields[i].toLowerCase(); + if (vals.indexOf(fld) === -1) { + vals.push(fld); + val = val ? val + ", " + fields[i] : fields[i]; + } + } + return val; + } + function parse(header) { + var end = 0; + var list = []; + var start = 0; + for (var i = 0, len = header.length; i < len; i++) { + switch (header.charCodeAt(i)) { + case 32: + if (start === end) { + start = end = i + 1; + } + break; + case 44: + list.push(header.substring(start, end)); + start = end = i + 1; + break; + default: + end = i + 1; + break; + } + } + list.push(header.substring(start, end)); + return list; + } + function vary(res, field) { + if (!res || !res.getHeader || !res.setHeader) { + throw new TypeError("res argument is required"); + } + var val = res.getHeader("Vary") || ""; + var header = Array.isArray(val) ? val.join(", ") : String(val); + if (val = append(header, field)) { + res.setHeader("Vary", val); + } + } + } +}); +var require_response = __commonJS2({ + "node_modules/express/lib/response.js"(exports2, module2) { + "use strict"; + var contentDisposition = require_content_disposition(); + var createError = require_http_errors(); + var encodeUrl = require_encodeurl(); + var escapeHtml = require_escape_html(); + var http = require("node:http"); + var onFinished = require_on_finished(); + var mime = require_mime_types2(); + var path = require("node:path"); + var pathIsAbsolute = require("node:path").isAbsolute; + var statuses = require_statuses(); + var sign = require_cookie_signature().sign; + var normalizeType = require_utils3().normalizeType; + var normalizeTypes = require_utils3().normalizeTypes; + var setCharset = require_utils3().setCharset; + var cookie = require_cookie(); + var send = require_send(); + var extname = path.extname; + var resolve = path.resolve; + var vary = require_vary(); + var res = Object.create(http.ServerResponse.prototype); + module2.exports = res; + res.status = function status(code) { + if (!Number.isInteger(code)) { + throw new TypeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be an integer.`); + } + if (code < 100 || code > 999) { + throw new RangeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be greater than 99 and less than 1000.`); + } + this.statusCode = code; + return this; + }; + res.links = function(links) { + var link = this.get("Link") || ""; + if (link) link += ", "; + return this.set("Link", link + Object.keys(links).map(function(rel) { + if (Array.isArray(links[rel])) { + return links[rel].map(function(singleLink) { + return `<${singleLink}>; rel="${rel}"`; + }).join(", "); + } else { + return `<${links[rel]}>; rel="${rel}"`; + } + }).join(", ")); + }; + res.send = function send2(body) { + var chunk = body; + var encoding; + var req = this.req; + var type; + var app = this.app; + switch (typeof chunk) { + // string defaulting to html + case "string": + if (!this.get("Content-Type")) { + this.type("html"); + } + break; + case "boolean": + case "number": + case "object": + if (chunk === null) { + chunk = ""; + } else if (ArrayBuffer.isView(chunk)) { + if (!this.get("Content-Type")) { + this.type("bin"); + } + } else { + return this.json(chunk); + } + break; + } + if (typeof chunk === "string") { + encoding = "utf8"; + type = this.get("Content-Type"); + if (typeof type === "string") { + this.set("Content-Type", setCharset(type, "utf-8")); + } + } + var etagFn = app.get("etag fn"); + var generateETag = !this.get("ETag") && typeof etagFn === "function"; + var len; + if (chunk !== void 0) { + if (Buffer.isBuffer(chunk)) { + len = chunk.length; + } else if (!generateETag && chunk.length < 1e3) { + len = Buffer.byteLength(chunk, encoding); + } else { + chunk = Buffer.from(chunk, encoding); + encoding = void 0; + len = chunk.length; + } + this.set("Content-Length", len); + } + var etag; + if (generateETag && len !== void 0) { + if (etag = etagFn(chunk, encoding)) { + this.set("ETag", etag); + } + } + if (req.fresh) this.status(304); + if (204 === this.statusCode || 304 === this.statusCode) { + this.removeHeader("Content-Type"); + this.removeHeader("Content-Length"); + this.removeHeader("Transfer-Encoding"); + chunk = ""; + } + if (this.statusCode === 205) { + this.set("Content-Length", "0"); + this.removeHeader("Transfer-Encoding"); + chunk = ""; + } + if (req.method === "HEAD") { + this.end(); + } else { + this.end(chunk, encoding); + } + return this; + }; + res.json = function json(obj) { + var app = this.app; + var escape2 = app.get("json escape"); + var replacer = app.get("json replacer"); + var spaces = app.get("json spaces"); + var body = stringify(obj, replacer, spaces, escape2); + if (!this.get("Content-Type")) { + this.set("Content-Type", "application/json"); + } + return this.send(body); + }; + res.jsonp = function jsonp(obj) { + var app = this.app; + var escape2 = app.get("json escape"); + var replacer = app.get("json replacer"); + var spaces = app.get("json spaces"); + var body = stringify(obj, replacer, spaces, escape2); + var callback = this.req.query[app.get("jsonp callback name")]; + if (!this.get("Content-Type")) { + this.set("X-Content-Type-Options", "nosniff"); + this.set("Content-Type", "application/json"); + } + if (Array.isArray(callback)) { + callback = callback[0]; + } + if (typeof callback === "string" && callback.length !== 0) { + this.set("X-Content-Type-Options", "nosniff"); + this.set("Content-Type", "text/javascript"); + callback = callback.replace(/[^\[\]\w$.]/g, ""); + if (body === void 0) { + body = ""; + } else if (typeof body === "string") { + body = body.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029"); + } + body = "/**/ typeof " + callback + " === 'function' && " + callback + "(" + body + ");"; + } + return this.send(body); + }; + res.sendStatus = function sendStatus(statusCode) { + var body = statuses.message[statusCode] || String(statusCode); + this.status(statusCode); + this.type("txt"); + return this.send(body); + }; + res.sendFile = function sendFile(path2, options, callback) { + var done = callback; + var req = this.req; + var res2 = this; + var next = req.next; + var opts = options || {}; + if (!path2) { + throw new TypeError("path argument is required to res.sendFile"); + } + if (typeof path2 !== "string") { + throw new TypeError("path must be a string to res.sendFile"); + } + if (typeof options === "function") { + done = options; + opts = {}; + } + if (!opts.root && !pathIsAbsolute(path2)) { + throw new TypeError("path must be absolute or specify root to res.sendFile"); + } + var pathname = encodeURI(path2); + opts.etag = this.app.enabled("etag"); + var file = send(req, pathname, opts); + sendfile(res2, file, opts, function(err2) { + if (done) return done(err2); + if (err2 && err2.code === "EISDIR") return next(); + if (err2 && err2.code !== "ECONNABORTED" && err2.syscall !== "write") { + next(err2); + } + }); + }; + res.download = function download(path2, filename, options, callback) { + var done = callback; + var name = filename; + var opts = options || null; + if (typeof filename === "function") { + done = filename; + name = null; + opts = null; + } else if (typeof options === "function") { + done = options; + opts = null; + } + if (typeof filename === "object" && (typeof options === "function" || options === void 0)) { + name = null; + opts = filename; + } + var headers = { + "Content-Disposition": contentDisposition(name || path2) + }; + if (opts && opts.headers) { + var keys = Object.keys(opts.headers); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (key.toLowerCase() !== "content-disposition") { + headers[key] = opts.headers[key]; + } + } + } + opts = Object.create(opts); + opts.headers = headers; + var fullPath = !opts.root ? resolve(path2) : path2; + return this.sendFile(fullPath, opts, done); + }; + res.contentType = res.type = function contentType2(type) { + var ct = type.indexOf("/") === -1 ? mime.contentType(type) || "application/octet-stream" : type; + return this.set("Content-Type", ct); + }; + res.format = function(obj) { + var req = this.req; + var next = req.next; + var keys = Object.keys(obj).filter(function(v) { + return v !== "default"; + }); + var key = keys.length > 0 ? req.accepts(keys) : false; + this.vary("Accept"); + if (key) { + this.set("Content-Type", normalizeType(key).value); + obj[key](req, this, next); + } else if (obj.default) { + obj.default(req, this, next); + } else { + next(createError(406, { + types: normalizeTypes(keys).map(function(o) { + return o.value; + }) + })); + } + return this; + }; + res.attachment = function attachment(filename) { + if (filename) { + this.type(extname(filename)); + } + this.set("Content-Disposition", contentDisposition(filename)); + return this; + }; + res.append = function append(field, val) { + var prev = this.get(field); + var value = val; + if (prev) { + value = Array.isArray(prev) ? prev.concat(val) : Array.isArray(val) ? [prev].concat(val) : [prev, val]; + } + return this.set(field, value); + }; + res.set = res.header = function header(field, val) { + if (arguments.length === 2) { + var value = Array.isArray(val) ? val.map(String) : String(val); + if (field.toLowerCase() === "content-type") { + if (Array.isArray(value)) { + throw new TypeError("Content-Type cannot be set to an Array"); + } + value = mime.contentType(value); + } + this.setHeader(field, value); + } else { + for (var key in field) { + this.set(key, field[key]); + } + } + return this; + }; + res.get = function(field) { + return this.getHeader(field); + }; + res.clearCookie = function clearCookie(name, options) { + const opts = { path: "/", ...options, expires: /* @__PURE__ */ new Date(1) }; + delete opts.maxAge; + return this.cookie(name, "", opts); + }; + res.cookie = function(name, value, options) { + var opts = { ...options }; + var secret = this.req.secret; + var signed = opts.signed; + if (signed && !secret) { + throw new Error('cookieParser("secret") required for signed cookies'); + } + var val = typeof value === "object" ? "j:" + JSON.stringify(value) : String(value); + if (signed) { + val = "s:" + sign(val, secret); + } + if (opts.maxAge != null) { + var maxAge = opts.maxAge - 0; + if (!isNaN(maxAge)) { + opts.expires = new Date(Date.now() + maxAge); + opts.maxAge = Math.floor(maxAge / 1e3); + } + } + if (opts.path == null) { + opts.path = "/"; + } + this.append("Set-Cookie", cookie.serialize(name, String(val), opts)); + return this; + }; + res.location = function location(url) { + return this.set("Location", encodeUrl(url)); + }; + res.redirect = function redirect(url) { + var address = url; + var body; + var status = 302; + if (arguments.length === 2) { + status = arguments[0]; + address = arguments[1]; + } + address = this.location(address).get("Location"); + this.format({ + text: function() { + body = statuses.message[status] + ". Redirecting to " + address; + }, + html: function() { + var u = escapeHtml(address); + body = "

" + statuses.message[status] + ". Redirecting to " + u + "

"; + }, + default: function() { + body = ""; + } + }); + this.status(status); + this.set("Content-Length", Buffer.byteLength(body)); + if (this.req.method === "HEAD") { + this.end(); + } else { + this.end(body); + } + }; + res.vary = function(field) { + vary(this, field); + return this; + }; + res.render = function render(view, options, callback) { + var app = this.req.app; + var done = callback; + var opts = options || {}; + var req = this.req; + var self2 = this; + if (typeof options === "function") { + done = options; + opts = {}; + } + opts._locals = self2.locals; + done = done || function(err2, str) { + if (err2) return req.next(err2); + self2.send(str); + }; + app.render(view, opts, done); + }; + function sendfile(res2, file, options, callback) { + var done = false; + var streaming; + function onaborted() { + if (done) return; + done = true; + var err2 = new Error("Request aborted"); + err2.code = "ECONNABORTED"; + callback(err2); + } + function ondirectory() { + if (done) return; + done = true; + var err2 = new Error("EISDIR, read"); + err2.code = "EISDIR"; + callback(err2); + } + function onerror(err2) { + if (done) return; + done = true; + callback(err2); + } + function onend() { + if (done) return; + done = true; + callback(); + } + function onfile() { + streaming = false; + } + function onfinish(err2) { + if (err2 && err2.code === "ECONNRESET") return onaborted(); + if (err2) return onerror(err2); + if (done) return; + setImmediate(function() { + if (streaming !== false && !done) { + onaborted(); + return; + } + if (done) return; + done = true; + callback(); + }); + } + function onstream() { + streaming = true; + } + file.on("directory", ondirectory); + file.on("end", onend); + file.on("error", onerror); + file.on("file", onfile); + file.on("stream", onstream); + onFinished(res2, onfinish); + if (options.headers) { + file.on("headers", function headers(res3) { + var obj = options.headers; + var keys = Object.keys(obj); + for (var i = 0; i < keys.length; i++) { + var k = keys[i]; + res3.setHeader(k, obj[k]); + } + }); + } + file.pipe(res2); + } + function stringify(value, replacer, spaces, escape2) { + var json = replacer || spaces ? JSON.stringify(value, replacer, spaces) : JSON.stringify(value); + if (escape2 && typeof json === "string") { + json = json.replace(/[<>&]/g, function(c) { + switch (c.charCodeAt(0)) { + case 60: + return "\\u003c"; + case 62: + return "\\u003e"; + case 38: + return "\\u0026"; + /* istanbul ignore next: unreachable default */ + default: + return c; + } + }); + } + return json; + } + } +}); +var require_serve_static = __commonJS2({ + "node_modules/serve-static/index.js"(exports2, module2) { + "use strict"; + var encodeUrl = require_encodeurl(); + var escapeHtml = require_escape_html(); + var parseUrl = require_parseurl(); + var resolve = require("path").resolve; + var send = require_send(); + var url = require("url"); + module2.exports = serveStatic; + function serveStatic(root, options) { + if (!root) { + throw new TypeError("root path required"); + } + if (typeof root !== "string") { + throw new TypeError("root path must be a string"); + } + var opts = Object.create(options || null); + var fallthrough = opts.fallthrough !== false; + var redirect = opts.redirect !== false; + var setHeaders = opts.setHeaders; + if (setHeaders && typeof setHeaders !== "function") { + throw new TypeError("option setHeaders must be function"); + } + opts.maxage = opts.maxage || opts.maxAge || 0; + opts.root = resolve(root); + var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener(); + return function serveStatic2(req, res, next) { + if (req.method !== "GET" && req.method !== "HEAD") { + if (fallthrough) { + return next(); + } + res.statusCode = 405; + res.setHeader("Allow", "GET, HEAD"); + res.setHeader("Content-Length", "0"); + res.end(); + return; + } + var forwardError = !fallthrough; + var originalUrl = parseUrl.original(req); + var path = parseUrl(req).pathname; + if (path === "/" && originalUrl.pathname.substr(-1) !== "/") { + path = ""; + } + var stream = send(req, path, opts); + stream.on("directory", onDirectory); + if (setHeaders) { + stream.on("headers", setHeaders); + } + if (fallthrough) { + stream.on("file", function onFile() { + forwardError = true; + }); + } + stream.on("error", function error(err2) { + if (forwardError || !(err2.statusCode < 500)) { + next(err2); + return; + } + next(); + }); + stream.pipe(res); + }; + } + function collapseLeadingSlashes(str) { + for (var i = 0; i < str.length; i++) { + if (str.charCodeAt(i) !== 47) { + break; + } + } + return i > 1 ? "/" + str.substr(i) : str; + } + function createHtmlDocument(title, body) { + return '\n\n\n\n' + title + "\n\n\n
" + body + "
\n\n\n"; + } + function createNotFoundDirectoryListener() { + return function notFound() { + this.error(404); + }; + } + function createRedirectDirectoryListener() { + return function redirect(res) { + if (this.hasTrailingSlash()) { + this.error(404); + return; + } + var originalUrl = parseUrl.original(this.req); + originalUrl.path = null; + originalUrl.pathname = collapseLeadingSlashes(originalUrl.pathname + "/"); + var loc = encodeUrl(url.format(originalUrl)); + var doc = createHtmlDocument("Redirecting", "Redirecting to " + escapeHtml(loc)); + res.statusCode = 301; + res.setHeader("Content-Type", "text/html; charset=UTF-8"); + res.setHeader("Content-Length", Buffer.byteLength(doc)); + res.setHeader("Content-Security-Policy", "default-src 'none'"); + res.setHeader("X-Content-Type-Options", "nosniff"); + res.setHeader("Location", loc); + res.end(doc); + }; + } + } +}); +var require_express = __commonJS2({ + "node_modules/express/lib/express.js"(exports2, module2) { + "use strict"; + var bodyParser = require_body_parser(); + var EventEmitter = require("node:events").EventEmitter; + var mixin = require_merge_descriptors(); + var proto2 = require_application(); + var Router = require_router(); + var req = require_request(); + var res = require_response(); + exports2 = module2.exports = createApplication; + function createApplication() { + var app = function(req2, res2, next) { + app.handle(req2, res2, next); + }; + mixin(app, EventEmitter.prototype, false); + mixin(app, proto2, false); + app.request = Object.create(req, { + app: { configurable: true, enumerable: true, writable: true, value: app } + }); + app.response = Object.create(res, { + app: { configurable: true, enumerable: true, writable: true, value: app } + }); + app.init(); + return app; + } + exports2.application = proto2; + exports2.request = req; + exports2.response = res; + exports2.Route = Router.Route; + exports2.Router = Router; + exports2.json = bodyParser.json; + exports2.raw = bodyParser.raw; + exports2.static = require_serve_static(); + exports2.text = bodyParser.text; + exports2.urlencoded = bodyParser.urlencoded; + } +}); +var require_express2 = __commonJS2({ + "node_modules/express/index.js"(exports2, module2) { + "use strict"; + module2.exports = require_express(); + } +}); +var require_lodash = __commonJS2({ + "node_modules/lodash/lodash.js"(exports2, module2) { + (function() { + var undefined2; + var VERSION = "4.17.21"; + var LARGE_ARRAY_SIZE = 200; + var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`"; + var HASH_UNDEFINED = "__lodash_hash_undefined__"; + var MAX_MEMOIZE_SIZE = 500; + var PLACEHOLDER = "__lodash_placeholder__"; + var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4; + var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2; + var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512; + var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "..."; + var HOT_COUNT = 800, HOT_SPAN = 16; + var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3; + var INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0; + var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; + var wrapFlags = [ + ["ary", WRAP_ARY_FLAG], + ["bind", WRAP_BIND_FLAG], + ["bindKey", WRAP_BIND_KEY_FLAG], + ["curry", WRAP_CURRY_FLAG], + ["curryRight", WRAP_CURRY_RIGHT_FLAG], + ["flip", WRAP_FLIP_FLAG], + ["partial", WRAP_PARTIAL_FLAG], + ["partialRight", WRAP_PARTIAL_RIGHT_FLAG], + ["rearg", WRAP_REARG_FLAG] + ]; + var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", domExcTag = "[object DOMException]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]", weakSetTag = "[object WeakSet]"; + var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]"; + var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; + var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source); + var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g; + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source); + var reTrimStart = /^\s+/; + var reWhitespace = /\s/; + var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /; + var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; + var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/; + var reEscapeChar = /\\(\\)?/g; + var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; + var reFlags = /\w*$/; + var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + var reIsBinary = /^0b[01]+$/i; + var reIsHostCtor = /^\[object .+?Constructor\]$/; + var reIsOctal = /^0o[0-7]+$/i; + var reIsUint = /^(?:0|[1-9]\d*)$/; + var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; + var reNoMatch = /($^)/; + var reUnescapedString = /['\n\r\u2028\u2029\\]/g; + var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; + var rsApos = "['\u2019]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d"; + var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")"; + var reApos = RegExp(rsApos, "g"); + var reComboMark = RegExp(rsCombo, "g"); + var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g"); + var reUnicodeWord = RegExp([ + rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")", + rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")", + rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower, + rsUpper + "+" + rsOptContrUpper, + rsOrdUpper, + rsOrdLower, + rsDigits, + rsEmoji + ].join("|"), "g"); + var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]"); + var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; + var contextProps = [ + "Array", + "Buffer", + "DataView", + "Date", + "Error", + "Float32Array", + "Float64Array", + "Function", + "Int8Array", + "Int16Array", + "Int32Array", + "Map", + "Math", + "Object", + "Promise", + "RegExp", + "Set", + "String", + "Symbol", + "TypeError", + "Uint8Array", + "Uint8ClampedArray", + "Uint16Array", + "Uint32Array", + "WeakMap", + "_", + "clearTimeout", + "isFinite", + "parseInt", + "setTimeout" + ]; + var templateCounter = -1; + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; + var cloneableTags = {}; + cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; + cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false; + var deburredLetters = { + // Latin-1 Supplement block. + "\xC0": "A", + "\xC1": "A", + "\xC2": "A", + "\xC3": "A", + "\xC4": "A", + "\xC5": "A", + "\xE0": "a", + "\xE1": "a", + "\xE2": "a", + "\xE3": "a", + "\xE4": "a", + "\xE5": "a", + "\xC7": "C", + "\xE7": "c", + "\xD0": "D", + "\xF0": "d", + "\xC8": "E", + "\xC9": "E", + "\xCA": "E", + "\xCB": "E", + "\xE8": "e", + "\xE9": "e", + "\xEA": "e", + "\xEB": "e", + "\xCC": "I", + "\xCD": "I", + "\xCE": "I", + "\xCF": "I", + "\xEC": "i", + "\xED": "i", + "\xEE": "i", + "\xEF": "i", + "\xD1": "N", + "\xF1": "n", + "\xD2": "O", + "\xD3": "O", + "\xD4": "O", + "\xD5": "O", + "\xD6": "O", + "\xD8": "O", + "\xF2": "o", + "\xF3": "o", + "\xF4": "o", + "\xF5": "o", + "\xF6": "o", + "\xF8": "o", + "\xD9": "U", + "\xDA": "U", + "\xDB": "U", + "\xDC": "U", + "\xF9": "u", + "\xFA": "u", + "\xFB": "u", + "\xFC": "u", + "\xDD": "Y", + "\xFD": "y", + "\xFF": "y", + "\xC6": "Ae", + "\xE6": "ae", + "\xDE": "Th", + "\xFE": "th", + "\xDF": "ss", + // Latin Extended-A block. + "\u0100": "A", + "\u0102": "A", + "\u0104": "A", + "\u0101": "a", + "\u0103": "a", + "\u0105": "a", + "\u0106": "C", + "\u0108": "C", + "\u010A": "C", + "\u010C": "C", + "\u0107": "c", + "\u0109": "c", + "\u010B": "c", + "\u010D": "c", + "\u010E": "D", + "\u0110": "D", + "\u010F": "d", + "\u0111": "d", + "\u0112": "E", + "\u0114": "E", + "\u0116": "E", + "\u0118": "E", + "\u011A": "E", + "\u0113": "e", + "\u0115": "e", + "\u0117": "e", + "\u0119": "e", + "\u011B": "e", + "\u011C": "G", + "\u011E": "G", + "\u0120": "G", + "\u0122": "G", + "\u011D": "g", + "\u011F": "g", + "\u0121": "g", + "\u0123": "g", + "\u0124": "H", + "\u0126": "H", + "\u0125": "h", + "\u0127": "h", + "\u0128": "I", + "\u012A": "I", + "\u012C": "I", + "\u012E": "I", + "\u0130": "I", + "\u0129": "i", + "\u012B": "i", + "\u012D": "i", + "\u012F": "i", + "\u0131": "i", + "\u0134": "J", + "\u0135": "j", + "\u0136": "K", + "\u0137": "k", + "\u0138": "k", + "\u0139": "L", + "\u013B": "L", + "\u013D": "L", + "\u013F": "L", + "\u0141": "L", + "\u013A": "l", + "\u013C": "l", + "\u013E": "l", + "\u0140": "l", + "\u0142": "l", + "\u0143": "N", + "\u0145": "N", + "\u0147": "N", + "\u014A": "N", + "\u0144": "n", + "\u0146": "n", + "\u0148": "n", + "\u014B": "n", + "\u014C": "O", + "\u014E": "O", + "\u0150": "O", + "\u014D": "o", + "\u014F": "o", + "\u0151": "o", + "\u0154": "R", + "\u0156": "R", + "\u0158": "R", + "\u0155": "r", + "\u0157": "r", + "\u0159": "r", + "\u015A": "S", + "\u015C": "S", + "\u015E": "S", + "\u0160": "S", + "\u015B": "s", + "\u015D": "s", + "\u015F": "s", + "\u0161": "s", + "\u0162": "T", + "\u0164": "T", + "\u0166": "T", + "\u0163": "t", + "\u0165": "t", + "\u0167": "t", + "\u0168": "U", + "\u016A": "U", + "\u016C": "U", + "\u016E": "U", + "\u0170": "U", + "\u0172": "U", + "\u0169": "u", + "\u016B": "u", + "\u016D": "u", + "\u016F": "u", + "\u0171": "u", + "\u0173": "u", + "\u0174": "W", + "\u0175": "w", + "\u0176": "Y", + "\u0177": "y", + "\u0178": "Y", + "\u0179": "Z", + "\u017B": "Z", + "\u017D": "Z", + "\u017A": "z", + "\u017C": "z", + "\u017E": "z", + "\u0132": "IJ", + "\u0133": "ij", + "\u0152": "Oe", + "\u0153": "oe", + "\u0149": "'n", + "\u017F": "s" + }; + var htmlEscapes = { + "&": "&", + "<": "<", + ">": ">", + '"': """, + "'": "'" + }; + var htmlUnescapes = { + "&": "&", + "<": "<", + ">": ">", + """: '"', + "'": "'" + }; + var stringEscapes = { + "\\": "\\", + "'": "'", + "\n": "n", + "\r": "r", + "\u2028": "u2028", + "\u2029": "u2029" + }; + var freeParseFloat = parseFloat, freeParseInt = parseInt; + var freeGlobal = typeof global == "object" && global && global.Object === Object && global; + var freeSelf = typeof self == "object" && self && self.Object === Object && self; + var root = freeGlobal || freeSelf || Function("return this")(); + var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2; + var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2; + var moduleExports = freeModule && freeModule.exports === freeExports; + var freeProcess = moduleExports && freeGlobal.process; + var nodeUtil = (function() { + try { + var types = freeModule && freeModule.require && freeModule.require("util").types; + if (types) { + return types; + } + return freeProcess && freeProcess.binding && freeProcess.binding("util"); + } catch (e) { + } + })(); + var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + function apply(func, thisArg, args) { + switch (args.length) { + case 0: + return func.call(thisArg); + case 1: + return func.call(thisArg, args[0]); + case 2: + return func.call(thisArg, args[0], args[1]); + case 3: + return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + function arrayAggregator(array, setter, iteratee, accumulator) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + var value = array[index]; + setter(accumulator, value, iteratee(value), array); + } + return accumulator; + } + function arrayEach(array, iteratee) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + function arrayEachRight(array, iteratee) { + var length = array == null ? 0 : array.length; + while (length--) { + if (iteratee(array[length], length, array) === false) { + break; + } + } + return array; + } + function arrayEvery(array, predicate) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + if (!predicate(array[index], index, array)) { + return false; + } + } + return true; + } + function arrayFilter(array, predicate) { + var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = []; + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; + } + function arrayIncludes(array, value) { + var length = array == null ? 0 : array.length; + return !!length && baseIndexOf(array, value, 0) > -1; + } + function arrayIncludesWith(array, value, comparator) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + if (comparator(value, array[index])) { + return true; + } + } + return false; + } + function arrayMap(array, iteratee) { + var index = -1, length = array == null ? 0 : array.length, result = Array(length); + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + function arrayPush(array, values) { + var index = -1, length = values.length, offset = array.length; + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + function arrayReduce(array, iteratee, accumulator, initAccum) { + var index = -1, length = array == null ? 0 : array.length; + if (initAccum && length) { + accumulator = array[++index]; + } + while (++index < length) { + accumulator = iteratee(accumulator, array[index], index, array); + } + return accumulator; + } + function arrayReduceRight(array, iteratee, accumulator, initAccum) { + var length = array == null ? 0 : array.length; + if (initAccum && length) { + accumulator = array[--length]; + } + while (length--) { + accumulator = iteratee(accumulator, array[length], length, array); + } + return accumulator; + } + function arraySome(array, predicate) { + var index = -1, length = array == null ? 0 : array.length; + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + var asciiSize = baseProperty("length"); + function asciiToArray(string) { + return string.split(""); + } + function asciiWords(string) { + return string.match(reAsciiWord) || []; + } + function baseFindKey(collection, predicate, eachFunc) { + var result; + eachFunc(collection, function(value, key, collection2) { + if (predicate(value, key, collection2)) { + result = key; + return false; + } + }); + return result; + } + function baseFindIndex(array, predicate, fromIndex, fromRight) { + var length = array.length, index = fromIndex + (fromRight ? 1 : -1); + while (fromRight ? index-- : ++index < length) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; + } + function baseIndexOf(array, value, fromIndex) { + return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex); + } + function baseIndexOfWith(array, value, fromIndex, comparator) { + var index = fromIndex - 1, length = array.length; + while (++index < length) { + if (comparator(array[index], value)) { + return index; + } + } + return -1; + } + function baseIsNaN(value) { + return value !== value; + } + function baseMean(array, iteratee) { + var length = array == null ? 0 : array.length; + return length ? baseSum(array, iteratee) / length : NAN; + } + function baseProperty(key) { + return function(object) { + return object == null ? undefined2 : object[key]; + }; + } + function basePropertyOf(object) { + return function(key) { + return object == null ? undefined2 : object[key]; + }; + } + function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection, function(value, index, collection2) { + accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2); + }); + return accumulator; + } + function baseSortBy(array, comparer) { + var length = array.length; + array.sort(comparer); + while (length--) { + array[length] = array[length].value; + } + return array; + } + function baseSum(array, iteratee) { + var result, index = -1, length = array.length; + while (++index < length) { + var current = iteratee(array[index]); + if (current !== undefined2) { + result = result === undefined2 ? current : result + current; + } + } + return result; + } + function baseTimes(n, iteratee) { + var index = -1, result = Array(n); + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + function baseToPairs(object, props) { + return arrayMap(props, function(key) { + return [key, object[key]]; + }); + } + function baseTrim(string) { + return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string; + } + function baseUnary(func) { + return function(value) { + return func(value); + }; + } + function baseValues(object, props) { + return arrayMap(props, function(key) { + return object[key]; + }); + } + function cacheHas(cache, key) { + return cache.has(key); + } + function charsStartIndex(strSymbols, chrSymbols) { + var index = -1, length = strSymbols.length; + while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { + } + return index; + } + function charsEndIndex(strSymbols, chrSymbols) { + var index = strSymbols.length; + while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) { + } + return index; + } + function countHolders(array, placeholder) { + var length = array.length, result = 0; + while (length--) { + if (array[length] === placeholder) { + ++result; + } + } + return result; + } + var deburrLetter = basePropertyOf(deburredLetters); + var escapeHtmlChar = basePropertyOf(htmlEscapes); + function escapeStringChar(chr) { + return "\\" + stringEscapes[chr]; + } + function getValue(object, key) { + return object == null ? undefined2 : object[key]; + } + function hasUnicode(string) { + return reHasUnicode.test(string); + } + function hasUnicodeWord(string) { + return reHasUnicodeWord.test(string); + } + function iteratorToArray(iterator) { + var data, result = []; + while (!(data = iterator.next()).done) { + result.push(data.value); + } + return result; + } + function mapToArray(map) { + var index = -1, result = Array(map.size); + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + function replaceHolders(array, placeholder) { + var index = -1, length = array.length, resIndex = 0, result = []; + while (++index < length) { + var value = array[index]; + if (value === placeholder || value === PLACEHOLDER) { + array[index] = PLACEHOLDER; + result[resIndex++] = index; + } + } + return result; + } + function setToArray(set) { + var index = -1, result = Array(set.size); + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + function setToPairs(set) { + var index = -1, result = Array(set.size); + set.forEach(function(value) { + result[++index] = [value, value]; + }); + return result; + } + function strictIndexOf(array, value, fromIndex) { + var index = fromIndex - 1, length = array.length; + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + function strictLastIndexOf(array, value, fromIndex) { + var index = fromIndex + 1; + while (index--) { + if (array[index] === value) { + return index; + } + } + return index; + } + function stringSize(string) { + return hasUnicode(string) ? unicodeSize(string) : asciiSize(string); + } + function stringToArray(string) { + return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string); + } + function trimmedEndIndex(string) { + var index = string.length; + while (index-- && reWhitespace.test(string.charAt(index))) { + } + return index; + } + var unescapeHtmlChar = basePropertyOf(htmlUnescapes); + function unicodeSize(string) { + var result = reUnicode.lastIndex = 0; + while (reUnicode.test(string)) { + ++result; + } + return result; + } + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } + function unicodeWords(string) { + return string.match(reUnicodeWord) || []; + } + var runInContext = function runInContext2(context) { + context = context == null ? root : _2.defaults(root.Object(), context, _2.pick(root, contextProps)); + var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError; + var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype; + var coreJsData = context["__core-js_shared__"]; + var funcToString = funcProto.toString; + var hasOwnProperty = objectProto.hasOwnProperty; + var idCounter = 0; + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ""); + return uid ? "Symbol(src)_1." + uid : ""; + })(); + var nativeObjectToString = objectProto.toString; + var objectCtorString = funcToString.call(Object2); + var oldDash = root._; + var reIsNative = RegExp2( + "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$" + ); + var Buffer2 = moduleExports ? context.Buffer : undefined2, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined2, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined2, symIterator = Symbol2 ? Symbol2.iterator : undefined2, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined2; + var defineProperty = (function() { + try { + var func = getNative(Object2, "defineProperty"); + func({}, "", {}); + return func; + } catch (e) { + } + })(); + var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; + var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse; + var DataView2 = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap2 = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create"); + var metaMap = WeakMap2 && new WeakMap2(); + var realNames = {}; + var dataViewCtorString = toSource(DataView2), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2); + var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2; + function lodash(value) { + if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { + if (value instanceof LodashWrapper) { + return value; + } + if (hasOwnProperty.call(value, "__wrapped__")) { + return wrapperClone(value); + } + } + return new LodashWrapper(value); + } + var baseCreate = /* @__PURE__ */ (function() { + function object() { + } + return function(proto2) { + if (!isObject(proto2)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto2); + } + object.prototype = proto2; + var result2 = new object(); + object.prototype = undefined2; + return result2; + }; + })(); + function baseLodash() { + } + function LodashWrapper(value, chainAll) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__chain__ = !!chainAll; + this.__index__ = 0; + this.__values__ = undefined2; + } + lodash.templateSettings = { + /** + * Used to detect `data` property values to be HTML-escaped. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + "escape": reEscape, + /** + * Used to detect code to be evaluated. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + "evaluate": reEvaluate, + /** + * Used to detect `data` property values to inject. + * + * @memberOf _.templateSettings + * @type {RegExp} + */ + "interpolate": reInterpolate, + /** + * Used to reference the data object in the template text. + * + * @memberOf _.templateSettings + * @type {string} + */ + "variable": "", + /** + * Used to import variables into the compiled template. + * + * @memberOf _.templateSettings + * @type {Object} + */ + "imports": { + /** + * A reference to the `lodash` function. + * + * @memberOf _.templateSettings.imports + * @type {Function} + */ + "_": lodash + } + }; + lodash.prototype = baseLodash.prototype; + lodash.prototype.constructor = lodash; + LodashWrapper.prototype = baseCreate(baseLodash.prototype); + LodashWrapper.prototype.constructor = LodashWrapper; + function LazyWrapper(value) { + this.__wrapped__ = value; + this.__actions__ = []; + this.__dir__ = 1; + this.__filtered__ = false; + this.__iteratees__ = []; + this.__takeCount__ = MAX_ARRAY_LENGTH; + this.__views__ = []; + } + function lazyClone() { + var result2 = new LazyWrapper(this.__wrapped__); + result2.__actions__ = copyArray(this.__actions__); + result2.__dir__ = this.__dir__; + result2.__filtered__ = this.__filtered__; + result2.__iteratees__ = copyArray(this.__iteratees__); + result2.__takeCount__ = this.__takeCount__; + result2.__views__ = copyArray(this.__views__); + return result2; + } + function lazyReverse() { + if (this.__filtered__) { + var result2 = new LazyWrapper(this); + result2.__dir__ = -1; + result2.__filtered__ = true; + } else { + result2 = this.clone(); + result2.__dir__ *= -1; + } + return result2; + } + function lazyValue() { + var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__); + if (!isArr || !isRight && arrLength == length && takeCount == length) { + return baseWrapperValue(array, this.__actions__); + } + var result2 = []; + outer: + while (length-- && resIndex < takeCount) { + index += dir; + var iterIndex = -1, value = array[index]; + while (++iterIndex < iterLength) { + var data = iteratees[iterIndex], iteratee2 = data.iteratee, type = data.type, computed = iteratee2(value); + if (type == LAZY_MAP_FLAG) { + value = computed; + } else if (!computed) { + if (type == LAZY_FILTER_FLAG) { + continue outer; + } else { + break outer; + } + } + } + result2[resIndex++] = value; + } + return result2; + } + LazyWrapper.prototype = baseCreate(baseLodash.prototype); + LazyWrapper.prototype.constructor = LazyWrapper; + function Hash(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry2 = entries[index]; + this.set(entry2[0], entry2[1]); + } + } + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + function hashDelete(key) { + var result2 = this.has(key) && delete this.__data__[key]; + this.size -= result2 ? 1 : 0; + return result2; + } + function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result2 = data[key]; + return result2 === HASH_UNDEFINED ? undefined2 : result2; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined2; + } + function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined2 : hasOwnProperty.call(data, key); + } + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value; + return this; + } + Hash.prototype.clear = hashClear; + Hash.prototype["delete"] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + function ListCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry2 = entries[index]; + this.set(entry2[0], entry2[1]); + } + } + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + function listCacheDelete(key) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + function listCacheGet(key) { + var data = this.__data__, index = assocIndexOf(data, key); + return index < 0 ? undefined2 : data[index][1]; + } + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + function listCacheSet(key, value) { + var data = this.__data__, index = assocIndexOf(data, key); + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + ListCache.prototype.clear = listCacheClear; + ListCache.prototype["delete"] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + function MapCache(entries) { + var index = -1, length = entries == null ? 0 : entries.length; + this.clear(); + while (++index < length) { + var entry2 = entries[index]; + this.set(entry2[0], entry2[1]); + } + } + function mapCacheClear() { + this.size = 0; + this.__data__ = { + "hash": new Hash(), + "map": new (Map2 || ListCache)(), + "string": new Hash() + }; + } + function mapCacheDelete(key) { + var result2 = getMapData(this, key)["delete"](key); + this.size -= result2 ? 1 : 0; + return result2; + } + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + function mapCacheSet(key, value) { + var data = getMapData(this, key), size2 = data.size; + data.set(key, value); + this.size += data.size == size2 ? 0 : 1; + return this; + } + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype["delete"] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + function SetCache(values2) { + var index = -1, length = values2 == null ? 0 : values2.length; + this.__data__ = new MapCache(); + while (++index < length) { + this.add(values2[index]); + } + } + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + function setCacheHas(value) { + return this.__data__.has(value); + } + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; + } + function stackClear() { + this.__data__ = new ListCache(); + this.size = 0; + } + function stackDelete(key) { + var data = this.__data__, result2 = data["delete"](key); + this.size = data.size; + return result2; + } + function stackGet(key) { + return this.__data__.get(key); + } + function stackHas(key) { + return this.__data__.has(key); + } + function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; + } + Stack.prototype.clear = stackClear; + Stack.prototype["delete"] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length; + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode. + (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers. + isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays. + isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties. + isIndex(key, length)))) { + result2.push(key); + } + } + return result2; + } + function arraySample(array) { + var length = array.length; + return length ? array[baseRandom(0, length - 1)] : undefined2; + } + function arraySampleSize(array, n) { + return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); + } + function arrayShuffle(array) { + return shuffleSelf(copyArray(array)); + } + function assignMergeValue(object, key, value) { + if (value !== undefined2 && !eq(object[key], value) || value === undefined2 && !(key in object)) { + baseAssignValue(object, key, value); + } + } + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined2 && !(key in object)) { + baseAssignValue(object, key, value); + } + } + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + function baseAggregator(collection, setter, iteratee2, accumulator) { + baseEach(collection, function(value, key, collection2) { + setter(accumulator, value, iteratee2(value), collection2); + }); + return accumulator; + } + function baseAssign(object, source) { + return object && copyObject(source, keys(source), object); + } + function baseAssignIn(object, source) { + return object && copyObject(source, keysIn(source), object); + } + function baseAssignValue(object, key, value) { + if (key == "__proto__" && defineProperty) { + defineProperty(object, key, { + "configurable": true, + "enumerable": true, + "value": value, + "writable": true + }); + } else { + object[key] = value; + } + } + function baseAt(object, paths) { + var index = -1, length = paths.length, result2 = Array2(length), skip = object == null; + while (++index < length) { + result2[index] = skip ? undefined2 : get(object, paths[index]); + } + return result2; + } + function baseClamp(number, lower, upper) { + if (number === number) { + if (upper !== undefined2) { + number = number <= upper ? number : upper; + } + if (lower !== undefined2) { + number = number >= lower ? number : lower; + } + } + return number; + } + function baseClone(value, bitmask, customizer, key, object, stack) { + var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG; + if (customizer) { + result2 = object ? customizer(value, key, object, stack) : customizer(value); + } + if (result2 !== undefined2) { + return result2; + } + if (!isObject(value)) { + return value; + } + var isArr = isArray(value); + if (isArr) { + result2 = initCloneArray(value); + if (!isDeep) { + return copyArray(value, result2); + } + } else { + var tag = getTag(value), isFunc = tag == funcTag || tag == genTag; + if (isBuffer(value)) { + return cloneBuffer(value, isDeep); + } + if (tag == objectTag || tag == argsTag || isFunc && !object) { + result2 = isFlat || isFunc ? {} : initCloneObject(value); + if (!isDeep) { + return isFlat ? copySymbolsIn(value, baseAssignIn(result2, value)) : copySymbols(value, baseAssign(result2, value)); + } + } else { + if (!cloneableTags[tag]) { + return object ? value : {}; + } + result2 = initCloneByTag(value, tag, isDeep); + } + } + stack || (stack = new Stack()); + var stacked = stack.get(value); + if (stacked) { + return stacked; + } + stack.set(value, result2); + if (isSet(value)) { + value.forEach(function(subValue) { + result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); + }); + } else if (isMap(value)) { + value.forEach(function(subValue, key2) { + result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack)); + }); + } + var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys; + var props = isArr ? undefined2 : keysFunc(value); + arrayEach(props || value, function(subValue, key2) { + if (props) { + key2 = subValue; + subValue = value[key2]; + } + assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack)); + }); + return result2; + } + function baseConforms(source) { + var props = keys(source); + return function(object) { + return baseConformsTo(object, source, props); + }; + } + function baseConformsTo(object, source, props) { + var length = props.length; + if (object == null) { + return !length; + } + object = Object2(object); + while (length--) { + var key = props[length], predicate = source[key], value = object[key]; + if (value === undefined2 && !(key in object) || !predicate(value)) { + return false; + } + } + return true; + } + function baseDelay(func, wait, args) { + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + return setTimeout2(function() { + func.apply(undefined2, args); + }, wait); + } + function baseDifference(array, values2, iteratee2, comparator) { + var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length; + if (!length) { + return result2; + } + if (iteratee2) { + values2 = arrayMap(values2, baseUnary(iteratee2)); + } + if (comparator) { + includes2 = arrayIncludesWith; + isCommon = false; + } else if (values2.length >= LARGE_ARRAY_SIZE) { + includes2 = cacheHas; + isCommon = false; + values2 = new SetCache(values2); + } + outer: + while (++index < length) { + var value = array[index], computed = iteratee2 == null ? value : iteratee2(value); + value = comparator || value !== 0 ? value : 0; + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values2[valuesIndex] === computed) { + continue outer; + } + } + result2.push(value); + } else if (!includes2(values2, computed, comparator)) { + result2.push(value); + } + } + return result2; + } + var baseEach = createBaseEach(baseForOwn); + var baseEachRight = createBaseEach(baseForOwnRight, true); + function baseEvery(collection, predicate) { + var result2 = true; + baseEach(collection, function(value, index, collection2) { + result2 = !!predicate(value, index, collection2); + return result2; + }); + return result2; + } + function baseExtremum(array, iteratee2, comparator) { + var index = -1, length = array.length; + while (++index < length) { + var value = array[index], current = iteratee2(value); + if (current != null && (computed === undefined2 ? current === current && !isSymbol(current) : comparator(current, computed))) { + var computed = current, result2 = value; + } + } + return result2; + } + function baseFill(array, value, start, end) { + var length = array.length; + start = toInteger(start); + if (start < 0) { + start = -start > length ? 0 : length + start; + } + end = end === undefined2 || end > length ? length : toInteger(end); + if (end < 0) { + end += length; + } + end = start > end ? 0 : toLength(end); + while (start < end) { + array[start++] = value; + } + return array; + } + function baseFilter(collection, predicate) { + var result2 = []; + baseEach(collection, function(value, index, collection2) { + if (predicate(value, index, collection2)) { + result2.push(value); + } + }); + return result2; + } + function baseFlatten(array, depth, predicate, isStrict, result2) { + var index = -1, length = array.length; + predicate || (predicate = isFlattenable); + result2 || (result2 = []); + while (++index < length) { + var value = array[index]; + if (depth > 0 && predicate(value)) { + if (depth > 1) { + baseFlatten(value, depth - 1, predicate, isStrict, result2); + } else { + arrayPush(result2, value); + } + } else if (!isStrict) { + result2[result2.length] = value; + } + } + return result2; + } + var baseFor = createBaseFor(); + var baseForRight = createBaseFor(true); + function baseForOwn(object, iteratee2) { + return object && baseFor(object, iteratee2, keys); + } + function baseForOwnRight(object, iteratee2) { + return object && baseForRight(object, iteratee2, keys); + } + function baseFunctions(object, props) { + return arrayFilter(props, function(key) { + return isFunction(object[key]); + }); + } + function baseGet(object, path) { + path = castPath(path, object); + var index = 0, length = path.length; + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return index && index == length ? object : undefined2; + } + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result2 = keysFunc(object); + return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object)); + } + function baseGetTag(value) { + if (value == null) { + return value === undefined2 ? undefinedTag : nullTag; + } + return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString(value); + } + function baseGt(value, other) { + return value > other; + } + function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); + } + function baseHasIn(object, key) { + return object != null && key in Object2(object); + } + function baseInRange(number, start, end) { + return number >= nativeMin(start, end) && number < nativeMax(start, end); + } + function baseIntersection(arrays, iteratee2, comparator) { + var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = []; + while (othIndex--) { + var array = arrays[othIndex]; + if (othIndex && iteratee2) { + array = arrayMap(array, baseUnary(iteratee2)); + } + maxLength = nativeMin(array.length, maxLength); + caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined2; + } + array = arrays[0]; + var index = -1, seen = caches[0]; + outer: + while (++index < length && result2.length < maxLength) { + var value = array[index], computed = iteratee2 ? iteratee2(value) : value; + value = comparator || value !== 0 ? value : 0; + if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) { + othIndex = othLength; + while (--othIndex) { + var cache = caches[othIndex]; + if (!(cache ? cacheHas(cache, computed) : includes2(arrays[othIndex], computed, comparator))) { + continue outer; + } + } + if (seen) { + seen.push(computed); + } + result2.push(value); + } + } + return result2; + } + function baseInverter(object, setter, iteratee2, accumulator) { + baseForOwn(object, function(value, key, object2) { + setter(accumulator, iteratee2(value), key, object2); + }); + return accumulator; + } + function baseInvoke(object, path, args) { + path = castPath(path, object); + object = parent(object, path); + var func = object == null ? object : object[toKey(last(path))]; + return func == null ? undefined2 : apply(func, object, args); + } + function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; + } + function baseIsArrayBuffer(value) { + return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; + } + function baseIsDate(value) { + return isObjectLike(value) && baseGetTag(value) == dateTag; + } + function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); + } + function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other); + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag; + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack()); + return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__"); + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other; + stack || (stack = new Stack()); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack()); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); + } + function baseIsMap(value) { + return isObjectLike(value) && getTag(value) == mapTag; + } + function baseIsMatch(object, source, matchData, customizer) { + var index = matchData.length, length = index, noCustomizer = !customizer; + if (object == null) { + return !length; + } + object = Object2(object); + while (index--) { + var data = matchData[index]; + if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], objValue = object[key], srcValue = data[1]; + if (noCustomizer && data[2]) { + if (objValue === undefined2 && !(key in object)) { + return false; + } + } else { + var stack = new Stack(); + if (customizer) { + var result2 = customizer(objValue, srcValue, key, object, source, stack); + } + if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) { + return false; + } + } + } + return true; + } + function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + function baseIsRegExp(value) { + return isObjectLike(value) && baseGetTag(value) == regexpTag; + } + function baseIsSet(value) { + return isObjectLike(value) && getTag(value) == setTag; + } + function baseIsTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; + } + function baseIteratee(value) { + if (typeof value == "function") { + return value; + } + if (value == null) { + return identity; + } + if (typeof value == "object") { + return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value); + } + return property(value); + } + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result2 = []; + for (var key in Object2(object)) { + if (hasOwnProperty.call(object, key) && key != "constructor") { + result2.push(key); + } + } + return result2; + } + function baseKeysIn(object) { + if (!isObject(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), result2 = []; + for (var key in object) { + if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) { + result2.push(key); + } + } + return result2; + } + function baseLt(value, other) { + return value < other; + } + function baseMap(collection, iteratee2) { + var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : []; + baseEach(collection, function(value, key, collection2) { + result2[++index] = iteratee2(value, key, collection2); + }); + return result2; + } + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable(matchData[0][0], matchData[0][1]); + } + return function(object) { + return object === source || baseIsMatch(object, source, matchData); + }; + } + function baseMatchesProperty(path, srcValue) { + if (isKey(path) && isStrictComparable(srcValue)) { + return matchesStrictComparable(toKey(path), srcValue); + } + return function(object) { + var objValue = get(object, path); + return objValue === undefined2 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); + }; + } + function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor(source, function(srcValue, key) { + stack || (stack = new Stack()); + if (isObject(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } else { + var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : undefined2; + if (newValue === undefined2) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); + } + function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue); + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined2; + var isCommon = newValue === undefined2; + if (isCommon) { + var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue); + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (isArray(objValue)) { + newValue = objValue; + } else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } else { + newValue = []; + } + } else if (isPlainObject(srcValue) || isArguments(srcValue)) { + newValue = objValue; + if (isArguments(objValue)) { + newValue = toPlainObject(objValue); + } else if (!isObject(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); + } + } else { + isCommon = false; + } + } + if (isCommon) { + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack["delete"](srcValue); + } + assignMergeValue(object, key, newValue); + } + function baseNth(array, n) { + var length = array.length; + if (!length) { + return; + } + n += n < 0 ? length : 0; + return isIndex(n, length) ? array[n] : undefined2; + } + function baseOrderBy(collection, iteratees, orders) { + if (iteratees.length) { + iteratees = arrayMap(iteratees, function(iteratee2) { + if (isArray(iteratee2)) { + return function(value) { + return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2); + }; + } + return iteratee2; + }); + } else { + iteratees = [identity]; + } + var index = -1; + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + var result2 = baseMap(collection, function(value, key, collection2) { + var criteria = arrayMap(iteratees, function(iteratee2) { + return iteratee2(value); + }); + return { "criteria": criteria, "index": ++index, "value": value }; + }); + return baseSortBy(result2, function(object, other) { + return compareMultiple(object, other, orders); + }); + } + function basePick(object, paths) { + return basePickBy(object, paths, function(value, path) { + return hasIn(object, path); + }); + } + function basePickBy(object, paths, predicate) { + var index = -1, length = paths.length, result2 = {}; + while (++index < length) { + var path = paths[index], value = baseGet(object, path); + if (predicate(value, path)) { + baseSet(result2, castPath(path, object), value); + } + } + return result2; + } + function basePropertyDeep(path) { + return function(object) { + return baseGet(object, path); + }; + } + function basePullAll(array, values2, iteratee2, comparator) { + var indexOf2 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array; + if (array === values2) { + values2 = copyArray(values2); + } + if (iteratee2) { + seen = arrayMap(array, baseUnary(iteratee2)); + } + while (++index < length) { + var fromIndex = 0, value = values2[index], computed = iteratee2 ? iteratee2(value) : value; + while ((fromIndex = indexOf2(seen, computed, fromIndex, comparator)) > -1) { + if (seen !== array) { + splice.call(seen, fromIndex, 1); + } + splice.call(array, fromIndex, 1); + } + } + return array; + } + function basePullAt(array, indexes) { + var length = array ? indexes.length : 0, lastIndex = length - 1; + while (length--) { + var index = indexes[length]; + if (length == lastIndex || index !== previous) { + var previous = index; + if (isIndex(index)) { + splice.call(array, index, 1); + } else { + baseUnset(array, index); + } + } + } + return array; + } + function baseRandom(lower, upper) { + return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); + } + function baseRange(start, end, step, fromRight) { + var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length); + while (length--) { + result2[fromRight ? length : ++index] = start; + start += step; + } + return result2; + } + function baseRepeat(string, n) { + var result2 = ""; + if (!string || n < 1 || n > MAX_SAFE_INTEGER) { + return result2; + } + do { + if (n % 2) { + result2 += string; + } + n = nativeFloor(n / 2); + if (n) { + string += string; + } + } while (n); + return result2; + } + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ""); + } + function baseSample(collection) { + return arraySample(values(collection)); + } + function baseSampleSize(collection, n) { + var array = values(collection); + return shuffleSelf(array, baseClamp(n, 0, array.length)); + } + function baseSet(object, path, value, customizer) { + if (!isObject(object)) { + return object; + } + path = castPath(path, object); + var index = -1, length = path.length, lastIndex = length - 1, nested = object; + while (nested != null && ++index < length) { + var key = toKey(path[index]), newValue = value; + if (key === "__proto__" || key === "constructor" || key === "prototype") { + return object; + } + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined2; + if (newValue === undefined2) { + newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {}; + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; + } + var baseSetData = !metaMap ? identity : function(func, data) { + metaMap.set(func, data); + return func; + }; + var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, "toString", { + "configurable": true, + "enumerable": false, + "value": constant(string), + "writable": true + }); + }; + function baseShuffle(collection) { + return shuffleSelf(values(collection)); + } + function baseSlice(array, start, end) { + var index = -1, length = array.length; + if (start < 0) { + start = -start > length ? 0 : length + start; + } + end = end > length ? length : end; + if (end < 0) { + end += length; + } + length = start > end ? 0 : end - start >>> 0; + start >>>= 0; + var result2 = Array2(length); + while (++index < length) { + result2[index] = array[index + start]; + } + return result2; + } + function baseSome(collection, predicate) { + var result2; + baseEach(collection, function(value, index, collection2) { + result2 = predicate(value, index, collection2); + return !result2; + }); + return !!result2; + } + function baseSortedIndex(array, value, retHighest) { + var low = 0, high = array == null ? low : array.length; + if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) { + while (low < high) { + var mid = low + high >>> 1, computed = array[mid]; + if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) { + low = mid + 1; + } else { + high = mid; + } + } + return high; + } + return baseSortedIndexBy(array, value, identity, retHighest); + } + function baseSortedIndexBy(array, value, iteratee2, retHighest) { + var low = 0, high = array == null ? 0 : array.length; + if (high === 0) { + return 0; + } + value = iteratee2(value); + var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined2; + while (low < high) { + var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined2, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed); + if (valIsNaN) { + var setLow = retHighest || othIsReflexive; + } else if (valIsUndefined) { + setLow = othIsReflexive && (retHighest || othIsDefined); + } else if (valIsNull) { + setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); + } else if (valIsSymbol) { + setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); + } else if (othIsNull || othIsSymbol) { + setLow = false; + } else { + setLow = retHighest ? computed <= value : computed < value; + } + if (setLow) { + low = mid + 1; + } else { + high = mid; + } + } + return nativeMin(high, MAX_ARRAY_INDEX); + } + function baseSortedUniq(array, iteratee2) { + var index = -1, length = array.length, resIndex = 0, result2 = []; + while (++index < length) { + var value = array[index], computed = iteratee2 ? iteratee2(value) : value; + if (!index || !eq(computed, seen)) { + var seen = computed; + result2[resIndex++] = value === 0 ? 0 : value; + } + } + return result2; + } + function baseToNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + return +value; + } + function baseToString(value) { + if (typeof value == "string") { + return value; + } + if (isArray(value)) { + return arrayMap(value, baseToString) + ""; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ""; + } + var result2 = value + ""; + return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2; + } + function baseUniq(array, iteratee2, comparator) { + var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2; + if (comparator) { + isCommon = false; + includes2 = arrayIncludesWith; + } else if (length >= LARGE_ARRAY_SIZE) { + var set2 = iteratee2 ? null : createSet(array); + if (set2) { + return setToArray(set2); + } + isCommon = false; + includes2 = cacheHas; + seen = new SetCache(); + } else { + seen = iteratee2 ? [] : result2; + } + outer: + while (++index < length) { + var value = array[index], computed = iteratee2 ? iteratee2(value) : value; + value = comparator || value !== 0 ? value : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee2) { + seen.push(computed); + } + result2.push(value); + } else if (!includes2(seen, computed, comparator)) { + if (seen !== result2) { + seen.push(computed); + } + result2.push(value); + } + } + return result2; + } + function baseUnset(object, path) { + path = castPath(path, object); + object = parent(object, path); + return object == null || delete object[toKey(last(path))]; + } + function baseUpdate(object, path, updater, customizer) { + return baseSet(object, path, updater(baseGet(object, path)), customizer); + } + function baseWhile(array, predicate, isDrop, fromRight) { + var length = array.length, index = fromRight ? length : -1; + while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) { + } + return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index); + } + function baseWrapperValue(value, actions) { + var result2 = value; + if (result2 instanceof LazyWrapper) { + result2 = result2.value(); + } + return arrayReduce(actions, function(result3, action) { + return action.func.apply(action.thisArg, arrayPush([result3], action.args)); + }, result2); + } + function baseXor(arrays, iteratee2, comparator) { + var length = arrays.length; + if (length < 2) { + return length ? baseUniq(arrays[0]) : []; + } + var index = -1, result2 = Array2(length); + while (++index < length) { + var array = arrays[index], othIndex = -1; + while (++othIndex < length) { + if (othIndex != index) { + result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator); + } + } + } + return baseUniq(baseFlatten(result2, 1), iteratee2, comparator); + } + function baseZipObject(props, values2, assignFunc) { + var index = -1, length = props.length, valsLength = values2.length, result2 = {}; + while (++index < length) { + var value = index < valsLength ? values2[index] : undefined2; + assignFunc(result2, props[index], value); + } + return result2; + } + function castArrayLikeObject(value) { + return isArrayLikeObject(value) ? value : []; + } + function castFunction(value) { + return typeof value == "function" ? value : identity; + } + function castPath(value, object) { + if (isArray(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath(toString(value)); + } + var castRest = baseRest; + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined2 ? length : end; + return !start && end >= length ? array : baseSlice(array, start, end); + } + var clearTimeout2 = ctxClearTimeout || function(id) { + return root.clearTimeout(id); + }; + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + buffer.copy(result2); + return result2; + } + function cloneArrayBuffer(arrayBuffer) { + var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer)); + return result2; + } + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + function cloneRegExp(regexp) { + var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result2.lastIndex = regexp.lastIndex; + return result2; + } + function cloneSymbol(symbol) { + return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {}; + } + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + function compareAscending(value, other) { + if (value !== other) { + var valIsDefined = value !== undefined2, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value); + var othIsDefined = other !== undefined2, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other); + if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) { + return 1; + } + if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) { + return -1; + } + } + return 0; + } + function compareMultiple(object, other, orders) { + var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length; + while (++index < length) { + var result2 = compareAscending(objCriteria[index], othCriteria[index]); + if (result2) { + if (index >= ordersLength) { + return result2; + } + var order = orders[index]; + return result2 * (order == "desc" ? -1 : 1); + } + } + return object.index - other.index; + } + function composeArgs(args, partials, holders, isCurried) { + var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried; + while (++leftIndex < leftLength) { + result2[leftIndex] = partials[leftIndex]; + } + while (++argsIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result2[holders[argsIndex]] = args[argsIndex]; + } + } + while (rangeLength--) { + result2[leftIndex++] = args[argsIndex++]; + } + return result2; + } + function composeArgsRight(args, partials, holders, isCurried) { + var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried; + while (++argsIndex < rangeLength) { + result2[argsIndex] = args[argsIndex]; + } + var offset = argsIndex; + while (++rightIndex < rightLength) { + result2[offset + rightIndex] = partials[rightIndex]; + } + while (++holdersIndex < holdersLength) { + if (isUncurried || argsIndex < argsLength) { + result2[offset + holders[holdersIndex]] = args[argsIndex++]; + } + } + return result2; + } + function copyArray(source, array) { + var index = -1, length = source.length; + array || (array = Array2(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + var index = -1, length = props.length; + while (++index < length) { + var key = props[index]; + var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined2; + if (newValue === undefined2) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; + } + function copySymbols(source, object) { + return copyObject(source, getSymbols(source), object); + } + function copySymbolsIn(source, object) { + return copyObject(source, getSymbolsIn(source), object); + } + function createAggregator(setter, initializer) { + return function(collection, iteratee2) { + var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {}; + return func(collection, setter, getIteratee(iteratee2, 2), accumulator); + }; + } + function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined2, guard = length > 2 ? sources[2] : undefined2; + customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined2; + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined2 : customizer; + length = 1; + } + object = Object2(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); + } + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee2) { + if (collection == null) { + return collection; + } + if (!isArrayLike(collection)) { + return eachFunc(collection, iteratee2); + } + var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection); + while (fromRight ? index-- : ++index < length) { + if (iteratee2(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + function createBaseFor(fromRight) { + return function(object, iteratee2, keysFunc) { + var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length; + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee2(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + function createBind(func, bitmask, thisArg) { + var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); + function wrapper() { + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return fn.apply(isBind ? thisArg : this, arguments); + } + return wrapper; + } + function createCaseFirst(methodName) { + return function(string) { + string = toString(string); + var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined2; + var chr = strSymbols ? strSymbols[0] : string.charAt(0); + var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1); + return chr[methodName]() + trailing; + }; + } + function createCompounder(callback) { + return function(string) { + return arrayReduce(words(deburr(string).replace(reApos, "")), callback, ""); + }; + } + function createCtor(Ctor) { + return function() { + var args = arguments; + switch (args.length) { + case 0: + return new Ctor(); + case 1: + return new Ctor(args[0]); + case 2: + return new Ctor(args[0], args[1]); + case 3: + return new Ctor(args[0], args[1], args[2]); + case 4: + return new Ctor(args[0], args[1], args[2], args[3]); + case 5: + return new Ctor(args[0], args[1], args[2], args[3], args[4]); + case 6: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); + case 7: + return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); + } + var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args); + return isObject(result2) ? result2 : thisBinding; + }; + } + function createCurry(func, bitmask, arity) { + var Ctor = createCtor(func); + function wrapper() { + var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper); + while (index--) { + args[index] = arguments[index]; + } + var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder); + length -= holders.length; + if (length < arity) { + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + undefined2, + args, + holders, + undefined2, + undefined2, + arity - length + ); + } + var fn = this && this !== root && this instanceof wrapper ? Ctor : func; + return apply(fn, this, args); + } + return wrapper; + } + function createFind(findIndexFunc) { + return function(collection, predicate, fromIndex) { + var iterable = Object2(collection); + if (!isArrayLike(collection)) { + var iteratee2 = getIteratee(predicate, 3); + collection = keys(collection); + predicate = function(key) { + return iteratee2(iterable[key], key, iterable); + }; + } + var index = findIndexFunc(collection, predicate, fromIndex); + return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2; + }; + } + function createFlow(fromRight) { + return flatRest(function(funcs) { + var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru; + if (fromRight) { + funcs.reverse(); + } + while (index--) { + var func = funcs[index]; + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + if (prereq && !wrapper && getFuncName(func) == "wrapper") { + var wrapper = new LodashWrapper([], true); + } + } + index = wrapper ? index : length; + while (++index < length) { + func = funcs[index]; + var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : undefined2; + if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) { + wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); + } else { + wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func); + } + } + return function() { + var args = arguments, value = args[0]; + if (wrapper && args.length == 1 && isArray(value)) { + return wrapper.plant(value).value(); + } + var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value; + while (++index2 < length) { + result2 = funcs[index2].call(this, result2); + } + return result2; + }; + }); + } + function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) { + var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined2 : createCtor(func); + function wrapper() { + var length = arguments.length, args = Array2(length), index = length; + while (index--) { + args[index] = arguments[index]; + } + if (isCurried) { + var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder); + } + if (partials) { + args = composeArgs(args, partials, holders, isCurried); + } + if (partialsRight) { + args = composeArgsRight(args, partialsRight, holdersRight, isCurried); + } + length -= holdersCount; + if (isCurried && length < arity) { + var newHolders = replaceHolders(args, placeholder); + return createRecurry( + func, + bitmask, + createHybrid, + wrapper.placeholder, + thisArg, + args, + newHolders, + argPos, + ary2, + arity - length + ); + } + var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func; + length = args.length; + if (argPos) { + args = reorder(args, argPos); + } else if (isFlip && length > 1) { + args.reverse(); + } + if (isAry && ary2 < length) { + args.length = ary2; + } + if (this && this !== root && this instanceof wrapper) { + fn = Ctor || createCtor(fn); + } + return fn.apply(thisBinding, args); + } + return wrapper; + } + function createInverter(setter, toIteratee) { + return function(object, iteratee2) { + return baseInverter(object, setter, toIteratee(iteratee2), {}); + }; + } + function createMathOperation(operator, defaultValue) { + return function(value, other) { + var result2; + if (value === undefined2 && other === undefined2) { + return defaultValue; + } + if (value !== undefined2) { + result2 = value; + } + if (other !== undefined2) { + if (result2 === undefined2) { + return other; + } + if (typeof value == "string" || typeof other == "string") { + value = baseToString(value); + other = baseToString(other); + } else { + value = baseToNumber(value); + other = baseToNumber(other); + } + result2 = operator(value, other); + } + return result2; + }; + } + function createOver(arrayFunc) { + return flatRest(function(iteratees) { + iteratees = arrayMap(iteratees, baseUnary(getIteratee())); + return baseRest(function(args) { + var thisArg = this; + return arrayFunc(iteratees, function(iteratee2) { + return apply(iteratee2, thisArg, args); + }); + }); + }); + } + function createPadding(length, chars) { + chars = chars === undefined2 ? " " : baseToString(chars); + var charsLength = chars.length; + if (charsLength < 2) { + return charsLength ? baseRepeat(chars, length) : chars; + } + var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars))); + return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length); + } + function createPartial(func, bitmask, thisArg, partials) { + var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func); + function wrapper() { + var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func; + while (++leftIndex < leftLength) { + args[leftIndex] = partials[leftIndex]; + } + while (argsLength--) { + args[leftIndex++] = arguments[++argsIndex]; + } + return apply(fn, isBind ? thisArg : this, args); + } + return wrapper; + } + function createRange(fromRight) { + return function(start, end, step) { + if (step && typeof step != "number" && isIterateeCall(start, end, step)) { + end = step = undefined2; + } + start = toFinite(start); + if (end === undefined2) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + step = step === undefined2 ? start < end ? 1 : -1 : toFinite(step); + return baseRange(start, end, step, fromRight); + }; + } + function createRelationalOperation(operator) { + return function(value, other) { + if (!(typeof value == "string" && typeof other == "string")) { + value = toNumber(value); + other = toNumber(other); + } + return operator(value, other); + }; + } + function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) { + var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined2, newHoldersRight = isCurry ? undefined2 : holders, newPartials = isCurry ? partials : undefined2, newPartialsRight = isCurry ? undefined2 : partials; + bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG; + bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); + if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { + bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); + } + var newData = [ + func, + bitmask, + thisArg, + newPartials, + newHolders, + newPartialsRight, + newHoldersRight, + argPos, + ary2, + arity + ]; + var result2 = wrapFunc.apply(undefined2, newData); + if (isLaziable(func)) { + setData(result2, newData); + } + result2.placeholder = placeholder; + return setWrapToString(result2, func, bitmask); + } + function createRound(methodName) { + var func = Math2[methodName]; + return function(number, precision) { + number = toNumber(number); + precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); + if (precision && nativeIsFinite(number)) { + var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision)); + pair = (toString(value) + "e").split("e"); + return +(pair[0] + "e" + (+pair[1] - precision)); + } + return func(number); + }; + } + var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values2) { + return new Set2(values2); + }; + function createToPairs(keysFunc) { + return function(object) { + var tag = getTag(object); + if (tag == mapTag) { + return mapToArray(object); + } + if (tag == setTag) { + return setToPairs(object); + } + return baseToPairs(object, keysFunc(object)); + }; + } + function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) { + var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; + if (!isBindKey && typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + var length = partials ? partials.length : 0; + if (!length) { + bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); + partials = holders = undefined2; + } + ary2 = ary2 === undefined2 ? ary2 : nativeMax(toInteger(ary2), 0); + arity = arity === undefined2 ? arity : toInteger(arity); + length -= holders ? holders.length : 0; + if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { + var partialsRight = partials, holdersRight = holders; + partials = holders = undefined2; + } + var data = isBindKey ? undefined2 : getData(func); + var newData = [ + func, + bitmask, + thisArg, + partials, + holders, + partialsRight, + holdersRight, + argPos, + ary2, + arity + ]; + if (data) { + mergeData(newData, data); + } + func = newData[0]; + bitmask = newData[1]; + thisArg = newData[2]; + partials = newData[3]; + holders = newData[4]; + arity = newData[9] = newData[9] === undefined2 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0); + if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { + bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); + } + if (!bitmask || bitmask == WRAP_BIND_FLAG) { + var result2 = createBind(func, bitmask, thisArg); + } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { + result2 = createCurry(func, bitmask, arity); + } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { + result2 = createPartial(func, bitmask, thisArg, partials); + } else { + result2 = createHybrid.apply(undefined2, newData); + } + var setter = data ? baseSetData : setData; + return setWrapToString(setter(result2, newData), func, bitmask); + } + function customDefaultsAssignIn(objValue, srcValue, key, object) { + if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key)) { + return srcValue; + } + return objValue; + } + function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { + if (isObject(objValue) && isObject(srcValue)) { + stack.set(srcValue, objValue); + baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack); + stack["delete"](srcValue); + } + return objValue; + } + function customOmitClone(value) { + return isPlainObject(value) ? undefined2 : value; + } + function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length; + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined2; + stack.set(array, other); + stack.set(other, array); + while (++index < arrLength) { + var arrValue = array[index], othValue = other[index]; + if (customizer) { + var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined2) { + if (compared) { + continue; + } + result2 = false; + break; + } + if (seen) { + if (!arraySome(other, function(othValue2, othIndex) { + if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result2 = false; + break; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + result2 = false; + break; + } + } + stack["delete"](array); + stack["delete"](other); + return result2; + } + function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) { + return false; + } + object = object.buffer; + other = other.buffer; + case arrayBufferTag: + if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) { + return false; + } + return true; + case boolTag: + case dateTag: + case numberTag: + return eq(+object, +other); + case errorTag: + return object.name == other.name && object.message == other.message; + case regexpTag: + case stringTag: + return object == other + ""; + case mapTag: + var convert = mapToArray; + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + if (object.size != other.size && !isPartial) { + return false; + } + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + stack.set(object, other); + var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack["delete"](object); + return result2; + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; + } + function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length; + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + var objStacked = stack.get(object); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + var result2 = true; + stack.set(object, other); + stack.set(other, object); + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], othValue = other[key]; + if (customizer) { + var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack); + } + if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) { + result2 = false; + break; + } + skipCtor || (skipCtor = key == "constructor"); + } + if (result2 && !skipCtor) { + var objCtor = object.constructor, othCtor = other.constructor; + if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) { + result2 = false; + } + } + stack["delete"](object); + stack["delete"](other); + return result2; + } + function flatRest(func) { + return setToString(overRest(func, undefined2, flatten), func + ""); + } + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); + } + function getAllKeysIn(object) { + return baseGetAllKeys(object, keysIn, getSymbolsIn); + } + var getData = !metaMap ? noop : function(func) { + return metaMap.get(func); + }; + function getFuncName(func) { + var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty.call(realNames, result2) ? array.length : 0; + while (length--) { + var data = array[length], otherFunc = data.func; + if (otherFunc == null || otherFunc == func) { + return data.name; + } + } + return result2; + } + function getHolder(func) { + var object = hasOwnProperty.call(lodash, "placeholder") ? lodash : func; + return object.placeholder; + } + function getIteratee() { + var result2 = lodash.iteratee || iteratee; + result2 = result2 === iteratee ? baseIteratee : result2; + return arguments.length ? result2(arguments[0], arguments[1]) : result2; + } + function getMapData(map2, key) { + var data = map2.__data__; + return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map; + } + function getMatchData(object) { + var result2 = keys(object), length = result2.length; + while (length--) { + var key = result2[length], value = object[key]; + result2[length] = [key, value, isStrictComparable(value)]; + } + return result2; + } + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined2; + } + function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag]; + try { + value[symToStringTag] = undefined2; + var unmasked = true; + } catch (e) { + } + var result2 = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result2; + } + var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object2(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); + }; + var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { + var result2 = []; + while (object) { + arrayPush(result2, getSymbols(object)); + object = getPrototype(object); + } + return result2; + }; + var getTag = baseGetTag; + if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) { + getTag = function(value) { + var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : ""; + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag; + case mapCtorString: + return mapTag; + case promiseCtorString: + return promiseTag; + case setCtorString: + return setTag; + case weakMapCtorString: + return weakMapTag; + } + } + return result2; + }; + } + function getView(start, end, transforms) { + var index = -1, length = transforms.length; + while (++index < length) { + var data = transforms[index], size2 = data.size; + switch (data.type) { + case "drop": + start += size2; + break; + case "dropRight": + end -= size2; + break; + case "take": + end = nativeMin(end, start + size2); + break; + case "takeRight": + start = nativeMax(start, end - size2); + break; + } + } + return { "start": start, "end": end }; + } + function getWrapDetails(source) { + var match = source.match(reWrapDetails); + return match ? match[1].split(reSplitDetails) : []; + } + function hasPath(object, path, hasFunc) { + path = castPath(path, object); + var index = -1, length = path.length, result2 = false; + while (++index < length) { + var key = toKey(path[index]); + if (!(result2 = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result2 || ++index != length) { + return result2; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object)); + } + function initCloneArray(array) { + var length = array.length, result2 = new array.constructor(length); + if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) { + result2.index = array.index; + result2.input = array.input; + } + return result2; + } + function initCloneObject(object) { + return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {}; + } + function initCloneByTag(object, tag, isDeep) { + var Ctor = object.constructor; + switch (tag) { + case arrayBufferTag: + return cloneArrayBuffer(object); + case boolTag: + case dateTag: + return new Ctor(+object); + case dataViewTag: + return cloneDataView(object, isDeep); + case float32Tag: + case float64Tag: + case int8Tag: + case int16Tag: + case int32Tag: + case uint8Tag: + case uint8ClampedTag: + case uint16Tag: + case uint32Tag: + return cloneTypedArray(object, isDeep); + case mapTag: + return new Ctor(); + case numberTag: + case stringTag: + return new Ctor(object); + case regexpTag: + return cloneRegExp(object); + case setTag: + return new Ctor(); + case symbolTag: + return cloneSymbol(object); + } + } + function insertWrapDetails(source, details) { + var length = details.length; + if (!length) { + return source; + } + var lastIndex = length - 1; + details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex]; + details = details.join(length > 2 ? ", " : " "); + return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n"); + } + function isFlattenable(value) { + return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]); + } + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length); + } + function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + var type = typeof index; + if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) { + return eq(object[index], value); + } + return false; + } + function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object); + } + function isKeyable(value) { + var type = typeof value; + return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null; + } + function isLaziable(func) { + var funcName = getFuncName(func), other = lodash[funcName]; + if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) { + return false; + } + if (func === other) { + return true; + } + var data = getData(other); + return !!data && func === data[0]; + } + function isMasked(func) { + return !!maskSrcKey && maskSrcKey in func; + } + var isMaskable = coreJsData ? isFunction : stubFalse; + function isPrototype(value) { + var Ctor = value && value.constructor, proto2 = typeof Ctor == "function" && Ctor.prototype || objectProto; + return value === proto2; + } + function isStrictComparable(value) { + return value === value && !isObject(value); + } + function matchesStrictComparable(key, srcValue) { + return function(object) { + if (object == null) { + return false; + } + return object[key] === srcValue && (srcValue !== undefined2 || key in Object2(object)); + }; + } + function memoizeCapped(func) { + var result2 = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + var cache = result2.cache; + return result2; + } + function mergeData(data, source) { + var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); + var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG; + if (!(isCommon || isCombo)) { + return data; + } + if (srcBitmask & WRAP_BIND_FLAG) { + data[2] = source[2]; + newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; + } + var value = source[3]; + if (value) { + var partials = data[3]; + data[3] = partials ? composeArgs(partials, value, source[4]) : value; + data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; + } + value = source[5]; + if (value) { + partials = data[5]; + data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; + data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; + } + value = source[7]; + if (value) { + data[7] = value; + } + if (srcBitmask & WRAP_ARY_FLAG) { + data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); + } + if (data[9] == null) { + data[9] = source[9]; + } + data[0] = source[0]; + data[1] = newBitmask; + return data; + } + function nativeKeysIn(object) { + var result2 = []; + if (object != null) { + for (var key in Object2(object)) { + result2.push(key); + } + } + return result2; + } + function objectToString(value) { + return nativeObjectToString.call(value); + } + function overRest(func, start, transform2) { + start = nativeMax(start === undefined2 ? func.length - 1 : start, 0); + return function() { + var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length); + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array2(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform2(array); + return apply(func, this, otherArgs); + }; + } + function parent(object, path) { + return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); + } + function reorder(array, indexes) { + var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array); + while (length--) { + var index = indexes[length]; + array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined2; + } + return array; + } + function safeGet(object, key) { + if (key === "constructor" && typeof object[key] === "function") { + return; + } + if (key == "__proto__") { + return; + } + return object[key]; + } + var setData = shortOut(baseSetData); + var setTimeout2 = ctxSetTimeout || function(func, wait) { + return root.setTimeout(func, wait); + }; + var setToString = shortOut(baseSetToString); + function setWrapToString(wrapper, reference, bitmask) { + var source = reference + ""; + return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); + } + function shortOut(func) { + var count = 0, lastCalled = 0; + return function() { + var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled); + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(undefined2, arguments); + }; + } + function shuffleSelf(array, size2) { + var index = -1, length = array.length, lastIndex = length - 1; + size2 = size2 === undefined2 ? length : size2; + while (++index < size2) { + var rand = baseRandom(index, lastIndex), value = array[rand]; + array[rand] = array[index]; + array[index] = value; + } + array.length = size2; + return array; + } + var stringToPath = memoizeCapped(function(string) { + var result2 = []; + if (string.charCodeAt(0) === 46) { + result2.push(""); + } + string.replace(rePropName, function(match, number, quote, subString) { + result2.push(quote ? subString.replace(reEscapeChar, "$1") : number || match); + }); + return result2; + }); + function toKey(value) { + if (typeof value == "string" || isSymbol(value)) { + return value; + } + var result2 = value + ""; + return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2; + } + function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) { + } + try { + return func + ""; + } catch (e) { + } + } + return ""; + } + function updateWrapDetails(details, bitmask) { + arrayEach(wrapFlags, function(pair) { + var value = "_." + pair[0]; + if (bitmask & pair[1] && !arrayIncludes(details, value)) { + details.push(value); + } + }); + return details.sort(); + } + function wrapperClone(wrapper) { + if (wrapper instanceof LazyWrapper) { + return wrapper.clone(); + } + var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); + result2.__actions__ = copyArray(wrapper.__actions__); + result2.__index__ = wrapper.__index__; + result2.__values__ = wrapper.__values__; + return result2; + } + function chunk(array, size2, guard) { + if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined2) { + size2 = 1; + } else { + size2 = nativeMax(toInteger(size2), 0); + } + var length = array == null ? 0 : array.length; + if (!length || size2 < 1) { + return []; + } + var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2)); + while (index < length) { + result2[resIndex++] = baseSlice(array, index, index += size2); + } + return result2; + } + function compact(array) { + var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = []; + while (++index < length) { + var value = array[index]; + if (value) { + result2[resIndex++] = value; + } + } + return result2; + } + function concat() { + var length = arguments.length; + if (!length) { + return []; + } + var args = Array2(length - 1), array = arguments[0], index = length; + while (index--) { + args[index - 1] = arguments[index]; + } + return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); + } + var difference = baseRest(function(array, values2) { + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : []; + }); + var differenceBy = baseRest(function(array, values2) { + var iteratee2 = last(values2); + if (isArrayLikeObject(iteratee2)) { + iteratee2 = undefined2; + } + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : []; + }); + var differenceWith = baseRest(function(array, values2) { + var comparator = last(values2); + if (isArrayLikeObject(comparator)) { + comparator = undefined2; + } + return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined2, comparator) : []; + }); + function drop(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined2 ? 1 : toInteger(n); + return baseSlice(array, n < 0 ? 0 : n, length); + } + function dropRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined2 ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, 0, n < 0 ? 0 : n); + } + function dropRightWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : []; + } + function dropWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : []; + } + function fill(array, value, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (start && typeof start != "number" && isIterateeCall(array, value, start)) { + start = 0; + end = length; + } + return baseFill(array, value, start, end); + } + function findIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseFindIndex(array, getIteratee(predicate, 3), index); + } + function findLastIndex(array, predicate, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length - 1; + if (fromIndex !== undefined2) { + index = toInteger(fromIndex); + index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + return baseFindIndex(array, getIteratee(predicate, 3), index, true); + } + function flatten(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, 1) : []; + } + function flattenDeep(array) { + var length = array == null ? 0 : array.length; + return length ? baseFlatten(array, INFINITY) : []; + } + function flattenDepth(array, depth) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + depth = depth === undefined2 ? 1 : toInteger(depth); + return baseFlatten(array, depth); + } + function fromPairs(pairs) { + var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {}; + while (++index < length) { + var pair = pairs[index]; + result2[pair[0]] = pair[1]; + } + return result2; + } + function head(array) { + return array && array.length ? array[0] : undefined2; + } + function indexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger(fromIndex); + if (index < 0) { + index = nativeMax(length + index, 0); + } + return baseIndexOf(array, value, index); + } + function initial(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 0, -1) : []; + } + var intersection = baseRest(function(arrays) { + var mapped = arrayMap(arrays, castArrayLikeObject); + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : []; + }); + var intersectionBy = baseRest(function(arrays) { + var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject); + if (iteratee2 === last(mapped)) { + iteratee2 = undefined2; + } else { + mapped.pop(); + } + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : []; + }); + var intersectionWith = baseRest(function(arrays) { + var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject); + comparator = typeof comparator == "function" ? comparator : undefined2; + if (comparator) { + mapped.pop(); + } + return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : []; + }); + function join(array, separator) { + return array == null ? "" : nativeJoin.call(array, separator); + } + function last(array) { + var length = array == null ? 0 : array.length; + return length ? array[length - 1] : undefined2; + } + function lastIndexOf(array, value, fromIndex) { + var length = array == null ? 0 : array.length; + if (!length) { + return -1; + } + var index = length; + if (fromIndex !== undefined2) { + index = toInteger(fromIndex); + index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); + } + return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true); + } + function nth(array, n) { + return array && array.length ? baseNth(array, toInteger(n)) : undefined2; + } + var pull = baseRest(pullAll); + function pullAll(array, values2) { + return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array; + } + function pullAllBy(array, values2, iteratee2) { + return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array; + } + function pullAllWith(array, values2, comparator) { + return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array; + } + var pullAt = flatRest(function(array, indexes) { + var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes); + basePullAt(array, arrayMap(indexes, function(index) { + return isIndex(index, length) ? +index : index; + }).sort(compareAscending)); + return result2; + }); + function remove(array, predicate) { + var result2 = []; + if (!(array && array.length)) { + return result2; + } + var index = -1, indexes = [], length = array.length; + predicate = getIteratee(predicate, 3); + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result2.push(value); + indexes.push(index); + } + } + basePullAt(array, indexes); + return result2; + } + function reverse(array) { + return array == null ? array : nativeReverse.call(array); + } + function slice(array, start, end) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + if (end && typeof end != "number" && isIterateeCall(array, start, end)) { + start = 0; + end = length; + } else { + start = start == null ? 0 : toInteger(start); + end = end === undefined2 ? length : toInteger(end); + } + return baseSlice(array, start, end); + } + function sortedIndex(array, value) { + return baseSortedIndex(array, value); + } + function sortedIndexBy(array, value, iteratee2) { + return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2)); + } + function sortedIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value); + if (index < length && eq(array[index], value)) { + return index; + } + } + return -1; + } + function sortedLastIndex(array, value) { + return baseSortedIndex(array, value, true); + } + function sortedLastIndexBy(array, value, iteratee2) { + return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true); + } + function sortedLastIndexOf(array, value) { + var length = array == null ? 0 : array.length; + if (length) { + var index = baseSortedIndex(array, value, true) - 1; + if (eq(array[index], value)) { + return index; + } + } + return -1; + } + function sortedUniq(array) { + return array && array.length ? baseSortedUniq(array) : []; + } + function sortedUniqBy(array, iteratee2) { + return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : []; + } + function tail(array) { + var length = array == null ? 0 : array.length; + return length ? baseSlice(array, 1, length) : []; + } + function take(array, n, guard) { + if (!(array && array.length)) { + return []; + } + n = guard || n === undefined2 ? 1 : toInteger(n); + return baseSlice(array, 0, n < 0 ? 0 : n); + } + function takeRight(array, n, guard) { + var length = array == null ? 0 : array.length; + if (!length) { + return []; + } + n = guard || n === undefined2 ? 1 : toInteger(n); + n = length - n; + return baseSlice(array, n < 0 ? 0 : n, length); + } + function takeRightWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : []; + } + function takeWhile(array, predicate) { + return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : []; + } + var union = baseRest(function(arrays) { + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); + }); + var unionBy = baseRest(function(arrays) { + var iteratee2 = last(arrays); + if (isArrayLikeObject(iteratee2)) { + iteratee2 = undefined2; + } + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)); + }); + var unionWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == "function" ? comparator : undefined2; + return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined2, comparator); + }); + function uniq(array) { + return array && array.length ? baseUniq(array) : []; + } + function uniqBy(array, iteratee2) { + return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : []; + } + function uniqWith(array, comparator) { + comparator = typeof comparator == "function" ? comparator : undefined2; + return array && array.length ? baseUniq(array, undefined2, comparator) : []; + } + function unzip(array) { + if (!(array && array.length)) { + return []; + } + var length = 0; + array = arrayFilter(array, function(group) { + if (isArrayLikeObject(group)) { + length = nativeMax(group.length, length); + return true; + } + }); + return baseTimes(length, function(index) { + return arrayMap(array, baseProperty(index)); + }); + } + function unzipWith(array, iteratee2) { + if (!(array && array.length)) { + return []; + } + var result2 = unzip(array); + if (iteratee2 == null) { + return result2; + } + return arrayMap(result2, function(group) { + return apply(iteratee2, undefined2, group); + }); + } + var without = baseRest(function(array, values2) { + return isArrayLikeObject(array) ? baseDifference(array, values2) : []; + }); + var xor = baseRest(function(arrays) { + return baseXor(arrayFilter(arrays, isArrayLikeObject)); + }); + var xorBy = baseRest(function(arrays) { + var iteratee2 = last(arrays); + if (isArrayLikeObject(iteratee2)) { + iteratee2 = undefined2; + } + return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2)); + }); + var xorWith = baseRest(function(arrays) { + var comparator = last(arrays); + comparator = typeof comparator == "function" ? comparator : undefined2; + return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined2, comparator); + }); + var zip = baseRest(unzip); + function zipObject(props, values2) { + return baseZipObject(props || [], values2 || [], assignValue); + } + function zipObjectDeep(props, values2) { + return baseZipObject(props || [], values2 || [], baseSet); + } + var zipWith = baseRest(function(arrays) { + var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined2; + iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined2; + return unzipWith(arrays, iteratee2); + }); + function chain(value) { + var result2 = lodash(value); + result2.__chain__ = true; + return result2; + } + function tap(value, interceptor) { + interceptor(value); + return value; + } + function thru(value, interceptor) { + return interceptor(value); + } + var wrapperAt = flatRest(function(paths) { + var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) { + return baseAt(object, paths); + }; + if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) { + return this.thru(interceptor); + } + value = value.slice(start, +start + (length ? 1 : 0)); + value.__actions__.push({ + "func": thru, + "args": [interceptor], + "thisArg": undefined2 + }); + return new LodashWrapper(value, this.__chain__).thru(function(array) { + if (length && !array.length) { + array.push(undefined2); + } + return array; + }); + }); + function wrapperChain() { + return chain(this); + } + function wrapperCommit() { + return new LodashWrapper(this.value(), this.__chain__); + } + function wrapperNext() { + if (this.__values__ === undefined2) { + this.__values__ = toArray(this.value()); + } + var done = this.__index__ >= this.__values__.length, value = done ? undefined2 : this.__values__[this.__index__++]; + return { "done": done, "value": value }; + } + function wrapperToIterator() { + return this; + } + function wrapperPlant(value) { + var result2, parent2 = this; + while (parent2 instanceof baseLodash) { + var clone2 = wrapperClone(parent2); + clone2.__index__ = 0; + clone2.__values__ = undefined2; + if (result2) { + previous.__wrapped__ = clone2; + } else { + result2 = clone2; + } + var previous = clone2; + parent2 = parent2.__wrapped__; + } + previous.__wrapped__ = value; + return result2; + } + function wrapperReverse() { + var value = this.__wrapped__; + if (value instanceof LazyWrapper) { + var wrapped = value; + if (this.__actions__.length) { + wrapped = new LazyWrapper(this); + } + wrapped = wrapped.reverse(); + wrapped.__actions__.push({ + "func": thru, + "args": [reverse], + "thisArg": undefined2 + }); + return new LodashWrapper(wrapped, this.__chain__); + } + return this.thru(reverse); + } + function wrapperValue() { + return baseWrapperValue(this.__wrapped__, this.__actions__); + } + var countBy = createAggregator(function(result2, value, key) { + if (hasOwnProperty.call(result2, key)) { + ++result2[key]; + } else { + baseAssignValue(result2, key, 1); + } + }); + function every(collection, predicate, guard) { + var func = isArray(collection) ? arrayEvery : baseEvery; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined2; + } + return func(collection, getIteratee(predicate, 3)); + } + function filter(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, getIteratee(predicate, 3)); + } + var find = createFind(findIndex); + var findLast = createFind(findLastIndex); + function flatMap(collection, iteratee2) { + return baseFlatten(map(collection, iteratee2), 1); + } + function flatMapDeep(collection, iteratee2) { + return baseFlatten(map(collection, iteratee2), INFINITY); + } + function flatMapDepth(collection, iteratee2, depth) { + depth = depth === undefined2 ? 1 : toInteger(depth); + return baseFlatten(map(collection, iteratee2), depth); + } + function forEach(collection, iteratee2) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, getIteratee(iteratee2, 3)); + } + function forEachRight(collection, iteratee2) { + var func = isArray(collection) ? arrayEachRight : baseEachRight; + return func(collection, getIteratee(iteratee2, 3)); + } + var groupBy = createAggregator(function(result2, value, key) { + if (hasOwnProperty.call(result2, key)) { + result2[key].push(value); + } else { + baseAssignValue(result2, key, [value]); + } + }); + function includes(collection, value, fromIndex, guard) { + collection = isArrayLike(collection) ? collection : values(collection); + fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0; + var length = collection.length; + if (fromIndex < 0) { + fromIndex = nativeMax(length + fromIndex, 0); + } + return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1; + } + var invokeMap = baseRest(function(collection, path, args) { + var index = -1, isFunc = typeof path == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : []; + baseEach(collection, function(value) { + result2[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); + }); + return result2; + }); + var keyBy = createAggregator(function(result2, value, key) { + baseAssignValue(result2, key, value); + }); + function map(collection, iteratee2) { + var func = isArray(collection) ? arrayMap : baseMap; + return func(collection, getIteratee(iteratee2, 3)); + } + function orderBy(collection, iteratees, orders, guard) { + if (collection == null) { + return []; + } + if (!isArray(iteratees)) { + iteratees = iteratees == null ? [] : [iteratees]; + } + orders = guard ? undefined2 : orders; + if (!isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + return baseOrderBy(collection, iteratees, orders); + } + var partition = createAggregator(function(result2, value, key) { + result2[key ? 0 : 1].push(value); + }, function() { + return [[], []]; + }); + function reduce(collection, iteratee2, accumulator) { + var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3; + return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach); + } + function reduceRight(collection, iteratee2, accumulator) { + var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3; + return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight); + } + function reject(collection, predicate) { + var func = isArray(collection) ? arrayFilter : baseFilter; + return func(collection, negate(getIteratee(predicate, 3))); + } + function sample(collection) { + var func = isArray(collection) ? arraySample : baseSample; + return func(collection); + } + function sampleSize(collection, n, guard) { + if (guard ? isIterateeCall(collection, n, guard) : n === undefined2) { + n = 1; + } else { + n = toInteger(n); + } + var func = isArray(collection) ? arraySampleSize : baseSampleSize; + return func(collection, n); + } + function shuffle(collection) { + var func = isArray(collection) ? arrayShuffle : baseShuffle; + return func(collection); + } + function size(collection) { + if (collection == null) { + return 0; + } + if (isArrayLike(collection)) { + return isString(collection) ? stringSize(collection) : collection.length; + } + var tag = getTag(collection); + if (tag == mapTag || tag == setTag) { + return collection.size; + } + return baseKeys(collection).length; + } + function some(collection, predicate, guard) { + var func = isArray(collection) ? arraySome : baseSome; + if (guard && isIterateeCall(collection, predicate, guard)) { + predicate = undefined2; + } + return func(collection, getIteratee(predicate, 3)); + } + var sortBy = baseRest(function(collection, iteratees) { + if (collection == null) { + return []; + } + var length = iteratees.length; + if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + return baseOrderBy(collection, baseFlatten(iteratees, 1), []); + }); + var now = ctxNow || function() { + return root.Date.now(); + }; + function after(n, func) { + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n < 1) { + return func.apply(this, arguments); + } + }; + } + function ary(func, n, guard) { + n = guard ? undefined2 : n; + n = func && n == null ? func.length : n; + return createWrap(func, WRAP_ARY_FLAG, undefined2, undefined2, undefined2, undefined2, n); + } + function before(n, func) { + var result2; + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + n = toInteger(n); + return function() { + if (--n > 0) { + result2 = func.apply(this, arguments); + } + if (n <= 1) { + func = undefined2; + } + return result2; + }; + } + var bind = baseRest(function(func, thisArg, partials) { + var bitmask = WRAP_BIND_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bind)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(func, bitmask, thisArg, partials, holders); + }); + var bindKey = baseRest(function(object, key, partials) { + var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; + if (partials.length) { + var holders = replaceHolders(partials, getHolder(bindKey)); + bitmask |= WRAP_PARTIAL_FLAG; + } + return createWrap(key, bitmask, object, partials, holders); + }); + function curry(func, arity, guard) { + arity = guard ? undefined2 : arity; + var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity); + result2.placeholder = curry.placeholder; + return result2; + } + function curryRight(func, arity, guard) { + arity = guard ? undefined2 : arity; + var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity); + result2.placeholder = curryRight.placeholder; + return result2; + } + function debounce(func, wait, options) { + var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true; + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = "maxWait" in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = "trailing" in options ? !!options.trailing : trailing; + } + function invokeFunc(time) { + var args = lastArgs, thisArg = lastThis; + lastArgs = lastThis = undefined2; + lastInvokeTime = time; + result2 = func.apply(thisArg, args); + return result2; + } + function leadingEdge(time) { + lastInvokeTime = time; + timerId = setTimeout2(timerExpired, wait); + return leading ? invokeFunc(time) : result2; + } + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall; + return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting; + } + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime; + return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait; + } + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + timerId = setTimeout2(timerExpired, remainingWait(time)); + } + function trailingEdge(time) { + timerId = undefined2; + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined2; + return result2; + } + function cancel() { + if (timerId !== undefined2) { + clearTimeout2(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined2; + } + function flush() { + return timerId === undefined2 ? result2 : trailingEdge(now()); + } + function debounced() { + var time = now(), isInvoking = shouldInvoke(time); + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + if (isInvoking) { + if (timerId === undefined2) { + return leadingEdge(lastCallTime); + } + if (maxing) { + clearTimeout2(timerId); + timerId = setTimeout2(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined2) { + timerId = setTimeout2(timerExpired, wait); + } + return result2; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; + } + var defer = baseRest(function(func, args) { + return baseDelay(func, 1, args); + }); + var delay = baseRest(function(func, wait, args) { + return baseDelay(func, toNumber(wait) || 0, args); + }); + function flip(func) { + return createWrap(func, WRAP_FLIP_FLAG); + } + function memoize(func, resolver) { + if (typeof func != "function" || resolver != null && typeof resolver != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + var result2 = func.apply(this, args); + memoized.cache = cache.set(key, result2) || cache; + return result2; + }; + memoized.cache = new (memoize.Cache || MapCache)(); + return memoized; + } + memoize.Cache = MapCache; + function negate(predicate) { + if (typeof predicate != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + return function() { + var args = arguments; + switch (args.length) { + case 0: + return !predicate.call(this); + case 1: + return !predicate.call(this, args[0]); + case 2: + return !predicate.call(this, args[0], args[1]); + case 3: + return !predicate.call(this, args[0], args[1], args[2]); + } + return !predicate.apply(this, args); + }; + } + function once(func) { + return before(2, func); + } + var overArgs = castRest(function(func, transforms) { + transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); + var funcsLength = transforms.length; + return baseRest(function(args) { + var index = -1, length = nativeMin(args.length, funcsLength); + while (++index < length) { + args[index] = transforms[index].call(this, args[index]); + } + return apply(func, this, args); + }); + }); + var partial = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partial)); + return createWrap(func, WRAP_PARTIAL_FLAG, undefined2, partials, holders); + }); + var partialRight = baseRest(function(func, partials) { + var holders = replaceHolders(partials, getHolder(partialRight)); + return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined2, partials, holders); + }); + var rearg = flatRest(function(func, indexes) { + return createWrap(func, WRAP_REARG_FLAG, undefined2, undefined2, undefined2, indexes); + }); + function rest(func, start) { + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + start = start === undefined2 ? start : toInteger(start); + return baseRest(func, start); + } + function spread(func, start) { + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + start = start == null ? 0 : nativeMax(toInteger(start), 0); + return baseRest(function(args) { + var array = args[start], otherArgs = castSlice(args, 0, start); + if (array) { + arrayPush(otherArgs, array); + } + return apply(func, this, otherArgs); + }); + } + function throttle(func, wait, options) { + var leading = true, trailing = true; + if (typeof func != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + if (isObject(options)) { + leading = "leading" in options ? !!options.leading : leading; + trailing = "trailing" in options ? !!options.trailing : trailing; + } + return debounce(func, wait, { + "leading": leading, + "maxWait": wait, + "trailing": trailing + }); + } + function unary(func) { + return ary(func, 1); + } + function wrap(value, wrapper) { + return partial(castFunction(wrapper), value); + } + function castArray() { + if (!arguments.length) { + return []; + } + var value = arguments[0]; + return isArray(value) ? value : [value]; + } + function clone(value) { + return baseClone(value, CLONE_SYMBOLS_FLAG); + } + function cloneWith(value, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); + } + function cloneDeep(value) { + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); + } + function cloneDeepWith(value, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); + } + function conformsTo(object, source) { + return source == null || baseConformsTo(object, source, keys(source)); + } + function eq(value, other) { + return value === other || value !== value && other !== other; + } + var gt = createRelationalOperation(baseGt); + var gte = createRelationalOperation(function(value, other) { + return value >= other; + }); + var isArguments = baseIsArguments(/* @__PURE__ */ (function() { + return arguments; + })()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee"); + }; + var isArray = Array2.isArray; + var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + function isBoolean(value) { + return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag; + } + var isBuffer = nativeIsBuffer || stubFalse; + var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; + function isElement(value) { + return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); + } + function isEmpty(value) { + if (value == null) { + return true; + } + if (isArrayLike(value) && (isArray(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) { + return !value.length; + } + var tag = getTag(value); + if (tag == mapTag || tag == setTag) { + return !value.size; + } + if (isPrototype(value)) { + return !baseKeys(value).length; + } + for (var key in value) { + if (hasOwnProperty.call(value, key)) { + return false; + } + } + return true; + } + function isEqual(value, other) { + return baseIsEqual(value, other); + } + function isEqualWith(value, other, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + var result2 = customizer ? customizer(value, other) : undefined2; + return result2 === undefined2 ? baseIsEqual(value, other, undefined2, customizer) : !!result2; + } + function isError(value) { + if (!isObjectLike(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value); + } + function isFinite2(value) { + return typeof value == "number" && nativeIsFinite(value); + } + function isFunction(value) { + if (!isObject(value)) { + return false; + } + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + function isInteger(value) { + return typeof value == "number" && value == toInteger(value); + } + function isLength(value) { + return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + function isObject(value) { + var type = typeof value; + return value != null && (type == "object" || type == "function"); + } + function isObjectLike(value) { + return value != null && typeof value == "object"; + } + var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; + function isMatch(object, source) { + return object === source || baseIsMatch(object, source, getMatchData(source)); + } + function isMatchWith(object, source, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + return baseIsMatch(object, source, getMatchData(source), customizer); + } + function isNaN2(value) { + return isNumber(value) && value != +value; + } + function isNative(value) { + if (isMaskable(value)) { + throw new Error2(CORE_ERROR_TEXT); + } + return baseIsNative(value); + } + function isNull(value) { + return value === null; + } + function isNil(value) { + return value == null; + } + function isNumber(value) { + return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag; + } + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag) { + return false; + } + var proto2 = getPrototype(value); + if (proto2 === null) { + return true; + } + var Ctor = hasOwnProperty.call(proto2, "constructor") && proto2.constructor; + return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString; + } + var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; + function isSafeInteger(value) { + return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; + } + var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; + function isString(value) { + return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag; + } + function isSymbol(value) { + return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag; + } + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + function isUndefined(value) { + return value === undefined2; + } + function isWeakMap(value) { + return isObjectLike(value) && getTag(value) == weakMapTag; + } + function isWeakSet(value) { + return isObjectLike(value) && baseGetTag(value) == weakSetTag; + } + var lt = createRelationalOperation(baseLt); + var lte = createRelationalOperation(function(value, other) { + return value <= other; + }); + function toArray(value) { + if (!value) { + return []; + } + if (isArrayLike(value)) { + return isString(value) ? stringToArray(value) : copyArray(value); + } + if (symIterator && value[symIterator]) { + return iteratorToArray(value[symIterator]()); + } + var tag = getTag(value), func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values; + return func(value); + } + function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === INFINITY || value === -INFINITY) { + var sign = value < 0 ? -1 : 1; + return sign * MAX_INTEGER; + } + return value === value ? value : 0; + } + function toInteger(value) { + var result2 = toFinite(value), remainder = result2 % 1; + return result2 === result2 ? remainder ? result2 - remainder : result2 : 0; + } + function toLength(value) { + return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; + } + function toNumber(value) { + if (typeof value == "number") { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == "function" ? value.valueOf() : value; + value = isObject(other) ? other + "" : other; + } + if (typeof value != "string") { + return value === 0 ? value : +value; + } + value = baseTrim(value); + var isBinary = reIsBinary.test(value); + return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value; + } + function toPlainObject(value) { + return copyObject(value, keysIn(value)); + } + function toSafeInteger(value) { + return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0; + } + function toString(value) { + return value == null ? "" : baseToString(value); + } + var assign = createAssigner(function(object, source) { + if (isPrototype(source) || isArrayLike(source)) { + copyObject(source, keys(source), object); + return; + } + for (var key in source) { + if (hasOwnProperty.call(source, key)) { + assignValue(object, key, source[key]); + } + } + }); + var assignIn = createAssigner(function(object, source) { + copyObject(source, keysIn(source), object); + }); + var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keysIn(source), object, customizer); + }); + var assignWith = createAssigner(function(object, source, srcIndex, customizer) { + copyObject(source, keys(source), object, customizer); + }); + var at = flatRest(baseAt); + function create(prototype, properties) { + var result2 = baseCreate(prototype); + return properties == null ? result2 : baseAssign(result2, properties); + } + var defaults = baseRest(function(object, sources) { + object = Object2(object); + var index = -1; + var length = sources.length; + var guard = length > 2 ? sources[2] : undefined2; + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + while (++index < length) { + var source = sources[index]; + var props = keysIn(source); + var propsIndex = -1; + var propsLength = props.length; + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value = object[key]; + if (value === undefined2 || eq(value, objectProto[key]) && !hasOwnProperty.call(object, key)) { + object[key] = source[key]; + } + } + } + return object; + }); + var defaultsDeep = baseRest(function(args) { + args.push(undefined2, customDefaultsMerge); + return apply(mergeWith, undefined2, args); + }); + function findKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); + } + function findLastKey(object, predicate) { + return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); + } + function forIn(object, iteratee2) { + return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn); + } + function forInRight(object, iteratee2) { + return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn); + } + function forOwn(object, iteratee2) { + return object && baseForOwn(object, getIteratee(iteratee2, 3)); + } + function forOwnRight(object, iteratee2) { + return object && baseForOwnRight(object, getIteratee(iteratee2, 3)); + } + function functions(object) { + return object == null ? [] : baseFunctions(object, keys(object)); + } + function functionsIn(object) { + return object == null ? [] : baseFunctions(object, keysIn(object)); + } + function get(object, path, defaultValue) { + var result2 = object == null ? undefined2 : baseGet(object, path); + return result2 === undefined2 ? defaultValue : result2; + } + function has(object, path) { + return object != null && hasPath(object, path, baseHas); + } + function hasIn(object, path) { + return object != null && hasPath(object, path, baseHasIn); + } + var invert = createInverter(function(result2, value, key) { + if (value != null && typeof value.toString != "function") { + value = nativeObjectToString.call(value); + } + result2[value] = key; + }, constant(identity)); + var invertBy = createInverter(function(result2, value, key) { + if (value != null && typeof value.toString != "function") { + value = nativeObjectToString.call(value); + } + if (hasOwnProperty.call(result2, value)) { + result2[value].push(key); + } else { + result2[value] = [key]; + } + }, getIteratee); + var invoke = baseRest(baseInvoke); + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); + } + function mapKeys(object, iteratee2) { + var result2 = {}; + iteratee2 = getIteratee(iteratee2, 3); + baseForOwn(object, function(value, key, object2) { + baseAssignValue(result2, iteratee2(value, key, object2), value); + }); + return result2; + } + function mapValues(object, iteratee2) { + var result2 = {}; + iteratee2 = getIteratee(iteratee2, 3); + baseForOwn(object, function(value, key, object2) { + baseAssignValue(result2, key, iteratee2(value, key, object2)); + }); + return result2; + } + var merge = createAssigner(function(object, source, srcIndex) { + baseMerge(object, source, srcIndex); + }); + var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); + }); + var omit = flatRest(function(object, paths) { + var result2 = {}; + if (object == null) { + return result2; + } + var isDeep = false; + paths = arrayMap(paths, function(path) { + path = castPath(path, object); + isDeep || (isDeep = path.length > 1); + return path; + }); + copyObject(object, getAllKeysIn(object), result2); + if (isDeep) { + result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); + } + var length = paths.length; + while (length--) { + baseUnset(result2, paths[length]); + } + return result2; + }); + function omitBy(object, predicate) { + return pickBy(object, negate(getIteratee(predicate))); + } + var pick = flatRest(function(object, paths) { + return object == null ? {} : basePick(object, paths); + }); + function pickBy(object, predicate) { + if (object == null) { + return {}; + } + var props = arrayMap(getAllKeysIn(object), function(prop) { + return [prop]; + }); + predicate = getIteratee(predicate); + return basePickBy(object, props, function(value, path) { + return predicate(value, path[0]); + }); + } + function result(object, path, defaultValue) { + path = castPath(path, object); + var index = -1, length = path.length; + if (!length) { + length = 1; + object = undefined2; + } + while (++index < length) { + var value = object == null ? undefined2 : object[toKey(path[index])]; + if (value === undefined2) { + index = length; + value = defaultValue; + } + object = isFunction(value) ? value.call(object) : value; + } + return object; + } + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); + } + function setWith(object, path, value, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + return object == null ? object : baseSet(object, path, value, customizer); + } + var toPairs = createToPairs(keys); + var toPairsIn = createToPairs(keysIn); + function transform(object, iteratee2, accumulator) { + var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object); + iteratee2 = getIteratee(iteratee2, 4); + if (accumulator == null) { + var Ctor = object && object.constructor; + if (isArrLike) { + accumulator = isArr ? new Ctor() : []; + } else if (isObject(object)) { + accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; + } else { + accumulator = {}; + } + } + (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) { + return iteratee2(accumulator, value, index, object2); + }); + return accumulator; + } + function unset(object, path) { + return object == null ? true : baseUnset(object, path); + } + function update(object, path, updater) { + return object == null ? object : baseUpdate(object, path, castFunction(updater)); + } + function updateWith(object, path, updater, customizer) { + customizer = typeof customizer == "function" ? customizer : undefined2; + return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); + } + function values(object) { + return object == null ? [] : baseValues(object, keys(object)); + } + function valuesIn(object) { + return object == null ? [] : baseValues(object, keysIn(object)); + } + function clamp(number, lower, upper) { + if (upper === undefined2) { + upper = lower; + lower = undefined2; + } + if (upper !== undefined2) { + upper = toNumber(upper); + upper = upper === upper ? upper : 0; + } + if (lower !== undefined2) { + lower = toNumber(lower); + lower = lower === lower ? lower : 0; + } + return baseClamp(toNumber(number), lower, upper); + } + function inRange(number, start, end) { + start = toFinite(start); + if (end === undefined2) { + end = start; + start = 0; + } else { + end = toFinite(end); + } + number = toNumber(number); + return baseInRange(number, start, end); + } + function random(lower, upper, floating) { + if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) { + upper = floating = undefined2; + } + if (floating === undefined2) { + if (typeof upper == "boolean") { + floating = upper; + upper = undefined2; + } else if (typeof lower == "boolean") { + floating = lower; + lower = undefined2; + } + } + if (lower === undefined2 && upper === undefined2) { + lower = 0; + upper = 1; + } else { + lower = toFinite(lower); + if (upper === undefined2) { + upper = lower; + lower = 0; + } else { + upper = toFinite(upper); + } + } + if (lower > upper) { + var temp = lower; + lower = upper; + upper = temp; + } + if (floating || lower % 1 || upper % 1) { + var rand = nativeRandom(); + return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper); + } + return baseRandom(lower, upper); + } + var camelCase = createCompounder(function(result2, word, index) { + word = word.toLowerCase(); + return result2 + (index ? capitalize(word) : word); + }); + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); + } + function deburr(string) { + string = toString(string); + return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ""); + } + function endsWith(string, target, position) { + string = toString(string); + target = baseToString(target); + var length = string.length; + position = position === undefined2 ? length : baseClamp(toInteger(position), 0, length); + var end = position; + position -= target.length; + return position >= 0 && string.slice(position, end) == target; + } + function escape2(string) { + string = toString(string); + return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string; + } + function escapeRegExp(string) { + string = toString(string); + return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string; + } + var kebabCase = createCompounder(function(result2, word, index) { + return result2 + (index ? "-" : "") + word.toLowerCase(); + }); + var lowerCase = createCompounder(function(result2, word, index) { + return result2 + (index ? " " : "") + word.toLowerCase(); + }); + var lowerFirst = createCaseFirst("toLowerCase"); + function pad(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + if (!length || strLength >= length) { + return string; + } + var mid = (length - strLength) / 2; + return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars); + } + function padEnd(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length ? string + createPadding(length - strLength, chars) : string; + } + function padStart(string, length, chars) { + string = toString(string); + length = toInteger(length); + var strLength = length ? stringSize(string) : 0; + return length && strLength < length ? createPadding(length - strLength, chars) + string : string; + } + function parseInt2(string, radix, guard) { + if (guard || radix == null) { + radix = 0; + } else if (radix) { + radix = +radix; + } + return nativeParseInt(toString(string).replace(reTrimStart, ""), radix || 0); + } + function repeat(string, n, guard) { + if (guard ? isIterateeCall(string, n, guard) : n === undefined2) { + n = 1; + } else { + n = toInteger(n); + } + return baseRepeat(toString(string), n); + } + function replace() { + var args = arguments, string = toString(args[0]); + return args.length < 3 ? string : string.replace(args[1], args[2]); + } + var snakeCase = createCompounder(function(result2, word, index) { + return result2 + (index ? "_" : "") + word.toLowerCase(); + }); + function split(string, separator, limit) { + if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) { + separator = limit = undefined2; + } + limit = limit === undefined2 ? MAX_ARRAY_LENGTH : limit >>> 0; + if (!limit) { + return []; + } + string = toString(string); + if (string && (typeof separator == "string" || separator != null && !isRegExp(separator))) { + separator = baseToString(separator); + if (!separator && hasUnicode(string)) { + return castSlice(stringToArray(string), 0, limit); + } + } + return string.split(separator, limit); + } + var startCase = createCompounder(function(result2, word, index) { + return result2 + (index ? " " : "") + upperFirst(word); + }); + function startsWith(string, target, position) { + string = toString(string); + position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length); + target = baseToString(target); + return string.slice(position, position + target.length) == target; + } + function template(string, options, guard) { + var settings = lodash.templateSettings; + if (guard && isIterateeCall(string, options, guard)) { + options = undefined2; + } + string = toString(string); + options = assignInWith({}, options, settings, customDefaultsAssignIn); + var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys); + var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '"; + var reDelimiters = RegExp2( + (options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", + "g" + ); + var sourceURL = "//# sourceURL=" + (hasOwnProperty.call(options, "sourceURL") ? (options.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n"; + string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) { + interpolateValue || (interpolateValue = esTemplateValue); + source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar); + if (escapeValue) { + isEscaping = true; + source += "' +\n__e(" + escapeValue + ") +\n'"; + } + if (evaluateValue) { + isEvaluating = true; + source += "';\n" + evaluateValue + ";\n__p += '"; + } + if (interpolateValue) { + source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'"; + } + index = offset + match.length; + return match; + }); + source += "';\n"; + var variable = hasOwnProperty.call(options, "variable") && options.variable; + if (!variable) { + source = "with (obj) {\n" + source + "\n}\n"; + } else if (reForbiddenIdentifierChars.test(variable)) { + throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT); + } + source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;"); + source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}"; + var result2 = attempt(function() { + return Function2(importsKeys, sourceURL + "return " + source).apply(undefined2, importsValues); + }); + result2.source = source; + if (isError(result2)) { + throw result2; + } + return result2; + } + function toLower(value) { + return toString(value).toLowerCase(); + } + function toUpper(value) { + return toString(value).toUpperCase(); + } + function trim(string, chars, guard) { + string = toString(string); + if (string && (guard || chars === undefined2)) { + return baseTrim(string); + } + if (!string || !(chars = baseToString(chars))) { + return string; + } + var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1; + return castSlice(strSymbols, start, end).join(""); + } + function trimEnd(string, chars, guard) { + string = toString(string); + if (string && (guard || chars === undefined2)) { + return string.slice(0, trimmedEndIndex(string) + 1); + } + if (!string || !(chars = baseToString(chars))) { + return string; + } + var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1; + return castSlice(strSymbols, 0, end).join(""); + } + function trimStart(string, chars, guard) { + string = toString(string); + if (string && (guard || chars === undefined2)) { + return string.replace(reTrimStart, ""); + } + if (!string || !(chars = baseToString(chars))) { + return string; + } + var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars)); + return castSlice(strSymbols, start).join(""); + } + function truncate(string, options) { + var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION; + if (isObject(options)) { + var separator = "separator" in options ? options.separator : separator; + length = "length" in options ? toInteger(options.length) : length; + omission = "omission" in options ? baseToString(options.omission) : omission; + } + string = toString(string); + var strLength = string.length; + if (hasUnicode(string)) { + var strSymbols = stringToArray(string); + strLength = strSymbols.length; + } + if (length >= strLength) { + return string; + } + var end = length - stringSize(omission); + if (end < 1) { + return omission; + } + var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end); + if (separator === undefined2) { + return result2 + omission; + } + if (strSymbols) { + end += result2.length - end; + } + if (isRegExp(separator)) { + if (string.slice(end).search(separator)) { + var match, substring = result2; + if (!separator.global) { + separator = RegExp2(separator.source, toString(reFlags.exec(separator)) + "g"); + } + separator.lastIndex = 0; + while (match = separator.exec(substring)) { + var newEnd = match.index; + } + result2 = result2.slice(0, newEnd === undefined2 ? end : newEnd); + } + } else if (string.indexOf(baseToString(separator), end) != end) { + var index = result2.lastIndexOf(separator); + if (index > -1) { + result2 = result2.slice(0, index); + } + } + return result2 + omission; + } + function unescape2(string) { + string = toString(string); + return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string; + } + var upperCase = createCompounder(function(result2, word, index) { + return result2 + (index ? " " : "") + word.toUpperCase(); + }); + var upperFirst = createCaseFirst("toUpperCase"); + function words(string, pattern, guard) { + string = toString(string); + pattern = guard ? undefined2 : pattern; + if (pattern === undefined2) { + return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string); + } + return string.match(pattern) || []; + } + var attempt = baseRest(function(func, args) { + try { + return apply(func, undefined2, args); + } catch (e) { + return isError(e) ? e : new Error2(e); + } + }); + var bindAll = flatRest(function(object, methodNames) { + arrayEach(methodNames, function(key) { + key = toKey(key); + baseAssignValue(object, key, bind(object[key], object)); + }); + return object; + }); + function cond(pairs) { + var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee(); + pairs = !length ? [] : arrayMap(pairs, function(pair) { + if (typeof pair[1] != "function") { + throw new TypeError2(FUNC_ERROR_TEXT); + } + return [toIteratee(pair[0]), pair[1]]; + }); + return baseRest(function(args) { + var index = -1; + while (++index < length) { + var pair = pairs[index]; + if (apply(pair[0], this, args)) { + return apply(pair[1], this, args); + } + } + }); + } + function conforms(source) { + return baseConforms(baseClone(source, CLONE_DEEP_FLAG)); + } + function constant(value) { + return function() { + return value; + }; + } + function defaultTo(value, defaultValue) { + return value == null || value !== value ? defaultValue : value; + } + var flow = createFlow(); + var flowRight = createFlow(true); + function identity(value) { + return value; + } + function iteratee(func) { + return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG)); + } + function matches(source) { + return baseMatches(baseClone(source, CLONE_DEEP_FLAG)); + } + function matchesProperty(path, srcValue) { + return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG)); + } + var method = baseRest(function(path, args) { + return function(object) { + return baseInvoke(object, path, args); + }; + }); + var methodOf = baseRest(function(object, args) { + return function(path) { + return baseInvoke(object, path, args); + }; + }); + function mixin(object, source, options) { + var props = keys(source), methodNames = baseFunctions(source, props); + if (options == null && !(isObject(source) && (methodNames.length || !props.length))) { + options = source; + source = object; + object = this; + methodNames = baseFunctions(source, keys(source)); + } + var chain2 = !(isObject(options) && "chain" in options) || !!options.chain, isFunc = isFunction(object); + arrayEach(methodNames, function(methodName) { + var func = source[methodName]; + object[methodName] = func; + if (isFunc) { + object.prototype[methodName] = function() { + var chainAll = this.__chain__; + if (chain2 || chainAll) { + var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__); + actions.push({ "func": func, "args": arguments, "thisArg": object }); + result2.__chain__ = chainAll; + return result2; + } + return func.apply(object, arrayPush([this.value()], arguments)); + }; + } + }); + return object; + } + function noConflict() { + if (root._ === this) { + root._ = oldDash; + } + return this; + } + function noop() { + } + function nthArg(n) { + n = toInteger(n); + return baseRest(function(args) { + return baseNth(args, n); + }); + } + var over = createOver(arrayMap); + var overEvery = createOver(arrayEvery); + var overSome = createOver(arraySome); + function property(path) { + return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); + } + function propertyOf(object) { + return function(path) { + return object == null ? undefined2 : baseGet(object, path); + }; + } + var range = createRange(); + var rangeRight = createRange(true); + function stubArray() { + return []; + } + function stubFalse() { + return false; + } + function stubObject() { + return {}; + } + function stubString() { + return ""; + } + function stubTrue() { + return true; + } + function times(n, iteratee2) { + n = toInteger(n); + if (n < 1 || n > MAX_SAFE_INTEGER) { + return []; + } + var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH); + iteratee2 = getIteratee(iteratee2); + n -= MAX_ARRAY_LENGTH; + var result2 = baseTimes(length, iteratee2); + while (++index < n) { + iteratee2(index); + } + return result2; + } + function toPath(value) { + if (isArray(value)) { + return arrayMap(value, toKey); + } + return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value))); + } + function uniqueId(prefix) { + var id = ++idCounter; + return toString(prefix) + id; + } + var add = createMathOperation(function(augend, addend) { + return augend + addend; + }, 0); + var ceil = createRound("ceil"); + var divide = createMathOperation(function(dividend, divisor) { + return dividend / divisor; + }, 1); + var floor = createRound("floor"); + function max(array) { + return array && array.length ? baseExtremum(array, identity, baseGt) : undefined2; + } + function maxBy(array, iteratee2) { + return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2; + } + function mean(array) { + return baseMean(array, identity); + } + function meanBy(array, iteratee2) { + return baseMean(array, getIteratee(iteratee2, 2)); + } + function min(array) { + return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2; + } + function minBy(array, iteratee2) { + return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2; + } + var multiply = createMathOperation(function(multiplier, multiplicand) { + return multiplier * multiplicand; + }, 1); + var round = createRound("round"); + var subtract = createMathOperation(function(minuend, subtrahend) { + return minuend - subtrahend; + }, 0); + function sum(array) { + return array && array.length ? baseSum(array, identity) : 0; + } + function sumBy(array, iteratee2) { + return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0; + } + lodash.after = after; + lodash.ary = ary; + lodash.assign = assign; + lodash.assignIn = assignIn; + lodash.assignInWith = assignInWith; + lodash.assignWith = assignWith; + lodash.at = at; + lodash.before = before; + lodash.bind = bind; + lodash.bindAll = bindAll; + lodash.bindKey = bindKey; + lodash.castArray = castArray; + lodash.chain = chain; + lodash.chunk = chunk; + lodash.compact = compact; + lodash.concat = concat; + lodash.cond = cond; + lodash.conforms = conforms; + lodash.constant = constant; + lodash.countBy = countBy; + lodash.create = create; + lodash.curry = curry; + lodash.curryRight = curryRight; + lodash.debounce = debounce; + lodash.defaults = defaults; + lodash.defaultsDeep = defaultsDeep; + lodash.defer = defer; + lodash.delay = delay; + lodash.difference = difference; + lodash.differenceBy = differenceBy; + lodash.differenceWith = differenceWith; + lodash.drop = drop; + lodash.dropRight = dropRight; + lodash.dropRightWhile = dropRightWhile; + lodash.dropWhile = dropWhile; + lodash.fill = fill; + lodash.filter = filter; + lodash.flatMap = flatMap; + lodash.flatMapDeep = flatMapDeep; + lodash.flatMapDepth = flatMapDepth; + lodash.flatten = flatten; + lodash.flattenDeep = flattenDeep; + lodash.flattenDepth = flattenDepth; + lodash.flip = flip; + lodash.flow = flow; + lodash.flowRight = flowRight; + lodash.fromPairs = fromPairs; + lodash.functions = functions; + lodash.functionsIn = functionsIn; + lodash.groupBy = groupBy; + lodash.initial = initial; + lodash.intersection = intersection; + lodash.intersectionBy = intersectionBy; + lodash.intersectionWith = intersectionWith; + lodash.invert = invert; + lodash.invertBy = invertBy; + lodash.invokeMap = invokeMap; + lodash.iteratee = iteratee; + lodash.keyBy = keyBy; + lodash.keys = keys; + lodash.keysIn = keysIn; + lodash.map = map; + lodash.mapKeys = mapKeys; + lodash.mapValues = mapValues; + lodash.matches = matches; + lodash.matchesProperty = matchesProperty; + lodash.memoize = memoize; + lodash.merge = merge; + lodash.mergeWith = mergeWith; + lodash.method = method; + lodash.methodOf = methodOf; + lodash.mixin = mixin; + lodash.negate = negate; + lodash.nthArg = nthArg; + lodash.omit = omit; + lodash.omitBy = omitBy; + lodash.once = once; + lodash.orderBy = orderBy; + lodash.over = over; + lodash.overArgs = overArgs; + lodash.overEvery = overEvery; + lodash.overSome = overSome; + lodash.partial = partial; + lodash.partialRight = partialRight; + lodash.partition = partition; + lodash.pick = pick; + lodash.pickBy = pickBy; + lodash.property = property; + lodash.propertyOf = propertyOf; + lodash.pull = pull; + lodash.pullAll = pullAll; + lodash.pullAllBy = pullAllBy; + lodash.pullAllWith = pullAllWith; + lodash.pullAt = pullAt; + lodash.range = range; + lodash.rangeRight = rangeRight; + lodash.rearg = rearg; + lodash.reject = reject; + lodash.remove = remove; + lodash.rest = rest; + lodash.reverse = reverse; + lodash.sampleSize = sampleSize; + lodash.set = set; + lodash.setWith = setWith; + lodash.shuffle = shuffle; + lodash.slice = slice; + lodash.sortBy = sortBy; + lodash.sortedUniq = sortedUniq; + lodash.sortedUniqBy = sortedUniqBy; + lodash.split = split; + lodash.spread = spread; + lodash.tail = tail; + lodash.take = take; + lodash.takeRight = takeRight; + lodash.takeRightWhile = takeRightWhile; + lodash.takeWhile = takeWhile; + lodash.tap = tap; + lodash.throttle = throttle; + lodash.thru = thru; + lodash.toArray = toArray; + lodash.toPairs = toPairs; + lodash.toPairsIn = toPairsIn; + lodash.toPath = toPath; + lodash.toPlainObject = toPlainObject; + lodash.transform = transform; + lodash.unary = unary; + lodash.union = union; + lodash.unionBy = unionBy; + lodash.unionWith = unionWith; + lodash.uniq = uniq; + lodash.uniqBy = uniqBy; + lodash.uniqWith = uniqWith; + lodash.unset = unset; + lodash.unzip = unzip; + lodash.unzipWith = unzipWith; + lodash.update = update; + lodash.updateWith = updateWith; + lodash.values = values; + lodash.valuesIn = valuesIn; + lodash.without = without; + lodash.words = words; + lodash.wrap = wrap; + lodash.xor = xor; + lodash.xorBy = xorBy; + lodash.xorWith = xorWith; + lodash.zip = zip; + lodash.zipObject = zipObject; + lodash.zipObjectDeep = zipObjectDeep; + lodash.zipWith = zipWith; + lodash.entries = toPairs; + lodash.entriesIn = toPairsIn; + lodash.extend = assignIn; + lodash.extendWith = assignInWith; + mixin(lodash, lodash); + lodash.add = add; + lodash.attempt = attempt; + lodash.camelCase = camelCase; + lodash.capitalize = capitalize; + lodash.ceil = ceil; + lodash.clamp = clamp; + lodash.clone = clone; + lodash.cloneDeep = cloneDeep; + lodash.cloneDeepWith = cloneDeepWith; + lodash.cloneWith = cloneWith; + lodash.conformsTo = conformsTo; + lodash.deburr = deburr; + lodash.defaultTo = defaultTo; + lodash.divide = divide; + lodash.endsWith = endsWith; + lodash.eq = eq; + lodash.escape = escape2; + lodash.escapeRegExp = escapeRegExp; + lodash.every = every; + lodash.find = find; + lodash.findIndex = findIndex; + lodash.findKey = findKey; + lodash.findLast = findLast; + lodash.findLastIndex = findLastIndex; + lodash.findLastKey = findLastKey; + lodash.floor = floor; + lodash.forEach = forEach; + lodash.forEachRight = forEachRight; + lodash.forIn = forIn; + lodash.forInRight = forInRight; + lodash.forOwn = forOwn; + lodash.forOwnRight = forOwnRight; + lodash.get = get; + lodash.gt = gt; + lodash.gte = gte; + lodash.has = has; + lodash.hasIn = hasIn; + lodash.head = head; + lodash.identity = identity; + lodash.includes = includes; + lodash.indexOf = indexOf; + lodash.inRange = inRange; + lodash.invoke = invoke; + lodash.isArguments = isArguments; + lodash.isArray = isArray; + lodash.isArrayBuffer = isArrayBuffer; + lodash.isArrayLike = isArrayLike; + lodash.isArrayLikeObject = isArrayLikeObject; + lodash.isBoolean = isBoolean; + lodash.isBuffer = isBuffer; + lodash.isDate = isDate; + lodash.isElement = isElement; + lodash.isEmpty = isEmpty; + lodash.isEqual = isEqual; + lodash.isEqualWith = isEqualWith; + lodash.isError = isError; + lodash.isFinite = isFinite2; + lodash.isFunction = isFunction; + lodash.isInteger = isInteger; + lodash.isLength = isLength; + lodash.isMap = isMap; + lodash.isMatch = isMatch; + lodash.isMatchWith = isMatchWith; + lodash.isNaN = isNaN2; + lodash.isNative = isNative; + lodash.isNil = isNil; + lodash.isNull = isNull; + lodash.isNumber = isNumber; + lodash.isObject = isObject; + lodash.isObjectLike = isObjectLike; + lodash.isPlainObject = isPlainObject; + lodash.isRegExp = isRegExp; + lodash.isSafeInteger = isSafeInteger; + lodash.isSet = isSet; + lodash.isString = isString; + lodash.isSymbol = isSymbol; + lodash.isTypedArray = isTypedArray; + lodash.isUndefined = isUndefined; + lodash.isWeakMap = isWeakMap; + lodash.isWeakSet = isWeakSet; + lodash.join = join; + lodash.kebabCase = kebabCase; + lodash.last = last; + lodash.lastIndexOf = lastIndexOf; + lodash.lowerCase = lowerCase; + lodash.lowerFirst = lowerFirst; + lodash.lt = lt; + lodash.lte = lte; + lodash.max = max; + lodash.maxBy = maxBy; + lodash.mean = mean; + lodash.meanBy = meanBy; + lodash.min = min; + lodash.minBy = minBy; + lodash.stubArray = stubArray; + lodash.stubFalse = stubFalse; + lodash.stubObject = stubObject; + lodash.stubString = stubString; + lodash.stubTrue = stubTrue; + lodash.multiply = multiply; + lodash.nth = nth; + lodash.noConflict = noConflict; + lodash.noop = noop; + lodash.now = now; + lodash.pad = pad; + lodash.padEnd = padEnd; + lodash.padStart = padStart; + lodash.parseInt = parseInt2; + lodash.random = random; + lodash.reduce = reduce; + lodash.reduceRight = reduceRight; + lodash.repeat = repeat; + lodash.replace = replace; + lodash.result = result; + lodash.round = round; + lodash.runInContext = runInContext2; + lodash.sample = sample; + lodash.size = size; + lodash.snakeCase = snakeCase; + lodash.some = some; + lodash.sortedIndex = sortedIndex; + lodash.sortedIndexBy = sortedIndexBy; + lodash.sortedIndexOf = sortedIndexOf; + lodash.sortedLastIndex = sortedLastIndex; + lodash.sortedLastIndexBy = sortedLastIndexBy; + lodash.sortedLastIndexOf = sortedLastIndexOf; + lodash.startCase = startCase; + lodash.startsWith = startsWith; + lodash.subtract = subtract; + lodash.sum = sum; + lodash.sumBy = sumBy; + lodash.template = template; + lodash.times = times; + lodash.toFinite = toFinite; + lodash.toInteger = toInteger; + lodash.toLength = toLength; + lodash.toLower = toLower; + lodash.toNumber = toNumber; + lodash.toSafeInteger = toSafeInteger; + lodash.toString = toString; + lodash.toUpper = toUpper; + lodash.trim = trim; + lodash.trimEnd = trimEnd; + lodash.trimStart = trimStart; + lodash.truncate = truncate; + lodash.unescape = unescape2; + lodash.uniqueId = uniqueId; + lodash.upperCase = upperCase; + lodash.upperFirst = upperFirst; + lodash.each = forEach; + lodash.eachRight = forEachRight; + lodash.first = head; + mixin(lodash, (function() { + var source = {}; + baseForOwn(lodash, function(func, methodName) { + if (!hasOwnProperty.call(lodash.prototype, methodName)) { + source[methodName] = func; + } + }); + return source; + })(), { "chain": false }); + lodash.VERSION = VERSION; + arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) { + lodash[methodName].placeholder = lodash; + }); + arrayEach(["drop", "take"], function(methodName, index) { + LazyWrapper.prototype[methodName] = function(n) { + n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0); + var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone(); + if (result2.__filtered__) { + result2.__takeCount__ = nativeMin(n, result2.__takeCount__); + } else { + result2.__views__.push({ + "size": nativeMin(n, MAX_ARRAY_LENGTH), + "type": methodName + (result2.__dir__ < 0 ? "Right" : "") + }); + } + return result2; + }; + LazyWrapper.prototype[methodName + "Right"] = function(n) { + return this.reverse()[methodName](n).reverse(); + }; + }); + arrayEach(["filter", "map", "takeWhile"], function(methodName, index) { + var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG; + LazyWrapper.prototype[methodName] = function(iteratee2) { + var result2 = this.clone(); + result2.__iteratees__.push({ + "iteratee": getIteratee(iteratee2, 3), + "type": type + }); + result2.__filtered__ = result2.__filtered__ || isFilter; + return result2; + }; + }); + arrayEach(["head", "last"], function(methodName, index) { + var takeName = "take" + (index ? "Right" : ""); + LazyWrapper.prototype[methodName] = function() { + return this[takeName](1).value()[0]; + }; + }); + arrayEach(["initial", "tail"], function(methodName, index) { + var dropName = "drop" + (index ? "" : "Right"); + LazyWrapper.prototype[methodName] = function() { + return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1); + }; + }); + LazyWrapper.prototype.compact = function() { + return this.filter(identity); + }; + LazyWrapper.prototype.find = function(predicate) { + return this.filter(predicate).head(); + }; + LazyWrapper.prototype.findLast = function(predicate) { + return this.reverse().find(predicate); + }; + LazyWrapper.prototype.invokeMap = baseRest(function(path, args) { + if (typeof path == "function") { + return new LazyWrapper(this); + } + return this.map(function(value) { + return baseInvoke(value, path, args); + }); + }); + LazyWrapper.prototype.reject = function(predicate) { + return this.filter(negate(getIteratee(predicate))); + }; + LazyWrapper.prototype.slice = function(start, end) { + start = toInteger(start); + var result2 = this; + if (result2.__filtered__ && (start > 0 || end < 0)) { + return new LazyWrapper(result2); + } + if (start < 0) { + result2 = result2.takeRight(-start); + } else if (start) { + result2 = result2.drop(start); + } + if (end !== undefined2) { + end = toInteger(end); + result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start); + } + return result2; + }; + LazyWrapper.prototype.takeRightWhile = function(predicate) { + return this.reverse().takeWhile(predicate).reverse(); + }; + LazyWrapper.prototype.toArray = function() { + return this.take(MAX_ARRAY_LENGTH); + }; + baseForOwn(LazyWrapper.prototype, function(func, methodName) { + var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName); + if (!lodashFunc) { + return; + } + lodash.prototype[methodName] = function() { + var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value); + var interceptor = function(value2) { + var result3 = lodashFunc.apply(lodash, arrayPush([value2], args)); + return isTaker && chainAll ? result3[0] : result3; + }; + if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) { + isLazy = useLazy = false; + } + var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid; + if (!retUnwrapped && useLazy) { + value = onlyLazy ? value : new LazyWrapper(this); + var result2 = func.apply(value, args); + result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined2 }); + return new LodashWrapper(result2, chainAll); + } + if (isUnwrapped && onlyLazy) { + return func.apply(this, args); + } + result2 = this.thru(interceptor); + return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2; + }; + }); + arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) { + var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName); + lodash.prototype[methodName] = function() { + var args = arguments; + if (retUnwrapped && !this.__chain__) { + var value = this.value(); + return func.apply(isArray(value) ? value : [], args); + } + return this[chainName](function(value2) { + return func.apply(isArray(value2) ? value2 : [], args); + }); + }; + }); + baseForOwn(LazyWrapper.prototype, function(func, methodName) { + var lodashFunc = lodash[methodName]; + if (lodashFunc) { + var key = lodashFunc.name + ""; + if (!hasOwnProperty.call(realNames, key)) { + realNames[key] = []; + } + realNames[key].push({ "name": methodName, "func": lodashFunc }); + } + }); + realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{ + "name": "wrapper", + "func": undefined2 + }]; + LazyWrapper.prototype.clone = lazyClone; + LazyWrapper.prototype.reverse = lazyReverse; + LazyWrapper.prototype.value = lazyValue; + lodash.prototype.at = wrapperAt; + lodash.prototype.chain = wrapperChain; + lodash.prototype.commit = wrapperCommit; + lodash.prototype.next = wrapperNext; + lodash.prototype.plant = wrapperPlant; + lodash.prototype.reverse = wrapperReverse; + lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue; + lodash.prototype.first = lodash.prototype.head; + if (symIterator) { + lodash.prototype[symIterator] = wrapperToIterator; + } + return lodash; + }; + var _2 = runInContext(); + if (typeof define == "function" && typeof define.amd == "object" && define.amd) { + root._ = _2; + define(function() { + return _2; + }); + } else if (freeModule) { + (freeModule.exports = _2)._ = _2; + freeExports._ = _2; + } else { + root._ = _2; + } + }).call(exports2); + } +}); +var require_color_name = __commonJS2({ + "node_modules/color-name/index.js"(exports2, module2) { + "use strict"; + module2.exports = { + "aliceblue": [240, 248, 255], + "antiquewhite": [250, 235, 215], + "aqua": [0, 255, 255], + "aquamarine": [127, 255, 212], + "azure": [240, 255, 255], + "beige": [245, 245, 220], + "bisque": [255, 228, 196], + "black": [0, 0, 0], + "blanchedalmond": [255, 235, 205], + "blue": [0, 0, 255], + "blueviolet": [138, 43, 226], + "brown": [165, 42, 42], + "burlywood": [222, 184, 135], + "cadetblue": [95, 158, 160], + "chartreuse": [127, 255, 0], + "chocolate": [210, 105, 30], + "coral": [255, 127, 80], + "cornflowerblue": [100, 149, 237], + "cornsilk": [255, 248, 220], + "crimson": [220, 20, 60], + "cyan": [0, 255, 255], + "darkblue": [0, 0, 139], + "darkcyan": [0, 139, 139], + "darkgoldenrod": [184, 134, 11], + "darkgray": [169, 169, 169], + "darkgreen": [0, 100, 0], + "darkgrey": [169, 169, 169], + "darkkhaki": [189, 183, 107], + "darkmagenta": [139, 0, 139], + "darkolivegreen": [85, 107, 47], + "darkorange": [255, 140, 0], + "darkorchid": [153, 50, 204], + "darkred": [139, 0, 0], + "darksalmon": [233, 150, 122], + "darkseagreen": [143, 188, 143], + "darkslateblue": [72, 61, 139], + "darkslategray": [47, 79, 79], + "darkslategrey": [47, 79, 79], + "darkturquoise": [0, 206, 209], + "darkviolet": [148, 0, 211], + "deeppink": [255, 20, 147], + "deepskyblue": [0, 191, 255], + "dimgray": [105, 105, 105], + "dimgrey": [105, 105, 105], + "dodgerblue": [30, 144, 255], + "firebrick": [178, 34, 34], + "floralwhite": [255, 250, 240], + "forestgreen": [34, 139, 34], + "fuchsia": [255, 0, 255], + "gainsboro": [220, 220, 220], + "ghostwhite": [248, 248, 255], + "gold": [255, 215, 0], + "goldenrod": [218, 165, 32], + "gray": [128, 128, 128], + "green": [0, 128, 0], + "greenyellow": [173, 255, 47], + "grey": [128, 128, 128], + "honeydew": [240, 255, 240], + "hotpink": [255, 105, 180], + "indianred": [205, 92, 92], + "indigo": [75, 0, 130], + "ivory": [255, 255, 240], + "khaki": [240, 230, 140], + "lavender": [230, 230, 250], + "lavenderblush": [255, 240, 245], + "lawngreen": [124, 252, 0], + "lemonchiffon": [255, 250, 205], + "lightblue": [173, 216, 230], + "lightcoral": [240, 128, 128], + "lightcyan": [224, 255, 255], + "lightgoldenrodyellow": [250, 250, 210], + "lightgray": [211, 211, 211], + "lightgreen": [144, 238, 144], + "lightgrey": [211, 211, 211], + "lightpink": [255, 182, 193], + "lightsalmon": [255, 160, 122], + "lightseagreen": [32, 178, 170], + "lightskyblue": [135, 206, 250], + "lightslategray": [119, 136, 153], + "lightslategrey": [119, 136, 153], + "lightsteelblue": [176, 196, 222], + "lightyellow": [255, 255, 224], + "lime": [0, 255, 0], + "limegreen": [50, 205, 50], + "linen": [250, 240, 230], + "magenta": [255, 0, 255], + "maroon": [128, 0, 0], + "mediumaquamarine": [102, 205, 170], + "mediumblue": [0, 0, 205], + "mediumorchid": [186, 85, 211], + "mediumpurple": [147, 112, 219], + "mediumseagreen": [60, 179, 113], + "mediumslateblue": [123, 104, 238], + "mediumspringgreen": [0, 250, 154], + "mediumturquoise": [72, 209, 204], + "mediumvioletred": [199, 21, 133], + "midnightblue": [25, 25, 112], + "mintcream": [245, 255, 250], + "mistyrose": [255, 228, 225], + "moccasin": [255, 228, 181], + "navajowhite": [255, 222, 173], + "navy": [0, 0, 128], + "oldlace": [253, 245, 230], + "olive": [128, 128, 0], + "olivedrab": [107, 142, 35], + "orange": [255, 165, 0], + "orangered": [255, 69, 0], + "orchid": [218, 112, 214], + "palegoldenrod": [238, 232, 170], + "palegreen": [152, 251, 152], + "paleturquoise": [175, 238, 238], + "palevioletred": [219, 112, 147], + "papayawhip": [255, 239, 213], + "peachpuff": [255, 218, 185], + "peru": [205, 133, 63], + "pink": [255, 192, 203], + "plum": [221, 160, 221], + "powderblue": [176, 224, 230], + "purple": [128, 0, 128], + "rebeccapurple": [102, 51, 153], + "red": [255, 0, 0], + "rosybrown": [188, 143, 143], + "royalblue": [65, 105, 225], + "saddlebrown": [139, 69, 19], + "salmon": [250, 128, 114], + "sandybrown": [244, 164, 96], + "seagreen": [46, 139, 87], + "seashell": [255, 245, 238], + "sienna": [160, 82, 45], + "silver": [192, 192, 192], + "skyblue": [135, 206, 235], + "slateblue": [106, 90, 205], + "slategray": [112, 128, 144], + "slategrey": [112, 128, 144], + "snow": [255, 250, 250], + "springgreen": [0, 255, 127], + "steelblue": [70, 130, 180], + "tan": [210, 180, 140], + "teal": [0, 128, 128], + "thistle": [216, 191, 216], + "tomato": [255, 99, 71], + "turquoise": [64, 224, 208], + "violet": [238, 130, 238], + "wheat": [245, 222, 179], + "white": [255, 255, 255], + "whitesmoke": [245, 245, 245], + "yellow": [255, 255, 0], + "yellowgreen": [154, 205, 50] + }; + } +}); +var require_conversions = __commonJS2({ + "node_modules/color-convert/conversions.js"(exports2, module2) { + var cssKeywords = require_color_name(); + var reverseKeywords = {}; + for (const key of Object.keys(cssKeywords)) { + reverseKeywords[cssKeywords[key]] = key; + } + var convert = { + rgb: { channels: 3, labels: "rgb" }, + hsl: { channels: 3, labels: "hsl" }, + hsv: { channels: 3, labels: "hsv" }, + hwb: { channels: 3, labels: "hwb" }, + cmyk: { channels: 4, labels: "cmyk" }, + xyz: { channels: 3, labels: "xyz" }, + lab: { channels: 3, labels: "lab" }, + lch: { channels: 3, labels: "lch" }, + hex: { channels: 1, labels: ["hex"] }, + keyword: { channels: 1, labels: ["keyword"] }, + ansi16: { channels: 1, labels: ["ansi16"] }, + ansi256: { channels: 1, labels: ["ansi256"] }, + hcg: { channels: 3, labels: ["h", "c", "g"] }, + apple: { channels: 3, labels: ["r16", "g16", "b16"] }, + gray: { channels: 1, labels: ["gray"] } + }; + module2.exports = convert; + for (const model of Object.keys(convert)) { + if (!("channels" in convert[model])) { + throw new Error("missing channels property: " + model); + } + if (!("labels" in convert[model])) { + throw new Error("missing channel labels property: " + model); + } + if (convert[model].labels.length !== convert[model].channels) { + throw new Error("channel and label counts mismatch: " + model); + } + const { channels, labels } = convert[model]; + delete convert[model].channels; + delete convert[model].labels; + Object.defineProperty(convert[model], "channels", { value: channels }); + Object.defineProperty(convert[model], "labels", { value: labels }); + } + convert.rgb.hsl = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const min = Math.min(r, g, b); + const max = Math.max(r, g, b); + const delta = max - min; + let h; + let s; + if (max === min) { + h = 0; + } else if (r === max) { + h = (g - b) / delta; + } else if (g === max) { + h = 2 + (b - r) / delta; + } else if (b === max) { + h = 4 + (r - g) / delta; + } + h = Math.min(h * 60, 360); + if (h < 0) { + h += 360; + } + const l = (min + max) / 2; + if (max === min) { + s = 0; + } else if (l <= 0.5) { + s = delta / (max + min); + } else { + s = delta / (2 - max - min); + } + return [h, s * 100, l * 100]; + }; + convert.rgb.hsv = function(rgb) { + let rdif; + let gdif; + let bdif; + let h; + let s; + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const v = Math.max(r, g, b); + const diff = v - Math.min(r, g, b); + const diffc = function(c) { + return (v - c) / 6 / diff + 1 / 2; + }; + if (diff === 0) { + h = 0; + s = 0; + } else { + s = diff / v; + rdif = diffc(r); + gdif = diffc(g); + bdif = diffc(b); + if (r === v) { + h = bdif - gdif; + } else if (g === v) { + h = 1 / 3 + rdif - bdif; + } else if (b === v) { + h = 2 / 3 + gdif - rdif; + } + if (h < 0) { + h += 1; + } else if (h > 1) { + h -= 1; + } + } + return [ + h * 360, + s * 100, + v * 100 + ]; + }; + convert.rgb.hwb = function(rgb) { + const r = rgb[0]; + const g = rgb[1]; + let b = rgb[2]; + const h = convert.rgb.hsl(rgb)[0]; + const w = 1 / 255 * Math.min(r, Math.min(g, b)); + b = 1 - 1 / 255 * Math.max(r, Math.max(g, b)); + return [h, w * 100, b * 100]; + }; + convert.rgb.cmyk = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const k = Math.min(1 - r, 1 - g, 1 - b); + const c = (1 - r - k) / (1 - k) || 0; + const m = (1 - g - k) / (1 - k) || 0; + const y = (1 - b - k) / (1 - k) || 0; + return [c * 100, m * 100, y * 100, k * 100]; + }; + function comparativeDistance(x, y) { + return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2; + } + convert.rgb.keyword = function(rgb) { + const reversed = reverseKeywords[rgb]; + if (reversed) { + return reversed; + } + let currentClosestDistance = Infinity; + let currentClosestKeyword; + for (const keyword of Object.keys(cssKeywords)) { + const value = cssKeywords[keyword]; + const distance = comparativeDistance(rgb, value); + if (distance < currentClosestDistance) { + currentClosestDistance = distance; + currentClosestKeyword = keyword; + } + } + return currentClosestKeyword; + }; + convert.keyword.rgb = function(keyword) { + return cssKeywords[keyword]; + }; + convert.rgb.xyz = function(rgb) { + let r = rgb[0] / 255; + let g = rgb[1] / 255; + let b = rgb[2] / 255; + r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92; + g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92; + b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92; + const x = r * 0.4124 + g * 0.3576 + b * 0.1805; + const y = r * 0.2126 + g * 0.7152 + b * 0.0722; + const z2 = r * 0.0193 + g * 0.1192 + b * 0.9505; + return [x * 100, y * 100, z2 * 100]; + }; + convert.rgb.lab = function(rgb) { + const xyz = convert.rgb.xyz(rgb); + let x = xyz[0]; + let y = xyz[1]; + let z2 = xyz[2]; + x /= 95.047; + y /= 100; + z2 /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z2); + return [l, a, b]; + }; + convert.hsl.rgb = function(hsl) { + const h = hsl[0] / 360; + const s = hsl[1] / 100; + const l = hsl[2] / 100; + let t2; + let t3; + let val; + if (s === 0) { + val = l * 255; + return [val, val, val]; + } + if (l < 0.5) { + t2 = l * (1 + s); + } else { + t2 = l + s - l * s; + } + const t1 = 2 * l - t2; + const rgb = [0, 0, 0]; + for (let i = 0; i < 3; i++) { + t3 = h + 1 / 3 * -(i - 1); + if (t3 < 0) { + t3++; + } + if (t3 > 1) { + t3--; + } + if (6 * t3 < 1) { + val = t1 + (t2 - t1) * 6 * t3; + } else if (2 * t3 < 1) { + val = t2; + } else if (3 * t3 < 2) { + val = t1 + (t2 - t1) * (2 / 3 - t3) * 6; + } else { + val = t1; + } + rgb[i] = val * 255; + } + return rgb; + }; + convert.hsl.hsv = function(hsl) { + const h = hsl[0]; + let s = hsl[1] / 100; + let l = hsl[2] / 100; + let smin = s; + const lmin = Math.max(l, 0.01); + l *= 2; + s *= l <= 1 ? l : 2 - l; + smin *= lmin <= 1 ? lmin : 2 - lmin; + const v = (l + s) / 2; + const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s); + return [h, sv * 100, v * 100]; + }; + convert.hsv.rgb = function(hsv) { + const h = hsv[0] / 60; + const s = hsv[1] / 100; + let v = hsv[2] / 100; + const hi = Math.floor(h) % 6; + const f = h - Math.floor(h); + const p = 255 * v * (1 - s); + const q = 255 * v * (1 - s * f); + const t = 255 * v * (1 - s * (1 - f)); + v *= 255; + switch (hi) { + case 0: + return [v, t, p]; + case 1: + return [q, v, p]; + case 2: + return [p, v, t]; + case 3: + return [p, q, v]; + case 4: + return [t, p, v]; + case 5: + return [v, p, q]; + } + }; + convert.hsv.hsl = function(hsv) { + const h = hsv[0]; + const s = hsv[1] / 100; + const v = hsv[2] / 100; + const vmin = Math.max(v, 0.01); + let sl; + let l; + l = (2 - s) * v; + const lmin = (2 - s) * vmin; + sl = s * vmin; + sl /= lmin <= 1 ? lmin : 2 - lmin; + sl = sl || 0; + l /= 2; + return [h, sl * 100, l * 100]; + }; + convert.hwb.rgb = function(hwb) { + const h = hwb[0] / 360; + let wh = hwb[1] / 100; + let bl = hwb[2] / 100; + const ratio = wh + bl; + let f; + if (ratio > 1) { + wh /= ratio; + bl /= ratio; + } + const i = Math.floor(6 * h); + const v = 1 - bl; + f = 6 * h - i; + if ((i & 1) !== 0) { + f = 1 - f; + } + const n = wh + f * (v - wh); + let r; + let g; + let b; + switch (i) { + default: + case 6: + case 0: + r = v; + g = n; + b = wh; + break; + case 1: + r = n; + g = v; + b = wh; + break; + case 2: + r = wh; + g = v; + b = n; + break; + case 3: + r = wh; + g = n; + b = v; + break; + case 4: + r = n; + g = wh; + b = v; + break; + case 5: + r = v; + g = wh; + b = n; + break; + } + return [r * 255, g * 255, b * 255]; + }; + convert.cmyk.rgb = function(cmyk) { + const c = cmyk[0] / 100; + const m = cmyk[1] / 100; + const y = cmyk[2] / 100; + const k = cmyk[3] / 100; + const r = 1 - Math.min(1, c * (1 - k) + k); + const g = 1 - Math.min(1, m * (1 - k) + k); + const b = 1 - Math.min(1, y * (1 - k) + k); + return [r * 255, g * 255, b * 255]; + }; + convert.xyz.rgb = function(xyz) { + const x = xyz[0] / 100; + const y = xyz[1] / 100; + const z2 = xyz[2] / 100; + let r; + let g; + let b; + r = x * 3.2406 + y * -1.5372 + z2 * -0.4986; + g = x * -0.9689 + y * 1.8758 + z2 * 0.0415; + b = x * 0.0557 + y * -0.204 + z2 * 1.057; + r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92; + g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92; + b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92; + r = Math.min(Math.max(0, r), 1); + g = Math.min(Math.max(0, g), 1); + b = Math.min(Math.max(0, b), 1); + return [r * 255, g * 255, b * 255]; + }; + convert.xyz.lab = function(xyz) { + let x = xyz[0]; + let y = xyz[1]; + let z2 = xyz[2]; + x /= 95.047; + y /= 100; + z2 /= 108.883; + x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116; + y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116; + z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116; + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z2); + return [l, a, b]; + }; + convert.lab.xyz = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let x; + let y; + let z2; + y = (l + 16) / 116; + x = a / 500 + y; + z2 = y - b / 200; + const y2 = y ** 3; + const x2 = x ** 3; + const z22 = z2 ** 3; + y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787; + x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787; + z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787; + x *= 95.047; + y *= 100; + z2 *= 108.883; + return [x, y, z2]; + }; + convert.lab.lch = function(lab) { + const l = lab[0]; + const a = lab[1]; + const b = lab[2]; + let h; + const hr = Math.atan2(b, a); + h = hr * 360 / 2 / Math.PI; + if (h < 0) { + h += 360; + } + const c = Math.sqrt(a * a + b * b); + return [l, c, h]; + }; + convert.lch.lab = function(lch) { + const l = lch[0]; + const c = lch[1]; + const h = lch[2]; + const hr = h / 360 * 2 * Math.PI; + const a = c * Math.cos(hr); + const b = c * Math.sin(hr); + return [l, a, b]; + }; + convert.rgb.ansi16 = function(args, saturation = null) { + const [r, g, b] = args; + let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; + value = Math.round(value / 50); + if (value === 0) { + return 30; + } + let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255)); + if (value === 2) { + ansi += 60; + } + return ansi; + }; + convert.hsv.ansi16 = function(args) { + return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]); + }; + convert.rgb.ansi256 = function(args) { + const r = args[0]; + const g = args[1]; + const b = args[2]; + if (r === g && g === b) { + if (r < 8) { + return 16; + } + if (r > 248) { + return 231; + } + return Math.round((r - 8) / 247 * 24) + 232; + } + const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5); + return ansi; + }; + convert.ansi16.rgb = function(args) { + let color = args % 10; + if (color === 0 || color === 7) { + if (args > 50) { + color += 3.5; + } + color = color / 10.5 * 255; + return [color, color, color]; + } + const mult = (~~(args > 50) + 1) * 0.5; + const r = (color & 1) * mult * 255; + const g = (color >> 1 & 1) * mult * 255; + const b = (color >> 2 & 1) * mult * 255; + return [r, g, b]; + }; + convert.ansi256.rgb = function(args) { + if (args >= 232) { + const c = (args - 232) * 10 + 8; + return [c, c, c]; + } + args -= 16; + let rem; + const r = Math.floor(args / 36) / 5 * 255; + const g = Math.floor((rem = args % 36) / 6) / 5 * 255; + const b = rem % 6 / 5 * 255; + return [r, g, b]; + }; + convert.rgb.hex = function(args) { + const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255); + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; + }; + convert.hex.rgb = function(args) { + const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i); + if (!match) { + return [0, 0, 0]; + } + let colorString = match[0]; + if (match[0].length === 3) { + colorString = colorString.split("").map((char) => { + return char + char; + }).join(""); + } + const integer = parseInt(colorString, 16); + const r = integer >> 16 & 255; + const g = integer >> 8 & 255; + const b = integer & 255; + return [r, g, b]; + }; + convert.rgb.hcg = function(rgb) { + const r = rgb[0] / 255; + const g = rgb[1] / 255; + const b = rgb[2] / 255; + const max = Math.max(Math.max(r, g), b); + const min = Math.min(Math.min(r, g), b); + const chroma = max - min; + let grayscale; + let hue; + if (chroma < 1) { + grayscale = min / (1 - chroma); + } else { + grayscale = 0; + } + if (chroma <= 0) { + hue = 0; + } else if (max === r) { + hue = (g - b) / chroma % 6; + } else if (max === g) { + hue = 2 + (b - r) / chroma; + } else { + hue = 4 + (r - g) / chroma; + } + hue /= 6; + hue %= 1; + return [hue * 360, chroma * 100, grayscale * 100]; + }; + convert.hsl.hcg = function(hsl) { + const s = hsl[1] / 100; + const l = hsl[2] / 100; + const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l); + let f = 0; + if (c < 1) { + f = (l - 0.5 * c) / (1 - c); + } + return [hsl[0], c * 100, f * 100]; + }; + convert.hsv.hcg = function(hsv) { + const s = hsv[1] / 100; + const v = hsv[2] / 100; + const c = s * v; + let f = 0; + if (c < 1) { + f = (v - c) / (1 - c); + } + return [hsv[0], c * 100, f * 100]; + }; + convert.hcg.rgb = function(hcg) { + const h = hcg[0] / 360; + const c = hcg[1] / 100; + const g = hcg[2] / 100; + if (c === 0) { + return [g * 255, g * 255, g * 255]; + } + const pure = [0, 0, 0]; + const hi = h % 1 * 6; + const v = hi % 1; + const w = 1 - v; + let mg = 0; + switch (Math.floor(hi)) { + case 0: + pure[0] = 1; + pure[1] = v; + pure[2] = 0; + break; + case 1: + pure[0] = w; + pure[1] = 1; + pure[2] = 0; + break; + case 2: + pure[0] = 0; + pure[1] = 1; + pure[2] = v; + break; + case 3: + pure[0] = 0; + pure[1] = w; + pure[2] = 1; + break; + case 4: + pure[0] = v; + pure[1] = 0; + pure[2] = 1; + break; + default: + pure[0] = 1; + pure[1] = 0; + pure[2] = w; + } + mg = (1 - c) * g; + return [ + (c * pure[0] + mg) * 255, + (c * pure[1] + mg) * 255, + (c * pure[2] + mg) * 255 + ]; + }; + convert.hcg.hsv = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + let f = 0; + if (v > 0) { + f = c / v; + } + return [hcg[0], f * 100, v * 100]; + }; + convert.hcg.hsl = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const l = g * (1 - c) + 0.5 * c; + let s = 0; + if (l > 0 && l < 0.5) { + s = c / (2 * l); + } else if (l >= 0.5 && l < 1) { + s = c / (2 * (1 - l)); + } + return [hcg[0], s * 100, l * 100]; + }; + convert.hcg.hwb = function(hcg) { + const c = hcg[1] / 100; + const g = hcg[2] / 100; + const v = c + g * (1 - c); + return [hcg[0], (v - c) * 100, (1 - v) * 100]; + }; + convert.hwb.hcg = function(hwb) { + const w = hwb[1] / 100; + const b = hwb[2] / 100; + const v = 1 - b; + const c = v - w; + let g = 0; + if (c < 1) { + g = (v - c) / (1 - c); + } + return [hwb[0], c * 100, g * 100]; + }; + convert.apple.rgb = function(apple) { + return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255]; + }; + convert.rgb.apple = function(rgb) { + return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535]; + }; + convert.gray.rgb = function(args) { + return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255]; + }; + convert.gray.hsl = function(args) { + return [0, 0, args[0]]; + }; + convert.gray.hsv = convert.gray.hsl; + convert.gray.hwb = function(gray) { + return [0, 100, gray[0]]; + }; + convert.gray.cmyk = function(gray) { + return [0, 0, 0, gray[0]]; + }; + convert.gray.lab = function(gray) { + return [gray[0], 0, 0]; + }; + convert.gray.hex = function(gray) { + const val = Math.round(gray[0] / 100 * 255) & 255; + const integer = (val << 16) + (val << 8) + val; + const string = integer.toString(16).toUpperCase(); + return "000000".substring(string.length) + string; + }; + convert.rgb.gray = function(rgb) { + const val = (rgb[0] + rgb[1] + rgb[2]) / 3; + return [val / 255 * 100]; + }; + } +}); +var require_route2 = __commonJS2({ + "node_modules/color-convert/route.js"(exports2, module2) { + var conversions = require_conversions(); + function buildGraph() { + const graph = {}; + const models = Object.keys(conversions); + for (let len = models.length, i = 0; i < len; i++) { + graph[models[i]] = { + // http://jsperf.com/1-vs-infinity + // micro-opt, but this is simple. + distance: -1, + parent: null + }; + } + return graph; + } + function deriveBFS(fromModel) { + const graph = buildGraph(); + const queue = [fromModel]; + graph[fromModel].distance = 0; + while (queue.length) { + const current = queue.pop(); + const adjacents = Object.keys(conversions[current]); + for (let len = adjacents.length, i = 0; i < len; i++) { + const adjacent = adjacents[i]; + const node = graph[adjacent]; + if (node.distance === -1) { + node.distance = graph[current].distance + 1; + node.parent = current; + queue.unshift(adjacent); + } + } + } + return graph; + } + function link(from, to) { + return function(args) { + return to(from(args)); + }; + } + function wrapConversion(toModel, graph) { + const path = [graph[toModel].parent, toModel]; + let fn = conversions[graph[toModel].parent][toModel]; + let cur = graph[toModel].parent; + while (graph[cur].parent) { + path.unshift(graph[cur].parent); + fn = link(conversions[graph[cur].parent][cur], fn); + cur = graph[cur].parent; + } + fn.conversion = path; + return fn; + } + module2.exports = function(fromModel) { + const graph = deriveBFS(fromModel); + const conversion = {}; + const models = Object.keys(graph); + for (let len = models.length, i = 0; i < len; i++) { + const toModel = models[i]; + const node = graph[toModel]; + if (node.parent === null) { + continue; + } + conversion[toModel] = wrapConversion(toModel, graph); + } + return conversion; + }; + } +}); +var require_color_convert = __commonJS2({ + "node_modules/color-convert/index.js"(exports2, module2) { + var conversions = require_conversions(); + var route = require_route2(); + var convert = {}; + var models = Object.keys(conversions); + function wrapRaw(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + return fn(args); + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; + } + function wrapRounded(fn) { + const wrappedFn = function(...args) { + const arg0 = args[0]; + if (arg0 === void 0 || arg0 === null) { + return arg0; + } + if (arg0.length > 1) { + args = arg0; + } + const result = fn(args); + if (typeof result === "object") { + for (let len = result.length, i = 0; i < len; i++) { + result[i] = Math.round(result[i]); + } + } + return result; + }; + if ("conversion" in fn) { + wrappedFn.conversion = fn.conversion; + } + return wrappedFn; + } + models.forEach((fromModel) => { + convert[fromModel] = {}; + Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels }); + Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels }); + const routes = route(fromModel); + const routeModels = Object.keys(routes); + routeModels.forEach((toModel) => { + const fn = routes[toModel]; + convert[fromModel][toModel] = wrapRounded(fn); + convert[fromModel][toModel].raw = wrapRaw(fn); + }); + }); + module2.exports = convert; + } +}); +var require_ansi_styles = __commonJS2({ + "node_modules/ansi-styles/index.js"(exports2, module2) { + "use strict"; + var wrapAnsi162 = (fn, offset) => (...args) => { + const code = fn(...args); + return `\x1B[${code + offset}m`; + }; + var wrapAnsi2562 = (fn, offset) => (...args) => { + const code = fn(...args); + return `\x1B[${38 + offset};5;${code}m`; + }; + var wrapAnsi16m2 = (fn, offset) => (...args) => { + const rgb = fn(...args); + return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; + }; + var ansi2ansi = (n) => n; + var rgb2rgb = (r, g, b) => [r, g, b]; + var setLazyProperty = (object, property, get) => { + Object.defineProperty(object, property, { + get: () => { + const value = get(); + Object.defineProperty(object, property, { + value, + enumerable: true, + configurable: true + }); + return value; + }, + enumerable: true, + configurable: true + }); + }; + var colorConvert; + var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => { + if (colorConvert === void 0) { + colorConvert = require_color_convert(); + } + const offset = isBackground ? 10 : 0; + const styles3 = {}; + for (const [sourceSpace, suite] of Object.entries(colorConvert)) { + const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace; + if (sourceSpace === targetSpace) { + styles3[name] = wrap(identity, offset); + } else if (typeof suite === "object") { + styles3[name] = wrap(suite[targetSpace], offset); + } + } + return styles3; + }; + function assembleStyles2() { + const codes = /* @__PURE__ */ new Map(); + const styles3 = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29] + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + // Bright color + blackBright: [90, 39], + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39] + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + // Bright color + bgBlackBright: [100, 49], + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49] + } + }; + styles3.color.gray = styles3.color.blackBright; + styles3.bgColor.bgGray = styles3.bgColor.bgBlackBright; + styles3.color.grey = styles3.color.blackBright; + styles3.bgColor.bgGrey = styles3.bgColor.bgBlackBright; + for (const [groupName, group] of Object.entries(styles3)) { + for (const [styleName, style] of Object.entries(group)) { + styles3[styleName] = { + open: `\x1B[${style[0]}m`, + close: `\x1B[${style[1]}m` + }; + group[styleName] = styles3[styleName]; + codes.set(style[0], style[1]); + } + Object.defineProperty(styles3, groupName, { + value: group, + enumerable: false + }); + } + Object.defineProperty(styles3, "codes", { + value: codes, + enumerable: false + }); + styles3.color.close = "\x1B[39m"; + styles3.bgColor.close = "\x1B[49m"; + setLazyProperty(styles3.color, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, false)); + setLazyProperty(styles3.color, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, false)); + setLazyProperty(styles3.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, false)); + setLazyProperty(styles3.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, true)); + setLazyProperty(styles3.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, true)); + setLazyProperty(styles3.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, true)); + return styles3; + } + Object.defineProperty(module2, "exports", { + enumerable: true, + get: assembleStyles2 + }); + } +}); +var require_util2 = __commonJS2({ + "node_modules/chalk/source/util.js"(exports2, module2) { + "use strict"; + var stringReplaceAll2 = (string, substring, replacer) => { + let index = string.indexOf(substring); + if (index === -1) { + return string; + } + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ""; + do { + returnValue += string.substr(endIndex, index - endIndex) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + returnValue += string.substr(endIndex); + return returnValue; + }; + var stringEncaseCRLFWithFirstIndex2 = (string, prefix, postfix, index) => { + let endIndex = 0; + let returnValue = ""; + do { + const gotCR = string[index - 1] === "\r"; + returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix; + endIndex = index + 1; + index = string.indexOf("\n", endIndex); + } while (index !== -1); + returnValue += string.substr(endIndex); + return returnValue; + }; + module2.exports = { + stringReplaceAll: stringReplaceAll2, + stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex2 + }; + } +}); +var require_templates = __commonJS2({ + "node_modules/chalk/source/templates.js"(exports2, module2) { + "use strict"; + var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi; + var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g; + var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/; + var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi; + var ESCAPES = /* @__PURE__ */ new Map([ + ["n", "\n"], + ["r", "\r"], + ["t", " "], + ["b", "\b"], + ["f", "\f"], + ["v", "\v"], + ["0", "\0"], + ["\\", "\\"], + ["e", "\x1B"], + ["a", "\x07"] + ]); + function unescape2(c) { + const u = c[0] === "u"; + const bracket = c[1] === "{"; + if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) { + return String.fromCharCode(parseInt(c.slice(1), 16)); + } + if (u && bracket) { + return String.fromCodePoint(parseInt(c.slice(2, -1), 16)); + } + return ESCAPES.get(c) || c; + } + function parseArguments(name, arguments_) { + const results = []; + const chunks = arguments_.trim().split(/\s*,\s*/g); + let matches; + for (const chunk of chunks) { + const number = Number(chunk); + if (!Number.isNaN(number)) { + results.push(number); + } else if (matches = chunk.match(STRING_REGEX)) { + results.push(matches[2].replace(ESCAPE_REGEX, (m, escape2, character) => escape2 ? unescape2(escape2) : character)); + } else { + throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`); + } + } + return results; + } + function parseStyle(style) { + STYLE_REGEX.lastIndex = 0; + const results = []; + let matches; + while ((matches = STYLE_REGEX.exec(style)) !== null) { + const name = matches[1]; + if (matches[2]) { + const args = parseArguments(name, matches[2]); + results.push([name].concat(args)); + } else { + results.push([name]); + } + } + return results; + } + function buildStyle(chalk2, styles3) { + const enabled = {}; + for (const layer of styles3) { + for (const style of layer.styles) { + enabled[style[0]] = layer.inverse ? null : style.slice(1); + } + } + let current = chalk2; + for (const [styleName, styles22] of Object.entries(enabled)) { + if (!Array.isArray(styles22)) { + continue; + } + if (!(styleName in current)) { + throw new Error(`Unknown Chalk style: ${styleName}`); + } + current = styles22.length > 0 ? current[styleName](...styles22) : current[styleName]; + } + return current; + } + module2.exports = (chalk2, temporary) => { + const styles3 = []; + const chunks = []; + let chunk = []; + temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => { + if (escapeCharacter) { + chunk.push(unescape2(escapeCharacter)); + } else if (style) { + const string = chunk.join(""); + chunk = []; + chunks.push(styles3.length === 0 ? string : buildStyle(chalk2, styles3)(string)); + styles3.push({ inverse, styles: parseStyle(style) }); + } else if (close) { + if (styles3.length === 0) { + throw new Error("Found extraneous } in Chalk template literal"); + } + chunks.push(buildStyle(chalk2, styles3)(chunk.join(""))); + chunk = []; + styles3.pop(); + } else { + chunk.push(character); + } + }); + chunks.push(chunk.join("")); + if (styles3.length > 0) { + const errMessage = `Chalk template literal is missing ${styles3.length} closing bracket${styles3.length === 1 ? "" : "s"} (\`}\`)`; + throw new Error(errMessage); + } + return chunks.join(""); + }; + } +}); +var require_source = __commonJS2({ + "node_modules/chalk/source/index.js"(exports2, module2) { + "use strict"; + var ansiStyles2 = require_ansi_styles(); + var { stdout: stdoutColor2, stderr: stderrColor2 } = require_supports_color(); + var { + stringReplaceAll: stringReplaceAll2, + stringEncaseCRLFWithFirstIndex: stringEncaseCRLFWithFirstIndex2 + } = require_util2(); + var { isArray } = Array; + var levelMapping2 = [ + "ansi", + "ansi", + "ansi256", + "ansi16m" + ]; + var styles3 = /* @__PURE__ */ Object.create(null); + var applyOptions2 = (object, options = {}) => { + if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { + throw new Error("The `level` option should be an integer from 0 to 3"); + } + const colorLevel = stdoutColor2 ? stdoutColor2.level : 0; + object.level = options.level === void 0 ? colorLevel : options.level; + }; + var ChalkClass = class { + constructor(options) { + return chalkFactory2(options); + } + }; + var chalkFactory2 = (options) => { + const chalk3 = {}; + applyOptions2(chalk3, options); + chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_); + Object.setPrototypeOf(chalk3, Chalk.prototype); + Object.setPrototypeOf(chalk3.template, chalk3); + chalk3.template.constructor = () => { + throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead."); + }; + chalk3.template.Instance = ChalkClass; + return chalk3.template; + }; + function Chalk(options) { + return chalkFactory2(options); + } + for (const [styleName, style] of Object.entries(ansiStyles2)) { + styles3[styleName] = { + get() { + const builder = createBuilder2(this, createStyler2(style.open, style.close, this._styler), this._isEmpty); + Object.defineProperty(this, styleName, { value: builder }); + return builder; + } + }; + } + styles3.visible = { + get() { + const builder = createBuilder2(this, this._styler, true); + Object.defineProperty(this, "visible", { value: builder }); + return builder; + } + }; + var usedModels2 = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"]; + for (const model of usedModels2) { + styles3[model] = { + get() { + const { level } = this; + return function(...arguments_) { + const styler = createStyler2(ansiStyles2.color[levelMapping2[level]][model](...arguments_), ansiStyles2.color.close, this._styler); + return createBuilder2(this, styler, this._isEmpty); + }; + } + }; + } + for (const model of usedModels2) { + const bgModel = "bg" + model[0].toUpperCase() + model.slice(1); + styles3[bgModel] = { + get() { + const { level } = this; + return function(...arguments_) { + const styler = createStyler2(ansiStyles2.bgColor[levelMapping2[level]][model](...arguments_), ansiStyles2.bgColor.close, this._styler); + return createBuilder2(this, styler, this._isEmpty); + }; + } + }; + } + var proto2 = Object.defineProperties(() => { + }, { + ...styles3, + level: { + enumerable: true, + get() { + return this._generator.level; + }, + set(level) { + this._generator.level = level; + } + } + }); + var createStyler2 = (open, close, parent) => { + let openAll; + let closeAll; + if (parent === void 0) { + openAll = open; + closeAll = close; + } else { + openAll = parent.openAll + open; + closeAll = close + parent.closeAll; + } + return { + open, + close, + openAll, + closeAll, + parent + }; + }; + var createBuilder2 = (self2, _styler, _isEmpty) => { + const builder = (...arguments_) => { + if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) { + return applyStyle2(builder, chalkTag(builder, ...arguments_)); + } + return applyStyle2(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" ")); + }; + Object.setPrototypeOf(builder, proto2); + builder._generator = self2; + builder._styler = _styler; + builder._isEmpty = _isEmpty; + return builder; + }; + var applyStyle2 = (self2, string) => { + if (self2.level <= 0 || !string) { + return self2._isEmpty ? "" : string; + } + let styler = self2._styler; + if (styler === void 0) { + return string; + } + const { openAll, closeAll } = styler; + if (string.indexOf("\x1B") !== -1) { + while (styler !== void 0) { + string = stringReplaceAll2(string, styler.close, styler.open); + styler = styler.parent; + } + } + const lfIndex = string.indexOf("\n"); + if (lfIndex !== -1) { + string = stringEncaseCRLFWithFirstIndex2(string, closeAll, openAll, lfIndex); + } + return openAll + string + closeAll; + }; + var template; + var chalkTag = (chalk3, ...strings) => { + const [firstString] = strings; + if (!isArray(firstString) || !isArray(firstString.raw)) { + return strings.join(" "); + } + const arguments_ = strings.slice(1); + const parts = [firstString.raw[0]]; + for (let i = 1; i < firstString.length; i++) { + parts.push( + String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), + String(firstString.raw[i]) + ); + } + if (template === void 0) { + template = require_templates(); + } + return template(chalk3, parts.join("")); + }; + Object.defineProperties(Chalk.prototype, styles3); + var chalk2 = Chalk(); + chalk2.supportsColor = stdoutColor2; + chalk2.stderr = Chalk({ level: stderrColor2 ? stderrColor2.level : 0 }); + chalk2.stderr.supportsColor = stderrColor2; + module2.exports = chalk2; + } +}); +var require_object_assign = __commonJS2({ + "node_modules/object-assign/index.js"(exports2, module2) { + "use strict"; + var getOwnPropertySymbols = Object.getOwnPropertySymbols; + var hasOwnProperty = Object.prototype.hasOwnProperty; + var propIsEnumerable = Object.prototype.propertyIsEnumerable; + function toObject(val) { + if (val === null || val === void 0) { + throw new TypeError("Object.assign cannot be called with null or undefined"); + } + return Object(val); + } + function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } + var test1 = new String("abc"); + test1[5] = "de"; + if (Object.getOwnPropertyNames(test1)[0] === "5") { + return false; + } + var test2 = {}; + for (var i = 0; i < 10; i++) { + test2["_" + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function(n) { + return test2[n]; + }); + if (order2.join("") !== "0123456789") { + return false; + } + var test3 = {}; + "abcdefghijklmnopqrst".split("").forEach(function(letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") { + return false; + } + return true; + } catch (err2) { + return false; + } + } + module2.exports = shouldUseNative() ? Object.assign : function(target, source) { + var from; + var to = toObject(target); + var symbols; + for (var s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) { + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } + return to; + }; + } +}); +var require_lib4 = __commonJS2({ + "node_modules/cors/lib/index.js"(exports2, module2) { + (function() { + "use strict"; + var assign = require_object_assign(); + var vary = require_vary(); + var defaults = { + origin: "*", + methods: "GET,HEAD,PUT,PATCH,POST,DELETE", + preflightContinue: false, + optionsSuccessStatus: 204 + }; + function isString(s) { + return typeof s === "string" || s instanceof String; + } + function isOriginAllowed(origin, allowedOrigin) { + if (Array.isArray(allowedOrigin)) { + for (var i = 0; i < allowedOrigin.length; ++i) { + if (isOriginAllowed(origin, allowedOrigin[i])) { + return true; + } + } + return false; + } else if (isString(allowedOrigin)) { + return origin === allowedOrigin; + } else if (allowedOrigin instanceof RegExp) { + return allowedOrigin.test(origin); + } else { + return !!allowedOrigin; + } + } + function configureOrigin(options, req) { + var requestOrigin = req.headers.origin, headers = [], isAllowed; + if (!options.origin || options.origin === "*") { + headers.push([{ + key: "Access-Control-Allow-Origin", + value: "*" + }]); + } else if (isString(options.origin)) { + headers.push([{ + key: "Access-Control-Allow-Origin", + value: options.origin + }]); + headers.push([{ + key: "Vary", + value: "Origin" + }]); + } else { + isAllowed = isOriginAllowed(requestOrigin, options.origin); + headers.push([{ + key: "Access-Control-Allow-Origin", + value: isAllowed ? requestOrigin : false + }]); + headers.push([{ + key: "Vary", + value: "Origin" + }]); + } + return headers; + } + function configureMethods(options) { + var methods = options.methods; + if (methods.join) { + methods = options.methods.join(","); + } + return { + key: "Access-Control-Allow-Methods", + value: methods + }; + } + function configureCredentials(options) { + if (options.credentials === true) { + return { + key: "Access-Control-Allow-Credentials", + value: "true" + }; + } + return null; + } + function configureAllowedHeaders(options, req) { + var allowedHeaders = options.allowedHeaders || options.headers; + var headers = []; + if (!allowedHeaders) { + allowedHeaders = req.headers["access-control-request-headers"]; + headers.push([{ + key: "Vary", + value: "Access-Control-Request-Headers" + }]); + } else if (allowedHeaders.join) { + allowedHeaders = allowedHeaders.join(","); + } + if (allowedHeaders && allowedHeaders.length) { + headers.push([{ + key: "Access-Control-Allow-Headers", + value: allowedHeaders + }]); + } + return headers; + } + function configureExposedHeaders(options) { + var headers = options.exposedHeaders; + if (!headers) { + return null; + } else if (headers.join) { + headers = headers.join(","); + } + if (headers && headers.length) { + return { + key: "Access-Control-Expose-Headers", + value: headers + }; + } + return null; + } + function configureMaxAge(options) { + var maxAge = (typeof options.maxAge === "number" || options.maxAge) && options.maxAge.toString(); + if (maxAge && maxAge.length) { + return { + key: "Access-Control-Max-Age", + value: maxAge + }; + } + return null; + } + function applyHeaders(headers, res) { + for (var i = 0, n = headers.length; i < n; i++) { + var header = headers[i]; + if (header) { + if (Array.isArray(header)) { + applyHeaders(header, res); + } else if (header.key === "Vary" && header.value) { + vary(res, header.value); + } else if (header.value) { + res.setHeader(header.key, header.value); + } + } + } + } + function cors2(options, req, res, next) { + var headers = [], method = req.method && req.method.toUpperCase && req.method.toUpperCase(); + if (method === "OPTIONS") { + headers.push(configureOrigin(options, req)); + headers.push(configureCredentials(options, req)); + headers.push(configureMethods(options, req)); + headers.push(configureAllowedHeaders(options, req)); + headers.push(configureMaxAge(options, req)); + headers.push(configureExposedHeaders(options, req)); + applyHeaders(headers, res); + if (options.preflightContinue) { + next(); + } else { + res.statusCode = options.optionsSuccessStatus; + res.setHeader("Content-Length", "0"); + res.end(); + } + } else { + headers.push(configureOrigin(options, req)); + headers.push(configureCredentials(options, req)); + headers.push(configureExposedHeaders(options, req)); + applyHeaders(headers, res); + next(); + } + } + function middlewareWrapper(o) { + var optionsCallback = null; + if (typeof o === "function") { + optionsCallback = o; + } else { + optionsCallback = function(req, cb) { + cb(null, o); + }; + } + return function corsMiddleware(req, res, next) { + optionsCallback(req, function(err2, options) { + if (err2) { + next(err2); + } else { + var corsOptions = assign({}, defaults, options); + var originCallback = null; + if (corsOptions.origin && typeof corsOptions.origin === "function") { + originCallback = corsOptions.origin; + } else if (corsOptions.origin) { + originCallback = function(origin, cb) { + cb(null, corsOptions.origin); + }; + } + if (originCallback) { + originCallback(req.headers.origin, function(err22, origin) { + if (err22 || !origin) { + next(err22); + } else { + corsOptions.origin = origin; + cors2(corsOptions, req, res, next); + } + }); + } else { + next(); + } + } + }); + }; + } + module2.exports = middlewareWrapper; + })(); + } +}); +var util2; +(function(util22) { + util22.assertEqual = (val) => val; + function assertIs(_arg) { + } + util22.assertIs = assertIs; + function assertNever(_x) { + throw new Error(); + } + util22.assertNever = assertNever; + util22.arrayToEnum = (items) => { + const obj = {}; + for (const item of items) { + obj[item] = item; + } + return obj; + }; + util22.getValidEnumValues = (obj) => { + const validKeys = util22.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number"); + const filtered = {}; + for (const k of validKeys) { + filtered[k] = obj[k]; + } + return util22.objectValues(filtered); + }; + util22.objectValues = (obj) => { + return util22.objectKeys(obj).map(function(e) { + return obj[e]; + }); + }; + util22.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => { + const keys = []; + for (const key in object) { + if (Object.prototype.hasOwnProperty.call(object, key)) { + keys.push(key); + } + } + return keys; + }; + util22.find = (arr, checker) => { + for (const item of arr) { + if (checker(item)) + return item; + } + return void 0; + }; + util22.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val; + function joinValues(array, separator = " | ") { + return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator); + } + util22.joinValues = joinValues; + util22.jsonStringifyReplacer = (_2, value) => { + if (typeof value === "bigint") { + return value.toString(); + } + return value; + }; +})(util2 || (util2 = {})); +var objectUtil2; +(function(objectUtil22) { + objectUtil22.mergeShapes = (first, second) => { + return { + ...first, + ...second + // second overwrites first + }; + }; +})(objectUtil2 || (objectUtil2 = {})); +var ZodParsedType2 = util2.arrayToEnum([ + "string", + "nan", + "number", + "integer", + "float", + "boolean", + "date", + "bigint", + "symbol", + "function", + "undefined", + "null", + "array", + "object", + "unknown", + "promise", + "void", + "never", + "map", + "set" +]); +var getParsedType2 = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return ZodParsedType2.undefined; + case "string": + return ZodParsedType2.string; + case "number": + return isNaN(data) ? ZodParsedType2.nan : ZodParsedType2.number; + case "boolean": + return ZodParsedType2.boolean; + case "function": + return ZodParsedType2.function; + case "bigint": + return ZodParsedType2.bigint; + case "symbol": + return ZodParsedType2.symbol; + case "object": + if (Array.isArray(data)) { + return ZodParsedType2.array; + } + if (data === null) { + return ZodParsedType2.null; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return ZodParsedType2.promise; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return ZodParsedType2.map; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return ZodParsedType2.set; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return ZodParsedType2.date; + } + return ZodParsedType2.object; + default: + return ZodParsedType2.unknown; + } +}; +var ZodIssueCode2 = util2.arrayToEnum([ + "invalid_type", + "invalid_literal", + "custom", + "invalid_union", + "invalid_union_discriminator", + "invalid_enum_value", + "unrecognized_keys", + "invalid_arguments", + "invalid_return_type", + "invalid_date", + "invalid_string", + "too_small", + "too_big", + "invalid_intersection_types", + "not_multiple_of", + "not_finite" +]); +var quotelessJson2 = (obj) => { + const json = JSON.stringify(obj, null, 2); + return json.replace(/"([^"]+)":/g, "$1:"); +}; +var ZodError2 = class _ZodError extends Error { + get errors() { + return this.issues; + } + constructor(issues) { + super(); + this.issues = []; + this.addIssue = (sub) => { + this.issues = [...this.issues, sub]; + }; + this.addIssues = (subs = []) => { + this.issues = [...this.issues, ...subs]; + }; + const actualProto = new.target.prototype; + if (Object.setPrototypeOf) { + Object.setPrototypeOf(this, actualProto); + } else { + this.__proto__ = actualProto; + } + this.name = "ZodError"; + this.issues = issues; + } + format(_mapper) { + const mapper = _mapper || function(issue) { + return issue.message; + }; + const fieldErrors = { _errors: [] }; + const processError = (error) => { + for (const issue of error.issues) { + if (issue.code === "invalid_union") { + issue.unionErrors.map(processError); + } else if (issue.code === "invalid_return_type") { + processError(issue.returnTypeError); + } else if (issue.code === "invalid_arguments") { + processError(issue.argumentsError); + } else if (issue.path.length === 0) { + fieldErrors._errors.push(mapper(issue)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < issue.path.length) { + const el = issue.path[i]; + const terminal = i === issue.path.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue)); + } + curr = curr[el]; + i++; + } + } + } + }; + processError(this); + return fieldErrors; + } + static assert(value) { + if (!(value instanceof _ZodError)) { + throw new Error(`Not a ZodError: ${value}`); + } + } + toString() { + return this.message; + } + get message() { + return JSON.stringify(this.issues, util2.jsonStringifyReplacer, 2); + } + get isEmpty() { + return this.issues.length === 0; + } + flatten(mapper = (issue) => issue.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of this.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; + } + get formErrors() { + return this.flatten(); + } +}; +ZodError2.create = (issues) => { + const error = new ZodError2(issues); + return error; +}; +var errorMap2 = (issue, _ctx) => { + let message; + switch (issue.code) { + case ZodIssueCode2.invalid_type: + if (issue.received === ZodParsedType2.undefined) { + message = "Required"; + } else { + message = `Expected ${issue.expected}, received ${issue.received}`; + } + break; + case ZodIssueCode2.invalid_literal: + message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util2.jsonStringifyReplacer)}`; + break; + case ZodIssueCode2.unrecognized_keys: + message = `Unrecognized key(s) in object: ${util2.joinValues(issue.keys, ", ")}`; + break; + case ZodIssueCode2.invalid_union: + message = `Invalid input`; + break; + case ZodIssueCode2.invalid_union_discriminator: + message = `Invalid discriminator value. Expected ${util2.joinValues(issue.options)}`; + break; + case ZodIssueCode2.invalid_enum_value: + message = `Invalid enum value. Expected ${util2.joinValues(issue.options)}, received '${issue.received}'`; + break; + case ZodIssueCode2.invalid_arguments: + message = `Invalid function arguments`; + break; + case ZodIssueCode2.invalid_return_type: + message = `Invalid function return type`; + break; + case ZodIssueCode2.invalid_date: + message = `Invalid date`; + break; + case ZodIssueCode2.invalid_string: + if (typeof issue.validation === "object") { + if ("includes" in issue.validation) { + message = `Invalid input: must include "${issue.validation.includes}"`; + if (typeof issue.validation.position === "number") { + message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`; + } + } else if ("startsWith" in issue.validation) { + message = `Invalid input: must start with "${issue.validation.startsWith}"`; + } else if ("endsWith" in issue.validation) { + message = `Invalid input: must end with "${issue.validation.endsWith}"`; + } else { + util2.assertNever(issue.validation); + } + } else if (issue.validation !== "regex") { + message = `Invalid ${issue.validation}`; + } else { + message = "Invalid"; + } + break; + case ZodIssueCode2.too_small: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode2.too_big: + if (issue.type === "array") + message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`; + else if (issue.type === "string") + message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`; + else if (issue.type === "number") + message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "bigint") + message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`; + else if (issue.type === "date") + message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`; + else + message = "Invalid input"; + break; + case ZodIssueCode2.custom: + message = `Invalid input`; + break; + case ZodIssueCode2.invalid_intersection_types: + message = `Intersection results could not be merged`; + break; + case ZodIssueCode2.not_multiple_of: + message = `Number must be a multiple of ${issue.multipleOf}`; + break; + case ZodIssueCode2.not_finite: + message = "Number must be finite"; + break; + default: + message = _ctx.defaultError; + util2.assertNever(issue); + } + return { message }; +}; +var overrideErrorMap2 = errorMap2; +function setErrorMap2(map) { + overrideErrorMap2 = map; +} +function getErrorMap2() { + return overrideErrorMap2; +} +var makeIssue2 = (params) => { + const { data, path, errorMaps, issueData } = params; + const fullPath = [...path, ...issueData.path || []]; + const fullIssue = { + ...issueData, + path: fullPath + }; + if (issueData.message !== void 0) { + return { + ...issueData, + path: fullPath, + message: issueData.message + }; + } + let errorMessage = ""; + const maps = errorMaps.filter((m) => !!m).slice().reverse(); + for (const map of maps) { + errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message; + } + return { + ...issueData, + path: fullPath, + message: errorMessage + }; +}; +var EMPTY_PATH2 = []; +function addIssueToContext2(ctx, issueData) { + const overrideMap = getErrorMap2(); + const issue = makeIssue2({ + issueData, + data: ctx.data, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + // contextual error map is first priority + ctx.schemaErrorMap, + // then schema-bound map if available + overrideMap, + // then global override map + overrideMap === errorMap2 ? void 0 : errorMap2 + // then global default map + ].filter((x) => !!x) + }); + ctx.common.issues.push(issue); +} +var ParseStatus2 = class _ParseStatus { + constructor() { + this.value = "valid"; + } + dirty() { + if (this.value === "valid") + this.value = "dirty"; + } + abort() { + if (this.value !== "aborted") + this.value = "aborted"; + } + static mergeArray(status, results) { + const arrayValue = []; + for (const s of results) { + if (s.status === "aborted") + return INVALID2; + if (s.status === "dirty") + status.dirty(); + arrayValue.push(s.value); + } + return { status: status.value, value: arrayValue }; + } + static async mergeObjectAsync(status, pairs) { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value + }); + } + return _ParseStatus.mergeObjectSync(status, syncPairs); + } + static mergeObjectSync(status, pairs) { + const finalObject = {}; + for (const pair of pairs) { + const { key, value } = pair; + if (key.status === "aborted") + return INVALID2; + if (value.status === "aborted") + return INVALID2; + if (key.status === "dirty") + status.dirty(); + if (value.status === "dirty") + status.dirty(); + if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) { + finalObject[key.value] = value.value; + } + } + return { status: status.value, value: finalObject }; + } +}; +var INVALID2 = Object.freeze({ + status: "aborted" +}); +var DIRTY2 = (value) => ({ status: "dirty", value }); +var OK2 = (value) => ({ status: "valid", value }); +var isAborted2 = (x) => x.status === "aborted"; +var isDirty2 = (x) => x.status === "dirty"; +var isValid2 = (x) => x.status === "valid"; +var isAsync2 = (x) => typeof Promise !== "undefined" && x instanceof Promise; +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; +} +var errorUtil2; +(function(errorUtil22) { + errorUtil22.errToObj = (message) => typeof message === "string" ? { message } : message || {}; + errorUtil22.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message; +})(errorUtil2 || (errorUtil2 = {})); +var _ZodEnum_cache; +var _ZodNativeEnum_cache; +var ParseInputLazyPath2 = class { + constructor(parent, value, path, key) { + this._cachedPath = []; + this.parent = parent; + this.data = value; + this._path = path; + this._key = key; + } + get path() { + if (!this._cachedPath.length) { + if (this._key instanceof Array) { + this._cachedPath.push(...this._path, ...this._key); + } else { + this._cachedPath.push(...this._path, this._key); + } + } + return this._cachedPath; + } +}; +var handleResult2 = (ctx, result) => { + if (isValid2(result)) { + return { success: true, data: result.value }; + } else { + if (!ctx.common.issues.length) { + throw new Error("Validation failed but no issues detected."); + } + return { + success: false, + get error() { + if (this._error) + return this._error; + const error = new ZodError2(ctx.common.issues); + this._error = error; + return this._error; + } + }; + } +}; +function processCreateParams2(params) { + if (!params) + return {}; + const { errorMap: errorMap22, invalid_type_error, required_error, description } = params; + if (errorMap22 && (invalid_type_error || required_error)) { + throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`); + } + if (errorMap22) + return { errorMap: errorMap22, description }; + const customMap = (iss, ctx) => { + var _a, _b; + const { message } = params; + if (iss.code === "invalid_enum_value") { + return { message: message !== null && message !== void 0 ? message : ctx.defaultError }; + } + if (typeof ctx.data === "undefined") { + return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError }; + } + if (iss.code !== "invalid_type") + return { message: ctx.defaultError }; + return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError }; + }; + return { errorMap: customMap, description }; +} +var ZodType2 = class { + get description() { + return this._def.description; + } + _getType(input) { + return getParsedType2(input.data); + } + _getOrReturnCtx(input, ctx) { + return ctx || { + common: input.parent.common, + data: input.data, + parsedType: getParsedType2(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + }; + } + _processInputParams(input) { + return { + status: new ParseStatus2(), + ctx: { + common: input.parent.common, + data: input.data, + parsedType: getParsedType2(input.data), + schemaErrorMap: this._def.errorMap, + path: input.path, + parent: input.parent + } + }; + } + _parseSync(input) { + const result = this._parse(input); + if (isAsync2(result)) { + throw new Error("Synchronous parse encountered promise."); + } + return result; + } + _parseAsync(input) { + const result = this._parse(input); + return Promise.resolve(result); + } + parse(data, params) { + const result = this.safeParse(data, params); + if (result.success) + return result.data; + throw result.error; + } + safeParse(data, params) { + var _a; + const ctx = { + common: { + issues: [], + async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false, + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType2(data) + }; + const result = this._parseSync({ data, path: ctx.path, parent: ctx }); + return handleResult2(ctx, result); + } + "~validate"(data) { + var _a, _b; + const ctx = { + common: { + issues: [], + async: !!this["~standard"].async + }, + path: [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType2(data) + }; + if (!this["~standard"].async) { + try { + const result = this._parseSync({ data, path: [], parent: ctx }); + return isValid2(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }; + } catch (err2) { + if ((_b = (_a = err2 === null || err2 === void 0 ? void 0 : err2.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) { + this["~standard"].async = true; + } + ctx.common = { + issues: [], + async: true + }; + } + } + return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid2(result) ? { + value: result.value + } : { + issues: ctx.common.issues + }); + } + async parseAsync(data, params) { + const result = await this.safeParseAsync(data, params); + if (result.success) + return result.data; + throw result.error; + } + async safeParseAsync(data, params) { + const ctx = { + common: { + issues: [], + contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap, + async: true + }, + path: (params === null || params === void 0 ? void 0 : params.path) || [], + schemaErrorMap: this._def.errorMap, + parent: null, + data, + parsedType: getParsedType2(data) + }; + const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx }); + const result = await (isAsync2(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult)); + return handleResult2(ctx, result); + } + refine(check, message) { + const getIssueProperties = (val) => { + if (typeof message === "string" || typeof message === "undefined") { + return { message }; + } else if (typeof message === "function") { + return message(val); + } else { + return message; + } + }; + return this._refinement((val, ctx) => { + const result = check(val); + const setError = () => ctx.addIssue({ + code: ZodIssueCode2.custom, + ...getIssueProperties(val) + }); + if (typeof Promise !== "undefined" && result instanceof Promise) { + return result.then((data) => { + if (!data) { + setError(); + return false; + } else { + return true; + } + }); + } + if (!result) { + setError(); + return false; + } else { + return true; + } + }); + } + refinement(check, refinementData) { + return this._refinement((val, ctx) => { + if (!check(val)) { + ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData); + return false; + } else { + return true; + } + }); + } + _refinement(refinement) { + return new ZodEffects2({ + schema: this, + typeName: ZodFirstPartyTypeKind2.ZodEffects, + effect: { type: "refinement", refinement } + }); + } + superRefine(refinement) { + return this._refinement(refinement); + } + constructor(def) { + this.spa = this.safeParseAsync; + this._def = def; + this.parse = this.parse.bind(this); + this.safeParse = this.safeParse.bind(this); + this.parseAsync = this.parseAsync.bind(this); + this.safeParseAsync = this.safeParseAsync.bind(this); + this.spa = this.spa.bind(this); + this.refine = this.refine.bind(this); + this.refinement = this.refinement.bind(this); + this.superRefine = this.superRefine.bind(this); + this.optional = this.optional.bind(this); + this.nullable = this.nullable.bind(this); + this.nullish = this.nullish.bind(this); + this.array = this.array.bind(this); + this.promise = this.promise.bind(this); + this.or = this.or.bind(this); + this.and = this.and.bind(this); + this.transform = this.transform.bind(this); + this.brand = this.brand.bind(this); + this.default = this.default.bind(this); + this.catch = this.catch.bind(this); + this.describe = this.describe.bind(this); + this.pipe = this.pipe.bind(this); + this.readonly = this.readonly.bind(this); + this.isNullable = this.isNullable.bind(this); + this.isOptional = this.isOptional.bind(this); + this["~standard"] = { + version: 1, + vendor: "zod", + validate: (data) => this["~validate"](data) + }; + } + optional() { + return ZodOptional2.create(this, this._def); + } + nullable() { + return ZodNullable2.create(this, this._def); + } + nullish() { + return this.nullable().optional(); + } + array() { + return ZodArray2.create(this); + } + promise() { + return ZodPromise2.create(this, this._def); + } + or(option) { + return ZodUnion2.create([this, option], this._def); + } + and(incoming) { + return ZodIntersection2.create(this, incoming, this._def); + } + transform(transform) { + return new ZodEffects2({ + ...processCreateParams2(this._def), + schema: this, + typeName: ZodFirstPartyTypeKind2.ZodEffects, + effect: { type: "transform", transform } + }); + } + default(def) { + const defaultValueFunc = typeof def === "function" ? def : () => def; + return new ZodDefault2({ + ...processCreateParams2(this._def), + innerType: this, + defaultValue: defaultValueFunc, + typeName: ZodFirstPartyTypeKind2.ZodDefault + }); + } + brand() { + return new ZodBranded2({ + typeName: ZodFirstPartyTypeKind2.ZodBranded, + type: this, + ...processCreateParams2(this._def) + }); + } + catch(def) { + const catchValueFunc = typeof def === "function" ? def : () => def; + return new ZodCatch2({ + ...processCreateParams2(this._def), + innerType: this, + catchValue: catchValueFunc, + typeName: ZodFirstPartyTypeKind2.ZodCatch + }); + } + describe(description) { + const This = this.constructor; + return new This({ + ...this._def, + description + }); + } + pipe(target) { + return ZodPipeline2.create(this, target); + } + readonly() { + return ZodReadonly2.create(this); + } + isOptional() { + return this.safeParse(void 0).success; + } + isNullable() { + return this.safeParse(null).success; + } +}; +var cuidRegex2 = /^c[^\s-]{8,}$/i; +var cuid2Regex2 = /^[0-9a-z]+$/; +var ulidRegex2 = /^[0-9A-HJKMNP-TV-Z]{26}$/i; +var uuidRegex2 = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i; +var nanoidRegex2 = /^[a-z0-9_-]{21}$/i; +var jwtRegex2 = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/; +var durationRegex2 = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/; +var emailRegex2 = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i; +var _emojiRegex2 = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +var emojiRegex3; +var ipv4Regex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +var ipv4CidrRegex2 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/; +var ipv6Regex2 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/; +var ipv6CidrRegex2 = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64Regex2 = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/; +var base64urlRegex2 = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/; +var dateRegexSource2 = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`; +var dateRegex2 = new RegExp(`^${dateRegexSource2}$`); +function timeRegexSource2(args) { + let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`; + if (args.precision) { + regex = `${regex}\\.\\d{${args.precision}}`; + } else if (args.precision == null) { + regex = `${regex}(\\.\\d+)?`; + } + return regex; +} +function timeRegex2(args) { + return new RegExp(`^${timeRegexSource2(args)}$`); +} +function datetimeRegex2(args) { + let regex = `${dateRegexSource2}T${timeRegexSource2(args)}`; + const opts = []; + opts.push(args.local ? `Z?` : `Z`); + if (args.offset) + opts.push(`([+-]\\d{2}:?\\d{2})`); + regex = `${regex}(${opts.join("|")})`; + return new RegExp(`^${regex}$`); +} +function isValidIP2(ip, version) { + if ((version === "v4" || !version) && ipv4Regex2.test(ip)) { + return true; + } + if ((version === "v6" || !version) && ipv6Regex2.test(ip)) { + return true; + } + return false; +} +function isValidJWT2(jwt, alg) { + if (!jwtRegex2.test(jwt)) + return false; + try { + const [header] = jwt.split("."); + const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "="); + const decoded = JSON.parse(atob(base64)); + if (typeof decoded !== "object" || decoded === null) + return false; + if (!decoded.typ || !decoded.alg) + return false; + if (alg && decoded.alg !== alg) + return false; + return true; + } catch (_a) { + return false; + } +} +function isValidCidr2(ip, version) { + if ((version === "v4" || !version) && ipv4CidrRegex2.test(ip)) { + return true; + } + if ((version === "v6" || !version) && ipv6CidrRegex2.test(ip)) { + return true; + } + return false; +} +var ZodString2 = class _ZodString extends ZodType2 { + _parse(input) { + if (this._def.coerce) { + input.data = String(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.string) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext2(ctx2, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.string, + received: ctx2.parsedType + }); + return INVALID2; + } + const status = new ParseStatus2(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.length < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.length > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "length") { + const tooBig = input.data.length > check.value; + const tooSmall = input.data.length < check.value; + if (tooBig || tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + if (tooBig) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } else if (tooSmall) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: check.value, + type: "string", + inclusive: true, + exact: true, + message: check.message + }); + } + status.dirty(); + } + } else if (check.kind === "email") { + if (!emailRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "email", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "emoji") { + if (!emojiRegex3) { + emojiRegex3 = new RegExp(_emojiRegex2, "u"); + } + if (!emojiRegex3.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "emoji", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "uuid") { + if (!uuidRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "uuid", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "nanoid") { + if (!nanoidRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "nanoid", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid") { + if (!cuidRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "cuid", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cuid2") { + if (!cuid2Regex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "cuid2", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ulid") { + if (!ulidRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "ulid", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "url") { + try { + new URL(input.data); + } catch (_a) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "url", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "regex") { + check.regex.lastIndex = 0; + const testResult = check.regex.test(input.data); + if (!testResult) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "regex", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "trim") { + input.data = input.data.trim(); + } else if (check.kind === "includes") { + if (!input.data.includes(check.value, check.position)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: { includes: check.value, position: check.position }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "toLowerCase") { + input.data = input.data.toLowerCase(); + } else if (check.kind === "toUpperCase") { + input.data = input.data.toUpperCase(); + } else if (check.kind === "startsWith") { + if (!input.data.startsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: { startsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "endsWith") { + if (!input.data.endsWith(check.value)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: { endsWith: check.value }, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "datetime") { + const regex = datetimeRegex2(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: "datetime", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "date") { + const regex = dateRegex2; + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: "date", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "time") { + const regex = timeRegex2(check); + if (!regex.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_string, + validation: "time", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "duration") { + if (!durationRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "duration", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "ip") { + if (!isValidIP2(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "ip", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "jwt") { + if (!isValidJWT2(input.data, check.alg)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "jwt", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "cidr") { + if (!isValidCidr2(input.data, check.version)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "cidr", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "base64") { + if (!base64Regex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "base64", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "base64url") { + if (!base64urlRegex2.test(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + validation: "base64url", + code: ZodIssueCode2.invalid_string, + message: check.message + }); + status.dirty(); + } + } else { + util2.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + _regex(regex, validation, message) { + return this.refinement((data) => regex.test(data), { + validation, + code: ZodIssueCode2.invalid_string, + ...errorUtil2.errToObj(message) + }); + } + _addCheck(check) { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + email(message) { + return this._addCheck({ kind: "email", ...errorUtil2.errToObj(message) }); + } + url(message) { + return this._addCheck({ kind: "url", ...errorUtil2.errToObj(message) }); + } + emoji(message) { + return this._addCheck({ kind: "emoji", ...errorUtil2.errToObj(message) }); + } + uuid(message) { + return this._addCheck({ kind: "uuid", ...errorUtil2.errToObj(message) }); + } + nanoid(message) { + return this._addCheck({ kind: "nanoid", ...errorUtil2.errToObj(message) }); + } + cuid(message) { + return this._addCheck({ kind: "cuid", ...errorUtil2.errToObj(message) }); + } + cuid2(message) { + return this._addCheck({ kind: "cuid2", ...errorUtil2.errToObj(message) }); + } + ulid(message) { + return this._addCheck({ kind: "ulid", ...errorUtil2.errToObj(message) }); + } + base64(message) { + return this._addCheck({ kind: "base64", ...errorUtil2.errToObj(message) }); + } + base64url(message) { + return this._addCheck({ + kind: "base64url", + ...errorUtil2.errToObj(message) + }); + } + jwt(options) { + return this._addCheck({ kind: "jwt", ...errorUtil2.errToObj(options) }); + } + ip(options) { + return this._addCheck({ kind: "ip", ...errorUtil2.errToObj(options) }); + } + cidr(options) { + return this._addCheck({ kind: "cidr", ...errorUtil2.errToObj(options) }); + } + datetime(options) { + var _a, _b; + if (typeof options === "string") { + return this._addCheck({ + kind: "datetime", + precision: null, + offset: false, + local: false, + message: options + }); + } + return this._addCheck({ + kind: "datetime", + precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision, + offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false, + local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false, + ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message) + }); + } + date(message) { + return this._addCheck({ kind: "date", message }); + } + time(options) { + if (typeof options === "string") { + return this._addCheck({ + kind: "time", + precision: null, + message: options + }); + } + return this._addCheck({ + kind: "time", + precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision, + ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message) + }); + } + duration(message) { + return this._addCheck({ kind: "duration", ...errorUtil2.errToObj(message) }); + } + regex(regex, message) { + return this._addCheck({ + kind: "regex", + regex, + ...errorUtil2.errToObj(message) + }); + } + includes(value, options) { + return this._addCheck({ + kind: "includes", + value, + position: options === null || options === void 0 ? void 0 : options.position, + ...errorUtil2.errToObj(options === null || options === void 0 ? void 0 : options.message) + }); + } + startsWith(value, message) { + return this._addCheck({ + kind: "startsWith", + value, + ...errorUtil2.errToObj(message) + }); + } + endsWith(value, message) { + return this._addCheck({ + kind: "endsWith", + value, + ...errorUtil2.errToObj(message) + }); + } + min(minLength, message) { + return this._addCheck({ + kind: "min", + value: minLength, + ...errorUtil2.errToObj(message) + }); + } + max(maxLength, message) { + return this._addCheck({ + kind: "max", + value: maxLength, + ...errorUtil2.errToObj(message) + }); + } + length(len, message) { + return this._addCheck({ + kind: "length", + value: len, + ...errorUtil2.errToObj(message) + }); + } + /** + * Equivalent to `.min(1)` + */ + nonempty(message) { + return this.min(1, errorUtil2.errToObj(message)); + } + trim() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "trim" }] + }); + } + toLowerCase() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toLowerCase" }] + }); + } + toUpperCase() { + return new _ZodString({ + ...this._def, + checks: [...this._def.checks, { kind: "toUpperCase" }] + }); + } + get isDatetime() { + return !!this._def.checks.find((ch) => ch.kind === "datetime"); + } + get isDate() { + return !!this._def.checks.find((ch) => ch.kind === "date"); + } + get isTime() { + return !!this._def.checks.find((ch) => ch.kind === "time"); + } + get isDuration() { + return !!this._def.checks.find((ch) => ch.kind === "duration"); + } + get isEmail() { + return !!this._def.checks.find((ch) => ch.kind === "email"); + } + get isURL() { + return !!this._def.checks.find((ch) => ch.kind === "url"); + } + get isEmoji() { + return !!this._def.checks.find((ch) => ch.kind === "emoji"); + } + get isUUID() { + return !!this._def.checks.find((ch) => ch.kind === "uuid"); + } + get isNANOID() { + return !!this._def.checks.find((ch) => ch.kind === "nanoid"); + } + get isCUID() { + return !!this._def.checks.find((ch) => ch.kind === "cuid"); + } + get isCUID2() { + return !!this._def.checks.find((ch) => ch.kind === "cuid2"); + } + get isULID() { + return !!this._def.checks.find((ch) => ch.kind === "ulid"); + } + get isIP() { + return !!this._def.checks.find((ch) => ch.kind === "ip"); + } + get isCIDR() { + return !!this._def.checks.find((ch) => ch.kind === "cidr"); + } + get isBase64() { + return !!this._def.checks.find((ch) => ch.kind === "base64"); + } + get isBase64url() { + return !!this._def.checks.find((ch) => ch.kind === "base64url"); + } + get minLength() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxLength() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +}; +ZodString2.create = (params) => { + var _a; + return new ZodString2({ + checks: [], + typeName: ZodFirstPartyTypeKind2.ZodString, + coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false, + ...processCreateParams2(params) + }); +}; +function floatSafeRemainder2(val, step) { + const valDecCount = (val.toString().split(".")[1] || "").length; + const stepDecCount = (step.toString().split(".")[1] || "").length; + const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount; + const valInt = parseInt(val.toFixed(decCount).replace(".", "")); + const stepInt = parseInt(step.toFixed(decCount).replace(".", "")); + return valInt % stepInt / Math.pow(10, decCount); +} +var ZodNumber2 = class _ZodNumber extends ZodType2 { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + this.step = this.multipleOf; + } + _parse(input) { + if (this._def.coerce) { + input.data = Number(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.number) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext2(ctx2, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.number, + received: ctx2.parsedType + }); + return INVALID2; + } + let ctx = void 0; + const status = new ParseStatus2(); + for (const check of this._def.checks) { + if (check.kind === "int") { + if (!util2.isInteger(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: "integer", + received: "float", + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: check.value, + type: "number", + inclusive: check.inclusive, + exact: false, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (floatSafeRemainder2(input.data, check.value) !== 0) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "finite") { + if (!Number.isFinite(input.data)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.not_finite, + message: check.message + }); + status.dirty(); + } + } else { + util2.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil2.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil2.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil2.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil2.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodNumber({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil2.toString(message) + } + ] + }); + } + _addCheck(check) { + return new _ZodNumber({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + int(message) { + return this._addCheck({ + kind: "int", + message: errorUtil2.toString(message) + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: false, + message: errorUtil2.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: false, + message: errorUtil2.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: 0, + inclusive: true, + message: errorUtil2.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: 0, + inclusive: true, + message: errorUtil2.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil2.toString(message) + }); + } + finite(message) { + return this._addCheck({ + kind: "finite", + message: errorUtil2.toString(message) + }); + } + safe(message) { + return this._addCheck({ + kind: "min", + inclusive: true, + value: Number.MIN_SAFE_INTEGER, + message: errorUtil2.toString(message) + })._addCheck({ + kind: "max", + inclusive: true, + value: Number.MAX_SAFE_INTEGER, + message: errorUtil2.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } + get isInt() { + return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util2.isInteger(ch.value)); + } + get isFinite() { + let max = null, min = null; + for (const ch of this._def.checks) { + if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") { + return true; + } else if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } else if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return Number.isFinite(min) && Number.isFinite(max); + } +}; +ZodNumber2.create = (params) => { + return new ZodNumber2({ + checks: [], + typeName: ZodFirstPartyTypeKind2.ZodNumber, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams2(params) + }); +}; +var ZodBigInt2 = class _ZodBigInt extends ZodType2 { + constructor() { + super(...arguments); + this.min = this.gte; + this.max = this.lte; + } + _parse(input) { + if (this._def.coerce) { + try { + input.data = BigInt(input.data); + } catch (_a) { + return this._getInvalidInput(input); + } + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.bigint) { + return this._getInvalidInput(input); + } + let ctx = void 0; + const status = new ParseStatus2(); + for (const check of this._def.checks) { + if (check.kind === "min") { + const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value; + if (tooSmall) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + type: "bigint", + minimum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "max") { + const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value; + if (tooBig) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + type: "bigint", + maximum: check.value, + inclusive: check.inclusive, + message: check.message + }); + status.dirty(); + } + } else if (check.kind === "multipleOf") { + if (input.data % check.value !== BigInt(0)) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.not_multiple_of, + multipleOf: check.value, + message: check.message + }); + status.dirty(); + } + } else { + util2.assertNever(check); + } + } + return { status: status.value, value: input.data }; + } + _getInvalidInput(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.bigint, + received: ctx.parsedType + }); + return INVALID2; + } + gte(value, message) { + return this.setLimit("min", value, true, errorUtil2.toString(message)); + } + gt(value, message) { + return this.setLimit("min", value, false, errorUtil2.toString(message)); + } + lte(value, message) { + return this.setLimit("max", value, true, errorUtil2.toString(message)); + } + lt(value, message) { + return this.setLimit("max", value, false, errorUtil2.toString(message)); + } + setLimit(kind, value, inclusive, message) { + return new _ZodBigInt({ + ...this._def, + checks: [ + ...this._def.checks, + { + kind, + value, + inclusive, + message: errorUtil2.toString(message) + } + ] + }); + } + _addCheck(check) { + return new _ZodBigInt({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + positive(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: false, + message: errorUtil2.toString(message) + }); + } + negative(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: false, + message: errorUtil2.toString(message) + }); + } + nonpositive(message) { + return this._addCheck({ + kind: "max", + value: BigInt(0), + inclusive: true, + message: errorUtil2.toString(message) + }); + } + nonnegative(message) { + return this._addCheck({ + kind: "min", + value: BigInt(0), + inclusive: true, + message: errorUtil2.toString(message) + }); + } + multipleOf(value, message) { + return this._addCheck({ + kind: "multipleOf", + value, + message: errorUtil2.toString(message) + }); + } + get minValue() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min; + } + get maxValue() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max; + } +}; +ZodBigInt2.create = (params) => { + var _a; + return new ZodBigInt2({ + checks: [], + typeName: ZodFirstPartyTypeKind2.ZodBigInt, + coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false, + ...processCreateParams2(params) + }); +}; +var ZodBoolean2 = class extends ZodType2 { + _parse(input) { + if (this._def.coerce) { + input.data = Boolean(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.boolean) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.boolean, + received: ctx.parsedType + }); + return INVALID2; + } + return OK2(input.data); + } +}; +ZodBoolean2.create = (params) => { + return new ZodBoolean2({ + typeName: ZodFirstPartyTypeKind2.ZodBoolean, + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + ...processCreateParams2(params) + }); +}; +var ZodDate2 = class _ZodDate extends ZodType2 { + _parse(input) { + if (this._def.coerce) { + input.data = new Date(input.data); + } + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.date) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext2(ctx2, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.date, + received: ctx2.parsedType + }); + return INVALID2; + } + if (isNaN(input.data.getTime())) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext2(ctx2, { + code: ZodIssueCode2.invalid_date + }); + return INVALID2; + } + const status = new ParseStatus2(); + let ctx = void 0; + for (const check of this._def.checks) { + if (check.kind === "min") { + if (input.data.getTime() < check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + message: check.message, + inclusive: true, + exact: false, + minimum: check.value, + type: "date" + }); + status.dirty(); + } + } else if (check.kind === "max") { + if (input.data.getTime() > check.value) { + ctx = this._getOrReturnCtx(input, ctx); + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + message: check.message, + inclusive: true, + exact: false, + maximum: check.value, + type: "date" + }); + status.dirty(); + } + } else { + util2.assertNever(check); + } + } + return { + status: status.value, + value: new Date(input.data.getTime()) + }; + } + _addCheck(check) { + return new _ZodDate({ + ...this._def, + checks: [...this._def.checks, check] + }); + } + min(minDate, message) { + return this._addCheck({ + kind: "min", + value: minDate.getTime(), + message: errorUtil2.toString(message) + }); + } + max(maxDate, message) { + return this._addCheck({ + kind: "max", + value: maxDate.getTime(), + message: errorUtil2.toString(message) + }); + } + get minDate() { + let min = null; + for (const ch of this._def.checks) { + if (ch.kind === "min") { + if (min === null || ch.value > min) + min = ch.value; + } + } + return min != null ? new Date(min) : null; + } + get maxDate() { + let max = null; + for (const ch of this._def.checks) { + if (ch.kind === "max") { + if (max === null || ch.value < max) + max = ch.value; + } + } + return max != null ? new Date(max) : null; + } +}; +ZodDate2.create = (params) => { + return new ZodDate2({ + checks: [], + coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false, + typeName: ZodFirstPartyTypeKind2.ZodDate, + ...processCreateParams2(params) + }); +}; +var ZodSymbol2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.symbol) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.symbol, + received: ctx.parsedType + }); + return INVALID2; + } + return OK2(input.data); + } +}; +ZodSymbol2.create = (params) => { + return new ZodSymbol2({ + typeName: ZodFirstPartyTypeKind2.ZodSymbol, + ...processCreateParams2(params) + }); +}; +var ZodUndefined2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.undefined, + received: ctx.parsedType + }); + return INVALID2; + } + return OK2(input.data); + } +}; +ZodUndefined2.create = (params) => { + return new ZodUndefined2({ + typeName: ZodFirstPartyTypeKind2.ZodUndefined, + ...processCreateParams2(params) + }); +}; +var ZodNull2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.null) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.null, + received: ctx.parsedType + }); + return INVALID2; + } + return OK2(input.data); + } +}; +ZodNull2.create = (params) => { + return new ZodNull2({ + typeName: ZodFirstPartyTypeKind2.ZodNull, + ...processCreateParams2(params) + }); +}; +var ZodAny2 = class extends ZodType2 { + constructor() { + super(...arguments); + this._any = true; + } + _parse(input) { + return OK2(input.data); + } +}; +ZodAny2.create = (params) => { + return new ZodAny2({ + typeName: ZodFirstPartyTypeKind2.ZodAny, + ...processCreateParams2(params) + }); +}; +var ZodUnknown2 = class extends ZodType2 { + constructor() { + super(...arguments); + this._unknown = true; + } + _parse(input) { + return OK2(input.data); + } +}; +ZodUnknown2.create = (params) => { + return new ZodUnknown2({ + typeName: ZodFirstPartyTypeKind2.ZodUnknown, + ...processCreateParams2(params) + }); +}; +var ZodNever2 = class extends ZodType2 { + _parse(input) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.never, + received: ctx.parsedType + }); + return INVALID2; + } +}; +ZodNever2.create = (params) => { + return new ZodNever2({ + typeName: ZodFirstPartyTypeKind2.ZodNever, + ...processCreateParams2(params) + }); +}; +var ZodVoid2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.undefined) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.void, + received: ctx.parsedType + }); + return INVALID2; + } + return OK2(input.data); + } +}; +ZodVoid2.create = (params) => { + return new ZodVoid2({ + typeName: ZodFirstPartyTypeKind2.ZodVoid, + ...processCreateParams2(params) + }); +}; +var ZodArray2 = class _ZodArray extends ZodType2 { + _parse(input) { + const { ctx, status } = this._processInputParams(input); + const def = this._def; + if (ctx.parsedType !== ZodParsedType2.array) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.array, + received: ctx.parsedType + }); + return INVALID2; + } + if (def.exactLength !== null) { + const tooBig = ctx.data.length > def.exactLength.value; + const tooSmall = ctx.data.length < def.exactLength.value; + if (tooBig || tooSmall) { + addIssueToContext2(ctx, { + code: tooBig ? ZodIssueCode2.too_big : ZodIssueCode2.too_small, + minimum: tooSmall ? def.exactLength.value : void 0, + maximum: tooBig ? def.exactLength.value : void 0, + type: "array", + inclusive: true, + exact: true, + message: def.exactLength.message + }); + status.dirty(); + } + } + if (def.minLength !== null) { + if (ctx.data.length < def.minLength.value) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: def.minLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.minLength.message + }); + status.dirty(); + } + } + if (def.maxLength !== null) { + if (ctx.data.length > def.maxLength.value) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: def.maxLength.value, + type: "array", + inclusive: true, + exact: false, + message: def.maxLength.message + }); + status.dirty(); + } + } + if (ctx.common.async) { + return Promise.all([...ctx.data].map((item, i) => { + return def.type._parseAsync(new ParseInputLazyPath2(ctx, item, ctx.path, i)); + })).then((result2) => { + return ParseStatus2.mergeArray(status, result2); + }); + } + const result = [...ctx.data].map((item, i) => { + return def.type._parseSync(new ParseInputLazyPath2(ctx, item, ctx.path, i)); + }); + return ParseStatus2.mergeArray(status, result); + } + get element() { + return this._def.type; + } + min(minLength, message) { + return new _ZodArray({ + ...this._def, + minLength: { value: minLength, message: errorUtil2.toString(message) } + }); + } + max(maxLength, message) { + return new _ZodArray({ + ...this._def, + maxLength: { value: maxLength, message: errorUtil2.toString(message) } + }); + } + length(len, message) { + return new _ZodArray({ + ...this._def, + exactLength: { value: len, message: errorUtil2.toString(message) } + }); + } + nonempty(message) { + return this.min(1, message); + } +}; +ZodArray2.create = (schema, params) => { + return new ZodArray2({ + type: schema, + minLength: null, + maxLength: null, + exactLength: null, + typeName: ZodFirstPartyTypeKind2.ZodArray, + ...processCreateParams2(params) + }); +}; +function deepPartialify2(schema) { + if (schema instanceof ZodObject2) { + const newShape = {}; + for (const key in schema.shape) { + const fieldSchema = schema.shape[key]; + newShape[key] = ZodOptional2.create(deepPartialify2(fieldSchema)); + } + return new ZodObject2({ + ...schema._def, + shape: () => newShape + }); + } else if (schema instanceof ZodArray2) { + return new ZodArray2({ + ...schema._def, + type: deepPartialify2(schema.element) + }); + } else if (schema instanceof ZodOptional2) { + return ZodOptional2.create(deepPartialify2(schema.unwrap())); + } else if (schema instanceof ZodNullable2) { + return ZodNullable2.create(deepPartialify2(schema.unwrap())); + } else if (schema instanceof ZodTuple2) { + return ZodTuple2.create(schema.items.map((item) => deepPartialify2(item))); + } else { + return schema; + } +} +var ZodObject2 = class _ZodObject extends ZodType2 { + constructor() { + super(...arguments); + this._cached = null; + this.nonstrict = this.passthrough; + this.augment = this.extend; + } + _getCached() { + if (this._cached !== null) + return this._cached; + const shape = this._def.shape(); + const keys = util2.objectKeys(shape); + return this._cached = { shape, keys }; + } + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.object) { + const ctx2 = this._getOrReturnCtx(input); + addIssueToContext2(ctx2, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.object, + received: ctx2.parsedType + }); + return INVALID2; + } + const { status, ctx } = this._processInputParams(input); + const { shape, keys: shapeKeys } = this._getCached(); + const extraKeys = []; + if (!(this._def.catchall instanceof ZodNever2 && this._def.unknownKeys === "strip")) { + for (const key in ctx.data) { + if (!shapeKeys.includes(key)) { + extraKeys.push(key); + } + } + } + const pairs = []; + for (const key of shapeKeys) { + const keyValidator = shape[key]; + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: keyValidator._parse(new ParseInputLazyPath2(ctx, value, ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (this._def.catchall instanceof ZodNever2) { + const unknownKeys = this._def.unknownKeys; + if (unknownKeys === "passthrough") { + for (const key of extraKeys) { + pairs.push({ + key: { status: "valid", value: key }, + value: { status: "valid", value: ctx.data[key] } + }); + } + } else if (unknownKeys === "strict") { + if (extraKeys.length > 0) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.unrecognized_keys, + keys: extraKeys + }); + status.dirty(); + } + } else if (unknownKeys === "strip") ; + else { + throw new Error(`Internal ZodObject error: invalid unknownKeys value.`); + } + } else { + const catchall = this._def.catchall; + for (const key of extraKeys) { + const value = ctx.data[key]; + pairs.push({ + key: { status: "valid", value: key }, + value: catchall._parse( + new ParseInputLazyPath2(ctx, value, ctx.path, key) + //, ctx.child(key), value, getParsedType(value) + ), + alwaysSet: key in ctx.data + }); + } + } + if (ctx.common.async) { + return Promise.resolve().then(async () => { + const syncPairs = []; + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + syncPairs.push({ + key, + value, + alwaysSet: pair.alwaysSet + }); + } + return syncPairs; + }).then((syncPairs) => { + return ParseStatus2.mergeObjectSync(status, syncPairs); + }); + } else { + return ParseStatus2.mergeObjectSync(status, pairs); + } + } + get shape() { + return this._def.shape(); + } + strict(message) { + errorUtil2.errToObj; + return new _ZodObject({ + ...this._def, + unknownKeys: "strict", + ...message !== void 0 ? { + errorMap: (issue, ctx) => { + var _a, _b, _c, _d; + const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError; + if (issue.code === "unrecognized_keys") + return { + message: (_d = errorUtil2.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError + }; + return { + message: defaultError + }; + } + } : {} + }); + } + strip() { + return new _ZodObject({ + ...this._def, + unknownKeys: "strip" + }); + } + passthrough() { + return new _ZodObject({ + ...this._def, + unknownKeys: "passthrough" + }); + } + // const AugmentFactory = + // (def: Def) => + // ( + // augmentation: Augmentation + // ): ZodObject< + // extendShape, Augmentation>, + // Def["unknownKeys"], + // Def["catchall"] + // > => { + // return new ZodObject({ + // ...def, + // shape: () => ({ + // ...def.shape(), + // ...augmentation, + // }), + // }) as any; + // }; + extend(augmentation) { + return new _ZodObject({ + ...this._def, + shape: () => ({ + ...this._def.shape(), + ...augmentation + }) + }); + } + /** + * Prior to zod@1.0.12 there was a bug in the + * inferred type of merged objects. Please + * upgrade if you are experiencing issues. + */ + merge(merging) { + const merged = new _ZodObject({ + unknownKeys: merging._def.unknownKeys, + catchall: merging._def.catchall, + shape: () => ({ + ...this._def.shape(), + ...merging._def.shape() + }), + typeName: ZodFirstPartyTypeKind2.ZodObject + }); + return merged; + } + // merge< + // Incoming extends AnyZodObject, + // Augmentation extends Incoming["shape"], + // NewOutput extends { + // [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation + // ? Augmentation[k]["_output"] + // : k extends keyof Output + // ? Output[k] + // : never; + // }, + // NewInput extends { + // [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation + // ? Augmentation[k]["_input"] + // : k extends keyof Input + // ? Input[k] + // : never; + // } + // >( + // merging: Incoming + // ): ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"], + // NewOutput, + // NewInput + // > { + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + setKey(key, schema) { + return this.augment({ [key]: schema }); + } + // merge( + // merging: Incoming + // ): //ZodObject = (merging) => { + // ZodObject< + // extendShape>, + // Incoming["_def"]["unknownKeys"], + // Incoming["_def"]["catchall"] + // > { + // // const mergedShape = objectUtil.mergeShapes( + // // this._def.shape(), + // // merging._def.shape() + // // ); + // const merged: any = new ZodObject({ + // unknownKeys: merging._def.unknownKeys, + // catchall: merging._def.catchall, + // shape: () => + // objectUtil.mergeShapes(this._def.shape(), merging._def.shape()), + // typeName: ZodFirstPartyTypeKind.ZodObject, + // }) as any; + // return merged; + // } + catchall(index) { + return new _ZodObject({ + ...this._def, + catchall: index + }); + } + pick(mask) { + const shape = {}; + util2.objectKeys(mask).forEach((key) => { + if (mask[key] && this.shape[key]) { + shape[key] = this.shape[key]; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + omit(mask) { + const shape = {}; + util2.objectKeys(this.shape).forEach((key) => { + if (!mask[key]) { + shape[key] = this.shape[key]; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => shape + }); + } + /** + * @deprecated + */ + deepPartial() { + return deepPartialify2(this); + } + partial(mask) { + const newShape = {}; + util2.objectKeys(this.shape).forEach((key) => { + const fieldSchema = this.shape[key]; + if (mask && !mask[key]) { + newShape[key] = fieldSchema; + } else { + newShape[key] = fieldSchema.optional(); + } + }); + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); + } + required(mask) { + const newShape = {}; + util2.objectKeys(this.shape).forEach((key) => { + if (mask && !mask[key]) { + newShape[key] = this.shape[key]; + } else { + const fieldSchema = this.shape[key]; + let newField = fieldSchema; + while (newField instanceof ZodOptional2) { + newField = newField._def.innerType; + } + newShape[key] = newField; + } + }); + return new _ZodObject({ + ...this._def, + shape: () => newShape + }); + } + keyof() { + return createZodEnum2(util2.objectKeys(this.shape)); + } +}; +ZodObject2.create = (shape, params) => { + return new ZodObject2({ + shape: () => shape, + unknownKeys: "strip", + catchall: ZodNever2.create(), + typeName: ZodFirstPartyTypeKind2.ZodObject, + ...processCreateParams2(params) + }); +}; +ZodObject2.strictCreate = (shape, params) => { + return new ZodObject2({ + shape: () => shape, + unknownKeys: "strict", + catchall: ZodNever2.create(), + typeName: ZodFirstPartyTypeKind2.ZodObject, + ...processCreateParams2(params) + }); +}; +ZodObject2.lazycreate = (shape, params) => { + return new ZodObject2({ + shape, + unknownKeys: "strip", + catchall: ZodNever2.create(), + typeName: ZodFirstPartyTypeKind2.ZodObject, + ...processCreateParams2(params) + }); +}; +var ZodUnion2 = class extends ZodType2 { + _parse(input) { + const { ctx } = this._processInputParams(input); + const options = this._def.options; + function handleResults(results) { + for (const result of results) { + if (result.result.status === "valid") { + return result.result; + } + } + for (const result of results) { + if (result.result.status === "dirty") { + ctx.common.issues.push(...result.ctx.common.issues); + return result.result; + } + } + const unionErrors = results.map((result) => new ZodError2(result.ctx.common.issues)); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_union, + unionErrors + }); + return INVALID2; + } + if (ctx.common.async) { + return Promise.all(options.map(async (option) => { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + return { + result: await option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }), + ctx: childCtx + }; + })).then(handleResults); + } else { + let dirty = void 0; + const issues = []; + for (const option of options) { + const childCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + }, + parent: null + }; + const result = option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: childCtx + }); + if (result.status === "valid") { + return result; + } else if (result.status === "dirty" && !dirty) { + dirty = { result, ctx: childCtx }; + } + if (childCtx.common.issues.length) { + issues.push(childCtx.common.issues); + } + } + if (dirty) { + ctx.common.issues.push(...dirty.ctx.common.issues); + return dirty.result; + } + const unionErrors = issues.map((issues2) => new ZodError2(issues2)); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_union, + unionErrors + }); + return INVALID2; + } + } + get options() { + return this._def.options; + } +}; +ZodUnion2.create = (types, params) => { + return new ZodUnion2({ + options: types, + typeName: ZodFirstPartyTypeKind2.ZodUnion, + ...processCreateParams2(params) + }); +}; +var getDiscriminator2 = (type) => { + if (type instanceof ZodLazy2) { + return getDiscriminator2(type.schema); + } else if (type instanceof ZodEffects2) { + return getDiscriminator2(type.innerType()); + } else if (type instanceof ZodLiteral2) { + return [type.value]; + } else if (type instanceof ZodEnum2) { + return type.options; + } else if (type instanceof ZodNativeEnum2) { + return util2.objectValues(type.enum); + } else if (type instanceof ZodDefault2) { + return getDiscriminator2(type._def.innerType); + } else if (type instanceof ZodUndefined2) { + return [void 0]; + } else if (type instanceof ZodNull2) { + return [null]; + } else if (type instanceof ZodOptional2) { + return [void 0, ...getDiscriminator2(type.unwrap())]; + } else if (type instanceof ZodNullable2) { + return [null, ...getDiscriminator2(type.unwrap())]; + } else if (type instanceof ZodBranded2) { + return getDiscriminator2(type.unwrap()); + } else if (type instanceof ZodReadonly2) { + return getDiscriminator2(type.unwrap()); + } else if (type instanceof ZodCatch2) { + return getDiscriminator2(type._def.innerType); + } else { + return []; + } +}; +var ZodDiscriminatedUnion2 = class _ZodDiscriminatedUnion extends ZodType2 { + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.object) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.object, + received: ctx.parsedType + }); + return INVALID2; + } + const discriminator = this.discriminator; + const discriminatorValue = ctx.data[discriminator]; + const option = this.optionsMap.get(discriminatorValue); + if (!option) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_union_discriminator, + options: Array.from(this.optionsMap.keys()), + path: [discriminator] + }); + return INVALID2; + } + if (ctx.common.async) { + return option._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } else { + return option._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + } + } + get discriminator() { + return this._def.discriminator; + } + get options() { + return this._def.options; + } + get optionsMap() { + return this._def.optionsMap; + } + /** + * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor. + * However, it only allows a union of objects, all of which need to share a discriminator property. This property must + * have a different value for each object in the union. + * @param discriminator the name of the discriminator property + * @param types an array of object schemas + * @param params + */ + static create(discriminator, options, params) { + const optionsMap = /* @__PURE__ */ new Map(); + for (const type of options) { + const discriminatorValues = getDiscriminator2(type.shape[discriminator]); + if (!discriminatorValues.length) { + throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`); + } + for (const value of discriminatorValues) { + if (optionsMap.has(value)) { + throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`); + } + optionsMap.set(value, type); + } + } + return new _ZodDiscriminatedUnion({ + typeName: ZodFirstPartyTypeKind2.ZodDiscriminatedUnion, + discriminator, + options, + optionsMap, + ...processCreateParams2(params) + }); + } +}; +function mergeValues2(a, b) { + const aType = getParsedType2(a); + const bType = getParsedType2(b); + if (a === b) { + return { valid: true, data: a }; + } else if (aType === ZodParsedType2.object && bType === ZodParsedType2.object) { + const bKeys = util2.objectKeys(b); + const sharedKeys = util2.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues2(a[key], b[key]); + if (!sharedValue.valid) { + return { valid: false }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } else if (aType === ZodParsedType2.array && bType === ZodParsedType2.array) { + if (a.length !== b.length) { + return { valid: false }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues2(itemA, itemB); + if (!sharedValue.valid) { + return { valid: false }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } else if (aType === ZodParsedType2.date && bType === ZodParsedType2.date && +a === +b) { + return { valid: true, data: a }; + } else { + return { valid: false }; + } +} +var ZodIntersection2 = class extends ZodType2 { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const handleParsed = (parsedLeft, parsedRight) => { + if (isAborted2(parsedLeft) || isAborted2(parsedRight)) { + return INVALID2; + } + const merged = mergeValues2(parsedLeft.value, parsedRight.value); + if (!merged.valid) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_intersection_types + }); + return INVALID2; + } + if (isDirty2(parsedLeft) || isDirty2(parsedRight)) { + status.dirty(); + } + return { status: status.value, value: merged.data }; + }; + if (ctx.common.async) { + return Promise.all([ + this._def.left._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), + this._def.right._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }) + ]).then(([left, right]) => handleParsed(left, right)); + } else { + return handleParsed(this._def.left._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }), this._def.right._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + })); + } + } +}; +ZodIntersection2.create = (left, right, params) => { + return new ZodIntersection2({ + left, + right, + typeName: ZodFirstPartyTypeKind2.ZodIntersection, + ...processCreateParams2(params) + }); +}; +var ZodTuple2 = class _ZodTuple extends ZodType2 { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.array) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.array, + received: ctx.parsedType + }); + return INVALID2; + } + if (ctx.data.length < this._def.items.length) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + return INVALID2; + } + const rest = this._def.rest; + if (!rest && ctx.data.length > this._def.items.length) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: this._def.items.length, + inclusive: true, + exact: false, + type: "array" + }); + status.dirty(); + } + const items = [...ctx.data].map((item, itemIndex) => { + const schema = this._def.items[itemIndex] || this._def.rest; + if (!schema) + return null; + return schema._parse(new ParseInputLazyPath2(ctx, item, ctx.path, itemIndex)); + }).filter((x) => !!x); + if (ctx.common.async) { + return Promise.all(items).then((results) => { + return ParseStatus2.mergeArray(status, results); + }); + } else { + return ParseStatus2.mergeArray(status, items); + } + } + get items() { + return this._def.items; + } + rest(rest) { + return new _ZodTuple({ + ...this._def, + rest + }); + } +}; +ZodTuple2.create = (schemas, params) => { + if (!Array.isArray(schemas)) { + throw new Error("You must pass an array of schemas to z.tuple([ ... ])"); + } + return new ZodTuple2({ + items: schemas, + typeName: ZodFirstPartyTypeKind2.ZodTuple, + rest: null, + ...processCreateParams2(params) + }); +}; +var ZodRecord2 = class _ZodRecord extends ZodType2 { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.object) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.object, + received: ctx.parsedType + }); + return INVALID2; + } + const pairs = []; + const keyType = this._def.keyType; + const valueType = this._def.valueType; + for (const key in ctx.data) { + pairs.push({ + key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, key)), + value: valueType._parse(new ParseInputLazyPath2(ctx, ctx.data[key], ctx.path, key)), + alwaysSet: key in ctx.data + }); + } + if (ctx.common.async) { + return ParseStatus2.mergeObjectAsync(status, pairs); + } else { + return ParseStatus2.mergeObjectSync(status, pairs); + } + } + get element() { + return this._def.valueType; + } + static create(first, second, third) { + if (second instanceof ZodType2) { + return new _ZodRecord({ + keyType: first, + valueType: second, + typeName: ZodFirstPartyTypeKind2.ZodRecord, + ...processCreateParams2(third) + }); + } + return new _ZodRecord({ + keyType: ZodString2.create(), + valueType: first, + typeName: ZodFirstPartyTypeKind2.ZodRecord, + ...processCreateParams2(second) + }); + } +}; +var ZodMap2 = class extends ZodType2 { + get keySchema() { + return this._def.keyType; + } + get valueSchema() { + return this._def.valueType; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.map) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.map, + received: ctx.parsedType + }); + return INVALID2; + } + const keyType = this._def.keyType; + const valueType = this._def.valueType; + const pairs = [...ctx.data.entries()].map(([key, value], index) => { + return { + key: keyType._parse(new ParseInputLazyPath2(ctx, key, ctx.path, [index, "key"])), + value: valueType._parse(new ParseInputLazyPath2(ctx, value, ctx.path, [index, "value"])) + }; + }); + if (ctx.common.async) { + const finalMap = /* @__PURE__ */ new Map(); + return Promise.resolve().then(async () => { + for (const pair of pairs) { + const key = await pair.key; + const value = await pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID2; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + }); + } else { + const finalMap = /* @__PURE__ */ new Map(); + for (const pair of pairs) { + const key = pair.key; + const value = pair.value; + if (key.status === "aborted" || value.status === "aborted") { + return INVALID2; + } + if (key.status === "dirty" || value.status === "dirty") { + status.dirty(); + } + finalMap.set(key.value, value.value); + } + return { status: status.value, value: finalMap }; + } + } +}; +ZodMap2.create = (keyType, valueType, params) => { + return new ZodMap2({ + valueType, + keyType, + typeName: ZodFirstPartyTypeKind2.ZodMap, + ...processCreateParams2(params) + }); +}; +var ZodSet2 = class _ZodSet extends ZodType2 { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.set) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.set, + received: ctx.parsedType + }); + return INVALID2; + } + const def = this._def; + if (def.minSize !== null) { + if (ctx.data.size < def.minSize.value) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_small, + minimum: def.minSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.minSize.message + }); + status.dirty(); + } + } + if (def.maxSize !== null) { + if (ctx.data.size > def.maxSize.value) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.too_big, + maximum: def.maxSize.value, + type: "set", + inclusive: true, + exact: false, + message: def.maxSize.message + }); + status.dirty(); + } + } + const valueType = this._def.valueType; + function finalizeSet(elements2) { + const parsedSet = /* @__PURE__ */ new Set(); + for (const element of elements2) { + if (element.status === "aborted") + return INVALID2; + if (element.status === "dirty") + status.dirty(); + parsedSet.add(element.value); + } + return { status: status.value, value: parsedSet }; + } + const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath2(ctx, item, ctx.path, i))); + if (ctx.common.async) { + return Promise.all(elements).then((elements2) => finalizeSet(elements2)); + } else { + return finalizeSet(elements); + } + } + min(minSize, message) { + return new _ZodSet({ + ...this._def, + minSize: { value: minSize, message: errorUtil2.toString(message) } + }); + } + max(maxSize, message) { + return new _ZodSet({ + ...this._def, + maxSize: { value: maxSize, message: errorUtil2.toString(message) } + }); + } + size(size, message) { + return this.min(size, message).max(size, message); + } + nonempty(message) { + return this.min(1, message); + } +}; +ZodSet2.create = (valueType, params) => { + return new ZodSet2({ + valueType, + minSize: null, + maxSize: null, + typeName: ZodFirstPartyTypeKind2.ZodSet, + ...processCreateParams2(params) + }); +}; +var ZodFunction2 = class _ZodFunction extends ZodType2 { + constructor() { + super(...arguments); + this.validate = this.implement; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.function) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.function, + received: ctx.parsedType + }); + return INVALID2; + } + function makeArgsIssue(args, error) { + return makeIssue2({ + data: args, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap2(), + errorMap2 + ].filter((x) => !!x), + issueData: { + code: ZodIssueCode2.invalid_arguments, + argumentsError: error + } + }); + } + function makeReturnsIssue(returns, error) { + return makeIssue2({ + data: returns, + path: ctx.path, + errorMaps: [ + ctx.common.contextualErrorMap, + ctx.schemaErrorMap, + getErrorMap2(), + errorMap2 + ].filter((x) => !!x), + issueData: { + code: ZodIssueCode2.invalid_return_type, + returnTypeError: error + } + }); + } + const params = { errorMap: ctx.common.contextualErrorMap }; + const fn = ctx.data; + if (this._def.returns instanceof ZodPromise2) { + const me = this; + return OK2(async function(...args) { + const error = new ZodError2([]); + const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => { + error.addIssue(makeArgsIssue(args, e)); + throw error; + }); + const result = await Reflect.apply(fn, this, parsedArgs); + const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => { + error.addIssue(makeReturnsIssue(result, e)); + throw error; + }); + return parsedReturns; + }); + } else { + const me = this; + return OK2(function(...args) { + const parsedArgs = me._def.args.safeParse(args, params); + if (!parsedArgs.success) { + throw new ZodError2([makeArgsIssue(args, parsedArgs.error)]); + } + const result = Reflect.apply(fn, this, parsedArgs.data); + const parsedReturns = me._def.returns.safeParse(result, params); + if (!parsedReturns.success) { + throw new ZodError2([makeReturnsIssue(result, parsedReturns.error)]); + } + return parsedReturns.data; + }); + } + } + parameters() { + return this._def.args; + } + returnType() { + return this._def.returns; + } + args(...items) { + return new _ZodFunction({ + ...this._def, + args: ZodTuple2.create(items).rest(ZodUnknown2.create()) + }); + } + returns(returnType) { + return new _ZodFunction({ + ...this._def, + returns: returnType + }); + } + implement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + strictImplement(func) { + const validatedFunc = this.parse(func); + return validatedFunc; + } + static create(args, returns, params) { + return new _ZodFunction({ + args: args ? args : ZodTuple2.create([]).rest(ZodUnknown2.create()), + returns: returns || ZodUnknown2.create(), + typeName: ZodFirstPartyTypeKind2.ZodFunction, + ...processCreateParams2(params) + }); + } +}; +var ZodLazy2 = class extends ZodType2 { + get schema() { + return this._def.getter(); + } + _parse(input) { + const { ctx } = this._processInputParams(input); + const lazySchema = this._def.getter(); + return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx }); + } +}; +ZodLazy2.create = (getter, params) => { + return new ZodLazy2({ + getter, + typeName: ZodFirstPartyTypeKind2.ZodLazy, + ...processCreateParams2(params) + }); +}; +var ZodLiteral2 = class extends ZodType2 { + _parse(input) { + if (input.data !== this._def.value) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + received: ctx.data, + code: ZodIssueCode2.invalid_literal, + expected: this._def.value + }); + return INVALID2; + } + return { status: "valid", value: input.data }; + } + get value() { + return this._def.value; + } +}; +ZodLiteral2.create = (value, params) => { + return new ZodLiteral2({ + value, + typeName: ZodFirstPartyTypeKind2.ZodLiteral, + ...processCreateParams2(params) + }); +}; +function createZodEnum2(values, params) { + return new ZodEnum2({ + values, + typeName: ZodFirstPartyTypeKind2.ZodEnum, + ...processCreateParams2(params) + }); +} +var ZodEnum2 = class _ZodEnum extends ZodType2 { + constructor() { + super(...arguments); + _ZodEnum_cache.set(this, void 0); + } + _parse(input) { + if (typeof input.data !== "string") { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext2(ctx, { + expected: util2.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode2.invalid_type + }); + return INVALID2; + } + if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) { + __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f"); + } + if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) { + const ctx = this._getOrReturnCtx(input); + const expectedValues = this._def.values; + addIssueToContext2(ctx, { + received: ctx.data, + code: ZodIssueCode2.invalid_enum_value, + options: expectedValues + }); + return INVALID2; + } + return OK2(input.data); + } + get options() { + return this._def.values; + } + get enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Values() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + get Enum() { + const enumValues = {}; + for (const val of this._def.values) { + enumValues[val] = val; + } + return enumValues; + } + extract(values, newDef = this._def) { + return _ZodEnum.create(values, { + ...this._def, + ...newDef + }); + } + exclude(values, newDef = this._def) { + return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), { + ...this._def, + ...newDef + }); + } +}; +_ZodEnum_cache = /* @__PURE__ */ new WeakMap(); +ZodEnum2.create = createZodEnum2; +var ZodNativeEnum2 = class extends ZodType2 { + constructor() { + super(...arguments); + _ZodNativeEnum_cache.set(this, void 0); + } + _parse(input) { + const nativeEnumValues = util2.getValidEnumValues(this._def.values); + const ctx = this._getOrReturnCtx(input); + if (ctx.parsedType !== ZodParsedType2.string && ctx.parsedType !== ZodParsedType2.number) { + const expectedValues = util2.objectValues(nativeEnumValues); + addIssueToContext2(ctx, { + expected: util2.joinValues(expectedValues), + received: ctx.parsedType, + code: ZodIssueCode2.invalid_type + }); + return INVALID2; + } + if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) { + __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util2.getValidEnumValues(this._def.values)), "f"); + } + if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) { + const expectedValues = util2.objectValues(nativeEnumValues); + addIssueToContext2(ctx, { + received: ctx.data, + code: ZodIssueCode2.invalid_enum_value, + options: expectedValues + }); + return INVALID2; + } + return OK2(input.data); + } + get enum() { + return this._def.values; + } +}; +_ZodNativeEnum_cache = /* @__PURE__ */ new WeakMap(); +ZodNativeEnum2.create = (values, params) => { + return new ZodNativeEnum2({ + values, + typeName: ZodFirstPartyTypeKind2.ZodNativeEnum, + ...processCreateParams2(params) + }); +}; +var ZodPromise2 = class extends ZodType2 { + unwrap() { + return this._def.type; + } + _parse(input) { + const { ctx } = this._processInputParams(input); + if (ctx.parsedType !== ZodParsedType2.promise && ctx.common.async === false) { + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.promise, + received: ctx.parsedType + }); + return INVALID2; + } + const promisified = ctx.parsedType === ZodParsedType2.promise ? ctx.data : Promise.resolve(ctx.data); + return OK2(promisified.then((data) => { + return this._def.type.parseAsync(data, { + path: ctx.path, + errorMap: ctx.common.contextualErrorMap + }); + })); + } +}; +ZodPromise2.create = (schema, params) => { + return new ZodPromise2({ + type: schema, + typeName: ZodFirstPartyTypeKind2.ZodPromise, + ...processCreateParams2(params) + }); +}; +var ZodEffects2 = class extends ZodType2 { + innerType() { + return this._def.schema; + } + sourceType() { + return this._def.schema._def.typeName === ZodFirstPartyTypeKind2.ZodEffects ? this._def.schema.sourceType() : this._def.schema; + } + _parse(input) { + const { status, ctx } = this._processInputParams(input); + const effect = this._def.effect || null; + const checkCtx = { + addIssue: (arg) => { + addIssueToContext2(ctx, arg); + if (arg.fatal) { + status.abort(); + } else { + status.dirty(); + } + }, + get path() { + return ctx.path; + } + }; + checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx); + if (effect.type === "preprocess") { + const processed = effect.transform(ctx.data, checkCtx); + if (ctx.common.async) { + return Promise.resolve(processed).then(async (processed2) => { + if (status.value === "aborted") + return INVALID2; + const result = await this._def.schema._parseAsync({ + data: processed2, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID2; + if (result.status === "dirty") + return DIRTY2(result.value); + if (status.value === "dirty") + return DIRTY2(result.value); + return result; + }); + } else { + if (status.value === "aborted") + return INVALID2; + const result = this._def.schema._parseSync({ + data: processed, + path: ctx.path, + parent: ctx + }); + if (result.status === "aborted") + return INVALID2; + if (result.status === "dirty") + return DIRTY2(result.value); + if (status.value === "dirty") + return DIRTY2(result.value); + return result; + } + } + if (effect.type === "refinement") { + const executeRefinement = (acc) => { + const result = effect.refinement(acc, checkCtx); + if (ctx.common.async) { + return Promise.resolve(result); + } + if (result instanceof Promise) { + throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead."); + } + return acc; + }; + if (ctx.common.async === false) { + const inner = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inner.status === "aborted") + return INVALID2; + if (inner.status === "dirty") + status.dirty(); + executeRefinement(inner.value); + return { status: status.value, value: inner.value }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => { + if (inner.status === "aborted") + return INVALID2; + if (inner.status === "dirty") + status.dirty(); + return executeRefinement(inner.value).then(() => { + return { status: status.value, value: inner.value }; + }); + }); + } + } + if (effect.type === "transform") { + if (ctx.common.async === false) { + const base = this._def.schema._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (!isValid2(base)) + return base; + const result = effect.transform(base.value, checkCtx); + if (result instanceof Promise) { + throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`); + } + return { status: status.value, value: result }; + } else { + return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => { + if (!isValid2(base)) + return base; + return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result })); + }); + } + } + util2.assertNever(effect); + } +}; +ZodEffects2.create = (schema, effect, params) => { + return new ZodEffects2({ + schema, + typeName: ZodFirstPartyTypeKind2.ZodEffects, + effect, + ...processCreateParams2(params) + }); +}; +ZodEffects2.createWithPreprocess = (preprocess, schema, params) => { + return new ZodEffects2({ + schema, + effect: { type: "preprocess", transform: preprocess }, + typeName: ZodFirstPartyTypeKind2.ZodEffects, + ...processCreateParams2(params) + }); +}; +var ZodOptional2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType2.undefined) { + return OK2(void 0); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +}; +ZodOptional2.create = (type, params) => { + return new ZodOptional2({ + innerType: type, + typeName: ZodFirstPartyTypeKind2.ZodOptional, + ...processCreateParams2(params) + }); +}; +var ZodNullable2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType === ZodParsedType2.null) { + return OK2(null); + } + return this._def.innerType._parse(input); + } + unwrap() { + return this._def.innerType; + } +}; +ZodNullable2.create = (type, params) => { + return new ZodNullable2({ + innerType: type, + typeName: ZodFirstPartyTypeKind2.ZodNullable, + ...processCreateParams2(params) + }); +}; +var ZodDefault2 = class extends ZodType2 { + _parse(input) { + const { ctx } = this._processInputParams(input); + let data = ctx.data; + if (ctx.parsedType === ZodParsedType2.undefined) { + data = this._def.defaultValue(); + } + return this._def.innerType._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + removeDefault() { + return this._def.innerType; + } +}; +ZodDefault2.create = (type, params) => { + return new ZodDefault2({ + innerType: type, + typeName: ZodFirstPartyTypeKind2.ZodDefault, + defaultValue: typeof params.default === "function" ? params.default : () => params.default, + ...processCreateParams2(params) + }); +}; +var ZodCatch2 = class extends ZodType2 { + _parse(input) { + const { ctx } = this._processInputParams(input); + const newCtx = { + ...ctx, + common: { + ...ctx.common, + issues: [] + } + }; + const result = this._def.innerType._parse({ + data: newCtx.data, + path: newCtx.path, + parent: { + ...newCtx + } + }); + if (isAsync2(result)) { + return result.then((result2) => { + return { + status: "valid", + value: result2.status === "valid" ? result2.value : this._def.catchValue({ + get error() { + return new ZodError2(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + }); + } else { + return { + status: "valid", + value: result.status === "valid" ? result.value : this._def.catchValue({ + get error() { + return new ZodError2(newCtx.common.issues); + }, + input: newCtx.data + }) + }; + } + } + removeCatch() { + return this._def.innerType; + } +}; +ZodCatch2.create = (type, params) => { + return new ZodCatch2({ + innerType: type, + typeName: ZodFirstPartyTypeKind2.ZodCatch, + catchValue: typeof params.catch === "function" ? params.catch : () => params.catch, + ...processCreateParams2(params) + }); +}; +var ZodNaN2 = class extends ZodType2 { + _parse(input) { + const parsedType = this._getType(input); + if (parsedType !== ZodParsedType2.nan) { + const ctx = this._getOrReturnCtx(input); + addIssueToContext2(ctx, { + code: ZodIssueCode2.invalid_type, + expected: ZodParsedType2.nan, + received: ctx.parsedType + }); + return INVALID2; + } + return { status: "valid", value: input.data }; + } +}; +ZodNaN2.create = (params) => { + return new ZodNaN2({ + typeName: ZodFirstPartyTypeKind2.ZodNaN, + ...processCreateParams2(params) + }); +}; +var BRAND2 = Symbol("zod_brand"); +var ZodBranded2 = class extends ZodType2 { + _parse(input) { + const { ctx } = this._processInputParams(input); + const data = ctx.data; + return this._def.type._parse({ + data, + path: ctx.path, + parent: ctx + }); + } + unwrap() { + return this._def.type; + } +}; +var ZodPipeline2 = class _ZodPipeline extends ZodType2 { + _parse(input) { + const { status, ctx } = this._processInputParams(input); + if (ctx.common.async) { + const handleAsync = async () => { + const inResult = await this._def.in._parseAsync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID2; + if (inResult.status === "dirty") { + status.dirty(); + return DIRTY2(inResult.value); + } else { + return this._def.out._parseAsync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + }; + return handleAsync(); + } else { + const inResult = this._def.in._parseSync({ + data: ctx.data, + path: ctx.path, + parent: ctx + }); + if (inResult.status === "aborted") + return INVALID2; + if (inResult.status === "dirty") { + status.dirty(); + return { + status: "dirty", + value: inResult.value + }; + } else { + return this._def.out._parseSync({ + data: inResult.value, + path: ctx.path, + parent: ctx + }); + } + } + } + static create(a, b) { + return new _ZodPipeline({ + in: a, + out: b, + typeName: ZodFirstPartyTypeKind2.ZodPipeline + }); + } +}; +var ZodReadonly2 = class extends ZodType2 { + _parse(input) { + const result = this._def.innerType._parse(input); + const freeze = (data) => { + if (isValid2(data)) { + data.value = Object.freeze(data.value); + } + return data; + }; + return isAsync2(result) ? result.then((data) => freeze(data)) : freeze(result); + } + unwrap() { + return this._def.innerType; + } +}; +ZodReadonly2.create = (type, params) => { + return new ZodReadonly2({ + innerType: type, + typeName: ZodFirstPartyTypeKind2.ZodReadonly, + ...processCreateParams2(params) + }); +}; +function cleanParams2(params, data) { + const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params; + const p2 = typeof p === "string" ? { message: p } : p; + return p2; +} +function custom2(check, _params = {}, fatal) { + if (check) + return ZodAny2.create().superRefine((data, ctx) => { + var _a, _b; + const r = check(data); + if (r instanceof Promise) { + return r.then((r2) => { + var _a2, _b2; + if (!r2) { + const params = cleanParams2(_params, data); + const _fatal = (_b2 = (_a2 = params.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b2 !== void 0 ? _b2 : true; + ctx.addIssue({ code: "custom", ...params, fatal: _fatal }); + } + }); + } + if (!r) { + const params = cleanParams2(_params, data); + const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true; + ctx.addIssue({ code: "custom", ...params, fatal: _fatal }); + } + return; + }); + return ZodAny2.create(); +} +var late2 = { + object: ZodObject2.lazycreate +}; +var ZodFirstPartyTypeKind2; +(function(ZodFirstPartyTypeKind22) { + ZodFirstPartyTypeKind22["ZodString"] = "ZodString"; + ZodFirstPartyTypeKind22["ZodNumber"] = "ZodNumber"; + ZodFirstPartyTypeKind22["ZodNaN"] = "ZodNaN"; + ZodFirstPartyTypeKind22["ZodBigInt"] = "ZodBigInt"; + ZodFirstPartyTypeKind22["ZodBoolean"] = "ZodBoolean"; + ZodFirstPartyTypeKind22["ZodDate"] = "ZodDate"; + ZodFirstPartyTypeKind22["ZodSymbol"] = "ZodSymbol"; + ZodFirstPartyTypeKind22["ZodUndefined"] = "ZodUndefined"; + ZodFirstPartyTypeKind22["ZodNull"] = "ZodNull"; + ZodFirstPartyTypeKind22["ZodAny"] = "ZodAny"; + ZodFirstPartyTypeKind22["ZodUnknown"] = "ZodUnknown"; + ZodFirstPartyTypeKind22["ZodNever"] = "ZodNever"; + ZodFirstPartyTypeKind22["ZodVoid"] = "ZodVoid"; + ZodFirstPartyTypeKind22["ZodArray"] = "ZodArray"; + ZodFirstPartyTypeKind22["ZodObject"] = "ZodObject"; + ZodFirstPartyTypeKind22["ZodUnion"] = "ZodUnion"; + ZodFirstPartyTypeKind22["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion"; + ZodFirstPartyTypeKind22["ZodIntersection"] = "ZodIntersection"; + ZodFirstPartyTypeKind22["ZodTuple"] = "ZodTuple"; + ZodFirstPartyTypeKind22["ZodRecord"] = "ZodRecord"; + ZodFirstPartyTypeKind22["ZodMap"] = "ZodMap"; + ZodFirstPartyTypeKind22["ZodSet"] = "ZodSet"; + ZodFirstPartyTypeKind22["ZodFunction"] = "ZodFunction"; + ZodFirstPartyTypeKind22["ZodLazy"] = "ZodLazy"; + ZodFirstPartyTypeKind22["ZodLiteral"] = "ZodLiteral"; + ZodFirstPartyTypeKind22["ZodEnum"] = "ZodEnum"; + ZodFirstPartyTypeKind22["ZodEffects"] = "ZodEffects"; + ZodFirstPartyTypeKind22["ZodNativeEnum"] = "ZodNativeEnum"; + ZodFirstPartyTypeKind22["ZodOptional"] = "ZodOptional"; + ZodFirstPartyTypeKind22["ZodNullable"] = "ZodNullable"; + ZodFirstPartyTypeKind22["ZodDefault"] = "ZodDefault"; + ZodFirstPartyTypeKind22["ZodCatch"] = "ZodCatch"; + ZodFirstPartyTypeKind22["ZodPromise"] = "ZodPromise"; + ZodFirstPartyTypeKind22["ZodBranded"] = "ZodBranded"; + ZodFirstPartyTypeKind22["ZodPipeline"] = "ZodPipeline"; + ZodFirstPartyTypeKind22["ZodReadonly"] = "ZodReadonly"; +})(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {})); +var instanceOfType2 = (cls, params = { + message: `Input not instance of ${cls.name}` +}) => custom2((data) => data instanceof cls, params); +var stringType2 = ZodString2.create; +var numberType2 = ZodNumber2.create; +var nanType2 = ZodNaN2.create; +var bigIntType2 = ZodBigInt2.create; +var booleanType2 = ZodBoolean2.create; +var dateType2 = ZodDate2.create; +var symbolType2 = ZodSymbol2.create; +var undefinedType2 = ZodUndefined2.create; +var nullType2 = ZodNull2.create; +var anyType2 = ZodAny2.create; +var unknownType2 = ZodUnknown2.create; +var neverType2 = ZodNever2.create; +var voidType2 = ZodVoid2.create; +var arrayType2 = ZodArray2.create; +var objectType2 = ZodObject2.create; +var strictObjectType2 = ZodObject2.strictCreate; +var unionType2 = ZodUnion2.create; +var discriminatedUnionType2 = ZodDiscriminatedUnion2.create; +var intersectionType2 = ZodIntersection2.create; +var tupleType2 = ZodTuple2.create; +var recordType2 = ZodRecord2.create; +var mapType2 = ZodMap2.create; +var setType2 = ZodSet2.create; +var functionType2 = ZodFunction2.create; +var lazyType2 = ZodLazy2.create; +var literalType2 = ZodLiteral2.create; +var enumType2 = ZodEnum2.create; +var nativeEnumType2 = ZodNativeEnum2.create; +var promiseType2 = ZodPromise2.create; +var effectsType2 = ZodEffects2.create; +var optionalType2 = ZodOptional2.create; +var nullableType2 = ZodNullable2.create; +var preprocessType2 = ZodEffects2.createWithPreprocess; +var pipelineType2 = ZodPipeline2.create; +var ostring2 = () => stringType2().optional(); +var onumber2 = () => numberType2().optional(); +var oboolean2 = () => booleanType2().optional(); +var coerce2 = { + string: (arg) => ZodString2.create({ ...arg, coerce: true }), + number: (arg) => ZodNumber2.create({ ...arg, coerce: true }), + boolean: (arg) => ZodBoolean2.create({ + ...arg, + coerce: true + }), + bigint: (arg) => ZodBigInt2.create({ ...arg, coerce: true }), + date: (arg) => ZodDate2.create({ ...arg, coerce: true }) +}; +var NEVER2 = INVALID2; +var z = /* @__PURE__ */ Object.freeze({ + __proto__: null, + defaultErrorMap: errorMap2, + setErrorMap: setErrorMap2, + getErrorMap: getErrorMap2, + makeIssue: makeIssue2, + EMPTY_PATH: EMPTY_PATH2, + addIssueToContext: addIssueToContext2, + ParseStatus: ParseStatus2, + INVALID: INVALID2, + DIRTY: DIRTY2, + OK: OK2, + isAborted: isAborted2, + isDirty: isDirty2, + isValid: isValid2, + isAsync: isAsync2, + get util() { + return util2; + }, + get objectUtil() { + return objectUtil2; + }, + ZodParsedType: ZodParsedType2, + getParsedType: getParsedType2, + ZodType: ZodType2, + datetimeRegex: datetimeRegex2, + ZodString: ZodString2, + ZodNumber: ZodNumber2, + ZodBigInt: ZodBigInt2, + ZodBoolean: ZodBoolean2, + ZodDate: ZodDate2, + ZodSymbol: ZodSymbol2, + ZodUndefined: ZodUndefined2, + ZodNull: ZodNull2, + ZodAny: ZodAny2, + ZodUnknown: ZodUnknown2, + ZodNever: ZodNever2, + ZodVoid: ZodVoid2, + ZodArray: ZodArray2, + ZodObject: ZodObject2, + ZodUnion: ZodUnion2, + ZodDiscriminatedUnion: ZodDiscriminatedUnion2, + ZodIntersection: ZodIntersection2, + ZodTuple: ZodTuple2, + ZodRecord: ZodRecord2, + ZodMap: ZodMap2, + ZodSet: ZodSet2, + ZodFunction: ZodFunction2, + ZodLazy: ZodLazy2, + ZodLiteral: ZodLiteral2, + ZodEnum: ZodEnum2, + ZodNativeEnum: ZodNativeEnum2, + ZodPromise: ZodPromise2, + ZodEffects: ZodEffects2, + ZodTransformer: ZodEffects2, + ZodOptional: ZodOptional2, + ZodNullable: ZodNullable2, + ZodDefault: ZodDefault2, + ZodCatch: ZodCatch2, + ZodNaN: ZodNaN2, + BRAND: BRAND2, + ZodBranded: ZodBranded2, + ZodPipeline: ZodPipeline2, + ZodReadonly: ZodReadonly2, + custom: custom2, + Schema: ZodType2, + ZodSchema: ZodType2, + late: late2, + get ZodFirstPartyTypeKind() { + return ZodFirstPartyTypeKind2; + }, + coerce: coerce2, + any: anyType2, + array: arrayType2, + bigint: bigIntType2, + boolean: booleanType2, + date: dateType2, + discriminatedUnion: discriminatedUnionType2, + effect: effectsType2, + "enum": enumType2, + "function": functionType2, + "instanceof": instanceOfType2, + intersection: intersectionType2, + lazy: lazyType2, + literal: literalType2, + map: mapType2, + nan: nanType2, + nativeEnum: nativeEnumType2, + never: neverType2, + "null": nullType2, + nullable: nullableType2, + number: numberType2, + object: objectType2, + oboolean: oboolean2, + onumber: onumber2, + optional: optionalType2, + ostring: ostring2, + pipeline: pipelineType2, + preprocess: preprocessType2, + promise: promiseType2, + record: recordType2, + set: setType2, + strictObject: strictObjectType2, + string: stringType2, + symbol: symbolType2, + transformer: effectsType2, + tuple: tupleType2, + "undefined": undefinedType2, + union: unionType2, + unknown: unknownType2, + "void": voidType2, + NEVER: NEVER2, + ZodIssueCode: ZodIssueCode2, + quotelessJson: quotelessJson2, + ZodError: ZodError2 +}); +var LATEST_PROTOCOL_VERSION2 = "2025-06-18"; +var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26"; +var SUPPORTED_PROTOCOL_VERSIONS2 = [ + LATEST_PROTOCOL_VERSION2, + "2025-03-26", + "2024-11-05", + "2024-10-07" +]; +var JSONRPC_VERSION2 = "2.0"; +var ProgressTokenSchema2 = z.union([z.string(), z.number().int()]); +var CursorSchema2 = z.string(); +var RequestMetaSchema2 = z.object({ + /** + * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications. + */ + progressToken: z.optional(ProgressTokenSchema2) +}).passthrough(); +var BaseRequestParamsSchema2 = z.object({ + _meta: z.optional(RequestMetaSchema2) +}).passthrough(); +var RequestSchema2 = z.object({ + method: z.string(), + params: z.optional(BaseRequestParamsSchema2) +}); +var BaseNotificationParamsSchema2 = z.object({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var NotificationSchema2 = z.object({ + method: z.string(), + params: z.optional(BaseNotificationParamsSchema2) +}); +var ResultSchema2 = z.object({ + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var RequestIdSchema2 = z.union([z.string(), z.number().int()]); +var JSONRPCRequestSchema2 = z.object({ + jsonrpc: z.literal(JSONRPC_VERSION2), + id: RequestIdSchema2 +}).merge(RequestSchema2).strict(); +var isJSONRPCRequest2 = (value) => JSONRPCRequestSchema2.safeParse(value).success; +var JSONRPCNotificationSchema2 = z.object({ + jsonrpc: z.literal(JSONRPC_VERSION2) +}).merge(NotificationSchema2).strict(); +var JSONRPCResponseSchema2 = z.object({ + jsonrpc: z.literal(JSONRPC_VERSION2), + id: RequestIdSchema2, + result: ResultSchema2 +}).strict(); +var isJSONRPCResponse2 = (value) => JSONRPCResponseSchema2.safeParse(value).success; +var ErrorCode2; +(function(ErrorCode22) { + ErrorCode22[ErrorCode22["ConnectionClosed"] = -32e3] = "ConnectionClosed"; + ErrorCode22[ErrorCode22["RequestTimeout"] = -32001] = "RequestTimeout"; + ErrorCode22[ErrorCode22["ParseError"] = -32700] = "ParseError"; + ErrorCode22[ErrorCode22["InvalidRequest"] = -32600] = "InvalidRequest"; + ErrorCode22[ErrorCode22["MethodNotFound"] = -32601] = "MethodNotFound"; + ErrorCode22[ErrorCode22["InvalidParams"] = -32602] = "InvalidParams"; + ErrorCode22[ErrorCode22["InternalError"] = -32603] = "InternalError"; +})(ErrorCode2 || (ErrorCode2 = {})); +var JSONRPCErrorSchema2 = z.object({ + jsonrpc: z.literal(JSONRPC_VERSION2), + id: RequestIdSchema2, + error: z.object({ + /** + * The error type that occurred. + */ + code: z.number().int(), + /** + * A short description of the error. The message SHOULD be limited to a concise single sentence. + */ + message: z.string(), + /** + * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.). + */ + data: z.optional(z.unknown()) + }) +}).strict(); +var isJSONRPCError2 = (value) => JSONRPCErrorSchema2.safeParse(value).success; +var JSONRPCMessageSchema2 = z.union([ + JSONRPCRequestSchema2, + JSONRPCNotificationSchema2, + JSONRPCResponseSchema2, + JSONRPCErrorSchema2 +]); +var EmptyResultSchema2 = ResultSchema2.strict(); +var CancelledNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/cancelled"), + params: BaseNotificationParamsSchema2.extend({ + /** + * The ID of the request to cancel. + * + * This MUST correspond to the ID of a request previously issued in the same direction. + */ + requestId: RequestIdSchema2, + /** + * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user. + */ + reason: z.string().optional() + }) +}); +var BaseMetadataSchema2 = z.object({ + /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */ + name: z.string(), + /** + * Intended for UI and end-user contexts — optimized to be human-readable and easily understood, + * even by those unfamiliar with domain-specific terminology. + * + * If not provided, the name should be used for display (except for Tool, + * where `annotations.title` should be given precedence over using `name`, + * if present). + */ + title: z.optional(z.string()) +}).passthrough(); +var ImplementationSchema2 = BaseMetadataSchema2.extend({ + version: z.string() +}); +var ClientCapabilitiesSchema2 = z.object({ + /** + * Experimental, non-standard capabilities that the client supports. + */ + experimental: z.optional(z.object({}).passthrough()), + /** + * Present if the client supports sampling from an LLM. + */ + sampling: z.optional(z.object({}).passthrough()), + /** + * Present if the client supports eliciting user input. + */ + elicitation: z.optional(z.object({}).passthrough()), + /** + * Present if the client supports listing roots. + */ + roots: z.optional(z.object({ + /** + * Whether the client supports issuing notifications for changes to the roots list. + */ + listChanged: z.optional(z.boolean()) + }).passthrough()) +}).passthrough(); +var InitializeRequestSchema2 = RequestSchema2.extend({ + method: z.literal("initialize"), + params: BaseRequestParamsSchema2.extend({ + /** + * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well. + */ + protocolVersion: z.string(), + capabilities: ClientCapabilitiesSchema2, + clientInfo: ImplementationSchema2 + }) +}); +var isInitializeRequest = (value) => InitializeRequestSchema2.safeParse(value).success; +var ServerCapabilitiesSchema2 = z.object({ + /** + * Experimental, non-standard capabilities that the server supports. + */ + experimental: z.optional(z.object({}).passthrough()), + /** + * Present if the server supports sending log messages to the client. + */ + logging: z.optional(z.object({}).passthrough()), + /** + * Present if the server supports sending completions to the client. + */ + completions: z.optional(z.object({}).passthrough()), + /** + * Present if the server offers any prompt templates. + */ + prompts: z.optional(z.object({ + /** + * Whether this server supports issuing notifications for changes to the prompt list. + */ + listChanged: z.optional(z.boolean()) + }).passthrough()), + /** + * Present if the server offers any resources to read. + */ + resources: z.optional(z.object({ + /** + * Whether this server supports clients subscribing to resource updates. + */ + subscribe: z.optional(z.boolean()), + /** + * Whether this server supports issuing notifications for changes to the resource list. + */ + listChanged: z.optional(z.boolean()) + }).passthrough()), + /** + * Present if the server offers any tools to call. + */ + tools: z.optional(z.object({ + /** + * Whether this server supports issuing notifications for changes to the tool list. + */ + listChanged: z.optional(z.boolean()) + }).passthrough()) +}).passthrough(); +var InitializeResultSchema2 = ResultSchema2.extend({ + /** + * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect. + */ + protocolVersion: z.string(), + capabilities: ServerCapabilitiesSchema2, + serverInfo: ImplementationSchema2, + /** + * Instructions describing how to use the server and its features. + * + * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt. + */ + instructions: z.optional(z.string()) +}); +var InitializedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/initialized") +}); +var PingRequestSchema2 = RequestSchema2.extend({ + method: z.literal("ping") +}); +var ProgressSchema2 = z.object({ + /** + * The progress thus far. This should increase every time progress is made, even if the total is unknown. + */ + progress: z.number(), + /** + * Total number of items to process (or total progress required), if known. + */ + total: z.optional(z.number()), + /** + * An optional message describing the current progress. + */ + message: z.optional(z.string()) +}).passthrough(); +var ProgressNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/progress"), + params: BaseNotificationParamsSchema2.merge(ProgressSchema2).extend({ + /** + * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding. + */ + progressToken: ProgressTokenSchema2 + }) +}); +var PaginatedRequestSchema2 = RequestSchema2.extend({ + params: BaseRequestParamsSchema2.extend({ + /** + * An opaque token representing the current pagination position. + * If provided, the server should return results starting after this cursor. + */ + cursor: z.optional(CursorSchema2) + }).optional() +}); +var PaginatedResultSchema2 = ResultSchema2.extend({ + /** + * An opaque token representing the pagination position after the last returned result. + * If present, there may be more results available. + */ + nextCursor: z.optional(CursorSchema2) +}); +var ResourceContentsSchema2 = z.object({ + /** + * The URI of this resource. + */ + uri: z.string(), + /** + * The MIME type of this resource, if known. + */ + mimeType: z.optional(z.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var TextResourceContentsSchema2 = ResourceContentsSchema2.extend({ + /** + * The text of the item. This must only be set if the item can actually be represented as text (not binary data). + */ + text: z.string() +}); +var Base64Schema2 = z.string().refine((val) => { + try { + atob(val); + return true; + } catch (_a) { + return false; + } +}, { message: "Invalid Base64 string" }); +var BlobResourceContentsSchema2 = ResourceContentsSchema2.extend({ + /** + * A base64-encoded string representing the binary data of the item. + */ + blob: Base64Schema2 +}); +var ResourceSchema2 = BaseMetadataSchema2.extend({ + /** + * The URI of this resource. + */ + uri: z.string(), + /** + * A description of what this resource represents. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: z.optional(z.string()), + /** + * The MIME type of this resource, if known. + */ + mimeType: z.optional(z.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}); +var ResourceTemplateSchema2 = BaseMetadataSchema2.extend({ + /** + * A URI template (according to RFC 6570) that can be used to construct resource URIs. + */ + uriTemplate: z.string(), + /** + * A description of what this template is for. + * + * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model. + */ + description: z.optional(z.string()), + /** + * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type. + */ + mimeType: z.optional(z.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}); +var ListResourcesRequestSchema2 = PaginatedRequestSchema2.extend({ + method: z.literal("resources/list") +}); +var ListResourcesResultSchema2 = PaginatedResultSchema2.extend({ + resources: z.array(ResourceSchema2) +}); +var ListResourceTemplatesRequestSchema2 = PaginatedRequestSchema2.extend({ + method: z.literal("resources/templates/list") +}); +var ListResourceTemplatesResultSchema2 = PaginatedResultSchema2.extend({ + resourceTemplates: z.array(ResourceTemplateSchema2) +}); +var ReadResourceRequestSchema2 = RequestSchema2.extend({ + method: z.literal("resources/read"), + params: BaseRequestParamsSchema2.extend({ + /** + * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it. + */ + uri: z.string() + }) +}); +var ReadResourceResultSchema2 = ResultSchema2.extend({ + contents: z.array(z.union([TextResourceContentsSchema2, BlobResourceContentsSchema2])) +}); +var ResourceListChangedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/resources/list_changed") +}); +var SubscribeRequestSchema2 = RequestSchema2.extend({ + method: z.literal("resources/subscribe"), + params: BaseRequestParamsSchema2.extend({ + /** + * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it. + */ + uri: z.string() + }) +}); +var UnsubscribeRequestSchema2 = RequestSchema2.extend({ + method: z.literal("resources/unsubscribe"), + params: BaseRequestParamsSchema2.extend({ + /** + * The URI of the resource to unsubscribe from. + */ + uri: z.string() + }) +}); +var ResourceUpdatedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/resources/updated"), + params: BaseNotificationParamsSchema2.extend({ + /** + * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to. + */ + uri: z.string() + }) +}); +var PromptArgumentSchema2 = z.object({ + /** + * The name of the argument. + */ + name: z.string(), + /** + * A human-readable description of the argument. + */ + description: z.optional(z.string()), + /** + * Whether this argument must be provided. + */ + required: z.optional(z.boolean()) +}).passthrough(); +var PromptSchema2 = BaseMetadataSchema2.extend({ + /** + * An optional description of what this prompt provides + */ + description: z.optional(z.string()), + /** + * A list of arguments to use for templating the prompt. + */ + arguments: z.optional(z.array(PromptArgumentSchema2)), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}); +var ListPromptsRequestSchema2 = PaginatedRequestSchema2.extend({ + method: z.literal("prompts/list") +}); +var ListPromptsResultSchema2 = PaginatedResultSchema2.extend({ + prompts: z.array(PromptSchema2) +}); +var GetPromptRequestSchema2 = RequestSchema2.extend({ + method: z.literal("prompts/get"), + params: BaseRequestParamsSchema2.extend({ + /** + * The name of the prompt or prompt template. + */ + name: z.string(), + /** + * Arguments to use for templating the prompt. + */ + arguments: z.optional(z.record(z.string())) + }) +}); +var TextContentSchema2 = z.object({ + type: z.literal("text"), + /** + * The text content of the message. + */ + text: z.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var ImageContentSchema2 = z.object({ + type: z.literal("image"), + /** + * The base64-encoded image data. + */ + data: Base64Schema2, + /** + * The MIME type of the image. Different providers may support different image types. + */ + mimeType: z.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var AudioContentSchema2 = z.object({ + type: z.literal("audio"), + /** + * The base64-encoded audio data. + */ + data: Base64Schema2, + /** + * The MIME type of the audio. Different providers may support different audio types. + */ + mimeType: z.string(), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var EmbeddedResourceSchema2 = z.object({ + type: z.literal("resource"), + resource: z.union([TextResourceContentsSchema2, BlobResourceContentsSchema2]), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var ResourceLinkSchema2 = ResourceSchema2.extend({ + type: z.literal("resource_link") +}); +var ContentBlockSchema2 = z.union([ + TextContentSchema2, + ImageContentSchema2, + AudioContentSchema2, + ResourceLinkSchema2, + EmbeddedResourceSchema2 +]); +var PromptMessageSchema2 = z.object({ + role: z.enum(["user", "assistant"]), + content: ContentBlockSchema2 +}).passthrough(); +var GetPromptResultSchema2 = ResultSchema2.extend({ + /** + * An optional description for the prompt. + */ + description: z.optional(z.string()), + messages: z.array(PromptMessageSchema2) +}); +var PromptListChangedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/prompts/list_changed") +}); +var ToolAnnotationsSchema2 = z.object({ + /** + * A human-readable title for the tool. + */ + title: z.optional(z.string()), + /** + * If true, the tool does not modify its environment. + * + * Default: false + */ + readOnlyHint: z.optional(z.boolean()), + /** + * If true, the tool may perform destructive updates to its environment. + * If false, the tool performs only additive updates. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: true + */ + destructiveHint: z.optional(z.boolean()), + /** + * If true, calling the tool repeatedly with the same arguments + * will have no additional effect on the its environment. + * + * (This property is meaningful only when `readOnlyHint == false`) + * + * Default: false + */ + idempotentHint: z.optional(z.boolean()), + /** + * If true, this tool may interact with an "open world" of external + * entities. If false, the tool's domain of interaction is closed. + * For example, the world of a web search tool is open, whereas that + * of a memory tool is not. + * + * Default: true + */ + openWorldHint: z.optional(z.boolean()) +}).passthrough(); +var ToolSchema2 = BaseMetadataSchema2.extend({ + /** + * A human-readable description of the tool. + */ + description: z.optional(z.string()), + /** + * A JSON Schema object defining the expected parameters for the tool. + */ + inputSchema: z.object({ + type: z.literal("object"), + properties: z.optional(z.object({}).passthrough()), + required: z.optional(z.array(z.string())) + }).passthrough(), + /** + * An optional JSON Schema object defining the structure of the tool's output returned in + * the structuredContent field of a CallToolResult. + */ + outputSchema: z.optional(z.object({ + type: z.literal("object"), + properties: z.optional(z.object({}).passthrough()), + required: z.optional(z.array(z.string())) + }).passthrough()), + /** + * Optional additional tool information. + */ + annotations: z.optional(ToolAnnotationsSchema2), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}); +var ListToolsRequestSchema2 = PaginatedRequestSchema2.extend({ + method: z.literal("tools/list") +}); +var ListToolsResultSchema2 = PaginatedResultSchema2.extend({ + tools: z.array(ToolSchema2) +}); +var CallToolResultSchema2 = ResultSchema2.extend({ + /** + * A list of content objects that represent the result of the tool call. + * + * If the Tool does not define an outputSchema, this field MUST be present in the result. + * For backwards compatibility, this field is always present, but it may be empty. + */ + content: z.array(ContentBlockSchema2).default([]), + /** + * An object containing structured tool output. + * + * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema. + */ + structuredContent: z.object({}).passthrough().optional(), + /** + * Whether the tool call ended in an error. + * + * If not set, this is assumed to be false (the call was successful). + * + * Any errors that originate from the tool SHOULD be reported inside the result + * object, with `isError` set to true, _not_ as an MCP protocol-level error + * response. Otherwise, the LLM would not be able to see that an error occurred + * and self-correct. + * + * However, any errors in _finding_ the tool, an error indicating that the + * server does not support tool calls, or any other exceptional conditions, + * should be reported as an MCP error response. + */ + isError: z.optional(z.boolean()) +}); +var CompatibilityCallToolResultSchema2 = CallToolResultSchema2.or(ResultSchema2.extend({ + toolResult: z.unknown() +})); +var CallToolRequestSchema2 = RequestSchema2.extend({ + method: z.literal("tools/call"), + params: BaseRequestParamsSchema2.extend({ + name: z.string(), + arguments: z.optional(z.record(z.unknown())) + }) +}); +var ToolListChangedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/tools/list_changed") +}); +var LoggingLevelSchema2 = z.enum([ + "debug", + "info", + "notice", + "warning", + "error", + "critical", + "alert", + "emergency" +]); +var SetLevelRequestSchema2 = RequestSchema2.extend({ + method: z.literal("logging/setLevel"), + params: BaseRequestParamsSchema2.extend({ + /** + * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message. + */ + level: LoggingLevelSchema2 + }) +}); +var LoggingMessageNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/message"), + params: BaseNotificationParamsSchema2.extend({ + /** + * The severity of this log message. + */ + level: LoggingLevelSchema2, + /** + * An optional name of the logger issuing this message. + */ + logger: z.optional(z.string()), + /** + * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here. + */ + data: z.unknown() + }) +}); +var ModelHintSchema2 = z.object({ + /** + * A hint for a model name. + */ + name: z.string().optional() +}).passthrough(); +var ModelPreferencesSchema2 = z.object({ + /** + * Optional hints to use for model selection. + */ + hints: z.optional(z.array(ModelHintSchema2)), + /** + * How much to prioritize cost when selecting a model. + */ + costPriority: z.optional(z.number().min(0).max(1)), + /** + * How much to prioritize sampling speed (latency) when selecting a model. + */ + speedPriority: z.optional(z.number().min(0).max(1)), + /** + * How much to prioritize intelligence and capabilities when selecting a model. + */ + intelligencePriority: z.optional(z.number().min(0).max(1)) +}).passthrough(); +var SamplingMessageSchema2 = z.object({ + role: z.enum(["user", "assistant"]), + content: z.union([TextContentSchema2, ImageContentSchema2, AudioContentSchema2]) +}).passthrough(); +var CreateMessageRequestSchema2 = RequestSchema2.extend({ + method: z.literal("sampling/createMessage"), + params: BaseRequestParamsSchema2.extend({ + messages: z.array(SamplingMessageSchema2), + /** + * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt. + */ + systemPrompt: z.optional(z.string()), + /** + * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request. + */ + includeContext: z.optional(z.enum(["none", "thisServer", "allServers"])), + temperature: z.optional(z.number()), + /** + * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested. + */ + maxTokens: z.number().int(), + stopSequences: z.optional(z.array(z.string())), + /** + * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific. + */ + metadata: z.optional(z.object({}).passthrough()), + /** + * The server's preferences for which model to select. + */ + modelPreferences: z.optional(ModelPreferencesSchema2) + }) +}); +var CreateMessageResultSchema2 = ResultSchema2.extend({ + /** + * The name of the model that generated the message. + */ + model: z.string(), + /** + * The reason why sampling stopped. + */ + stopReason: z.optional(z.enum(["endTurn", "stopSequence", "maxTokens"]).or(z.string())), + role: z.enum(["user", "assistant"]), + content: z.discriminatedUnion("type", [ + TextContentSchema2, + ImageContentSchema2, + AudioContentSchema2 + ]) +}); +var BooleanSchemaSchema2 = z.object({ + type: z.literal("boolean"), + title: z.optional(z.string()), + description: z.optional(z.string()), + default: z.optional(z.boolean()) +}).passthrough(); +var StringSchemaSchema2 = z.object({ + type: z.literal("string"), + title: z.optional(z.string()), + description: z.optional(z.string()), + minLength: z.optional(z.number()), + maxLength: z.optional(z.number()), + format: z.optional(z.enum(["email", "uri", "date", "date-time"])) +}).passthrough(); +var NumberSchemaSchema2 = z.object({ + type: z.enum(["number", "integer"]), + title: z.optional(z.string()), + description: z.optional(z.string()), + minimum: z.optional(z.number()), + maximum: z.optional(z.number()) +}).passthrough(); +var EnumSchemaSchema2 = z.object({ + type: z.literal("string"), + title: z.optional(z.string()), + description: z.optional(z.string()), + enum: z.array(z.string()), + enumNames: z.optional(z.array(z.string())) +}).passthrough(); +var PrimitiveSchemaDefinitionSchema2 = z.union([ + BooleanSchemaSchema2, + StringSchemaSchema2, + NumberSchemaSchema2, + EnumSchemaSchema2 +]); +var ElicitRequestSchema2 = RequestSchema2.extend({ + method: z.literal("elicitation/create"), + params: BaseRequestParamsSchema2.extend({ + /** + * The message to present to the user. + */ + message: z.string(), + /** + * The schema for the requested user input. + */ + requestedSchema: z.object({ + type: z.literal("object"), + properties: z.record(z.string(), PrimitiveSchemaDefinitionSchema2), + required: z.optional(z.array(z.string())) + }).passthrough() + }) +}); +var ElicitResultSchema2 = ResultSchema2.extend({ + /** + * The user's response action. + */ + action: z.enum(["accept", "decline", "cancel"]), + /** + * The collected user input content (only present if action is "accept"). + */ + content: z.optional(z.record(z.string(), z.unknown())) +}); +var ResourceTemplateReferenceSchema2 = z.object({ + type: z.literal("ref/resource"), + /** + * The URI or URI template of the resource. + */ + uri: z.string() +}).passthrough(); +var PromptReferenceSchema2 = z.object({ + type: z.literal("ref/prompt"), + /** + * The name of the prompt or prompt template + */ + name: z.string() +}).passthrough(); +var CompleteRequestSchema2 = RequestSchema2.extend({ + method: z.literal("completion/complete"), + params: BaseRequestParamsSchema2.extend({ + ref: z.union([PromptReferenceSchema2, ResourceTemplateReferenceSchema2]), + /** + * The argument's information + */ + argument: z.object({ + /** + * The name of the argument + */ + name: z.string(), + /** + * The value of the argument to use for completion matching. + */ + value: z.string() + }).passthrough(), + context: z.optional(z.object({ + /** + * Previously-resolved variables in a URI template or prompt. + */ + arguments: z.optional(z.record(z.string(), z.string())) + })) + }) +}); +var CompleteResultSchema2 = ResultSchema2.extend({ + completion: z.object({ + /** + * An array of completion values. Must not exceed 100 items. + */ + values: z.array(z.string()).max(100), + /** + * The total number of completion options available. This can exceed the number of values actually sent in the response. + */ + total: z.optional(z.number().int()), + /** + * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown. + */ + hasMore: z.optional(z.boolean()) + }).passthrough() +}); +var RootSchema2 = z.object({ + /** + * The URI identifying the root. This *must* start with file:// for now. + */ + uri: z.string().startsWith("file://"), + /** + * An optional name for the root. + */ + name: z.optional(z.string()), + /** + * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields) + * for notes on _meta usage. + */ + _meta: z.optional(z.object({}).passthrough()) +}).passthrough(); +var ListRootsRequestSchema2 = RequestSchema2.extend({ + method: z.literal("roots/list") +}); +var ListRootsResultSchema2 = ResultSchema2.extend({ + roots: z.array(RootSchema2) +}); +var RootsListChangedNotificationSchema2 = NotificationSchema2.extend({ + method: z.literal("notifications/roots/list_changed") +}); +var ClientRequestSchema2 = z.union([ + PingRequestSchema2, + InitializeRequestSchema2, + CompleteRequestSchema2, + SetLevelRequestSchema2, + GetPromptRequestSchema2, + ListPromptsRequestSchema2, + ListResourcesRequestSchema2, + ListResourceTemplatesRequestSchema2, + ReadResourceRequestSchema2, + SubscribeRequestSchema2, + UnsubscribeRequestSchema2, + CallToolRequestSchema2, + ListToolsRequestSchema2 +]); +var ClientNotificationSchema2 = z.union([ + CancelledNotificationSchema2, + ProgressNotificationSchema2, + InitializedNotificationSchema2, + RootsListChangedNotificationSchema2 +]); +var ClientResultSchema2 = z.union([ + EmptyResultSchema2, + CreateMessageResultSchema2, + ElicitResultSchema2, + ListRootsResultSchema2 +]); +var ServerRequestSchema2 = z.union([ + PingRequestSchema2, + CreateMessageRequestSchema2, + ElicitRequestSchema2, + ListRootsRequestSchema2 +]); +var ServerNotificationSchema2 = z.union([ + CancelledNotificationSchema2, + ProgressNotificationSchema2, + LoggingMessageNotificationSchema2, + ResourceUpdatedNotificationSchema2, + ResourceListChangedNotificationSchema2, + ToolListChangedNotificationSchema2, + PromptListChangedNotificationSchema2 +]); +var ServerResultSchema2 = z.union([ + EmptyResultSchema2, + InitializeResultSchema2, + CompleteResultSchema2, + GetPromptResultSchema2, + ListPromptsResultSchema2, + ListResourcesResultSchema2, + ListResourceTemplatesResultSchema2, + ReadResourceResultSchema2, + CallToolResultSchema2, + ListToolsResultSchema2 +]); +var import_raw_body = __toESM2(require_raw_body(), 1); +var import_content_type = __toESM2(require_content_type(), 1); +var import_node_crypto = require("node:crypto"); +var MAXIMUM_MESSAGE_SIZE = "4mb"; +var StreamableHTTPServerTransport = class { + constructor(options) { + var _a, _b; + this._started = false; + this._streamMapping = /* @__PURE__ */ new Map(); + this._requestToStreamMapping = /* @__PURE__ */ new Map(); + this._requestResponseMap = /* @__PURE__ */ new Map(); + this._initialized = false; + this._enableJsonResponse = false; + this._standaloneSseStreamId = "_GET_stream"; + this.sessionIdGenerator = options.sessionIdGenerator; + this._enableJsonResponse = (_a = options.enableJsonResponse) !== null && _a !== void 0 ? _a : false; + this._eventStore = options.eventStore; + this._onsessioninitialized = options.onsessioninitialized; + this._onsessionclosed = options.onsessionclosed; + this._allowedHosts = options.allowedHosts; + this._allowedOrigins = options.allowedOrigins; + this._enableDnsRebindingProtection = (_b = options.enableDnsRebindingProtection) !== null && _b !== void 0 ? _b : false; + } + /** + * Starts the transport. This is required by the Transport interface but is a no-op + * for the Streamable HTTP transport as connections are managed per-request. + */ + async start() { + if (this._started) { + throw new Error("Transport already started"); + } + this._started = true; + } + /** + * Validates request headers for DNS rebinding protection. + * @returns Error message if validation fails, undefined if validation passes. + */ + validateRequestHeaders(req) { + if (!this._enableDnsRebindingProtection) { + return void 0; + } + if (this._allowedHosts && this._allowedHosts.length > 0) { + const hostHeader = req.headers.host; + if (!hostHeader || !this._allowedHosts.includes(hostHeader)) { + return `Invalid Host header: ${hostHeader}`; + } + } + if (this._allowedOrigins && this._allowedOrigins.length > 0) { + const originHeader = req.headers.origin; + if (!originHeader || !this._allowedOrigins.includes(originHeader)) { + return `Invalid Origin header: ${originHeader}`; + } + } + return void 0; + } + /** + * Handles an incoming HTTP request, whether GET or POST + */ + async handleRequest(req, res, parsedBody) { + var _a; + const validationError = this.validateRequestHeaders(req); + if (validationError) { + res.writeHead(403).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: validationError + }, + id: null + })); + (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(validationError)); + return; + } + if (req.method === "POST") { + await this.handlePostRequest(req, res, parsedBody); + } else if (req.method === "GET") { + await this.handleGetRequest(req, res); + } else if (req.method === "DELETE") { + await this.handleDeleteRequest(req, res); + } else { + await this.handleUnsupportedRequest(res); + } + } + /** + * Handles GET requests for SSE stream + */ + async handleGetRequest(req, res) { + const acceptHeader = req.headers.accept; + if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("text/event-stream"))) { + res.writeHead(406).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Not Acceptable: Client must accept text/event-stream" + }, + id: null + })); + return; + } + if (!this.validateSession(req, res)) { + return; + } + if (!this.validateProtocolVersion(req, res)) { + return; + } + if (this._eventStore) { + const lastEventId = req.headers["last-event-id"]; + if (lastEventId) { + await this.replayEvents(lastEventId, res); + return; + } + } + const headers = { + "Content-Type": "text/event-stream", + "Cache-Control": "no-cache, no-transform", + Connection: "keep-alive" + }; + if (this.sessionId !== void 0) { + headers["mcp-session-id"] = this.sessionId; + } + if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) { + res.writeHead(409).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Conflict: Only one SSE stream is allowed per session" + }, + id: null + })); + return; + } + res.writeHead(200, headers).flushHeaders(); + this._streamMapping.set(this._standaloneSseStreamId, res); + res.on("close", () => { + this._streamMapping.delete(this._standaloneSseStreamId); + }); + } + /** + * Replays events that would have been sent after the specified event ID + * Only used when resumability is enabled + */ + async replayEvents(lastEventId, res) { + var _a, _b; + if (!this._eventStore) { + return; + } + try { + const headers = { + "Content-Type": "text/event-stream", + "Cache-Control": "no-cache, no-transform", + Connection: "keep-alive" + }; + if (this.sessionId !== void 0) { + headers["mcp-session-id"] = this.sessionId; + } + res.writeHead(200, headers).flushHeaders(); + const streamId = await ((_a = this._eventStore) === null || _a === void 0 ? void 0 : _a.replayEventsAfter(lastEventId, { + send: async (eventId, message) => { + var _a2; + if (!this.writeSSEEvent(res, message, eventId)) { + (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, new Error("Failed replay events")); + res.end(); + } + } + })); + this._streamMapping.set(streamId, res); + } catch (error) { + (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error); + } + } + /** + * Writes an event to the SSE stream with proper formatting + */ + writeSSEEvent(res, message, eventId) { + let eventData = `event: message +`; + if (eventId) { + eventData += `id: ${eventId} +`; + } + eventData += `data: ${JSON.stringify(message)} + +`; + return res.write(eventData); + } + /** + * Handles unsupported requests (PUT, PATCH, etc.) + */ + async handleUnsupportedRequest(res) { + res.writeHead(405, { + "Allow": "GET, POST, DELETE" + }).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Method not allowed." + }, + id: null + })); + } + /** + * Handles POST requests containing JSON-RPC messages + */ + async handlePostRequest(req, res, parsedBody) { + var _a, _b, _c, _d, _e; + try { + const acceptHeader = req.headers.accept; + if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes("application/json")) || !acceptHeader.includes("text/event-stream")) { + res.writeHead(406).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Not Acceptable: Client must accept both application/json and text/event-stream" + }, + id: null + })); + return; + } + const ct = req.headers["content-type"]; + if (!ct || !ct.includes("application/json")) { + res.writeHead(415).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Unsupported Media Type: Content-Type must be application/json" + }, + id: null + })); + return; + } + const authInfo = req.auth; + const requestInfo = { headers: req.headers }; + let rawMessage; + if (parsedBody !== void 0) { + rawMessage = parsedBody; + } else { + const parsedCt = import_content_type.default.parse(ct); + const body = await (0, import_raw_body.default)(req, { + limit: MAXIMUM_MESSAGE_SIZE, + encoding: (_a = parsedCt.parameters.charset) !== null && _a !== void 0 ? _a : "utf-8" + }); + rawMessage = JSON.parse(body.toString()); + } + let messages; + if (Array.isArray(rawMessage)) { + messages = rawMessage.map((msg) => JSONRPCMessageSchema2.parse(msg)); + } else { + messages = [JSONRPCMessageSchema2.parse(rawMessage)]; + } + const isInitializationRequest = messages.some(isInitializeRequest); + if (isInitializationRequest) { + if (this._initialized && this.sessionId !== void 0) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32600, + message: "Invalid Request: Server already initialized" + }, + id: null + })); + return; + } + if (messages.length > 1) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32600, + message: "Invalid Request: Only one initialization request is allowed" + }, + id: null + })); + return; + } + this.sessionId = (_b = this.sessionIdGenerator) === null || _b === void 0 ? void 0 : _b.call(this); + this._initialized = true; + if (this.sessionId && this._onsessioninitialized) { + await Promise.resolve(this._onsessioninitialized(this.sessionId)); + } + } + if (!isInitializationRequest) { + if (!this.validateSession(req, res)) { + return; + } + if (!this.validateProtocolVersion(req, res)) { + return; + } + } + const hasRequests = messages.some(isJSONRPCRequest2); + if (!hasRequests) { + res.writeHead(202).end(); + for (const message of messages) { + (_c = this.onmessage) === null || _c === void 0 ? void 0 : _c.call(this, message, { authInfo, requestInfo }); + } + } else if (hasRequests) { + const streamId = (0, import_node_crypto.randomUUID)(); + if (!this._enableJsonResponse) { + const headers = { + "Content-Type": "text/event-stream", + "Cache-Control": "no-cache", + Connection: "keep-alive" + }; + if (this.sessionId !== void 0) { + headers["mcp-session-id"] = this.sessionId; + } + res.writeHead(200, headers); + } + for (const message of messages) { + if (isJSONRPCRequest2(message)) { + this._streamMapping.set(streamId, res); + this._requestToStreamMapping.set(message.id, streamId); + } + } + res.on("close", () => { + this._streamMapping.delete(streamId); + }); + for (const message of messages) { + (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, message, { authInfo, requestInfo }); + } + } + } catch (error) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32700, + message: "Parse error", + data: String(error) + }, + id: null + })); + (_e = this.onerror) === null || _e === void 0 ? void 0 : _e.call(this, error); + } + } + /** + * Handles DELETE requests to terminate sessions + */ + async handleDeleteRequest(req, res) { + var _a; + if (!this.validateSession(req, res)) { + return; + } + if (!this.validateProtocolVersion(req, res)) { + return; + } + await Promise.resolve((_a = this._onsessionclosed) === null || _a === void 0 ? void 0 : _a.call(this, this.sessionId)); + await this.close(); + res.writeHead(200).end(); + } + /** + * Validates session ID for non-initialization requests + * Returns true if the session is valid, false otherwise + */ + validateSession(req, res) { + if (this.sessionIdGenerator === void 0) { + return true; + } + if (!this._initialized) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Bad Request: Server not initialized" + }, + id: null + })); + return false; + } + const sessionId = req.headers["mcp-session-id"]; + if (!sessionId) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Bad Request: Mcp-Session-Id header is required" + }, + id: null + })); + return false; + } else if (Array.isArray(sessionId)) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Bad Request: Mcp-Session-Id header must be a single value" + }, + id: null + })); + return false; + } else if (sessionId !== this.sessionId) { + res.writeHead(404).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32001, + message: "Session not found" + }, + id: null + })); + return false; + } + return true; + } + validateProtocolVersion(req, res) { + var _a; + let protocolVersion = (_a = req.headers["mcp-protocol-version"]) !== null && _a !== void 0 ? _a : DEFAULT_NEGOTIATED_PROTOCOL_VERSION; + if (Array.isArray(protocolVersion)) { + protocolVersion = protocolVersion[protocolVersion.length - 1]; + } + if (!SUPPORTED_PROTOCOL_VERSIONS2.includes(protocolVersion)) { + res.writeHead(400).end(JSON.stringify({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: `Bad Request: Unsupported protocol version (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS2.join(", ")})` + }, + id: null + })); + return false; + } + return true; + } + async close() { + var _a; + this._streamMapping.forEach((response) => { + response.end(); + }); + this._streamMapping.clear(); + this._requestResponseMap.clear(); + (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this); + } + async send(message, options) { + let requestId = options === null || options === void 0 ? void 0 : options.relatedRequestId; + if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) { + requestId = message.id; + } + if (requestId === void 0) { + if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) { + throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request"); + } + const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId); + if (standaloneSse === void 0) { + return; + } + let eventId; + if (this._eventStore) { + eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message); + } + this.writeSSEEvent(standaloneSse, message, eventId); + return; + } + const streamId = this._requestToStreamMapping.get(requestId); + const response = this._streamMapping.get(streamId); + if (!streamId) { + throw new Error(`No connection established for request ID: ${String(requestId)}`); + } + if (!this._enableJsonResponse) { + let eventId; + if (this._eventStore) { + eventId = await this._eventStore.storeEvent(streamId, message); + } + if (response) { + this.writeSSEEvent(response, message, eventId); + } + } + if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) { + this._requestResponseMap.set(requestId, message); + const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_2, streamId2]) => this._streamMapping.get(streamId2) === response).map(([id]) => id); + const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id)); + if (allResponsesReady) { + if (!response) { + throw new Error(`No connection established for request ID: ${String(requestId)}`); + } + if (this._enableJsonResponse) { + const headers = { + "Content-Type": "application/json" + }; + if (this.sessionId !== void 0) { + headers["mcp-session-id"] = this.sessionId; + } + const responses = relatedIds.map((id) => this._requestResponseMap.get(id)); + response.writeHead(200, headers); + if (responses.length === 1) { + response.end(JSON.stringify(responses[0])); + } else { + response.end(JSON.stringify(responses)); + } + } else { + response.end(); + } + for (const id of relatedIds) { + this._requestResponseMap.delete(id); + this._requestToStreamMapping.delete(id); + } + } + } + } +}; +var import_express = __toESM2(require_express2(), 1); +var import_node_crypto2 = require("node:crypto"); +var import_lodash = __toESM2(require_lodash(), 1); +function ok(value) { + return { ok: true, value }; +} +function err(typeOrPayload, payload) { + if (payload !== void 0) { + return { ok: false, error: { type: typeOrPayload, ...payload } }; + } + return { ok: false, error: typeOrPayload }; +} +var ignoreOverride2 = Symbol("Let zodToJsonSchema decide on which parser to use"); +var defaultOptions2 = { + name: void 0, + $refStrategy: "root", + basePath: ["#"], + effectStrategy: "input", + pipeStrategy: "all", + dateStrategy: "format:date-time", + mapStrategy: "entries", + removeAdditionalStrategy: "passthrough", + definitionPath: "definitions", + target: "jsonSchema7", + strictUnions: false, + definitions: {}, + errorMessages: false, + markdownDescription: false, + patternStrategy: "escape", + applyRegexFlags: false, + emailStrategy: "format:email", + base64Strategy: "contentEncoding:base64", + nameStrategy: "ref" +}; +var getDefaultOptions2 = (options) => typeof options === "string" ? { + ...defaultOptions2, + name: options +} : { + ...defaultOptions2, + ...options +}; +var getRefs2 = (options) => { + const _options = getDefaultOptions2(options); + const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath; + return { + ..._options, + currentPath, + propertyPath: void 0, + seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [ + def._def, + { + def: def._def, + path: [..._options.basePath, _options.definitionPath, name], + // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now. + jsonSchema: void 0 + } + ])) + }; +}; +function addErrorMessage2(res, key, errorMessage, refs) { + if (!refs?.errorMessages) + return; + if (errorMessage) { + res.errorMessage = { + ...res.errorMessage, + [key]: errorMessage + }; + } +} +function setResponseValueAndErrors2(res, key, value, errorMessage, refs) { + res[key] = value; + addErrorMessage2(res, key, errorMessage, refs); +} +function parseAnyDef2() { + return {}; +} +function parseArrayDef2(def, refs) { + const res = { + type: "array" + }; + if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind2.ZodAny) { + res.items = parseDef2(def.type._def, { + ...refs, + currentPath: [...refs.currentPath, "items"] + }); + } + if (def.minLength) { + setResponseValueAndErrors2(res, "minItems", def.minLength.value, def.minLength.message, refs); + } + if (def.maxLength) { + setResponseValueAndErrors2(res, "maxItems", def.maxLength.value, def.maxLength.message, refs); + } + if (def.exactLength) { + setResponseValueAndErrors2(res, "minItems", def.exactLength.value, def.exactLength.message, refs); + setResponseValueAndErrors2(res, "maxItems", def.exactLength.value, def.exactLength.message, refs); + } + return res; +} +function parseBigintDef2(def, refs) { + const res = { + type: "integer", + format: "int64" + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs); + } else { + setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs); + } else { + setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} +function parseBooleanDef2() { + return { + type: "boolean" + }; +} +function parseBrandedDef2(_def, refs) { + return parseDef2(_def.type._def, refs); +} +var parseCatchDef2 = (def, refs) => { + return parseDef2(def.innerType._def, refs); +}; +function parseDateDef2(def, refs, overrideDateStrategy) { + const strategy = overrideDateStrategy ?? refs.dateStrategy; + if (Array.isArray(strategy)) { + return { + anyOf: strategy.map((item, i) => parseDateDef2(def, refs, item)) + }; + } + switch (strategy) { + case "string": + case "format:date-time": + return { + type: "string", + format: "date-time" + }; + case "format:date": + return { + type: "string", + format: "date" + }; + case "integer": + return integerDateParser2(def, refs); + } +} +var integerDateParser2 = (def, refs) => { + const res = { + type: "integer", + format: "unix-time" + }; + if (refs.target === "openApi3") { + return res; + } + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors2( + res, + "minimum", + check.value, + // This is in milliseconds + check.message, + refs + ); + break; + case "max": + setResponseValueAndErrors2( + res, + "maximum", + check.value, + // This is in milliseconds + check.message, + refs + ); + break; + } + } + return res; +}; +function parseDefaultDef2(_def, refs) { + return { + ...parseDef2(_def.innerType._def, refs), + default: _def.defaultValue() + }; +} +function parseEffectsDef2(_def, refs) { + return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : {}; +} +function parseEnumDef2(def) { + return { + type: "string", + enum: Array.from(def.values) + }; +} +var isJsonSchema7AllOfType2 = (type) => { + if ("type" in type && type.type === "string") + return false; + return "allOf" in type; +}; +function parseIntersectionDef2(def, refs) { + const allOf = [ + parseDef2(def.left._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"] + }), + parseDef2(def.right._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "1"] + }) + ].filter((x) => !!x); + let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0; + const mergedAllOf = []; + allOf.forEach((schema) => { + if (isJsonSchema7AllOfType2(schema)) { + mergedAllOf.push(...schema.allOf); + if (schema.unevaluatedProperties === void 0) { + unevaluatedProperties = void 0; + } + } else { + let nestedSchema = schema; + if ("additionalProperties" in schema && schema.additionalProperties === false) { + const { additionalProperties, ...rest } = schema; + nestedSchema = rest; + } else { + unevaluatedProperties = void 0; + } + mergedAllOf.push(nestedSchema); + } + }); + return mergedAllOf.length ? { + allOf: mergedAllOf, + ...unevaluatedProperties + } : void 0; +} +function parseLiteralDef2(def, refs) { + const parsedType = typeof def.value; + if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") { + return { + type: Array.isArray(def.value) ? "array" : "object" + }; + } + if (refs.target === "openApi3") { + return { + type: parsedType === "bigint" ? "integer" : parsedType, + enum: [def.value] + }; + } + return { + type: parsedType === "bigint" ? "integer" : parsedType, + const: def.value + }; +} +var emojiRegex22 = void 0; +var zodPatterns2 = { + /** + * `c` was changed to `[cC]` to replicate /i flag + */ + cuid: /^[cC][^\s-]{8,}$/, + cuid2: /^[0-9a-z]+$/, + ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/, + /** + * `a-z` was added to replicate /i flag + */ + email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/, + /** + * Constructed a valid Unicode RegExp + * + * Lazily instantiate since this type of regex isn't supported + * in all envs (e.g. React Native). + * + * See: + * https://github.com/colinhacks/zod/issues/2433 + * Fix in Zod: + * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b + */ + emoji: () => { + if (emojiRegex22 === void 0) { + emojiRegex22 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u"); + } + return emojiRegex22; + }, + /** + * Unused + */ + uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/, + /** + * Unused + */ + ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, + ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/, + /** + * Unused + */ + ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/, + ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, + base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, + base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, + nanoid: /^[a-zA-Z0-9_-]{21}$/, + jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/ +}; +function parseStringDef2(def, refs) { + const res = { + type: "string" + }; + if (def.checks) { + for (const check of def.checks) { + switch (check.kind) { + case "min": + setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs); + break; + case "max": + setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs); + break; + case "email": + switch (refs.emailStrategy) { + case "format:email": + addFormat2(res, "email", check.message, refs); + break; + case "format:idn-email": + addFormat2(res, "idn-email", check.message, refs); + break; + case "pattern:zod": + addPattern2(res, zodPatterns2.email, check.message, refs); + break; + } + break; + case "url": + addFormat2(res, "uri", check.message, refs); + break; + case "uuid": + addFormat2(res, "uuid", check.message, refs); + break; + case "regex": + addPattern2(res, check.regex, check.message, refs); + break; + case "cuid": + addPattern2(res, zodPatterns2.cuid, check.message, refs); + break; + case "cuid2": + addPattern2(res, zodPatterns2.cuid2, check.message, refs); + break; + case "startsWith": + addPattern2(res, RegExp(`^${escapeLiteralCheckValue2(check.value, refs)}`), check.message, refs); + break; + case "endsWith": + addPattern2(res, RegExp(`${escapeLiteralCheckValue2(check.value, refs)}$`), check.message, refs); + break; + case "datetime": + addFormat2(res, "date-time", check.message, refs); + break; + case "date": + addFormat2(res, "date", check.message, refs); + break; + case "time": + addFormat2(res, "time", check.message, refs); + break; + case "duration": + addFormat2(res, "duration", check.message, refs); + break; + case "length": + setResponseValueAndErrors2(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs); + setResponseValueAndErrors2(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs); + break; + case "includes": { + addPattern2(res, RegExp(escapeLiteralCheckValue2(check.value, refs)), check.message, refs); + break; + } + case "ip": { + if (check.version !== "v6") { + addFormat2(res, "ipv4", check.message, refs); + } + if (check.version !== "v4") { + addFormat2(res, "ipv6", check.message, refs); + } + break; + } + case "base64url": + addPattern2(res, zodPatterns2.base64url, check.message, refs); + break; + case "jwt": + addPattern2(res, zodPatterns2.jwt, check.message, refs); + break; + case "cidr": { + if (check.version !== "v6") { + addPattern2(res, zodPatterns2.ipv4Cidr, check.message, refs); + } + if (check.version !== "v4") { + addPattern2(res, zodPatterns2.ipv6Cidr, check.message, refs); + } + break; + } + case "emoji": + addPattern2(res, zodPatterns2.emoji(), check.message, refs); + break; + case "ulid": { + addPattern2(res, zodPatterns2.ulid, check.message, refs); + break; + } + case "base64": { + switch (refs.base64Strategy) { + case "format:binary": { + addFormat2(res, "binary", check.message, refs); + break; + } + case "contentEncoding:base64": { + setResponseValueAndErrors2(res, "contentEncoding", "base64", check.message, refs); + break; + } + case "pattern:zod": { + addPattern2(res, zodPatterns2.base64, check.message, refs); + break; + } + } + break; + } + case "nanoid": { + addPattern2(res, zodPatterns2.nanoid, check.message, refs); + } + case "toLowerCase": + case "toUpperCase": + case "trim": + break; + default: + /* @__PURE__ */ ((_2) => { + })(check); + } + } + } + return res; +} +function escapeLiteralCheckValue2(literal, refs) { + return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal) : literal; +} +var ALPHA_NUMERIC2 = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"); +function escapeNonAlphaNumeric2(source) { + let result = ""; + for (let i = 0; i < source.length; i++) { + if (!ALPHA_NUMERIC2.has(source[i])) { + result += "\\"; + } + result += source[i]; + } + return result; +} +function addFormat2(schema, value, message, refs) { + if (schema.format || schema.anyOf?.some((x) => x.format)) { + if (!schema.anyOf) { + schema.anyOf = []; + } + if (schema.format) { + schema.anyOf.push({ + format: schema.format, + ...schema.errorMessage && refs.errorMessages && { + errorMessage: { format: schema.errorMessage.format } + } + }); + delete schema.format; + if (schema.errorMessage) { + delete schema.errorMessage.format; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.anyOf.push({ + format: value, + ...message && refs.errorMessages && { errorMessage: { format: message } } + }); + } else { + setResponseValueAndErrors2(schema, "format", value, message, refs); + } +} +function addPattern2(schema, regex, message, refs) { + if (schema.pattern || schema.allOf?.some((x) => x.pattern)) { + if (!schema.allOf) { + schema.allOf = []; + } + if (schema.pattern) { + schema.allOf.push({ + pattern: schema.pattern, + ...schema.errorMessage && refs.errorMessages && { + errorMessage: { pattern: schema.errorMessage.pattern } + } + }); + delete schema.pattern; + if (schema.errorMessage) { + delete schema.errorMessage.pattern; + if (Object.keys(schema.errorMessage).length === 0) { + delete schema.errorMessage; + } + } + } + schema.allOf.push({ + pattern: stringifyRegExpWithFlags2(regex, refs), + ...message && refs.errorMessages && { errorMessage: { pattern: message } } + }); + } else { + setResponseValueAndErrors2(schema, "pattern", stringifyRegExpWithFlags2(regex, refs), message, refs); + } +} +function stringifyRegExpWithFlags2(regex, refs) { + if (!refs.applyRegexFlags || !regex.flags) { + return regex.source; + } + const flags = { + i: regex.flags.includes("i"), + m: regex.flags.includes("m"), + s: regex.flags.includes("s") + // `.` matches newlines + }; + const source = flags.i ? regex.source.toLowerCase() : regex.source; + let pattern = ""; + let isEscaped = false; + let inCharGroup = false; + let inCharRange = false; + for (let i = 0; i < source.length; i++) { + if (isEscaped) { + pattern += source[i]; + isEscaped = false; + continue; + } + if (flags.i) { + if (inCharGroup) { + if (source[i].match(/[a-z]/)) { + if (inCharRange) { + pattern += source[i]; + pattern += `${source[i - 2]}-${source[i]}`.toUpperCase(); + inCharRange = false; + } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) { + pattern += source[i]; + inCharRange = true; + } else { + pattern += `${source[i]}${source[i].toUpperCase()}`; + } + continue; + } + } else if (source[i].match(/[a-z]/)) { + pattern += `[${source[i]}${source[i].toUpperCase()}]`; + continue; + } + } + if (flags.m) { + if (source[i] === "^") { + pattern += `(^|(?<=[\r +]))`; + continue; + } else if (source[i] === "$") { + pattern += `($|(?=[\r +]))`; + continue; + } + } + if (flags.s && source[i] === ".") { + pattern += inCharGroup ? `${source[i]}\r +` : `[${source[i]}\r +]`; + continue; + } + pattern += source[i]; + if (source[i] === "\\") { + isEscaped = true; + } else if (inCharGroup && source[i] === "]") { + inCharGroup = false; + } else if (!inCharGroup && source[i] === "[") { + inCharGroup = true; + } + } + try { + new RegExp(pattern); + } catch { + console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`); + return regex.source; + } + return pattern; +} +function parseRecordDef2(def, refs) { + if (refs.target === "openAi") { + console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead."); + } + if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) { + return { + type: "object", + required: def.keyType._def.values, + properties: def.keyType._def.values.reduce((acc, key) => ({ + ...acc, + [key]: parseDef2(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", key] + }) ?? {} + }), {}), + additionalProperties: false + }; + } + const schema = { + type: "object", + additionalProperties: parseDef2(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"] + }) ?? {} + }; + if (refs.target === "openApi3") { + return schema; + } + if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.checks?.length) { + const { type, ...keyType } = parseStringDef2(def.keyType._def, refs); + return { + ...schema, + propertyNames: keyType + }; + } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) { + return { + ...schema, + propertyNames: { + enum: def.keyType._def.values + } + }; + } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.type._def.checks?.length) { + const { type, ...keyType } = parseBrandedDef2(def.keyType._def, refs); + return { + ...schema, + propertyNames: keyType + }; + } + return schema; +} +function parseMapDef2(def, refs) { + if (refs.mapStrategy === "record") { + return parseRecordDef2(def, refs); + } + const keys = parseDef2(def.keyType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "0"] + }) || {}; + const values = parseDef2(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items", "items", "1"] + }) || {}; + return { + type: "array", + maxItems: 125, + items: { + type: "array", + items: [keys, values], + minItems: 2, + maxItems: 2 + } + }; +} +function parseNativeEnumDef2(def) { + const object = def.values; + const actualKeys = Object.keys(def.values).filter((key) => { + return typeof object[object[key]] !== "number"; + }); + const actualValues = actualKeys.map((key) => object[key]); + const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values))); + return { + type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"], + enum: actualValues + }; +} +function parseNeverDef2() { + return { + not: {} + }; +} +function parseNullDef2(refs) { + return refs.target === "openApi3" ? { + enum: ["null"], + nullable: true + } : { + type: "null" + }; +} +var primitiveMappings2 = { + ZodString: "string", + ZodNumber: "number", + ZodBigInt: "integer", + ZodBoolean: "boolean", + ZodNull: "null" +}; +function parseUnionDef2(def, refs) { + if (refs.target === "openApi3") + return asAnyOf2(def, refs); + const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options; + if (options.every((x) => x._def.typeName in primitiveMappings2 && (!x._def.checks || !x._def.checks.length))) { + const types = options.reduce((types2, x) => { + const type = primitiveMappings2[x._def.typeName]; + return type && !types2.includes(type) ? [...types2, type] : types2; + }, []); + return { + type: types.length > 1 ? types : types[0] + }; + } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) { + const types = options.reduce((acc, x) => { + const type = typeof x._def.value; + switch (type) { + case "string": + case "number": + case "boolean": + return [...acc, type]; + case "bigint": + return [...acc, "integer"]; + case "object": + if (x._def.value === null) + return [...acc, "null"]; + case "symbol": + case "undefined": + case "function": + default: + return acc; + } + }, []); + if (types.length === options.length) { + const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i); + return { + type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0], + enum: options.reduce((acc, x) => { + return acc.includes(x._def.value) ? acc : [...acc, x._def.value]; + }, []) + }; + } + } else if (options.every((x) => x._def.typeName === "ZodEnum")) { + return { + type: "string", + enum: options.reduce((acc, x) => [ + ...acc, + ...x._def.values.filter((x2) => !acc.includes(x2)) + ], []) + }; + } + return asAnyOf2(def, refs); +} +var asAnyOf2 = (def, refs) => { + const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef2(x._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", `${i}`] + })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)); + return anyOf.length ? { anyOf } : void 0; +}; +function parseNullableDef2(def, refs) { + if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) { + if (refs.target === "openApi3") { + return { + type: primitiveMappings2[def.innerType._def.typeName], + nullable: true + }; + } + return { + type: [ + primitiveMappings2[def.innerType._def.typeName], + "null" + ] + }; + } + if (refs.target === "openApi3") { + const base2 = parseDef2(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath] + }); + if (base2 && "$ref" in base2) + return { allOf: [base2], nullable: true }; + return base2 && { ...base2, nullable: true }; + } + const base = parseDef2(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "0"] + }); + return base && { anyOf: [base, { type: "null" }] }; +} +function parseNumberDef2(def, refs) { + const res = { + type: "number" + }; + if (!def.checks) + return res; + for (const check of def.checks) { + switch (check.kind) { + case "int": + res.type = "integer"; + addErrorMessage2(res, "type", check.message, refs); + break; + case "min": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs); + } else { + setResponseValueAndErrors2(res, "exclusiveMinimum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMinimum = true; + } + setResponseValueAndErrors2(res, "minimum", check.value, check.message, refs); + } + break; + case "max": + if (refs.target === "jsonSchema7") { + if (check.inclusive) { + setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs); + } else { + setResponseValueAndErrors2(res, "exclusiveMaximum", check.value, check.message, refs); + } + } else { + if (!check.inclusive) { + res.exclusiveMaximum = true; + } + setResponseValueAndErrors2(res, "maximum", check.value, check.message, refs); + } + break; + case "multipleOf": + setResponseValueAndErrors2(res, "multipleOf", check.value, check.message, refs); + break; + } + } + return res; +} +function decideAdditionalProperties2(def, refs) { + if (refs.removeAdditionalStrategy === "strict") { + return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys !== "strict" : parseDef2(def.catchall._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"] + }) ?? true; + } else { + return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys === "passthrough" : parseDef2(def.catchall._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalProperties"] + }) ?? true; + } +} +function parseObjectDef2(def, refs) { + const forceOptionalIntoNullable = refs.target === "openAi"; + const result = { + type: "object", + ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => { + if (propDef === void 0 || propDef._def === void 0) + return acc; + let propOptional = propDef.isOptional(); + if (propOptional && forceOptionalIntoNullable) { + if (propDef instanceof ZodOptional2) { + propDef = propDef._def.innerType; + } + if (!propDef.isNullable()) { + propDef = propDef.nullable(); + } + propOptional = false; + } + const parsedDef = parseDef2(propDef._def, { + ...refs, + currentPath: [...refs.currentPath, "properties", propName], + propertyPath: [...refs.currentPath, "properties", propName] + }); + if (parsedDef === void 0) + return acc; + return { + properties: { ...acc.properties, [propName]: parsedDef }, + required: propOptional ? acc.required : [...acc.required, propName] + }; + }, { properties: {}, required: [] }), + additionalProperties: decideAdditionalProperties2(def, refs) + }; + if (!result.required.length) + delete result.required; + return result; +} +var parseOptionalDef2 = (def, refs) => { + if (refs.currentPath.toString() === refs.propertyPath?.toString()) { + return parseDef2(def.innerType._def, refs); + } + const innerSchema = parseDef2(def.innerType._def, { + ...refs, + currentPath: [...refs.currentPath, "anyOf", "1"] + }); + return innerSchema ? { + anyOf: [ + { + not: {} + }, + innerSchema + ] + } : {}; +}; +var parsePipelineDef2 = (def, refs) => { + if (refs.pipeStrategy === "input") { + return parseDef2(def.in._def, refs); + } else if (refs.pipeStrategy === "output") { + return parseDef2(def.out._def, refs); + } + const a = parseDef2(def.in._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", "0"] + }); + const b = parseDef2(def.out._def, { + ...refs, + currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"] + }); + return { + allOf: [a, b].filter((x) => x !== void 0) + }; +}; +function parsePromiseDef2(def, refs) { + return parseDef2(def.type._def, refs); +} +function parseSetDef2(def, refs) { + const items = parseDef2(def.valueType._def, { + ...refs, + currentPath: [...refs.currentPath, "items"] + }); + const schema = { + type: "array", + uniqueItems: true, + items + }; + if (def.minSize) { + setResponseValueAndErrors2(schema, "minItems", def.minSize.value, def.minSize.message, refs); + } + if (def.maxSize) { + setResponseValueAndErrors2(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs); + } + return schema; +} +function parseTupleDef2(def, refs) { + if (def.rest) { + return { + type: "array", + minItems: def.items.length, + items: def.items.map((x, i) => parseDef2(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`] + })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []), + additionalItems: parseDef2(def.rest._def, { + ...refs, + currentPath: [...refs.currentPath, "additionalItems"] + }) + }; + } else { + return { + type: "array", + minItems: def.items.length, + maxItems: def.items.length, + items: def.items.map((x, i) => parseDef2(x._def, { + ...refs, + currentPath: [...refs.currentPath, "items", `${i}`] + })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []) + }; + } +} +function parseUndefinedDef2() { + return { + not: {} + }; +} +function parseUnknownDef2() { + return {}; +} +var parseReadonlyDef2 = (def, refs) => { + return parseDef2(def.innerType._def, refs); +}; +var selectParser2 = (def, typeName, refs) => { + switch (typeName) { + case ZodFirstPartyTypeKind2.ZodString: + return parseStringDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodNumber: + return parseNumberDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodObject: + return parseObjectDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodBigInt: + return parseBigintDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodBoolean: + return parseBooleanDef2(); + case ZodFirstPartyTypeKind2.ZodDate: + return parseDateDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodUndefined: + return parseUndefinedDef2(); + case ZodFirstPartyTypeKind2.ZodNull: + return parseNullDef2(refs); + case ZodFirstPartyTypeKind2.ZodArray: + return parseArrayDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodUnion: + case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion: + return parseUnionDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodIntersection: + return parseIntersectionDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodTuple: + return parseTupleDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodRecord: + return parseRecordDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodLiteral: + return parseLiteralDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodEnum: + return parseEnumDef2(def); + case ZodFirstPartyTypeKind2.ZodNativeEnum: + return parseNativeEnumDef2(def); + case ZodFirstPartyTypeKind2.ZodNullable: + return parseNullableDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodOptional: + return parseOptionalDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodMap: + return parseMapDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodSet: + return parseSetDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodLazy: + return () => def.getter()._def; + case ZodFirstPartyTypeKind2.ZodPromise: + return parsePromiseDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodNaN: + case ZodFirstPartyTypeKind2.ZodNever: + return parseNeverDef2(); + case ZodFirstPartyTypeKind2.ZodEffects: + return parseEffectsDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodAny: + return parseAnyDef2(); + case ZodFirstPartyTypeKind2.ZodUnknown: + return parseUnknownDef2(); + case ZodFirstPartyTypeKind2.ZodDefault: + return parseDefaultDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodBranded: + return parseBrandedDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodReadonly: + return parseReadonlyDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodCatch: + return parseCatchDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodPipeline: + return parsePipelineDef2(def, refs); + case ZodFirstPartyTypeKind2.ZodFunction: + case ZodFirstPartyTypeKind2.ZodVoid: + case ZodFirstPartyTypeKind2.ZodSymbol: + return void 0; + default: + return /* @__PURE__ */ ((_2) => void 0)(typeName); + } +}; +function parseDef2(def, refs, forceResolution = false) { + const seenItem = refs.seen.get(def); + if (refs.override) { + const overrideResult = refs.override?.(def, refs, seenItem, forceResolution); + if (overrideResult !== ignoreOverride2) { + return overrideResult; + } + } + if (seenItem && !forceResolution) { + const seenSchema = get$ref2(seenItem, refs); + if (seenSchema !== void 0) { + return seenSchema; + } + } + const newItem = { def, path: refs.currentPath, jsonSchema: void 0 }; + refs.seen.set(def, newItem); + const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs); + const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter; + if (jsonSchema) { + addMeta2(def, refs, jsonSchema); + } + newItem.jsonSchema = jsonSchema; + return jsonSchema; +} +var get$ref2 = (item, refs) => { + switch (refs.$refStrategy) { + case "root": + return { $ref: item.path.join("/") }; + case "relative": + return { $ref: getRelativePath2(refs.currentPath, item.path) }; + case "none": + case "seen": { + if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) { + console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`); + return {}; + } + return refs.$refStrategy === "seen" ? {} : void 0; + } + } +}; +var getRelativePath2 = (pathA, pathB) => { + let i = 0; + for (; i < pathA.length && i < pathB.length; i++) { + if (pathA[i] !== pathB[i]) + break; + } + return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/"); +}; +var addMeta2 = (def, refs, jsonSchema) => { + if (def.description) { + jsonSchema.description = def.description; + if (refs.markdownDescription) { + jsonSchema.markdownDescription = def.description; + } + } + return jsonSchema; +}; +var zodToJsonSchema2 = (schema, options) => { + const refs = getRefs2(options); + const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({ + ...acc, + [name2]: parseDef2(schema2._def, { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name2] + }, true) ?? {} + }), {}) : void 0; + const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name; + const main = parseDef2(schema._def, name === void 0 ? refs : { + ...refs, + currentPath: [...refs.basePath, refs.definitionPath, name] + }, false) ?? {}; + const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0; + if (title !== void 0) { + main.title = title; + } + const combined = name === void 0 ? definitions ? { + ...main, + [refs.definitionPath]: definitions + } : main : { + $ref: [ + ...refs.$refStrategy === "relative" ? [] : refs.basePath, + refs.definitionPath, + name + ].join("/"), + [refs.definitionPath]: { + ...definitions, + [name]: main + } + }; + if (refs.target === "jsonSchema7") { + combined.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") { + combined.$schema = "https://json-schema.org/draft/2019-09/schema#"; + } + if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) { + console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property."); + } + return combined; +}; +function parseExpressRequestConfig(req) { + return JSON.parse(Buffer.from(req.query.config, "base64").toString()); +} +function parseAndValidateConfig(req, schema) { + let config = {}; + if (req.query.config) { + try { + config = parseExpressRequestConfig(req); + } catch (configError) { + return err({ + title: "Invalid config parameter", + status: 400, + detail: "Failed to parse config parameter", + instance: req.originalUrl + }); + } + } + for (const [key, value] of Object.entries(req.query)) { + if (key === "config" || key === "api_key" || key === "profile") + continue; + const pathParts = key.split("."); + const rawValue = Array.isArray(value) ? value[0] : value; + if (typeof rawValue !== "string") + continue; + let parsedValue = rawValue; + try { + parsedValue = JSON.parse(rawValue); + } catch { + } + import_lodash.default.set(config, pathParts, parsedValue); + } + if (schema) { + const result = schema.safeParse(config); + if (!result.success) { + const jsonSchema = zodToJsonSchema2(schema); + const errors = result.error.issues.map((issue) => { + let received = config; + for (const key of issue.path) { + if (received && typeof received === "object" && key in received) { + received = received[key]; + } else { + received = void 0; + break; + } + } + return { + param: issue.path.join(".") || "root", + pointer: `/${issue.path.join("/")}`, + reason: issue.message, + received + }; + }); + return err({ + title: "Invalid configuration parameters", + status: 422, + detail: "One or more config parameters are invalid.", + instance: req.originalUrl, + configSchema: jsonSchema, + errors + }); + } + return ok(result.data); + } + return ok(config); +} +var createLRUStore = (max = 1e3) => { + const cache = /* @__PURE__ */ new Map(); + return { + get: (id) => { + const t = cache.get(id); + if (!t) + return void 0; + cache.delete(id); + cache.set(id, t); + return t; + }, + set: (id, transport) => { + if (cache.has(id)) { + cache.delete(id); + } else if (cache.size >= max) { + const [lruId, lruTransport] = cache.entries().next().value; + lruTransport.close?.(); + cache.delete(lruId); + } + cache.set(id, transport); + }, + delete: (id) => cache.delete(id) + }; +}; +function createStatefulServer(createMcpServer, options) { + const app = options?.app ?? (0, import_express.default)(); + app.use("/mcp", import_express.default.json()); + const sessionStore = options?.sessionStore ?? createLRUStore(); + app.post("/mcp", async (req, res) => { + const sessionId = req.headers["mcp-session-id"]; + let transport; + if (sessionId && sessionStore.get(sessionId)) { + transport = sessionStore.get(sessionId); + } else if (!sessionId && isInitializeRequest(req.body)) { + const newSessionId = (0, import_node_crypto2.randomUUID)(); + transport = new StreamableHTTPServerTransport({ + sessionIdGenerator: () => newSessionId, + onsessioninitialized: (sessionId2) => { + sessionStore.set(sessionId2, transport); + } + }); + transport.onclose = () => { + if (transport.sessionId) { + sessionStore.delete?.(transport.sessionId); + } + }; + const configResult = parseAndValidateConfig(req, options?.schema); + if (!configResult.ok) { + const status = configResult.error.status || 400; + res.status(status).json(configResult.error); + return; + } + const config = configResult.value; + try { + const server = createMcpServer({ + sessionId: newSessionId, + config + }); + await server.connect(transport); + } catch (error) { + console.error("Error initializing server:", error); + res.status(500).json({ + jsonrpc: "2.0", + error: { + code: -32603, + message: "Error initializing server." + }, + id: null + }); + return; + } + } else { + res.status(400).json({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Session not found or expired" + }, + id: null + }); + return; + } + await transport.handleRequest(req, res, req.body); + }); + app.get("/.well-known/mcp-config", (req, res) => { + res.set("Content-Type", "application/schema+json; charset=utf-8"); + const baseSchema = options?.schema ? zodToJsonSchema2(options.schema) : { + type: "object", + properties: {}, + required: [] + }; + const configSchema2 = { + $schema: "https://json-schema.org/draft/2020-12/schema", + $id: `${req.protocol}://${req.get("host")}/.well-known/mcp-config`, + title: "MCP Session Configuration", + description: "Schema for the /mcp endpoint configuration", + "x-mcp-version": "1.0", + "x-query-style": "dot+bracket", + ...baseSchema + }; + res.json(configSchema2); + }); + app.get("/mcp", async (req, res) => { + const sessionId = req.headers["mcp-session-id"]; + if (!sessionId || !sessionStore.get(sessionId)) { + res.status(400).send("Invalid or expired session ID"); + return; + } + const transport = sessionStore.get(sessionId); + await transport.handleRequest(req, res); + }); + app.delete("/mcp", async (req, res) => { + const sessionId = req.headers["mcp-session-id"]; + if (!sessionId) { + res.status(400).json({ + jsonrpc: "2.0", + error: { + code: -32600, + message: "Missing mcp-session-id header" + }, + id: null + }); + return; + } + const transport = sessionStore.get(sessionId); + if (!transport) { + res.status(404).json({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Session not found or expired" + }, + id: null + }); + return; + } + transport.close?.(); + res.status(204).end(); + }); + return { app }; +} +var import_express2 = __toESM2(require_express2(), 1); +function createStatelessServer(createMcpServer, options) { + const app = options?.app ?? (0, import_express2.default)(); + app.use("/mcp", import_express2.default.json()); + app.post("/mcp", async (req, res) => { + try { + const configResult = parseAndValidateConfig(req, options?.schema); + if (!configResult.ok) { + const status = configResult.error.status || 400; + res.status(status).json(configResult.error); + return; + } + const config = configResult.value; + const server = createMcpServer({ + config + }); + const transport = new StreamableHTTPServerTransport({ + sessionIdGenerator: void 0 + }); + res.on("close", () => { + transport.close(); + server.close(); + }); + await server.connect(transport); + await transport.handleRequest(req, res, req.body); + } catch (error) { + console.error("Error handling MCP request:", error); + if (!res.headersSent) { + res.status(500).json({ + jsonrpc: "2.0", + error: { + code: -32603, + message: "Internal server error" + }, + id: null + }); + } + } + }); + app.get("/mcp", async (_req, res) => { + res.status(405).json({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Method not allowed." + }, + id: null + }); + }); + app.delete("/mcp", async (_req, res) => { + res.status(405).json({ + jsonrpc: "2.0", + error: { + code: -32e3, + message: "Method not allowed." + }, + id: null + }); + }); + app.get("/.well-known/mcp-config", (req, res) => { + res.set("Content-Type", "application/schema+json; charset=utf-8"); + const baseSchema = options?.schema ? zodToJsonSchema2(options.schema) : { + type: "object", + properties: {}, + required: [] + }; + const configSchema2 = { + $schema: "https://json-schema.org/draft/2020-12/schema", + $id: `${req.protocol}://${req.get("host")}/.well-known/mcp-config`, + title: "MCP Session Configuration", + description: "Schema for the /mcp endpoint configuration", + "x-mcp-version": "1.0", + "x-query-style": "dot+bracket", + ...baseSchema + }; + res.json(configSchema2); + }); + return { app }; +} +var import_chalk2 = __toESM2(require_source()); +var import_cors = __toESM2(require_lib4()); +var import_express3 = __toESM2(require_express2()); +var _entry = __toESM2((init_index(), __toCommonJS(index_exports))); +var entry = _entry; +async function startMcpServer() { + try { + const port = process.env.PORT || "8181"; + console.log( + `${import_chalk2.default.blue("[smithery]")} Starting MCP server on port ${port}` + ); + let server; + const app = (0, import_express3.default)(); + if (true) { + console.log(`${import_chalk2.default.blue("[smithery]")} Injecting cors middleware`); + app.use( + (0, import_cors.default)({ + exposedHeaders: ["mcp-session-id"] + }) + ); + } + if (entry.default && typeof entry.default === "function") { + console.log( + `${import_chalk2.default.blue("[smithery]")} Setting up ${entry.stateless ? "stateless" : "stateful"} server` + ); + if (entry.stateless) { + server = createStatelessServer( + entry.default, + { + schema: entry.configSchema, + app + } + ); + } else { + server = createStatefulServer(entry.default, { + schema: entry.configSchema, + app + }); + } + } else { + throw new Error( + "No valid server export found. Please export:\n- export default function({ sessionId, config }) { ... } (stateful)\n- export default function({ config }) { ... } (stateless)" + ); + } + server.app.listen(Number.parseInt(port)); + console.log( + `${import_chalk2.default.green("[smithery]")} MCP server started successfully on port ${port}` + ); + } catch (error) { + console.error( + `${import_chalk2.default.red("[smithery]")} Failed to start MCP server:`, + error + ); + process.exit(1); + } +} +startMcpServer(); +/*! Bundled license information: + +bytes/index.js: + (*! + * bytes + * Copyright(c) 2012-2014 TJ Holowaychuk + * Copyright(c) 2015 Jed Watson + * MIT Licensed + *) + +depd/index.js: + (*! + * depd + * Copyright(c) 2014-2018 Douglas Christopher Wilson + * MIT Licensed + *) + +statuses/index.js: + (*! + * statuses + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2016 Douglas Christopher Wilson + * MIT Licensed + *) + +toidentifier/index.js: + (*! + * toidentifier + * Copyright(c) 2016 Douglas Christopher Wilson + * MIT Licensed + *) + +http-errors/index.js: + (*! + * http-errors + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2016 Douglas Christopher Wilson + * MIT Licensed + *) + +unpipe/index.js: + (*! + * unpipe + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +raw-body/index.js: + (*! + * raw-body + * Copyright(c) 2013-2014 Jonathan Ong + * Copyright(c) 2014-2022 Douglas Christopher Wilson + * MIT Licensed + *) + +content-type/index.js: + (*! + * content-type + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +ee-first/index.js: + (*! + * ee-first + * Copyright(c) 2014 Jonathan Ong + * MIT Licensed + *) + +on-finished/index.js: + (*! + * on-finished + * Copyright(c) 2013 Jonathan Ong + * Copyright(c) 2014 Douglas Christopher Wilson + * MIT Licensed + *) + +body-parser/lib/read.js: +body-parser/lib/types/raw.js: +body-parser/lib/types/text.js: +body-parser/index.js: + (*! + * body-parser + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + *) + +mime-db/index.js: +mime-db/index.js: +mime-db/index.js: +mime-db/index.js: + (*! + * mime-db + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015-2022 Douglas Christopher Wilson + * MIT Licensed + *) + +mime-types/index.js: +mime-types/index.js: +mime-types/index.js: +mime-types/index.js: + (*! + * mime-types + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +media-typer/index.js: + (*! + * media-typer + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +type-is/index.js: + (*! + * type-is + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + *) + +body-parser/lib/types/json.js: +body-parser/lib/types/urlencoded.js: + (*! + * body-parser + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + *) + +encodeurl/index.js: + (*! + * encodeurl + * Copyright(c) 2016 Douglas Christopher Wilson + * MIT Licensed + *) + +escape-html/index.js: + (*! + * escape-html + * Copyright(c) 2012-2013 TJ Holowaychuk + * Copyright(c) 2015 Andreas Lubbe + * Copyright(c) 2015 Tiancheng "Timothy" Gu + * MIT Licensed + *) + +parseurl/index.js: + (*! + * parseurl + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +finalhandler/index.js: + (*! + * finalhandler + * Copyright(c) 2014-2022 Douglas Christopher Wilson + * MIT Licensed + *) + +express/lib/view.js: +express/lib/application.js: +express/lib/request.js: +express/lib/express.js: +express/index.js: + (*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + *) + +etag/index.js: + (*! + * etag + * Copyright(c) 2014-2016 Douglas Christopher Wilson + * MIT Licensed + *) + +forwarded/index.js: + (*! + * forwarded + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +proxy-addr/index.js: + (*! + * proxy-addr + * Copyright(c) 2014-2016 Douglas Christopher Wilson + * MIT Licensed + *) + +express/lib/utils.js: +express/lib/response.js: + (*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + *) + +router/lib/layer.js: +router/lib/route.js: +router/index.js: + (*! + * router + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2022 Douglas Christopher Wilson + * MIT Licensed + *) + +negotiator/index.js: + (*! + * negotiator + * Copyright(c) 2012 Federico Romero + * Copyright(c) 2012-2014 Isaac Z. Schlueter + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +accepts/index.js: + (*! + * accepts + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +fresh/index.js: + (*! + * fresh + * Copyright(c) 2012 TJ Holowaychuk + * Copyright(c) 2016-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +range-parser/index.js: + (*! + * range-parser + * Copyright(c) 2012-2014 TJ Holowaychuk + * Copyright(c) 2015-2016 Douglas Christopher Wilson + * MIT Licensed + *) + +safe-buffer/index.js: + (*! safe-buffer. MIT License. Feross Aboukhadijeh *) + +content-disposition/index.js: + (*! + * content-disposition + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +cookie/index.js: + (*! + * cookie + * Copyright(c) 2012-2014 Roman Shtylman + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + *) + +send/index.js: + (*! + * send + * Copyright(c) 2012 TJ Holowaychuk + * Copyright(c) 2014-2022 Douglas Christopher Wilson + * MIT Licensed + *) + +vary/index.js: + (*! + * vary + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + *) + +serve-static/index.js: + (*! + * serve-static + * Copyright(c) 2010 Sencha Inc. + * Copyright(c) 2011 TJ Holowaychuk + * Copyright(c) 2014-2016 Douglas Christopher Wilson + * MIT Licensed + *) + +lodash/lodash.js: + (** + * @license + * Lodash + * Copyright OpenJS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + *) + +object-assign/index.js: + (* + object-assign + (c) Sindre Sorhus + @license MIT + *) +*/ +/*! Bundled license information: + +uri-js/dist/es5/uri.all.js: + (** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js *) +*/ +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../node_modules/zod/v3/helpers/util.js", "../node_modules/zod/v3/ZodError.js", "../node_modules/zod/v3/locales/en.js", "../node_modules/zod/v3/errors.js", "../node_modules/zod/v3/helpers/parseUtil.js", "../node_modules/zod/v3/helpers/typeAliases.js", "../node_modules/zod/v3/helpers/errorUtil.js", "../node_modules/zod/v3/types.js", "../node_modules/zod/v3/external.js", "../node_modules/zod/index.js", "../node_modules/@modelcontextprotocol/sdk/src/types.ts", "../node_modules/@modelcontextprotocol/sdk/src/shared/protocol.ts", "../node_modules/uri-js/src/index.ts", "../node_modules/uri-js/src/schemes/urn-uuid.ts", "../node_modules/uri-js/src/schemes/urn.ts", "../node_modules/uri-js/src/schemes/mailto.ts", "../node_modules/uri-js/src/schemes/wss.ts", "../node_modules/uri-js/src/schemes/ws.ts", "../node_modules/uri-js/src/schemes/https.ts", "../node_modules/uri-js/src/schemes/http.ts", "../node_modules/uri-js/src/uri.ts", "../node_modules/uri-js/node_modules/punycode/punycode.es6.js", "../node_modules/uri-js/src/regexps-iri.ts", "../node_modules/uri-js/src/regexps-uri.ts", "../node_modules/uri-js/src/util.ts", "../node_modules/fast-deep-equal/index.js", "../node_modules/ajv/lib/compile/ucs2length.js", "../node_modules/ajv/lib/compile/util.js", "../node_modules/ajv/lib/compile/schema_obj.js", "../node_modules/json-schema-traverse/index.js", "../node_modules/ajv/lib/compile/resolve.js", "../node_modules/ajv/lib/compile/error_classes.js", "../node_modules/fast-json-stable-stringify/index.js", "../node_modules/ajv/lib/dotjs/validate.js", "../node_modules/ajv/lib/compile/index.js", "../node_modules/ajv/lib/cache.js", "../node_modules/ajv/lib/compile/formats.js", "../node_modules/ajv/lib/dotjs/ref.js", "../node_modules/ajv/lib/dotjs/allOf.js", "../node_modules/ajv/lib/dotjs/anyOf.js", "../node_modules/ajv/lib/dotjs/comment.js", "../node_modules/ajv/lib/dotjs/const.js", "../node_modules/ajv/lib/dotjs/contains.js", "../node_modules/ajv/lib/dotjs/dependencies.js", "../node_modules/ajv/lib/dotjs/enum.js", "../node_modules/ajv/lib/dotjs/format.js", "../node_modules/ajv/lib/dotjs/if.js", "../node_modules/ajv/lib/dotjs/items.js", "../node_modules/ajv/lib/dotjs/_limit.js", "../node_modules/ajv/lib/dotjs/_limitItems.js", "../node_modules/ajv/lib/dotjs/_limitLength.js", "../node_modules/ajv/lib/dotjs/_limitProperties.js", "../node_modules/ajv/lib/dotjs/multipleOf.js", "../node_modules/ajv/lib/dotjs/not.js", "../node_modules/ajv/lib/dotjs/oneOf.js", "../node_modules/ajv/lib/dotjs/pattern.js", "../node_modules/ajv/lib/dotjs/properties.js", "../node_modules/ajv/lib/dotjs/propertyNames.js", "../node_modules/ajv/lib/dotjs/required.js", "../node_modules/ajv/lib/dotjs/uniqueItems.js", "../node_modules/ajv/lib/dotjs/index.js", "../node_modules/ajv/lib/compile/rules.js", "../node_modules/ajv/lib/data.js", "../node_modules/ajv/lib/compile/async.js", "../node_modules/ajv/lib/dotjs/custom.js", "../node_modules/ajv/lib/refs/json-schema-draft-07.json", "../node_modules/ajv/lib/definition_schema.js", "../node_modules/ajv/lib/keyword.js", "../node_modules/ajv/lib/refs/data.json", "../node_modules/ajv/lib/ajv.js", "../node_modules/@modelcontextprotocol/sdk/src/server/index.ts", "../node_modules/zod-to-json-schema/dist/esm/Options.js", "../node_modules/zod-to-json-schema/dist/esm/Refs.js", "../node_modules/zod-to-json-schema/dist/esm/errorMessages.js", "../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/any.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/array.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/date.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/default.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/effects.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/enum.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/literal.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/string.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/record.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/map.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/never.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/null.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/union.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/number.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/object.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/optional.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/promise.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/set.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js", "../node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js", "../node_modules/zod-to-json-schema/dist/esm/selectParser.js", "../node_modules/zod-to-json-schema/dist/esm/parseDef.js", "../node_modules/zod-to-json-schema/dist/esm/parseTypes.js", "../node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js", "../node_modules/zod-to-json-schema/dist/esm/index.js", "../node_modules/chalk/source/vendor/ansi-styles/index.js", "../node_modules/chalk/source/vendor/supports-color/index.js", "../node_modules/chalk/source/utilities.js", "../node_modules/chalk/source/index.js", "../index.ts", "bootstrap:virtual:bootstrap"],
  "sourcesContent": ["export var util;\n(function (util) {\n    util.assertEqual = (_) => { };\n    function assertIs(_arg) { }\n    util.assertIs = assertIs;\n    function assertNever(_x) {\n        throw new Error();\n    }\n    util.assertNever = assertNever;\n    util.arrayToEnum = (items) => {\n        const obj = {};\n        for (const item of items) {\n            obj[item] = item;\n        }\n        return obj;\n    };\n    util.getValidEnumValues = (obj) => {\n        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== \"number\");\n        const filtered = {};\n        for (const k of validKeys) {\n            filtered[k] = obj[k];\n        }\n        return util.objectValues(filtered);\n    };\n    util.objectValues = (obj) => {\n        return util.objectKeys(obj).map(function (e) {\n            return obj[e];\n        });\n    };\n    util.objectKeys = typeof Object.keys === \"function\" // eslint-disable-line ban/ban\n        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban\n        : (object) => {\n            const keys = [];\n            for (const key in object) {\n                if (Object.prototype.hasOwnProperty.call(object, key)) {\n                    keys.push(key);\n                }\n            }\n            return keys;\n        };\n    util.find = (arr, checker) => {\n        for (const item of arr) {\n            if (checker(item))\n                return item;\n        }\n        return undefined;\n    };\n    util.isInteger = typeof Number.isInteger === \"function\"\n        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban\n        : (val) => typeof val === \"number\" && Number.isFinite(val) && Math.floor(val) === val;\n    function joinValues(array, separator = \" | \") {\n        return array.map((val) => (typeof val === \"string\" ? `'${val}'` : val)).join(separator);\n    }\n    util.joinValues = joinValues;\n    util.jsonStringifyReplacer = (_, value) => {\n        if (typeof value === \"bigint\") {\n            return value.toString();\n        }\n        return value;\n    };\n})(util || (util = {}));\nexport var objectUtil;\n(function (objectUtil) {\n    objectUtil.mergeShapes = (first, second) => {\n        return {\n            ...first,\n            ...second, // second overwrites first\n        };\n    };\n})(objectUtil || (objectUtil = {}));\nexport const ZodParsedType = util.arrayToEnum([\n    \"string\",\n    \"nan\",\n    \"number\",\n    \"integer\",\n    \"float\",\n    \"boolean\",\n    \"date\",\n    \"bigint\",\n    \"symbol\",\n    \"function\",\n    \"undefined\",\n    \"null\",\n    \"array\",\n    \"object\",\n    \"unknown\",\n    \"promise\",\n    \"void\",\n    \"never\",\n    \"map\",\n    \"set\",\n]);\nexport const getParsedType = (data) => {\n    const t = typeof data;\n    switch (t) {\n        case \"undefined\":\n            return ZodParsedType.undefined;\n        case \"string\":\n            return ZodParsedType.string;\n        case \"number\":\n            return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;\n        case \"boolean\":\n            return ZodParsedType.boolean;\n        case \"function\":\n            return ZodParsedType.function;\n        case \"bigint\":\n            return ZodParsedType.bigint;\n        case \"symbol\":\n            return ZodParsedType.symbol;\n        case \"object\":\n            if (Array.isArray(data)) {\n                return ZodParsedType.array;\n            }\n            if (data === null) {\n                return ZodParsedType.null;\n            }\n            if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n                return ZodParsedType.promise;\n            }\n            if (typeof Map !== \"undefined\" && data instanceof Map) {\n                return ZodParsedType.map;\n            }\n            if (typeof Set !== \"undefined\" && data instanceof Set) {\n                return ZodParsedType.set;\n            }\n            if (typeof Date !== \"undefined\" && data instanceof Date) {\n                return ZodParsedType.date;\n            }\n            return ZodParsedType.object;\n        default:\n            return ZodParsedType.unknown;\n    }\n};\n", "import { util } from \"./helpers/util.js\";\nexport const ZodIssueCode = util.arrayToEnum([\n    \"invalid_type\",\n    \"invalid_literal\",\n    \"custom\",\n    \"invalid_union\",\n    \"invalid_union_discriminator\",\n    \"invalid_enum_value\",\n    \"unrecognized_keys\",\n    \"invalid_arguments\",\n    \"invalid_return_type\",\n    \"invalid_date\",\n    \"invalid_string\",\n    \"too_small\",\n    \"too_big\",\n    \"invalid_intersection_types\",\n    \"not_multiple_of\",\n    \"not_finite\",\n]);\nexport const quotelessJson = (obj) => {\n    const json = JSON.stringify(obj, null, 2);\n    return json.replace(/\"([^\"]+)\":/g, \"$1:\");\n};\nexport class ZodError extends Error {\n    get errors() {\n        return this.issues;\n    }\n    constructor(issues) {\n        super();\n        this.issues = [];\n        this.addIssue = (sub) => {\n            this.issues = [...this.issues, sub];\n        };\n        this.addIssues = (subs = []) => {\n            this.issues = [...this.issues, ...subs];\n        };\n        const actualProto = new.target.prototype;\n        if (Object.setPrototypeOf) {\n            // eslint-disable-next-line ban/ban\n            Object.setPrototypeOf(this, actualProto);\n        }\n        else {\n            this.__proto__ = actualProto;\n        }\n        this.name = \"ZodError\";\n        this.issues = issues;\n    }\n    format(_mapper) {\n        const mapper = _mapper ||\n            function (issue) {\n                return issue.message;\n            };\n        const fieldErrors = { _errors: [] };\n        const processError = (error) => {\n            for (const issue of error.issues) {\n                if (issue.code === \"invalid_union\") {\n                    issue.unionErrors.map(processError);\n                }\n                else if (issue.code === \"invalid_return_type\") {\n                    processError(issue.returnTypeError);\n                }\n                else if (issue.code === \"invalid_arguments\") {\n                    processError(issue.argumentsError);\n                }\n                else if (issue.path.length === 0) {\n                    fieldErrors._errors.push(mapper(issue));\n                }\n                else {\n                    let curr = fieldErrors;\n                    let i = 0;\n                    while (i < issue.path.length) {\n                        const el = issue.path[i];\n                        const terminal = i === issue.path.length - 1;\n                        if (!terminal) {\n                            curr[el] = curr[el] || { _errors: [] };\n                            // if (typeof el === \"string\") {\n                            //   curr[el] = curr[el] || { _errors: [] };\n                            // } else if (typeof el === \"number\") {\n                            //   const errorArray: any = [];\n                            //   errorArray._errors = [];\n                            //   curr[el] = curr[el] || errorArray;\n                            // }\n                        }\n                        else {\n                            curr[el] = curr[el] || { _errors: [] };\n                            curr[el]._errors.push(mapper(issue));\n                        }\n                        curr = curr[el];\n                        i++;\n                    }\n                }\n            }\n        };\n        processError(this);\n        return fieldErrors;\n    }\n    static assert(value) {\n        if (!(value instanceof ZodError)) {\n            throw new Error(`Not a ZodError: ${value}`);\n        }\n    }\n    toString() {\n        return this.message;\n    }\n    get message() {\n        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);\n    }\n    get isEmpty() {\n        return this.issues.length === 0;\n    }\n    flatten(mapper = (issue) => issue.message) {\n        const fieldErrors = {};\n        const formErrors = [];\n        for (const sub of this.issues) {\n            if (sub.path.length > 0) {\n                const firstEl = sub.path[0];\n                fieldErrors[firstEl] = fieldErrors[firstEl] || [];\n                fieldErrors[firstEl].push(mapper(sub));\n            }\n            else {\n                formErrors.push(mapper(sub));\n            }\n        }\n        return { formErrors, fieldErrors };\n    }\n    get formErrors() {\n        return this.flatten();\n    }\n}\nZodError.create = (issues) => {\n    const error = new ZodError(issues);\n    return error;\n};\n", "import { ZodIssueCode } from \"../ZodError.js\";\nimport { util, ZodParsedType } from \"../helpers/util.js\";\nconst errorMap = (issue, _ctx) => {\n    let message;\n    switch (issue.code) {\n        case ZodIssueCode.invalid_type:\n            if (issue.received === ZodParsedType.undefined) {\n                message = \"Required\";\n            }\n            else {\n                message = `Expected ${issue.expected}, received ${issue.received}`;\n            }\n            break;\n        case ZodIssueCode.invalid_literal:\n            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;\n            break;\n        case ZodIssueCode.unrecognized_keys:\n            message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, \", \")}`;\n            break;\n        case ZodIssueCode.invalid_union:\n            message = `Invalid input`;\n            break;\n        case ZodIssueCode.invalid_union_discriminator:\n            message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;\n            break;\n        case ZodIssueCode.invalid_enum_value:\n            message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;\n            break;\n        case ZodIssueCode.invalid_arguments:\n            message = `Invalid function arguments`;\n            break;\n        case ZodIssueCode.invalid_return_type:\n            message = `Invalid function return type`;\n            break;\n        case ZodIssueCode.invalid_date:\n            message = `Invalid date`;\n            break;\n        case ZodIssueCode.invalid_string:\n            if (typeof issue.validation === \"object\") {\n                if (\"includes\" in issue.validation) {\n                    message = `Invalid input: must include \"${issue.validation.includes}\"`;\n                    if (typeof issue.validation.position === \"number\") {\n                        message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;\n                    }\n                }\n                else if (\"startsWith\" in issue.validation) {\n                    message = `Invalid input: must start with \"${issue.validation.startsWith}\"`;\n                }\n                else if (\"endsWith\" in issue.validation) {\n                    message = `Invalid input: must end with \"${issue.validation.endsWith}\"`;\n                }\n                else {\n                    util.assertNever(issue.validation);\n                }\n            }\n            else if (issue.validation !== \"regex\") {\n                message = `Invalid ${issue.validation}`;\n            }\n            else {\n                message = \"Invalid\";\n            }\n            break;\n        case ZodIssueCode.too_small:\n            if (issue.type === \"array\")\n                message = `Array must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;\n            else if (issue.type === \"string\")\n                message = `String must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;\n            else if (issue.type === \"number\")\n                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;\n            else if (issue.type === \"bigint\")\n                message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;\n            else if (issue.type === \"date\")\n                message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;\n            else\n                message = \"Invalid input\";\n            break;\n        case ZodIssueCode.too_big:\n            if (issue.type === \"array\")\n                message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;\n            else if (issue.type === \"string\")\n                message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;\n            else if (issue.type === \"number\")\n                message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n            else if (issue.type === \"bigint\")\n                message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n            else if (issue.type === \"date\")\n                message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;\n            else\n                message = \"Invalid input\";\n            break;\n        case ZodIssueCode.custom:\n            message = `Invalid input`;\n            break;\n        case ZodIssueCode.invalid_intersection_types:\n            message = `Intersection results could not be merged`;\n            break;\n        case ZodIssueCode.not_multiple_of:\n            message = `Number must be a multiple of ${issue.multipleOf}`;\n            break;\n        case ZodIssueCode.not_finite:\n            message = \"Number must be finite\";\n            break;\n        default:\n            message = _ctx.defaultError;\n            util.assertNever(issue);\n    }\n    return { message };\n};\nexport default errorMap;\n", "import defaultErrorMap from \"./locales/en.js\";\nlet overrideErrorMap = defaultErrorMap;\nexport { defaultErrorMap };\nexport function setErrorMap(map) {\n    overrideErrorMap = map;\n}\nexport function getErrorMap() {\n    return overrideErrorMap;\n}\n", "import { getErrorMap } from \"../errors.js\";\nimport defaultErrorMap from \"../locales/en.js\";\nexport const makeIssue = (params) => {\n    const { data, path, errorMaps, issueData } = params;\n    const fullPath = [...path, ...(issueData.path || [])];\n    const fullIssue = {\n        ...issueData,\n        path: fullPath,\n    };\n    if (issueData.message !== undefined) {\n        return {\n            ...issueData,\n            path: fullPath,\n            message: issueData.message,\n        };\n    }\n    let errorMessage = \"\";\n    const maps = errorMaps\n        .filter((m) => !!m)\n        .slice()\n        .reverse();\n    for (const map of maps) {\n        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;\n    }\n    return {\n        ...issueData,\n        path: fullPath,\n        message: errorMessage,\n    };\n};\nexport const EMPTY_PATH = [];\nexport function addIssueToContext(ctx, issueData) {\n    const overrideMap = getErrorMap();\n    const issue = makeIssue({\n        issueData: issueData,\n        data: ctx.data,\n        path: ctx.path,\n        errorMaps: [\n            ctx.common.contextualErrorMap, // contextual error map is first priority\n            ctx.schemaErrorMap, // then schema-bound map if available\n            overrideMap, // then global override map\n            overrideMap === defaultErrorMap ? undefined : defaultErrorMap, // then global default map\n        ].filter((x) => !!x),\n    });\n    ctx.common.issues.push(issue);\n}\nexport class ParseStatus {\n    constructor() {\n        this.value = \"valid\";\n    }\n    dirty() {\n        if (this.value === \"valid\")\n            this.value = \"dirty\";\n    }\n    abort() {\n        if (this.value !== \"aborted\")\n            this.value = \"aborted\";\n    }\n    static mergeArray(status, results) {\n        const arrayValue = [];\n        for (const s of results) {\n            if (s.status === \"aborted\")\n                return INVALID;\n            if (s.status === \"dirty\")\n                status.dirty();\n            arrayValue.push(s.value);\n        }\n        return { status: status.value, value: arrayValue };\n    }\n    static async mergeObjectAsync(status, pairs) {\n        const syncPairs = [];\n        for (const pair of pairs) {\n            const key = await pair.key;\n            const value = await pair.value;\n            syncPairs.push({\n                key,\n                value,\n            });\n        }\n        return ParseStatus.mergeObjectSync(status, syncPairs);\n    }\n    static mergeObjectSync(status, pairs) {\n        const finalObject = {};\n        for (const pair of pairs) {\n            const { key, value } = pair;\n            if (key.status === \"aborted\")\n                return INVALID;\n            if (value.status === \"aborted\")\n                return INVALID;\n            if (key.status === \"dirty\")\n                status.dirty();\n            if (value.status === \"dirty\")\n                status.dirty();\n            if (key.value !== \"__proto__\" && (typeof value.value !== \"undefined\" || pair.alwaysSet)) {\n                finalObject[key.value] = value.value;\n            }\n        }\n        return { status: status.value, value: finalObject };\n    }\n}\nexport const INVALID = Object.freeze({\n    status: \"aborted\",\n});\nexport const DIRTY = (value) => ({ status: \"dirty\", value });\nexport const OK = (value) => ({ status: \"valid\", value });\nexport const isAborted = (x) => x.status === \"aborted\";\nexport const isDirty = (x) => x.status === \"dirty\";\nexport const isValid = (x) => x.status === \"valid\";\nexport const isAsync = (x) => typeof Promise !== \"undefined\" && x instanceof Promise;\n", "export {};\n", "export var errorUtil;\n(function (errorUtil) {\n    errorUtil.errToObj = (message) => typeof message === \"string\" ? { message } : message || {};\n    // biome-ignore lint:\n    errorUtil.toString = (message) => typeof message === \"string\" ? message : message?.message;\n})(errorUtil || (errorUtil = {}));\n", "import { ZodError, ZodIssueCode, } from \"./ZodError.js\";\nimport { defaultErrorMap, getErrorMap } from \"./errors.js\";\nimport { errorUtil } from \"./helpers/errorUtil.js\";\nimport { DIRTY, INVALID, OK, ParseStatus, addIssueToContext, isAborted, isAsync, isDirty, isValid, makeIssue, } from \"./helpers/parseUtil.js\";\nimport { util, ZodParsedType, getParsedType } from \"./helpers/util.js\";\nclass ParseInputLazyPath {\n    constructor(parent, value, path, key) {\n        this._cachedPath = [];\n        this.parent = parent;\n        this.data = value;\n        this._path = path;\n        this._key = key;\n    }\n    get path() {\n        if (!this._cachedPath.length) {\n            if (Array.isArray(this._key)) {\n                this._cachedPath.push(...this._path, ...this._key);\n            }\n            else {\n                this._cachedPath.push(...this._path, this._key);\n            }\n        }\n        return this._cachedPath;\n    }\n}\nconst handleResult = (ctx, result) => {\n    if (isValid(result)) {\n        return { success: true, data: result.value };\n    }\n    else {\n        if (!ctx.common.issues.length) {\n            throw new Error(\"Validation failed but no issues detected.\");\n        }\n        return {\n            success: false,\n            get error() {\n                if (this._error)\n                    return this._error;\n                const error = new ZodError(ctx.common.issues);\n                this._error = error;\n                return this._error;\n            },\n        };\n    }\n};\nfunction processCreateParams(params) {\n    if (!params)\n        return {};\n    const { errorMap, invalid_type_error, required_error, description } = params;\n    if (errorMap && (invalid_type_error || required_error)) {\n        throw new Error(`Can't use \"invalid_type_error\" or \"required_error\" in conjunction with custom error map.`);\n    }\n    if (errorMap)\n        return { errorMap: errorMap, description };\n    const customMap = (iss, ctx) => {\n        const { message } = params;\n        if (iss.code === \"invalid_enum_value\") {\n            return { message: message ?? ctx.defaultError };\n        }\n        if (typeof ctx.data === \"undefined\") {\n            return { message: message ?? required_error ?? ctx.defaultError };\n        }\n        if (iss.code !== \"invalid_type\")\n            return { message: ctx.defaultError };\n        return { message: message ?? invalid_type_error ?? ctx.defaultError };\n    };\n    return { errorMap: customMap, description };\n}\nexport class ZodType {\n    get description() {\n        return this._def.description;\n    }\n    _getType(input) {\n        return getParsedType(input.data);\n    }\n    _getOrReturnCtx(input, ctx) {\n        return (ctx || {\n            common: input.parent.common,\n            data: input.data,\n            parsedType: getParsedType(input.data),\n            schemaErrorMap: this._def.errorMap,\n            path: input.path,\n            parent: input.parent,\n        });\n    }\n    _processInputParams(input) {\n        return {\n            status: new ParseStatus(),\n            ctx: {\n                common: input.parent.common,\n                data: input.data,\n                parsedType: getParsedType(input.data),\n                schemaErrorMap: this._def.errorMap,\n                path: input.path,\n                parent: input.parent,\n            },\n        };\n    }\n    _parseSync(input) {\n        const result = this._parse(input);\n        if (isAsync(result)) {\n            throw new Error(\"Synchronous parse encountered promise.\");\n        }\n        return result;\n    }\n    _parseAsync(input) {\n        const result = this._parse(input);\n        return Promise.resolve(result);\n    }\n    parse(data, params) {\n        const result = this.safeParse(data, params);\n        if (result.success)\n            return result.data;\n        throw result.error;\n    }\n    safeParse(data, params) {\n        const ctx = {\n            common: {\n                issues: [],\n                async: params?.async ?? false,\n                contextualErrorMap: params?.errorMap,\n            },\n            path: params?.path || [],\n            schemaErrorMap: this._def.errorMap,\n            parent: null,\n            data,\n            parsedType: getParsedType(data),\n        };\n        const result = this._parseSync({ data, path: ctx.path, parent: ctx });\n        return handleResult(ctx, result);\n    }\n    \"~validate\"(data) {\n        const ctx = {\n            common: {\n                issues: [],\n                async: !!this[\"~standard\"].async,\n            },\n            path: [],\n            schemaErrorMap: this._def.errorMap,\n            parent: null,\n            data,\n            parsedType: getParsedType(data),\n        };\n        if (!this[\"~standard\"].async) {\n            try {\n                const result = this._parseSync({ data, path: [], parent: ctx });\n                return isValid(result)\n                    ? {\n                        value: result.value,\n                    }\n                    : {\n                        issues: ctx.common.issues,\n                    };\n            }\n            catch (err) {\n                if (err?.message?.toLowerCase()?.includes(\"encountered\")) {\n                    this[\"~standard\"].async = true;\n                }\n                ctx.common = {\n                    issues: [],\n                    async: true,\n                };\n            }\n        }\n        return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result)\n            ? {\n                value: result.value,\n            }\n            : {\n                issues: ctx.common.issues,\n            });\n    }\n    async parseAsync(data, params) {\n        const result = await this.safeParseAsync(data, params);\n        if (result.success)\n            return result.data;\n        throw result.error;\n    }\n    async safeParseAsync(data, params) {\n        const ctx = {\n            common: {\n                issues: [],\n                contextualErrorMap: params?.errorMap,\n                async: true,\n            },\n            path: params?.path || [],\n            schemaErrorMap: this._def.errorMap,\n            parent: null,\n            data,\n            parsedType: getParsedType(data),\n        };\n        const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });\n        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));\n        return handleResult(ctx, result);\n    }\n    refine(check, message) {\n        const getIssueProperties = (val) => {\n            if (typeof message === \"string\" || typeof message === \"undefined\") {\n                return { message };\n            }\n            else if (typeof message === \"function\") {\n                return message(val);\n            }\n            else {\n                return message;\n            }\n        };\n        return this._refinement((val, ctx) => {\n            const result = check(val);\n            const setError = () => ctx.addIssue({\n                code: ZodIssueCode.custom,\n                ...getIssueProperties(val),\n            });\n            if (typeof Promise !== \"undefined\" && result instanceof Promise) {\n                return result.then((data) => {\n                    if (!data) {\n                        setError();\n                        return false;\n                    }\n                    else {\n                        return true;\n                    }\n                });\n            }\n            if (!result) {\n                setError();\n                return false;\n            }\n            else {\n                return true;\n            }\n        });\n    }\n    refinement(check, refinementData) {\n        return this._refinement((val, ctx) => {\n            if (!check(val)) {\n                ctx.addIssue(typeof refinementData === \"function\" ? refinementData(val, ctx) : refinementData);\n                return false;\n            }\n            else {\n                return true;\n            }\n        });\n    }\n    _refinement(refinement) {\n        return new ZodEffects({\n            schema: this,\n            typeName: ZodFirstPartyTypeKind.ZodEffects,\n            effect: { type: \"refinement\", refinement },\n        });\n    }\n    superRefine(refinement) {\n        return this._refinement(refinement);\n    }\n    constructor(def) {\n        /** Alias of safeParseAsync */\n        this.spa = this.safeParseAsync;\n        this._def = def;\n        this.parse = this.parse.bind(this);\n        this.safeParse = this.safeParse.bind(this);\n        this.parseAsync = this.parseAsync.bind(this);\n        this.safeParseAsync = this.safeParseAsync.bind(this);\n        this.spa = this.spa.bind(this);\n        this.refine = this.refine.bind(this);\n        this.refinement = this.refinement.bind(this);\n        this.superRefine = this.superRefine.bind(this);\n        this.optional = this.optional.bind(this);\n        this.nullable = this.nullable.bind(this);\n        this.nullish = this.nullish.bind(this);\n        this.array = this.array.bind(this);\n        this.promise = this.promise.bind(this);\n        this.or = this.or.bind(this);\n        this.and = this.and.bind(this);\n        this.transform = this.transform.bind(this);\n        this.brand = this.brand.bind(this);\n        this.default = this.default.bind(this);\n        this.catch = this.catch.bind(this);\n        this.describe = this.describe.bind(this);\n        this.pipe = this.pipe.bind(this);\n        this.readonly = this.readonly.bind(this);\n        this.isNullable = this.isNullable.bind(this);\n        this.isOptional = this.isOptional.bind(this);\n        this[\"~standard\"] = {\n            version: 1,\n            vendor: \"zod\",\n            validate: (data) => this[\"~validate\"](data),\n        };\n    }\n    optional() {\n        return ZodOptional.create(this, this._def);\n    }\n    nullable() {\n        return ZodNullable.create(this, this._def);\n    }\n    nullish() {\n        return this.nullable().optional();\n    }\n    array() {\n        return ZodArray.create(this);\n    }\n    promise() {\n        return ZodPromise.create(this, this._def);\n    }\n    or(option) {\n        return ZodUnion.create([this, option], this._def);\n    }\n    and(incoming) {\n        return ZodIntersection.create(this, incoming, this._def);\n    }\n    transform(transform) {\n        return new ZodEffects({\n            ...processCreateParams(this._def),\n            schema: this,\n            typeName: ZodFirstPartyTypeKind.ZodEffects,\n            effect: { type: \"transform\", transform },\n        });\n    }\n    default(def) {\n        const defaultValueFunc = typeof def === \"function\" ? def : () => def;\n        return new ZodDefault({\n            ...processCreateParams(this._def),\n            innerType: this,\n            defaultValue: defaultValueFunc,\n            typeName: ZodFirstPartyTypeKind.ZodDefault,\n        });\n    }\n    brand() {\n        return new ZodBranded({\n            typeName: ZodFirstPartyTypeKind.ZodBranded,\n            type: this,\n            ...processCreateParams(this._def),\n        });\n    }\n    catch(def) {\n        const catchValueFunc = typeof def === \"function\" ? def : () => def;\n        return new ZodCatch({\n            ...processCreateParams(this._def),\n            innerType: this,\n            catchValue: catchValueFunc,\n            typeName: ZodFirstPartyTypeKind.ZodCatch,\n        });\n    }\n    describe(description) {\n        const This = this.constructor;\n        return new This({\n            ...this._def,\n            description,\n        });\n    }\n    pipe(target) {\n        return ZodPipeline.create(this, target);\n    }\n    readonly() {\n        return ZodReadonly.create(this);\n    }\n    isOptional() {\n        return this.safeParse(undefined).success;\n    }\n    isNullable() {\n        return this.safeParse(null).success;\n    }\n}\nconst cuidRegex = /^c[^\\s-]{8,}$/i;\nconst cuid2Regex = /^[0-9a-z]+$/;\nconst ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;\n// const uuidRegex =\n//   /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;\nconst uuidRegex = /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/i;\nconst nanoidRegex = /^[a-z0-9_-]{21}$/i;\nconst jwtRegex = /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/;\nconst durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\n// from https://stackoverflow.com/a/46181/1550155\n// old version: too slow, didn't support unicode\n// const emailRegex = /^((([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+(\\.([a-z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(\\\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|\\d|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))\\.)+(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])|(([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])([a-z]|\\d|-|\\.|_|~|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])*([a-z]|[\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF])))$/i;\n//old email regex\n// const emailRegex = /^(([^<>()[\\].,;:\\s@\"]+(\\.[^<>()[\\].,;:\\s@\"]+)*)|(\".+\"))@((?!-)([^<>()[\\].,;:\\s@\"]+\\.)+[^<>()[\\].,;:\\s@\"]{1,})[^-<>()[\\].,;:\\s@\"]$/i;\n// eslint-disable-next-line\n// const emailRegex =\n//   /^(([^<>()[\\]\\\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@((\\[(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\])|(\\[IPv6:(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))\\])|([A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])*(\\.[A-Za-z]{2,})+))$/;\n// const emailRegex =\n//   /^[a-zA-Z0-9\\.\\!\\#\\$\\%\\&\\'\\*\\+\\/\\=\\?\\^\\_\\`\\{\\|\\}\\~\\-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\n// const emailRegex =\n//   /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$/i;\nconst emailRegex = /^(?!\\.)(?!.*\\.\\.)([A-Z0-9_'+\\-\\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\\-]*\\.)+[A-Z]{2,}$/i;\n// const emailRegex =\n//   /^[a-z0-9.!#$%&\u2019*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\\.[a-z0-9\\-]+)*$/i;\n// from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression\nconst _emojiRegex = `^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$`;\nlet emojiRegex;\n// faster, simpler, safer\nconst ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nconst ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/;\n// const ipv6Regex =\n// /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;\nconst ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;\nconst ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\n// https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript\nconst base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;\n// https://base64.guru/standards/base64url\nconst base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;\n// simple\n// const dateRegexSource = `\\\\d{4}-\\\\d{2}-\\\\d{2}`;\n// no leap year validation\n// const dateRegexSource = `\\\\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\\\\d|2\\\\d))`;\n// with leap year validation\nconst dateRegexSource = `((\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\\\d|30)|(02)-(0[1-9]|1\\\\d|2[0-8])))`;\nconst dateRegex = new RegExp(`^${dateRegexSource}$`);\nfunction timeRegexSource(args) {\n    let secondsRegexSource = `[0-5]\\\\d`;\n    if (args.precision) {\n        secondsRegexSource = `${secondsRegexSource}\\\\.\\\\d{${args.precision}}`;\n    }\n    else if (args.precision == null) {\n        secondsRegexSource = `${secondsRegexSource}(\\\\.\\\\d+)?`;\n    }\n    const secondsQuantifier = args.precision ? \"+\" : \"?\"; // require seconds if precision is nonzero\n    return `([01]\\\\d|2[0-3]):[0-5]\\\\d(:${secondsRegexSource})${secondsQuantifier}`;\n}\nfunction timeRegex(args) {\n    return new RegExp(`^${timeRegexSource(args)}$`);\n}\n// Adapted from https://stackoverflow.com/a/3143231\nexport function datetimeRegex(args) {\n    let regex = `${dateRegexSource}T${timeRegexSource(args)}`;\n    const opts = [];\n    opts.push(args.local ? `Z?` : `Z`);\n    if (args.offset)\n        opts.push(`([+-]\\\\d{2}:?\\\\d{2})`);\n    regex = `${regex}(${opts.join(\"|\")})`;\n    return new RegExp(`^${regex}$`);\n}\nfunction isValidIP(ip, version) {\n    if ((version === \"v4\" || !version) && ipv4Regex.test(ip)) {\n        return true;\n    }\n    if ((version === \"v6\" || !version) && ipv6Regex.test(ip)) {\n        return true;\n    }\n    return false;\n}\nfunction isValidJWT(jwt, alg) {\n    if (!jwtRegex.test(jwt))\n        return false;\n    try {\n        const [header] = jwt.split(\".\");\n        if (!header)\n            return false;\n        // Convert base64url to base64\n        const base64 = header\n            .replace(/-/g, \"+\")\n            .replace(/_/g, \"/\")\n            .padEnd(header.length + ((4 - (header.length % 4)) % 4), \"=\");\n        const decoded = JSON.parse(atob(base64));\n        if (typeof decoded !== \"object\" || decoded === null)\n            return false;\n        if (\"typ\" in decoded && decoded?.typ !== \"JWT\")\n            return false;\n        if (!decoded.alg)\n            return false;\n        if (alg && decoded.alg !== alg)\n            return false;\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\nfunction isValidCidr(ip, version) {\n    if ((version === \"v4\" || !version) && ipv4CidrRegex.test(ip)) {\n        return true;\n    }\n    if ((version === \"v6\" || !version) && ipv6CidrRegex.test(ip)) {\n        return true;\n    }\n    return false;\n}\nexport class ZodString extends ZodType {\n    _parse(input) {\n        if (this._def.coerce) {\n            input.data = String(input.data);\n        }\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.string) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.string,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const status = new ParseStatus();\n        let ctx = undefined;\n        for (const check of this._def.checks) {\n            if (check.kind === \"min\") {\n                if (input.data.length < check.value) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_small,\n                        minimum: check.value,\n                        type: \"string\",\n                        inclusive: true,\n                        exact: false,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"max\") {\n                if (input.data.length > check.value) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_big,\n                        maximum: check.value,\n                        type: \"string\",\n                        inclusive: true,\n                        exact: false,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"length\") {\n                const tooBig = input.data.length > check.value;\n                const tooSmall = input.data.length < check.value;\n                if (tooBig || tooSmall) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    if (tooBig) {\n                        addIssueToContext(ctx, {\n                            code: ZodIssueCode.too_big,\n                            maximum: check.value,\n                            type: \"string\",\n                            inclusive: true,\n                            exact: true,\n                            message: check.message,\n                        });\n                    }\n                    else if (tooSmall) {\n                        addIssueToContext(ctx, {\n                            code: ZodIssueCode.too_small,\n                            minimum: check.value,\n                            type: \"string\",\n                            inclusive: true,\n                            exact: true,\n                            message: check.message,\n                        });\n                    }\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"email\") {\n                if (!emailRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"email\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"emoji\") {\n                if (!emojiRegex) {\n                    emojiRegex = new RegExp(_emojiRegex, \"u\");\n                }\n                if (!emojiRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"emoji\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"uuid\") {\n                if (!uuidRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"uuid\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"nanoid\") {\n                if (!nanoidRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"nanoid\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"cuid\") {\n                if (!cuidRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"cuid\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"cuid2\") {\n                if (!cuid2Regex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"cuid2\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"ulid\") {\n                if (!ulidRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"ulid\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"url\") {\n                try {\n                    new URL(input.data);\n                }\n                catch {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"url\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"regex\") {\n                check.regex.lastIndex = 0;\n                const testResult = check.regex.test(input.data);\n                if (!testResult) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"regex\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"trim\") {\n                input.data = input.data.trim();\n            }\n            else if (check.kind === \"includes\") {\n                if (!input.data.includes(check.value, check.position)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: { includes: check.value, position: check.position },\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"toLowerCase\") {\n                input.data = input.data.toLowerCase();\n            }\n            else if (check.kind === \"toUpperCase\") {\n                input.data = input.data.toUpperCase();\n            }\n            else if (check.kind === \"startsWith\") {\n                if (!input.data.startsWith(check.value)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: { startsWith: check.value },\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"endsWith\") {\n                if (!input.data.endsWith(check.value)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: { endsWith: check.value },\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"datetime\") {\n                const regex = datetimeRegex(check);\n                if (!regex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: \"datetime\",\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"date\") {\n                const regex = dateRegex;\n                if (!regex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: \"date\",\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"time\") {\n                const regex = timeRegex(check);\n                if (!regex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_string,\n                        validation: \"time\",\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"duration\") {\n                if (!durationRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"duration\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"ip\") {\n                if (!isValidIP(input.data, check.version)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"ip\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"jwt\") {\n                if (!isValidJWT(input.data, check.alg)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"jwt\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"cidr\") {\n                if (!isValidCidr(input.data, check.version)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"cidr\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"base64\") {\n                if (!base64Regex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"base64\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"base64url\") {\n                if (!base64urlRegex.test(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        validation: \"base64url\",\n                        code: ZodIssueCode.invalid_string,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else {\n                util.assertNever(check);\n            }\n        }\n        return { status: status.value, value: input.data };\n    }\n    _regex(regex, validation, message) {\n        return this.refinement((data) => regex.test(data), {\n            validation,\n            code: ZodIssueCode.invalid_string,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    _addCheck(check) {\n        return new ZodString({\n            ...this._def,\n            checks: [...this._def.checks, check],\n        });\n    }\n    email(message) {\n        return this._addCheck({ kind: \"email\", ...errorUtil.errToObj(message) });\n    }\n    url(message) {\n        return this._addCheck({ kind: \"url\", ...errorUtil.errToObj(message) });\n    }\n    emoji(message) {\n        return this._addCheck({ kind: \"emoji\", ...errorUtil.errToObj(message) });\n    }\n    uuid(message) {\n        return this._addCheck({ kind: \"uuid\", ...errorUtil.errToObj(message) });\n    }\n    nanoid(message) {\n        return this._addCheck({ kind: \"nanoid\", ...errorUtil.errToObj(message) });\n    }\n    cuid(message) {\n        return this._addCheck({ kind: \"cuid\", ...errorUtil.errToObj(message) });\n    }\n    cuid2(message) {\n        return this._addCheck({ kind: \"cuid2\", ...errorUtil.errToObj(message) });\n    }\n    ulid(message) {\n        return this._addCheck({ kind: \"ulid\", ...errorUtil.errToObj(message) });\n    }\n    base64(message) {\n        return this._addCheck({ kind: \"base64\", ...errorUtil.errToObj(message) });\n    }\n    base64url(message) {\n        // base64url encoding is a modification of base64 that can safely be used in URLs and filenames\n        return this._addCheck({\n            kind: \"base64url\",\n            ...errorUtil.errToObj(message),\n        });\n    }\n    jwt(options) {\n        return this._addCheck({ kind: \"jwt\", ...errorUtil.errToObj(options) });\n    }\n    ip(options) {\n        return this._addCheck({ kind: \"ip\", ...errorUtil.errToObj(options) });\n    }\n    cidr(options) {\n        return this._addCheck({ kind: \"cidr\", ...errorUtil.errToObj(options) });\n    }\n    datetime(options) {\n        if (typeof options === \"string\") {\n            return this._addCheck({\n                kind: \"datetime\",\n                precision: null,\n                offset: false,\n                local: false,\n                message: options,\n            });\n        }\n        return this._addCheck({\n            kind: \"datetime\",\n            precision: typeof options?.precision === \"undefined\" ? null : options?.precision,\n            offset: options?.offset ?? false,\n            local: options?.local ?? false,\n            ...errorUtil.errToObj(options?.message),\n        });\n    }\n    date(message) {\n        return this._addCheck({ kind: \"date\", message });\n    }\n    time(options) {\n        if (typeof options === \"string\") {\n            return this._addCheck({\n                kind: \"time\",\n                precision: null,\n                message: options,\n            });\n        }\n        return this._addCheck({\n            kind: \"time\",\n            precision: typeof options?.precision === \"undefined\" ? null : options?.precision,\n            ...errorUtil.errToObj(options?.message),\n        });\n    }\n    duration(message) {\n        return this._addCheck({ kind: \"duration\", ...errorUtil.errToObj(message) });\n    }\n    regex(regex, message) {\n        return this._addCheck({\n            kind: \"regex\",\n            regex: regex,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    includes(value, options) {\n        return this._addCheck({\n            kind: \"includes\",\n            value: value,\n            position: options?.position,\n            ...errorUtil.errToObj(options?.message),\n        });\n    }\n    startsWith(value, message) {\n        return this._addCheck({\n            kind: \"startsWith\",\n            value: value,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    endsWith(value, message) {\n        return this._addCheck({\n            kind: \"endsWith\",\n            value: value,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    min(minLength, message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: minLength,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    max(maxLength, message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: maxLength,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    length(len, message) {\n        return this._addCheck({\n            kind: \"length\",\n            value: len,\n            ...errorUtil.errToObj(message),\n        });\n    }\n    /**\n     * Equivalent to `.min(1)`\n     */\n    nonempty(message) {\n        return this.min(1, errorUtil.errToObj(message));\n    }\n    trim() {\n        return new ZodString({\n            ...this._def,\n            checks: [...this._def.checks, { kind: \"trim\" }],\n        });\n    }\n    toLowerCase() {\n        return new ZodString({\n            ...this._def,\n            checks: [...this._def.checks, { kind: \"toLowerCase\" }],\n        });\n    }\n    toUpperCase() {\n        return new ZodString({\n            ...this._def,\n            checks: [...this._def.checks, { kind: \"toUpperCase\" }],\n        });\n    }\n    get isDatetime() {\n        return !!this._def.checks.find((ch) => ch.kind === \"datetime\");\n    }\n    get isDate() {\n        return !!this._def.checks.find((ch) => ch.kind === \"date\");\n    }\n    get isTime() {\n        return !!this._def.checks.find((ch) => ch.kind === \"time\");\n    }\n    get isDuration() {\n        return !!this._def.checks.find((ch) => ch.kind === \"duration\");\n    }\n    get isEmail() {\n        return !!this._def.checks.find((ch) => ch.kind === \"email\");\n    }\n    get isURL() {\n        return !!this._def.checks.find((ch) => ch.kind === \"url\");\n    }\n    get isEmoji() {\n        return !!this._def.checks.find((ch) => ch.kind === \"emoji\");\n    }\n    get isUUID() {\n        return !!this._def.checks.find((ch) => ch.kind === \"uuid\");\n    }\n    get isNANOID() {\n        return !!this._def.checks.find((ch) => ch.kind === \"nanoid\");\n    }\n    get isCUID() {\n        return !!this._def.checks.find((ch) => ch.kind === \"cuid\");\n    }\n    get isCUID2() {\n        return !!this._def.checks.find((ch) => ch.kind === \"cuid2\");\n    }\n    get isULID() {\n        return !!this._def.checks.find((ch) => ch.kind === \"ulid\");\n    }\n    get isIP() {\n        return !!this._def.checks.find((ch) => ch.kind === \"ip\");\n    }\n    get isCIDR() {\n        return !!this._def.checks.find((ch) => ch.kind === \"cidr\");\n    }\n    get isBase64() {\n        return !!this._def.checks.find((ch) => ch.kind === \"base64\");\n    }\n    get isBase64url() {\n        // base64url encoding is a modification of base64 that can safely be used in URLs and filenames\n        return !!this._def.checks.find((ch) => ch.kind === \"base64url\");\n    }\n    get minLength() {\n        let min = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"min\") {\n                if (min === null || ch.value > min)\n                    min = ch.value;\n            }\n        }\n        return min;\n    }\n    get maxLength() {\n        let max = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"max\") {\n                if (max === null || ch.value < max)\n                    max = ch.value;\n            }\n        }\n        return max;\n    }\n}\nZodString.create = (params) => {\n    return new ZodString({\n        checks: [],\n        typeName: ZodFirstPartyTypeKind.ZodString,\n        coerce: params?.coerce ?? false,\n        ...processCreateParams(params),\n    });\n};\n// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034\nfunction floatSafeRemainder(val, step) {\n    const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n    const stepDecCount = (step.toString().split(\".\")[1] || \"\").length;\n    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n    const valInt = Number.parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n    const stepInt = Number.parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n    return (valInt % stepInt) / 10 ** decCount;\n}\nexport class ZodNumber extends ZodType {\n    constructor() {\n        super(...arguments);\n        this.min = this.gte;\n        this.max = this.lte;\n        this.step = this.multipleOf;\n    }\n    _parse(input) {\n        if (this._def.coerce) {\n            input.data = Number(input.data);\n        }\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.number) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.number,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        let ctx = undefined;\n        const status = new ParseStatus();\n        for (const check of this._def.checks) {\n            if (check.kind === \"int\") {\n                if (!util.isInteger(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.invalid_type,\n                        expected: \"integer\",\n                        received: \"float\",\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"min\") {\n                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n                if (tooSmall) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_small,\n                        minimum: check.value,\n                        type: \"number\",\n                        inclusive: check.inclusive,\n                        exact: false,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"max\") {\n                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n                if (tooBig) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_big,\n                        maximum: check.value,\n                        type: \"number\",\n                        inclusive: check.inclusive,\n                        exact: false,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"multipleOf\") {\n                if (floatSafeRemainder(input.data, check.value) !== 0) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.not_multiple_of,\n                        multipleOf: check.value,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"finite\") {\n                if (!Number.isFinite(input.data)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.not_finite,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else {\n                util.assertNever(check);\n            }\n        }\n        return { status: status.value, value: input.data };\n    }\n    gte(value, message) {\n        return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n    }\n    gt(value, message) {\n        return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n    }\n    lte(value, message) {\n        return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n    }\n    lt(value, message) {\n        return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n    }\n    setLimit(kind, value, inclusive, message) {\n        return new ZodNumber({\n            ...this._def,\n            checks: [\n                ...this._def.checks,\n                {\n                    kind,\n                    value,\n                    inclusive,\n                    message: errorUtil.toString(message),\n                },\n            ],\n        });\n    }\n    _addCheck(check) {\n        return new ZodNumber({\n            ...this._def,\n            checks: [...this._def.checks, check],\n        });\n    }\n    int(message) {\n        return this._addCheck({\n            kind: \"int\",\n            message: errorUtil.toString(message),\n        });\n    }\n    positive(message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: 0,\n            inclusive: false,\n            message: errorUtil.toString(message),\n        });\n    }\n    negative(message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: 0,\n            inclusive: false,\n            message: errorUtil.toString(message),\n        });\n    }\n    nonpositive(message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: 0,\n            inclusive: true,\n            message: errorUtil.toString(message),\n        });\n    }\n    nonnegative(message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: 0,\n            inclusive: true,\n            message: errorUtil.toString(message),\n        });\n    }\n    multipleOf(value, message) {\n        return this._addCheck({\n            kind: \"multipleOf\",\n            value: value,\n            message: errorUtil.toString(message),\n        });\n    }\n    finite(message) {\n        return this._addCheck({\n            kind: \"finite\",\n            message: errorUtil.toString(message),\n        });\n    }\n    safe(message) {\n        return this._addCheck({\n            kind: \"min\",\n            inclusive: true,\n            value: Number.MIN_SAFE_INTEGER,\n            message: errorUtil.toString(message),\n        })._addCheck({\n            kind: \"max\",\n            inclusive: true,\n            value: Number.MAX_SAFE_INTEGER,\n            message: errorUtil.toString(message),\n        });\n    }\n    get minValue() {\n        let min = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"min\") {\n                if (min === null || ch.value > min)\n                    min = ch.value;\n            }\n        }\n        return min;\n    }\n    get maxValue() {\n        let max = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"max\") {\n                if (max === null || ch.value < max)\n                    max = ch.value;\n            }\n        }\n        return max;\n    }\n    get isInt() {\n        return !!this._def.checks.find((ch) => ch.kind === \"int\" || (ch.kind === \"multipleOf\" && util.isInteger(ch.value)));\n    }\n    get isFinite() {\n        let max = null;\n        let min = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"finite\" || ch.kind === \"int\" || ch.kind === \"multipleOf\") {\n                return true;\n            }\n            else if (ch.kind === \"min\") {\n                if (min === null || ch.value > min)\n                    min = ch.value;\n            }\n            else if (ch.kind === \"max\") {\n                if (max === null || ch.value < max)\n                    max = ch.value;\n            }\n        }\n        return Number.isFinite(min) && Number.isFinite(max);\n    }\n}\nZodNumber.create = (params) => {\n    return new ZodNumber({\n        checks: [],\n        typeName: ZodFirstPartyTypeKind.ZodNumber,\n        coerce: params?.coerce || false,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodBigInt extends ZodType {\n    constructor() {\n        super(...arguments);\n        this.min = this.gte;\n        this.max = this.lte;\n    }\n    _parse(input) {\n        if (this._def.coerce) {\n            try {\n                input.data = BigInt(input.data);\n            }\n            catch {\n                return this._getInvalidInput(input);\n            }\n        }\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.bigint) {\n            return this._getInvalidInput(input);\n        }\n        let ctx = undefined;\n        const status = new ParseStatus();\n        for (const check of this._def.checks) {\n            if (check.kind === \"min\") {\n                const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n                if (tooSmall) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_small,\n                        type: \"bigint\",\n                        minimum: check.value,\n                        inclusive: check.inclusive,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"max\") {\n                const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n                if (tooBig) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_big,\n                        type: \"bigint\",\n                        maximum: check.value,\n                        inclusive: check.inclusive,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"multipleOf\") {\n                if (input.data % check.value !== BigInt(0)) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.not_multiple_of,\n                        multipleOf: check.value,\n                        message: check.message,\n                    });\n                    status.dirty();\n                }\n            }\n            else {\n                util.assertNever(check);\n            }\n        }\n        return { status: status.value, value: input.data };\n    }\n    _getInvalidInput(input) {\n        const ctx = this._getOrReturnCtx(input);\n        addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_type,\n            expected: ZodParsedType.bigint,\n            received: ctx.parsedType,\n        });\n        return INVALID;\n    }\n    gte(value, message) {\n        return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n    }\n    gt(value, message) {\n        return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n    }\n    lte(value, message) {\n        return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n    }\n    lt(value, message) {\n        return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n    }\n    setLimit(kind, value, inclusive, message) {\n        return new ZodBigInt({\n            ...this._def,\n            checks: [\n                ...this._def.checks,\n                {\n                    kind,\n                    value,\n                    inclusive,\n                    message: errorUtil.toString(message),\n                },\n            ],\n        });\n    }\n    _addCheck(check) {\n        return new ZodBigInt({\n            ...this._def,\n            checks: [...this._def.checks, check],\n        });\n    }\n    positive(message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: BigInt(0),\n            inclusive: false,\n            message: errorUtil.toString(message),\n        });\n    }\n    negative(message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: BigInt(0),\n            inclusive: false,\n            message: errorUtil.toString(message),\n        });\n    }\n    nonpositive(message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: BigInt(0),\n            inclusive: true,\n            message: errorUtil.toString(message),\n        });\n    }\n    nonnegative(message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: BigInt(0),\n            inclusive: true,\n            message: errorUtil.toString(message),\n        });\n    }\n    multipleOf(value, message) {\n        return this._addCheck({\n            kind: \"multipleOf\",\n            value,\n            message: errorUtil.toString(message),\n        });\n    }\n    get minValue() {\n        let min = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"min\") {\n                if (min === null || ch.value > min)\n                    min = ch.value;\n            }\n        }\n        return min;\n    }\n    get maxValue() {\n        let max = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"max\") {\n                if (max === null || ch.value < max)\n                    max = ch.value;\n            }\n        }\n        return max;\n    }\n}\nZodBigInt.create = (params) => {\n    return new ZodBigInt({\n        checks: [],\n        typeName: ZodFirstPartyTypeKind.ZodBigInt,\n        coerce: params?.coerce ?? false,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodBoolean extends ZodType {\n    _parse(input) {\n        if (this._def.coerce) {\n            input.data = Boolean(input.data);\n        }\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.boolean) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.boolean,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n}\nZodBoolean.create = (params) => {\n    return new ZodBoolean({\n        typeName: ZodFirstPartyTypeKind.ZodBoolean,\n        coerce: params?.coerce || false,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodDate extends ZodType {\n    _parse(input) {\n        if (this._def.coerce) {\n            input.data = new Date(input.data);\n        }\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.date) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.date,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        if (Number.isNaN(input.data.getTime())) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_date,\n            });\n            return INVALID;\n        }\n        const status = new ParseStatus();\n        let ctx = undefined;\n        for (const check of this._def.checks) {\n            if (check.kind === \"min\") {\n                if (input.data.getTime() < check.value) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_small,\n                        message: check.message,\n                        inclusive: true,\n                        exact: false,\n                        minimum: check.value,\n                        type: \"date\",\n                    });\n                    status.dirty();\n                }\n            }\n            else if (check.kind === \"max\") {\n                if (input.data.getTime() > check.value) {\n                    ctx = this._getOrReturnCtx(input, ctx);\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.too_big,\n                        message: check.message,\n                        inclusive: true,\n                        exact: false,\n                        maximum: check.value,\n                        type: \"date\",\n                    });\n                    status.dirty();\n                }\n            }\n            else {\n                util.assertNever(check);\n            }\n        }\n        return {\n            status: status.value,\n            value: new Date(input.data.getTime()),\n        };\n    }\n    _addCheck(check) {\n        return new ZodDate({\n            ...this._def,\n            checks: [...this._def.checks, check],\n        });\n    }\n    min(minDate, message) {\n        return this._addCheck({\n            kind: \"min\",\n            value: minDate.getTime(),\n            message: errorUtil.toString(message),\n        });\n    }\n    max(maxDate, message) {\n        return this._addCheck({\n            kind: \"max\",\n            value: maxDate.getTime(),\n            message: errorUtil.toString(message),\n        });\n    }\n    get minDate() {\n        let min = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"min\") {\n                if (min === null || ch.value > min)\n                    min = ch.value;\n            }\n        }\n        return min != null ? new Date(min) : null;\n    }\n    get maxDate() {\n        let max = null;\n        for (const ch of this._def.checks) {\n            if (ch.kind === \"max\") {\n                if (max === null || ch.value < max)\n                    max = ch.value;\n            }\n        }\n        return max != null ? new Date(max) : null;\n    }\n}\nZodDate.create = (params) => {\n    return new ZodDate({\n        checks: [],\n        coerce: params?.coerce || false,\n        typeName: ZodFirstPartyTypeKind.ZodDate,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodSymbol extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.symbol) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.symbol,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n}\nZodSymbol.create = (params) => {\n    return new ZodSymbol({\n        typeName: ZodFirstPartyTypeKind.ZodSymbol,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodUndefined extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.undefined) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.undefined,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n}\nZodUndefined.create = (params) => {\n    return new ZodUndefined({\n        typeName: ZodFirstPartyTypeKind.ZodUndefined,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodNull extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.null) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.null,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n}\nZodNull.create = (params) => {\n    return new ZodNull({\n        typeName: ZodFirstPartyTypeKind.ZodNull,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodAny extends ZodType {\n    constructor() {\n        super(...arguments);\n        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.\n        this._any = true;\n    }\n    _parse(input) {\n        return OK(input.data);\n    }\n}\nZodAny.create = (params) => {\n    return new ZodAny({\n        typeName: ZodFirstPartyTypeKind.ZodAny,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodUnknown extends ZodType {\n    constructor() {\n        super(...arguments);\n        // required\n        this._unknown = true;\n    }\n    _parse(input) {\n        return OK(input.data);\n    }\n}\nZodUnknown.create = (params) => {\n    return new ZodUnknown({\n        typeName: ZodFirstPartyTypeKind.ZodUnknown,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodNever extends ZodType {\n    _parse(input) {\n        const ctx = this._getOrReturnCtx(input);\n        addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_type,\n            expected: ZodParsedType.never,\n            received: ctx.parsedType,\n        });\n        return INVALID;\n    }\n}\nZodNever.create = (params) => {\n    return new ZodNever({\n        typeName: ZodFirstPartyTypeKind.ZodNever,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodVoid extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.undefined) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.void,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n}\nZodVoid.create = (params) => {\n    return new ZodVoid({\n        typeName: ZodFirstPartyTypeKind.ZodVoid,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodArray extends ZodType {\n    _parse(input) {\n        const { ctx, status } = this._processInputParams(input);\n        const def = this._def;\n        if (ctx.parsedType !== ZodParsedType.array) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.array,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        if (def.exactLength !== null) {\n            const tooBig = ctx.data.length > def.exactLength.value;\n            const tooSmall = ctx.data.length < def.exactLength.value;\n            if (tooBig || tooSmall) {\n                addIssueToContext(ctx, {\n                    code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,\n                    minimum: (tooSmall ? def.exactLength.value : undefined),\n                    maximum: (tooBig ? def.exactLength.value : undefined),\n                    type: \"array\",\n                    inclusive: true,\n                    exact: true,\n                    message: def.exactLength.message,\n                });\n                status.dirty();\n            }\n        }\n        if (def.minLength !== null) {\n            if (ctx.data.length < def.minLength.value) {\n                addIssueToContext(ctx, {\n                    code: ZodIssueCode.too_small,\n                    minimum: def.minLength.value,\n                    type: \"array\",\n                    inclusive: true,\n                    exact: false,\n                    message: def.minLength.message,\n                });\n                status.dirty();\n            }\n        }\n        if (def.maxLength !== null) {\n            if (ctx.data.length > def.maxLength.value) {\n                addIssueToContext(ctx, {\n                    code: ZodIssueCode.too_big,\n                    maximum: def.maxLength.value,\n                    type: \"array\",\n                    inclusive: true,\n                    exact: false,\n                    message: def.maxLength.message,\n                });\n                status.dirty();\n            }\n        }\n        if (ctx.common.async) {\n            return Promise.all([...ctx.data].map((item, i) => {\n                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n            })).then((result) => {\n                return ParseStatus.mergeArray(status, result);\n            });\n        }\n        const result = [...ctx.data].map((item, i) => {\n            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n        });\n        return ParseStatus.mergeArray(status, result);\n    }\n    get element() {\n        return this._def.type;\n    }\n    min(minLength, message) {\n        return new ZodArray({\n            ...this._def,\n            minLength: { value: minLength, message: errorUtil.toString(message) },\n        });\n    }\n    max(maxLength, message) {\n        return new ZodArray({\n            ...this._def,\n            maxLength: { value: maxLength, message: errorUtil.toString(message) },\n        });\n    }\n    length(len, message) {\n        return new ZodArray({\n            ...this._def,\n            exactLength: { value: len, message: errorUtil.toString(message) },\n        });\n    }\n    nonempty(message) {\n        return this.min(1, message);\n    }\n}\nZodArray.create = (schema, params) => {\n    return new ZodArray({\n        type: schema,\n        minLength: null,\n        maxLength: null,\n        exactLength: null,\n        typeName: ZodFirstPartyTypeKind.ZodArray,\n        ...processCreateParams(params),\n    });\n};\nfunction deepPartialify(schema) {\n    if (schema instanceof ZodObject) {\n        const newShape = {};\n        for (const key in schema.shape) {\n            const fieldSchema = schema.shape[key];\n            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));\n        }\n        return new ZodObject({\n            ...schema._def,\n            shape: () => newShape,\n        });\n    }\n    else if (schema instanceof ZodArray) {\n        return new ZodArray({\n            ...schema._def,\n            type: deepPartialify(schema.element),\n        });\n    }\n    else if (schema instanceof ZodOptional) {\n        return ZodOptional.create(deepPartialify(schema.unwrap()));\n    }\n    else if (schema instanceof ZodNullable) {\n        return ZodNullable.create(deepPartialify(schema.unwrap()));\n    }\n    else if (schema instanceof ZodTuple) {\n        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));\n    }\n    else {\n        return schema;\n    }\n}\nexport class ZodObject extends ZodType {\n    constructor() {\n        super(...arguments);\n        this._cached = null;\n        /**\n         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.\n         * If you want to pass through unknown properties, use `.passthrough()` instead.\n         */\n        this.nonstrict = this.passthrough;\n        // extend<\n        //   Augmentation extends ZodRawShape,\n        //   NewOutput extends util.flatten<{\n        //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation\n        //       ? Augmentation[k][\"_output\"]\n        //       : k extends keyof Output\n        //       ? Output[k]\n        //       : never;\n        //   }>,\n        //   NewInput extends util.flatten<{\n        //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation\n        //       ? Augmentation[k][\"_input\"]\n        //       : k extends keyof Input\n        //       ? Input[k]\n        //       : never;\n        //   }>\n        // >(\n        //   augmentation: Augmentation\n        // ): ZodObject<\n        //   extendShape<T, Augmentation>,\n        //   UnknownKeys,\n        //   Catchall,\n        //   NewOutput,\n        //   NewInput\n        // > {\n        //   return new ZodObject({\n        //     ...this._def,\n        //     shape: () => ({\n        //       ...this._def.shape(),\n        //       ...augmentation,\n        //     }),\n        //   }) as any;\n        // }\n        /**\n         * @deprecated Use `.extend` instead\n         *  */\n        this.augment = this.extend;\n    }\n    _getCached() {\n        if (this._cached !== null)\n            return this._cached;\n        const shape = this._def.shape();\n        const keys = util.objectKeys(shape);\n        this._cached = { shape, keys };\n        return this._cached;\n    }\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.object) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.object,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const { status, ctx } = this._processInputParams(input);\n        const { shape, keys: shapeKeys } = this._getCached();\n        const extraKeys = [];\n        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === \"strip\")) {\n            for (const key in ctx.data) {\n                if (!shapeKeys.includes(key)) {\n                    extraKeys.push(key);\n                }\n            }\n        }\n        const pairs = [];\n        for (const key of shapeKeys) {\n            const keyValidator = shape[key];\n            const value = ctx.data[key];\n            pairs.push({\n                key: { status: \"valid\", value: key },\n                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),\n                alwaysSet: key in ctx.data,\n            });\n        }\n        if (this._def.catchall instanceof ZodNever) {\n            const unknownKeys = this._def.unknownKeys;\n            if (unknownKeys === \"passthrough\") {\n                for (const key of extraKeys) {\n                    pairs.push({\n                        key: { status: \"valid\", value: key },\n                        value: { status: \"valid\", value: ctx.data[key] },\n                    });\n                }\n            }\n            else if (unknownKeys === \"strict\") {\n                if (extraKeys.length > 0) {\n                    addIssueToContext(ctx, {\n                        code: ZodIssueCode.unrecognized_keys,\n                        keys: extraKeys,\n                    });\n                    status.dirty();\n                }\n            }\n            else if (unknownKeys === \"strip\") {\n            }\n            else {\n                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);\n            }\n        }\n        else {\n            // run catchall validation\n            const catchall = this._def.catchall;\n            for (const key of extraKeys) {\n                const value = ctx.data[key];\n                pairs.push({\n                    key: { status: \"valid\", value: key },\n                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)\n                    ),\n                    alwaysSet: key in ctx.data,\n                });\n            }\n        }\n        if (ctx.common.async) {\n            return Promise.resolve()\n                .then(async () => {\n                const syncPairs = [];\n                for (const pair of pairs) {\n                    const key = await pair.key;\n                    const value = await pair.value;\n                    syncPairs.push({\n                        key,\n                        value,\n                        alwaysSet: pair.alwaysSet,\n                    });\n                }\n                return syncPairs;\n            })\n                .then((syncPairs) => {\n                return ParseStatus.mergeObjectSync(status, syncPairs);\n            });\n        }\n        else {\n            return ParseStatus.mergeObjectSync(status, pairs);\n        }\n    }\n    get shape() {\n        return this._def.shape();\n    }\n    strict(message) {\n        errorUtil.errToObj;\n        return new ZodObject({\n            ...this._def,\n            unknownKeys: \"strict\",\n            ...(message !== undefined\n                ? {\n                    errorMap: (issue, ctx) => {\n                        const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;\n                        if (issue.code === \"unrecognized_keys\")\n                            return {\n                                message: errorUtil.errToObj(message).message ?? defaultError,\n                            };\n                        return {\n                            message: defaultError,\n                        };\n                    },\n                }\n                : {}),\n        });\n    }\n    strip() {\n        return new ZodObject({\n            ...this._def,\n            unknownKeys: \"strip\",\n        });\n    }\n    passthrough() {\n        return new ZodObject({\n            ...this._def,\n            unknownKeys: \"passthrough\",\n        });\n    }\n    // const AugmentFactory =\n    //   <Def extends ZodObjectDef>(def: Def) =>\n    //   <Augmentation extends ZodRawShape>(\n    //     augmentation: Augmentation\n    //   ): ZodObject<\n    //     extendShape<ReturnType<Def[\"shape\"]>, Augmentation>,\n    //     Def[\"unknownKeys\"],\n    //     Def[\"catchall\"]\n    //   > => {\n    //     return new ZodObject({\n    //       ...def,\n    //       shape: () => ({\n    //         ...def.shape(),\n    //         ...augmentation,\n    //       }),\n    //     }) as any;\n    //   };\n    extend(augmentation) {\n        return new ZodObject({\n            ...this._def,\n            shape: () => ({\n                ...this._def.shape(),\n                ...augmentation,\n            }),\n        });\n    }\n    /**\n     * Prior to zod@1.0.12 there was a bug in the\n     * inferred type of merged objects. Please\n     * upgrade if you are experiencing issues.\n     */\n    merge(merging) {\n        const merged = new ZodObject({\n            unknownKeys: merging._def.unknownKeys,\n            catchall: merging._def.catchall,\n            shape: () => ({\n                ...this._def.shape(),\n                ...merging._def.shape(),\n            }),\n            typeName: ZodFirstPartyTypeKind.ZodObject,\n        });\n        return merged;\n    }\n    // merge<\n    //   Incoming extends AnyZodObject,\n    //   Augmentation extends Incoming[\"shape\"],\n    //   NewOutput extends {\n    //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation\n    //       ? Augmentation[k][\"_output\"]\n    //       : k extends keyof Output\n    //       ? Output[k]\n    //       : never;\n    //   },\n    //   NewInput extends {\n    //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation\n    //       ? Augmentation[k][\"_input\"]\n    //       : k extends keyof Input\n    //       ? Input[k]\n    //       : never;\n    //   }\n    // >(\n    //   merging: Incoming\n    // ): ZodObject<\n    //   extendShape<T, ReturnType<Incoming[\"_def\"][\"shape\"]>>,\n    //   Incoming[\"_def\"][\"unknownKeys\"],\n    //   Incoming[\"_def\"][\"catchall\"],\n    //   NewOutput,\n    //   NewInput\n    // > {\n    //   const merged: any = new ZodObject({\n    //     unknownKeys: merging._def.unknownKeys,\n    //     catchall: merging._def.catchall,\n    //     shape: () =>\n    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n    //     typeName: ZodFirstPartyTypeKind.ZodObject,\n    //   }) as any;\n    //   return merged;\n    // }\n    setKey(key, schema) {\n        return this.augment({ [key]: schema });\n    }\n    // merge<Incoming extends AnyZodObject>(\n    //   merging: Incoming\n    // ): //ZodObject<T & Incoming[\"_shape\"], UnknownKeys, Catchall> = (merging) => {\n    // ZodObject<\n    //   extendShape<T, ReturnType<Incoming[\"_def\"][\"shape\"]>>,\n    //   Incoming[\"_def\"][\"unknownKeys\"],\n    //   Incoming[\"_def\"][\"catchall\"]\n    // > {\n    //   // const mergedShape = objectUtil.mergeShapes(\n    //   //   this._def.shape(),\n    //   //   merging._def.shape()\n    //   // );\n    //   const merged: any = new ZodObject({\n    //     unknownKeys: merging._def.unknownKeys,\n    //     catchall: merging._def.catchall,\n    //     shape: () =>\n    //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n    //     typeName: ZodFirstPartyTypeKind.ZodObject,\n    //   }) as any;\n    //   return merged;\n    // }\n    catchall(index) {\n        return new ZodObject({\n            ...this._def,\n            catchall: index,\n        });\n    }\n    pick(mask) {\n        const shape = {};\n        for (const key of util.objectKeys(mask)) {\n            if (mask[key] && this.shape[key]) {\n                shape[key] = this.shape[key];\n            }\n        }\n        return new ZodObject({\n            ...this._def,\n            shape: () => shape,\n        });\n    }\n    omit(mask) {\n        const shape = {};\n        for (const key of util.objectKeys(this.shape)) {\n            if (!mask[key]) {\n                shape[key] = this.shape[key];\n            }\n        }\n        return new ZodObject({\n            ...this._def,\n            shape: () => shape,\n        });\n    }\n    /**\n     * @deprecated\n     */\n    deepPartial() {\n        return deepPartialify(this);\n    }\n    partial(mask) {\n        const newShape = {};\n        for (const key of util.objectKeys(this.shape)) {\n            const fieldSchema = this.shape[key];\n            if (mask && !mask[key]) {\n                newShape[key] = fieldSchema;\n            }\n            else {\n                newShape[key] = fieldSchema.optional();\n            }\n        }\n        return new ZodObject({\n            ...this._def,\n            shape: () => newShape,\n        });\n    }\n    required(mask) {\n        const newShape = {};\n        for (const key of util.objectKeys(this.shape)) {\n            if (mask && !mask[key]) {\n                newShape[key] = this.shape[key];\n            }\n            else {\n                const fieldSchema = this.shape[key];\n                let newField = fieldSchema;\n                while (newField instanceof ZodOptional) {\n                    newField = newField._def.innerType;\n                }\n                newShape[key] = newField;\n            }\n        }\n        return new ZodObject({\n            ...this._def,\n            shape: () => newShape,\n        });\n    }\n    keyof() {\n        return createZodEnum(util.objectKeys(this.shape));\n    }\n}\nZodObject.create = (shape, params) => {\n    return new ZodObject({\n        shape: () => shape,\n        unknownKeys: \"strip\",\n        catchall: ZodNever.create(),\n        typeName: ZodFirstPartyTypeKind.ZodObject,\n        ...processCreateParams(params),\n    });\n};\nZodObject.strictCreate = (shape, params) => {\n    return new ZodObject({\n        shape: () => shape,\n        unknownKeys: \"strict\",\n        catchall: ZodNever.create(),\n        typeName: ZodFirstPartyTypeKind.ZodObject,\n        ...processCreateParams(params),\n    });\n};\nZodObject.lazycreate = (shape, params) => {\n    return new ZodObject({\n        shape,\n        unknownKeys: \"strip\",\n        catchall: ZodNever.create(),\n        typeName: ZodFirstPartyTypeKind.ZodObject,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodUnion extends ZodType {\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        const options = this._def.options;\n        function handleResults(results) {\n            // return first issue-free validation if it exists\n            for (const result of results) {\n                if (result.result.status === \"valid\") {\n                    return result.result;\n                }\n            }\n            for (const result of results) {\n                if (result.result.status === \"dirty\") {\n                    // add issues from dirty option\n                    ctx.common.issues.push(...result.ctx.common.issues);\n                    return result.result;\n                }\n            }\n            // return invalid\n            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_union,\n                unionErrors,\n            });\n            return INVALID;\n        }\n        if (ctx.common.async) {\n            return Promise.all(options.map(async (option) => {\n                const childCtx = {\n                    ...ctx,\n                    common: {\n                        ...ctx.common,\n                        issues: [],\n                    },\n                    parent: null,\n                };\n                return {\n                    result: await option._parseAsync({\n                        data: ctx.data,\n                        path: ctx.path,\n                        parent: childCtx,\n                    }),\n                    ctx: childCtx,\n                };\n            })).then(handleResults);\n        }\n        else {\n            let dirty = undefined;\n            const issues = [];\n            for (const option of options) {\n                const childCtx = {\n                    ...ctx,\n                    common: {\n                        ...ctx.common,\n                        issues: [],\n                    },\n                    parent: null,\n                };\n                const result = option._parseSync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: childCtx,\n                });\n                if (result.status === \"valid\") {\n                    return result;\n                }\n                else if (result.status === \"dirty\" && !dirty) {\n                    dirty = { result, ctx: childCtx };\n                }\n                if (childCtx.common.issues.length) {\n                    issues.push(childCtx.common.issues);\n                }\n            }\n            if (dirty) {\n                ctx.common.issues.push(...dirty.ctx.common.issues);\n                return dirty.result;\n            }\n            const unionErrors = issues.map((issues) => new ZodError(issues));\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_union,\n                unionErrors,\n            });\n            return INVALID;\n        }\n    }\n    get options() {\n        return this._def.options;\n    }\n}\nZodUnion.create = (types, params) => {\n    return new ZodUnion({\n        options: types,\n        typeName: ZodFirstPartyTypeKind.ZodUnion,\n        ...processCreateParams(params),\n    });\n};\n/////////////////////////////////////////////////////\n/////////////////////////////////////////////////////\n//////////                                 //////////\n//////////      ZodDiscriminatedUnion      //////////\n//////////                                 //////////\n/////////////////////////////////////////////////////\n/////////////////////////////////////////////////////\nconst getDiscriminator = (type) => {\n    if (type instanceof ZodLazy) {\n        return getDiscriminator(type.schema);\n    }\n    else if (type instanceof ZodEffects) {\n        return getDiscriminator(type.innerType());\n    }\n    else if (type instanceof ZodLiteral) {\n        return [type.value];\n    }\n    else if (type instanceof ZodEnum) {\n        return type.options;\n    }\n    else if (type instanceof ZodNativeEnum) {\n        // eslint-disable-next-line ban/ban\n        return util.objectValues(type.enum);\n    }\n    else if (type instanceof ZodDefault) {\n        return getDiscriminator(type._def.innerType);\n    }\n    else if (type instanceof ZodUndefined) {\n        return [undefined];\n    }\n    else if (type instanceof ZodNull) {\n        return [null];\n    }\n    else if (type instanceof ZodOptional) {\n        return [undefined, ...getDiscriminator(type.unwrap())];\n    }\n    else if (type instanceof ZodNullable) {\n        return [null, ...getDiscriminator(type.unwrap())];\n    }\n    else if (type instanceof ZodBranded) {\n        return getDiscriminator(type.unwrap());\n    }\n    else if (type instanceof ZodReadonly) {\n        return getDiscriminator(type.unwrap());\n    }\n    else if (type instanceof ZodCatch) {\n        return getDiscriminator(type._def.innerType);\n    }\n    else {\n        return [];\n    }\n};\nexport class ZodDiscriminatedUnion extends ZodType {\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.object) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.object,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const discriminator = this.discriminator;\n        const discriminatorValue = ctx.data[discriminator];\n        const option = this.optionsMap.get(discriminatorValue);\n        if (!option) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_union_discriminator,\n                options: Array.from(this.optionsMap.keys()),\n                path: [discriminator],\n            });\n            return INVALID;\n        }\n        if (ctx.common.async) {\n            return option._parseAsync({\n                data: ctx.data,\n                path: ctx.path,\n                parent: ctx,\n            });\n        }\n        else {\n            return option._parseSync({\n                data: ctx.data,\n                path: ctx.path,\n                parent: ctx,\n            });\n        }\n    }\n    get discriminator() {\n        return this._def.discriminator;\n    }\n    get options() {\n        return this._def.options;\n    }\n    get optionsMap() {\n        return this._def.optionsMap;\n    }\n    /**\n     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.\n     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must\n     * have a different value for each object in the union.\n     * @param discriminator the name of the discriminator property\n     * @param types an array of object schemas\n     * @param params\n     */\n    static create(discriminator, options, params) {\n        // Get all the valid discriminator values\n        const optionsMap = new Map();\n        // try {\n        for (const type of options) {\n            const discriminatorValues = getDiscriminator(type.shape[discriminator]);\n            if (!discriminatorValues.length) {\n                throw new Error(`A discriminator value for key \\`${discriminator}\\` could not be extracted from all schema options`);\n            }\n            for (const value of discriminatorValues) {\n                if (optionsMap.has(value)) {\n                    throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);\n                }\n                optionsMap.set(value, type);\n            }\n        }\n        return new ZodDiscriminatedUnion({\n            typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,\n            discriminator,\n            options,\n            optionsMap,\n            ...processCreateParams(params),\n        });\n    }\n}\nfunction mergeValues(a, b) {\n    const aType = getParsedType(a);\n    const bType = getParsedType(b);\n    if (a === b) {\n        return { valid: true, data: a };\n    }\n    else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {\n        const bKeys = util.objectKeys(b);\n        const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);\n        const newObj = { ...a, ...b };\n        for (const key of sharedKeys) {\n            const sharedValue = mergeValues(a[key], b[key]);\n            if (!sharedValue.valid) {\n                return { valid: false };\n            }\n            newObj[key] = sharedValue.data;\n        }\n        return { valid: true, data: newObj };\n    }\n    else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {\n        if (a.length !== b.length) {\n            return { valid: false };\n        }\n        const newArray = [];\n        for (let index = 0; index < a.length; index++) {\n            const itemA = a[index];\n            const itemB = b[index];\n            const sharedValue = mergeValues(itemA, itemB);\n            if (!sharedValue.valid) {\n                return { valid: false };\n            }\n            newArray.push(sharedValue.data);\n        }\n        return { valid: true, data: newArray };\n    }\n    else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {\n        return { valid: true, data: a };\n    }\n    else {\n        return { valid: false };\n    }\n}\nexport class ZodIntersection extends ZodType {\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        const handleParsed = (parsedLeft, parsedRight) => {\n            if (isAborted(parsedLeft) || isAborted(parsedRight)) {\n                return INVALID;\n            }\n            const merged = mergeValues(parsedLeft.value, parsedRight.value);\n            if (!merged.valid) {\n                addIssueToContext(ctx, {\n                    code: ZodIssueCode.invalid_intersection_types,\n                });\n                return INVALID;\n            }\n            if (isDirty(parsedLeft) || isDirty(parsedRight)) {\n                status.dirty();\n            }\n            return { status: status.value, value: merged.data };\n        };\n        if (ctx.common.async) {\n            return Promise.all([\n                this._def.left._parseAsync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: ctx,\n                }),\n                this._def.right._parseAsync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: ctx,\n                }),\n            ]).then(([left, right]) => handleParsed(left, right));\n        }\n        else {\n            return handleParsed(this._def.left._parseSync({\n                data: ctx.data,\n                path: ctx.path,\n                parent: ctx,\n            }), this._def.right._parseSync({\n                data: ctx.data,\n                path: ctx.path,\n                parent: ctx,\n            }));\n        }\n    }\n}\nZodIntersection.create = (left, right, params) => {\n    return new ZodIntersection({\n        left: left,\n        right: right,\n        typeName: ZodFirstPartyTypeKind.ZodIntersection,\n        ...processCreateParams(params),\n    });\n};\n// type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];\nexport class ZodTuple extends ZodType {\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.array) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.array,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        if (ctx.data.length < this._def.items.length) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.too_small,\n                minimum: this._def.items.length,\n                inclusive: true,\n                exact: false,\n                type: \"array\",\n            });\n            return INVALID;\n        }\n        const rest = this._def.rest;\n        if (!rest && ctx.data.length > this._def.items.length) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.too_big,\n                maximum: this._def.items.length,\n                inclusive: true,\n                exact: false,\n                type: \"array\",\n            });\n            status.dirty();\n        }\n        const items = [...ctx.data]\n            .map((item, itemIndex) => {\n            const schema = this._def.items[itemIndex] || this._def.rest;\n            if (!schema)\n                return null;\n            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));\n        })\n            .filter((x) => !!x); // filter nulls\n        if (ctx.common.async) {\n            return Promise.all(items).then((results) => {\n                return ParseStatus.mergeArray(status, results);\n            });\n        }\n        else {\n            return ParseStatus.mergeArray(status, items);\n        }\n    }\n    get items() {\n        return this._def.items;\n    }\n    rest(rest) {\n        return new ZodTuple({\n            ...this._def,\n            rest,\n        });\n    }\n}\nZodTuple.create = (schemas, params) => {\n    if (!Array.isArray(schemas)) {\n        throw new Error(\"You must pass an array of schemas to z.tuple([ ... ])\");\n    }\n    return new ZodTuple({\n        items: schemas,\n        typeName: ZodFirstPartyTypeKind.ZodTuple,\n        rest: null,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodRecord extends ZodType {\n    get keySchema() {\n        return this._def.keyType;\n    }\n    get valueSchema() {\n        return this._def.valueType;\n    }\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.object) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.object,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const pairs = [];\n        const keyType = this._def.keyType;\n        const valueType = this._def.valueType;\n        for (const key in ctx.data) {\n            pairs.push({\n                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),\n                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),\n                alwaysSet: key in ctx.data,\n            });\n        }\n        if (ctx.common.async) {\n            return ParseStatus.mergeObjectAsync(status, pairs);\n        }\n        else {\n            return ParseStatus.mergeObjectSync(status, pairs);\n        }\n    }\n    get element() {\n        return this._def.valueType;\n    }\n    static create(first, second, third) {\n        if (second instanceof ZodType) {\n            return new ZodRecord({\n                keyType: first,\n                valueType: second,\n                typeName: ZodFirstPartyTypeKind.ZodRecord,\n                ...processCreateParams(third),\n            });\n        }\n        return new ZodRecord({\n            keyType: ZodString.create(),\n            valueType: first,\n            typeName: ZodFirstPartyTypeKind.ZodRecord,\n            ...processCreateParams(second),\n        });\n    }\n}\nexport class ZodMap extends ZodType {\n    get keySchema() {\n        return this._def.keyType;\n    }\n    get valueSchema() {\n        return this._def.valueType;\n    }\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.map) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.map,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const keyType = this._def.keyType;\n        const valueType = this._def.valueType;\n        const pairs = [...ctx.data.entries()].map(([key, value], index) => {\n            return {\n                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, \"key\"])),\n                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, \"value\"])),\n            };\n        });\n        if (ctx.common.async) {\n            const finalMap = new Map();\n            return Promise.resolve().then(async () => {\n                for (const pair of pairs) {\n                    const key = await pair.key;\n                    const value = await pair.value;\n                    if (key.status === \"aborted\" || value.status === \"aborted\") {\n                        return INVALID;\n                    }\n                    if (key.status === \"dirty\" || value.status === \"dirty\") {\n                        status.dirty();\n                    }\n                    finalMap.set(key.value, value.value);\n                }\n                return { status: status.value, value: finalMap };\n            });\n        }\n        else {\n            const finalMap = new Map();\n            for (const pair of pairs) {\n                const key = pair.key;\n                const value = pair.value;\n                if (key.status === \"aborted\" || value.status === \"aborted\") {\n                    return INVALID;\n                }\n                if (key.status === \"dirty\" || value.status === \"dirty\") {\n                    status.dirty();\n                }\n                finalMap.set(key.value, value.value);\n            }\n            return { status: status.value, value: finalMap };\n        }\n    }\n}\nZodMap.create = (keyType, valueType, params) => {\n    return new ZodMap({\n        valueType,\n        keyType,\n        typeName: ZodFirstPartyTypeKind.ZodMap,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodSet extends ZodType {\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.set) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.set,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const def = this._def;\n        if (def.minSize !== null) {\n            if (ctx.data.size < def.minSize.value) {\n                addIssueToContext(ctx, {\n                    code: ZodIssueCode.too_small,\n                    minimum: def.minSize.value,\n                    type: \"set\",\n                    inclusive: true,\n                    exact: false,\n                    message: def.minSize.message,\n                });\n                status.dirty();\n            }\n        }\n        if (def.maxSize !== null) {\n            if (ctx.data.size > def.maxSize.value) {\n                addIssueToContext(ctx, {\n                    code: ZodIssueCode.too_big,\n                    maximum: def.maxSize.value,\n                    type: \"set\",\n                    inclusive: true,\n                    exact: false,\n                    message: def.maxSize.message,\n                });\n                status.dirty();\n            }\n        }\n        const valueType = this._def.valueType;\n        function finalizeSet(elements) {\n            const parsedSet = new Set();\n            for (const element of elements) {\n                if (element.status === \"aborted\")\n                    return INVALID;\n                if (element.status === \"dirty\")\n                    status.dirty();\n                parsedSet.add(element.value);\n            }\n            return { status: status.value, value: parsedSet };\n        }\n        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));\n        if (ctx.common.async) {\n            return Promise.all(elements).then((elements) => finalizeSet(elements));\n        }\n        else {\n            return finalizeSet(elements);\n        }\n    }\n    min(minSize, message) {\n        return new ZodSet({\n            ...this._def,\n            minSize: { value: minSize, message: errorUtil.toString(message) },\n        });\n    }\n    max(maxSize, message) {\n        return new ZodSet({\n            ...this._def,\n            maxSize: { value: maxSize, message: errorUtil.toString(message) },\n        });\n    }\n    size(size, message) {\n        return this.min(size, message).max(size, message);\n    }\n    nonempty(message) {\n        return this.min(1, message);\n    }\n}\nZodSet.create = (valueType, params) => {\n    return new ZodSet({\n        valueType,\n        minSize: null,\n        maxSize: null,\n        typeName: ZodFirstPartyTypeKind.ZodSet,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodFunction extends ZodType {\n    constructor() {\n        super(...arguments);\n        this.validate = this.implement;\n    }\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.function) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.function,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        function makeArgsIssue(args, error) {\n            return makeIssue({\n                data: args,\n                path: ctx.path,\n                errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), defaultErrorMap].filter((x) => !!x),\n                issueData: {\n                    code: ZodIssueCode.invalid_arguments,\n                    argumentsError: error,\n                },\n            });\n        }\n        function makeReturnsIssue(returns, error) {\n            return makeIssue({\n                data: returns,\n                path: ctx.path,\n                errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), defaultErrorMap].filter((x) => !!x),\n                issueData: {\n                    code: ZodIssueCode.invalid_return_type,\n                    returnTypeError: error,\n                },\n            });\n        }\n        const params = { errorMap: ctx.common.contextualErrorMap };\n        const fn = ctx.data;\n        if (this._def.returns instanceof ZodPromise) {\n            // Would love a way to avoid disabling this rule, but we need\n            // an alias (using an arrow function was what caused 2651).\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            const me = this;\n            return OK(async function (...args) {\n                const error = new ZodError([]);\n                const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {\n                    error.addIssue(makeArgsIssue(args, e));\n                    throw error;\n                });\n                const result = await Reflect.apply(fn, this, parsedArgs);\n                const parsedReturns = await me._def.returns._def.type\n                    .parseAsync(result, params)\n                    .catch((e) => {\n                    error.addIssue(makeReturnsIssue(result, e));\n                    throw error;\n                });\n                return parsedReturns;\n            });\n        }\n        else {\n            // Would love a way to avoid disabling this rule, but we need\n            // an alias (using an arrow function was what caused 2651).\n            // eslint-disable-next-line @typescript-eslint/no-this-alias\n            const me = this;\n            return OK(function (...args) {\n                const parsedArgs = me._def.args.safeParse(args, params);\n                if (!parsedArgs.success) {\n                    throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);\n                }\n                const result = Reflect.apply(fn, this, parsedArgs.data);\n                const parsedReturns = me._def.returns.safeParse(result, params);\n                if (!parsedReturns.success) {\n                    throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);\n                }\n                return parsedReturns.data;\n            });\n        }\n    }\n    parameters() {\n        return this._def.args;\n    }\n    returnType() {\n        return this._def.returns;\n    }\n    args(...items) {\n        return new ZodFunction({\n            ...this._def,\n            args: ZodTuple.create(items).rest(ZodUnknown.create()),\n        });\n    }\n    returns(returnType) {\n        return new ZodFunction({\n            ...this._def,\n            returns: returnType,\n        });\n    }\n    implement(func) {\n        const validatedFunc = this.parse(func);\n        return validatedFunc;\n    }\n    strictImplement(func) {\n        const validatedFunc = this.parse(func);\n        return validatedFunc;\n    }\n    static create(args, returns, params) {\n        return new ZodFunction({\n            args: (args ? args : ZodTuple.create([]).rest(ZodUnknown.create())),\n            returns: returns || ZodUnknown.create(),\n            typeName: ZodFirstPartyTypeKind.ZodFunction,\n            ...processCreateParams(params),\n        });\n    }\n}\nexport class ZodLazy extends ZodType {\n    get schema() {\n        return this._def.getter();\n    }\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        const lazySchema = this._def.getter();\n        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });\n    }\n}\nZodLazy.create = (getter, params) => {\n    return new ZodLazy({\n        getter: getter,\n        typeName: ZodFirstPartyTypeKind.ZodLazy,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodLiteral extends ZodType {\n    _parse(input) {\n        if (input.data !== this._def.value) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                received: ctx.data,\n                code: ZodIssueCode.invalid_literal,\n                expected: this._def.value,\n            });\n            return INVALID;\n        }\n        return { status: \"valid\", value: input.data };\n    }\n    get value() {\n        return this._def.value;\n    }\n}\nZodLiteral.create = (value, params) => {\n    return new ZodLiteral({\n        value: value,\n        typeName: ZodFirstPartyTypeKind.ZodLiteral,\n        ...processCreateParams(params),\n    });\n};\nfunction createZodEnum(values, params) {\n    return new ZodEnum({\n        values,\n        typeName: ZodFirstPartyTypeKind.ZodEnum,\n        ...processCreateParams(params),\n    });\n}\nexport class ZodEnum extends ZodType {\n    _parse(input) {\n        if (typeof input.data !== \"string\") {\n            const ctx = this._getOrReturnCtx(input);\n            const expectedValues = this._def.values;\n            addIssueToContext(ctx, {\n                expected: util.joinValues(expectedValues),\n                received: ctx.parsedType,\n                code: ZodIssueCode.invalid_type,\n            });\n            return INVALID;\n        }\n        if (!this._cache) {\n            this._cache = new Set(this._def.values);\n        }\n        if (!this._cache.has(input.data)) {\n            const ctx = this._getOrReturnCtx(input);\n            const expectedValues = this._def.values;\n            addIssueToContext(ctx, {\n                received: ctx.data,\n                code: ZodIssueCode.invalid_enum_value,\n                options: expectedValues,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n    get options() {\n        return this._def.values;\n    }\n    get enum() {\n        const enumValues = {};\n        for (const val of this._def.values) {\n            enumValues[val] = val;\n        }\n        return enumValues;\n    }\n    get Values() {\n        const enumValues = {};\n        for (const val of this._def.values) {\n            enumValues[val] = val;\n        }\n        return enumValues;\n    }\n    get Enum() {\n        const enumValues = {};\n        for (const val of this._def.values) {\n            enumValues[val] = val;\n        }\n        return enumValues;\n    }\n    extract(values, newDef = this._def) {\n        return ZodEnum.create(values, {\n            ...this._def,\n            ...newDef,\n        });\n    }\n    exclude(values, newDef = this._def) {\n        return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {\n            ...this._def,\n            ...newDef,\n        });\n    }\n}\nZodEnum.create = createZodEnum;\nexport class ZodNativeEnum extends ZodType {\n    _parse(input) {\n        const nativeEnumValues = util.getValidEnumValues(this._def.values);\n        const ctx = this._getOrReturnCtx(input);\n        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {\n            const expectedValues = util.objectValues(nativeEnumValues);\n            addIssueToContext(ctx, {\n                expected: util.joinValues(expectedValues),\n                received: ctx.parsedType,\n                code: ZodIssueCode.invalid_type,\n            });\n            return INVALID;\n        }\n        if (!this._cache) {\n            this._cache = new Set(util.getValidEnumValues(this._def.values));\n        }\n        if (!this._cache.has(input.data)) {\n            const expectedValues = util.objectValues(nativeEnumValues);\n            addIssueToContext(ctx, {\n                received: ctx.data,\n                code: ZodIssueCode.invalid_enum_value,\n                options: expectedValues,\n            });\n            return INVALID;\n        }\n        return OK(input.data);\n    }\n    get enum() {\n        return this._def.values;\n    }\n}\nZodNativeEnum.create = (values, params) => {\n    return new ZodNativeEnum({\n        values: values,\n        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodPromise extends ZodType {\n    unwrap() {\n        return this._def.type;\n    }\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.promise,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);\n        return OK(promisified.then((data) => {\n            return this._def.type.parseAsync(data, {\n                path: ctx.path,\n                errorMap: ctx.common.contextualErrorMap,\n            });\n        }));\n    }\n}\nZodPromise.create = (schema, params) => {\n    return new ZodPromise({\n        type: schema,\n        typeName: ZodFirstPartyTypeKind.ZodPromise,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodEffects extends ZodType {\n    innerType() {\n        return this._def.schema;\n    }\n    sourceType() {\n        return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects\n            ? this._def.schema.sourceType()\n            : this._def.schema;\n    }\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        const effect = this._def.effect || null;\n        const checkCtx = {\n            addIssue: (arg) => {\n                addIssueToContext(ctx, arg);\n                if (arg.fatal) {\n                    status.abort();\n                }\n                else {\n                    status.dirty();\n                }\n            },\n            get path() {\n                return ctx.path;\n            },\n        };\n        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);\n        if (effect.type === \"preprocess\") {\n            const processed = effect.transform(ctx.data, checkCtx);\n            if (ctx.common.async) {\n                return Promise.resolve(processed).then(async (processed) => {\n                    if (status.value === \"aborted\")\n                        return INVALID;\n                    const result = await this._def.schema._parseAsync({\n                        data: processed,\n                        path: ctx.path,\n                        parent: ctx,\n                    });\n                    if (result.status === \"aborted\")\n                        return INVALID;\n                    if (result.status === \"dirty\")\n                        return DIRTY(result.value);\n                    if (status.value === \"dirty\")\n                        return DIRTY(result.value);\n                    return result;\n                });\n            }\n            else {\n                if (status.value === \"aborted\")\n                    return INVALID;\n                const result = this._def.schema._parseSync({\n                    data: processed,\n                    path: ctx.path,\n                    parent: ctx,\n                });\n                if (result.status === \"aborted\")\n                    return INVALID;\n                if (result.status === \"dirty\")\n                    return DIRTY(result.value);\n                if (status.value === \"dirty\")\n                    return DIRTY(result.value);\n                return result;\n            }\n        }\n        if (effect.type === \"refinement\") {\n            const executeRefinement = (acc) => {\n                const result = effect.refinement(acc, checkCtx);\n                if (ctx.common.async) {\n                    return Promise.resolve(result);\n                }\n                if (result instanceof Promise) {\n                    throw new Error(\"Async refinement encountered during synchronous parse operation. Use .parseAsync instead.\");\n                }\n                return acc;\n            };\n            if (ctx.common.async === false) {\n                const inner = this._def.schema._parseSync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: ctx,\n                });\n                if (inner.status === \"aborted\")\n                    return INVALID;\n                if (inner.status === \"dirty\")\n                    status.dirty();\n                // return value is ignored\n                executeRefinement(inner.value);\n                return { status: status.value, value: inner.value };\n            }\n            else {\n                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {\n                    if (inner.status === \"aborted\")\n                        return INVALID;\n                    if (inner.status === \"dirty\")\n                        status.dirty();\n                    return executeRefinement(inner.value).then(() => {\n                        return { status: status.value, value: inner.value };\n                    });\n                });\n            }\n        }\n        if (effect.type === \"transform\") {\n            if (ctx.common.async === false) {\n                const base = this._def.schema._parseSync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: ctx,\n                });\n                if (!isValid(base))\n                    return INVALID;\n                const result = effect.transform(base.value, checkCtx);\n                if (result instanceof Promise) {\n                    throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);\n                }\n                return { status: status.value, value: result };\n            }\n            else {\n                return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {\n                    if (!isValid(base))\n                        return INVALID;\n                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({\n                        status: status.value,\n                        value: result,\n                    }));\n                });\n            }\n        }\n        util.assertNever(effect);\n    }\n}\nZodEffects.create = (schema, effect, params) => {\n    return new ZodEffects({\n        schema,\n        typeName: ZodFirstPartyTypeKind.ZodEffects,\n        effect,\n        ...processCreateParams(params),\n    });\n};\nZodEffects.createWithPreprocess = (preprocess, schema, params) => {\n    return new ZodEffects({\n        schema,\n        effect: { type: \"preprocess\", transform: preprocess },\n        typeName: ZodFirstPartyTypeKind.ZodEffects,\n        ...processCreateParams(params),\n    });\n};\nexport { ZodEffects as ZodTransformer };\nexport class ZodOptional extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType === ZodParsedType.undefined) {\n            return OK(undefined);\n        }\n        return this._def.innerType._parse(input);\n    }\n    unwrap() {\n        return this._def.innerType;\n    }\n}\nZodOptional.create = (type, params) => {\n    return new ZodOptional({\n        innerType: type,\n        typeName: ZodFirstPartyTypeKind.ZodOptional,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodNullable extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType === ZodParsedType.null) {\n            return OK(null);\n        }\n        return this._def.innerType._parse(input);\n    }\n    unwrap() {\n        return this._def.innerType;\n    }\n}\nZodNullable.create = (type, params) => {\n    return new ZodNullable({\n        innerType: type,\n        typeName: ZodFirstPartyTypeKind.ZodNullable,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodDefault extends ZodType {\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        let data = ctx.data;\n        if (ctx.parsedType === ZodParsedType.undefined) {\n            data = this._def.defaultValue();\n        }\n        return this._def.innerType._parse({\n            data,\n            path: ctx.path,\n            parent: ctx,\n        });\n    }\n    removeDefault() {\n        return this._def.innerType;\n    }\n}\nZodDefault.create = (type, params) => {\n    return new ZodDefault({\n        innerType: type,\n        typeName: ZodFirstPartyTypeKind.ZodDefault,\n        defaultValue: typeof params.default === \"function\" ? params.default : () => params.default,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodCatch extends ZodType {\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        // newCtx is used to not collect issues from inner types in ctx\n        const newCtx = {\n            ...ctx,\n            common: {\n                ...ctx.common,\n                issues: [],\n            },\n        };\n        const result = this._def.innerType._parse({\n            data: newCtx.data,\n            path: newCtx.path,\n            parent: {\n                ...newCtx,\n            },\n        });\n        if (isAsync(result)) {\n            return result.then((result) => {\n                return {\n                    status: \"valid\",\n                    value: result.status === \"valid\"\n                        ? result.value\n                        : this._def.catchValue({\n                            get error() {\n                                return new ZodError(newCtx.common.issues);\n                            },\n                            input: newCtx.data,\n                        }),\n                };\n            });\n        }\n        else {\n            return {\n                status: \"valid\",\n                value: result.status === \"valid\"\n                    ? result.value\n                    : this._def.catchValue({\n                        get error() {\n                            return new ZodError(newCtx.common.issues);\n                        },\n                        input: newCtx.data,\n                    }),\n            };\n        }\n    }\n    removeCatch() {\n        return this._def.innerType;\n    }\n}\nZodCatch.create = (type, params) => {\n    return new ZodCatch({\n        innerType: type,\n        typeName: ZodFirstPartyTypeKind.ZodCatch,\n        catchValue: typeof params.catch === \"function\" ? params.catch : () => params.catch,\n        ...processCreateParams(params),\n    });\n};\nexport class ZodNaN extends ZodType {\n    _parse(input) {\n        const parsedType = this._getType(input);\n        if (parsedType !== ZodParsedType.nan) {\n            const ctx = this._getOrReturnCtx(input);\n            addIssueToContext(ctx, {\n                code: ZodIssueCode.invalid_type,\n                expected: ZodParsedType.nan,\n                received: ctx.parsedType,\n            });\n            return INVALID;\n        }\n        return { status: \"valid\", value: input.data };\n    }\n}\nZodNaN.create = (params) => {\n    return new ZodNaN({\n        typeName: ZodFirstPartyTypeKind.ZodNaN,\n        ...processCreateParams(params),\n    });\n};\nexport const BRAND = Symbol(\"zod_brand\");\nexport class ZodBranded extends ZodType {\n    _parse(input) {\n        const { ctx } = this._processInputParams(input);\n        const data = ctx.data;\n        return this._def.type._parse({\n            data,\n            path: ctx.path,\n            parent: ctx,\n        });\n    }\n    unwrap() {\n        return this._def.type;\n    }\n}\nexport class ZodPipeline extends ZodType {\n    _parse(input) {\n        const { status, ctx } = this._processInputParams(input);\n        if (ctx.common.async) {\n            const handleAsync = async () => {\n                const inResult = await this._def.in._parseAsync({\n                    data: ctx.data,\n                    path: ctx.path,\n                    parent: ctx,\n                });\n                if (inResult.status === \"aborted\")\n                    return INVALID;\n                if (inResult.status === \"dirty\") {\n                    status.dirty();\n                    return DIRTY(inResult.value);\n                }\n                else {\n                    return this._def.out._parseAsync({\n                        data: inResult.value,\n                        path: ctx.path,\n                        parent: ctx,\n                    });\n                }\n            };\n            return handleAsync();\n        }\n        else {\n            const inResult = this._def.in._parseSync({\n                data: ctx.data,\n                path: ctx.path,\n                parent: ctx,\n            });\n            if (inResult.status === \"aborted\")\n                return INVALID;\n            if (inResult.status === \"dirty\") {\n                status.dirty();\n                return {\n                    status: \"dirty\",\n                    value: inResult.value,\n                };\n            }\n            else {\n                return this._def.out._parseSync({\n                    data: inResult.value,\n                    path: ctx.path,\n                    parent: ctx,\n                });\n            }\n        }\n    }\n    static create(a, b) {\n        return new ZodPipeline({\n            in: a,\n            out: b,\n            typeName: ZodFirstPartyTypeKind.ZodPipeline,\n        });\n    }\n}\nexport class ZodReadonly extends ZodType {\n    _parse(input) {\n        const result = this._def.innerType._parse(input);\n        const freeze = (data) => {\n            if (isValid(data)) {\n                data.value = Object.freeze(data.value);\n            }\n            return data;\n        };\n        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);\n    }\n    unwrap() {\n        return this._def.innerType;\n    }\n}\nZodReadonly.create = (type, params) => {\n    return new ZodReadonly({\n        innerType: type,\n        typeName: ZodFirstPartyTypeKind.ZodReadonly,\n        ...processCreateParams(params),\n    });\n};\n////////////////////////////////////////\n////////////////////////////////////////\n//////////                    //////////\n//////////      z.custom      //////////\n//////////                    //////////\n////////////////////////////////////////\n////////////////////////////////////////\nfunction cleanParams(params, data) {\n    const p = typeof params === \"function\" ? params(data) : typeof params === \"string\" ? { message: params } : params;\n    const p2 = typeof p === \"string\" ? { message: p } : p;\n    return p2;\n}\nexport function custom(check, _params = {}, \n/**\n * @deprecated\n *\n * Pass `fatal` into the params object instead:\n *\n * ```ts\n * z.string().custom((val) => val.length > 5, { fatal: false })\n * ```\n *\n */\nfatal) {\n    if (check)\n        return ZodAny.create().superRefine((data, ctx) => {\n            const r = check(data);\n            if (r instanceof Promise) {\n                return r.then((r) => {\n                    if (!r) {\n                        const params = cleanParams(_params, data);\n                        const _fatal = params.fatal ?? fatal ?? true;\n                        ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n                    }\n                });\n            }\n            if (!r) {\n                const params = cleanParams(_params, data);\n                const _fatal = params.fatal ?? fatal ?? true;\n                ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n            }\n            return;\n        });\n    return ZodAny.create();\n}\nexport { ZodType as Schema, ZodType as ZodSchema };\nexport const late = {\n    object: ZodObject.lazycreate,\n};\nexport var ZodFirstPartyTypeKind;\n(function (ZodFirstPartyTypeKind) {\n    ZodFirstPartyTypeKind[\"ZodString\"] = \"ZodString\";\n    ZodFirstPartyTypeKind[\"ZodNumber\"] = \"ZodNumber\";\n    ZodFirstPartyTypeKind[\"ZodNaN\"] = \"ZodNaN\";\n    ZodFirstPartyTypeKind[\"ZodBigInt\"] = \"ZodBigInt\";\n    ZodFirstPartyTypeKind[\"ZodBoolean\"] = \"ZodBoolean\";\n    ZodFirstPartyTypeKind[\"ZodDate\"] = \"ZodDate\";\n    ZodFirstPartyTypeKind[\"ZodSymbol\"] = \"ZodSymbol\";\n    ZodFirstPartyTypeKind[\"ZodUndefined\"] = \"ZodUndefined\";\n    ZodFirstPartyTypeKind[\"ZodNull\"] = \"ZodNull\";\n    ZodFirstPartyTypeKind[\"ZodAny\"] = \"ZodAny\";\n    ZodFirstPartyTypeKind[\"ZodUnknown\"] = \"ZodUnknown\";\n    ZodFirstPartyTypeKind[\"ZodNever\"] = \"ZodNever\";\n    ZodFirstPartyTypeKind[\"ZodVoid\"] = \"ZodVoid\";\n    ZodFirstPartyTypeKind[\"ZodArray\"] = \"ZodArray\";\n    ZodFirstPartyTypeKind[\"ZodObject\"] = \"ZodObject\";\n    ZodFirstPartyTypeKind[\"ZodUnion\"] = \"ZodUnion\";\n    ZodFirstPartyTypeKind[\"ZodDiscriminatedUnion\"] = \"ZodDiscriminatedUnion\";\n    ZodFirstPartyTypeKind[\"ZodIntersection\"] = \"ZodIntersection\";\n    ZodFirstPartyTypeKind[\"ZodTuple\"] = \"ZodTuple\";\n    ZodFirstPartyTypeKind[\"ZodRecord\"] = \"ZodRecord\";\n    ZodFirstPartyTypeKind[\"ZodMap\"] = \"ZodMap\";\n    ZodFirstPartyTypeKind[\"ZodSet\"] = \"ZodSet\";\n    ZodFirstPartyTypeKind[\"ZodFunction\"] = \"ZodFunction\";\n    ZodFirstPartyTypeKind[\"ZodLazy\"] = \"ZodLazy\";\n    ZodFirstPartyTypeKind[\"ZodLiteral\"] = \"ZodLiteral\";\n    ZodFirstPartyTypeKind[\"ZodEnum\"] = \"ZodEnum\";\n    ZodFirstPartyTypeKind[\"ZodEffects\"] = \"ZodEffects\";\n    ZodFirstPartyTypeKind[\"ZodNativeEnum\"] = \"ZodNativeEnum\";\n    ZodFirstPartyTypeKind[\"ZodOptional\"] = \"ZodOptional\";\n    ZodFirstPartyTypeKind[\"ZodNullable\"] = \"ZodNullable\";\n    ZodFirstPartyTypeKind[\"ZodDefault\"] = \"ZodDefault\";\n    ZodFirstPartyTypeKind[\"ZodCatch\"] = \"ZodCatch\";\n    ZodFirstPartyTypeKind[\"ZodPromise\"] = \"ZodPromise\";\n    ZodFirstPartyTypeKind[\"ZodBranded\"] = \"ZodBranded\";\n    ZodFirstPartyTypeKind[\"ZodPipeline\"] = \"ZodPipeline\";\n    ZodFirstPartyTypeKind[\"ZodReadonly\"] = \"ZodReadonly\";\n})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));\n// requires TS 4.4+\nclass Class {\n    constructor(..._) { }\n}\nconst instanceOfType = (\n// const instanceOfType = <T extends new (...args: any[]) => any>(\ncls, params = {\n    message: `Input not instance of ${cls.name}`,\n}) => custom((data) => data instanceof cls, params);\nconst stringType = ZodString.create;\nconst numberType = ZodNumber.create;\nconst nanType = ZodNaN.create;\nconst bigIntType = ZodBigInt.create;\nconst booleanType = ZodBoolean.create;\nconst dateType = ZodDate.create;\nconst symbolType = ZodSymbol.create;\nconst undefinedType = ZodUndefined.create;\nconst nullType = ZodNull.create;\nconst anyType = ZodAny.create;\nconst unknownType = ZodUnknown.create;\nconst neverType = ZodNever.create;\nconst voidType = ZodVoid.create;\nconst arrayType = ZodArray.create;\nconst objectType = ZodObject.create;\nconst strictObjectType = ZodObject.strictCreate;\nconst unionType = ZodUnion.create;\nconst discriminatedUnionType = ZodDiscriminatedUnion.create;\nconst intersectionType = ZodIntersection.create;\nconst tupleType = ZodTuple.create;\nconst recordType = ZodRecord.create;\nconst mapType = ZodMap.create;\nconst setType = ZodSet.create;\nconst functionType = ZodFunction.create;\nconst lazyType = ZodLazy.create;\nconst literalType = ZodLiteral.create;\nconst enumType = ZodEnum.create;\nconst nativeEnumType = ZodNativeEnum.create;\nconst promiseType = ZodPromise.create;\nconst effectsType = ZodEffects.create;\nconst optionalType = ZodOptional.create;\nconst nullableType = ZodNullable.create;\nconst preprocessType = ZodEffects.createWithPreprocess;\nconst pipelineType = ZodPipeline.create;\nconst ostring = () => stringType().optional();\nconst onumber = () => numberType().optional();\nconst oboolean = () => booleanType().optional();\nexport const coerce = {\n    string: ((arg) => ZodString.create({ ...arg, coerce: true })),\n    number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),\n    boolean: ((arg) => ZodBoolean.create({\n        ...arg,\n        coerce: true,\n    })),\n    bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),\n    date: ((arg) => ZodDate.create({ ...arg, coerce: true })),\n};\nexport { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };\nexport const NEVER = INVALID;\n", "export * from \"./errors.js\";\nexport * from \"./helpers/parseUtil.js\";\nexport * from \"./helpers/typeAliases.js\";\nexport * from \"./helpers/util.js\";\nexport * from \"./types.js\";\nexport * from \"./ZodError.js\";\n", "import * as z from \"./v3/external.js\";\nexport * from \"./v3/external.js\";\nexport { z };\nexport default z;\n", null, null, "import { SCHEMES } from \"./uri\";\n\nimport http from \"./schemes/http\";\nSCHEMES[http.scheme] = http;\n\nimport https from \"./schemes/https\";\nSCHEMES[https.scheme] = https;\n\nimport ws from \"./schemes/ws\";\nSCHEMES[ws.scheme] = ws;\n\nimport wss from \"./schemes/wss\";\nSCHEMES[wss.scheme] = wss;\n\nimport mailto from \"./schemes/mailto\";\nSCHEMES[mailto.scheme] = mailto;\n\nimport urn from \"./schemes/urn\";\nSCHEMES[urn.scheme] = urn;\n\nimport uuid from \"./schemes/urn-uuid\";\nSCHEMES[uuid.scheme] = uuid;\n\nexport * from \"./uri\";\n", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { URNComponents } from \"./urn\";\nimport { SCHEMES } from \"../uri\";\n\nexport interface UUIDComponents extends URNComponents {\n\tuuid?: string;\n}\n\nconst UUID = /^[0-9A-Fa-f]{8}(?:\\-[0-9A-Fa-f]{4}){3}\\-[0-9A-Fa-f]{12}$/;\nconst UUID_PARSE = /^[0-9A-Fa-f\\-]{36}/;\n\n//RFC 4122\nconst handler:URISchemeHandler<UUIDComponents, URIOptions, URNComponents> = {\n\tscheme : \"urn:uuid\",\n\n\tparse : function (urnComponents:URNComponents, options:URIOptions):UUIDComponents {\n\t\tconst uuidComponents = urnComponents as UUIDComponents;\n\t\tuuidComponents.uuid = uuidComponents.nss;\n\t\tuuidComponents.nss = undefined;\n\n\t\tif (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {\n\t\t\tuuidComponents.error = uuidComponents.error || \"UUID is not valid.\";\n\t\t}\n\n\t\treturn uuidComponents;\n\t},\n\n\tserialize : function (uuidComponents:UUIDComponents, options:URIOptions):URNComponents {\n\t\tconst urnComponents = uuidComponents as URNComponents;\n\t\t//normalize UUID\n\t\turnComponents.nss = (uuidComponents.uuid || \"\").toLowerCase();\n\t\treturn urnComponents;\n\t},\n};\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { pctEncChar, SCHEMES } from \"../uri\";\n\nexport interface URNComponents extends URIComponents {\n\tnid?:string;\n\tnss?:string;\n}\n\nexport interface URNOptions extends URIOptions {\n\tnid?:string;\n}\n\nconst NID$ = \"(?:[0-9A-Za-z][0-9A-Za-z\\\\-]{1,31})\";\nconst PCT_ENCODED$ = \"(?:\\\\%[0-9A-Fa-f]{2})\";\nconst TRANS$$ = \"[0-9A-Za-z\\\\(\\\\)\\\\+\\\\,\\\\-\\\\.\\\\:\\\\=\\\\@\\\\;\\\\$\\\\_\\\\!\\\\*\\\\'\\\\/\\\\?\\\\#]\";\nconst NSS$ = \"(?:(?:\" + PCT_ENCODED$ + \"|\" + TRANS$$ + \")+)\";\nconst URN_SCHEME = new RegExp(\"^urn\\\\:(\" + NID$ + \")$\");\nconst URN_PATH = new RegExp(\"^(\" + NID$ + \")\\\\:(\" + NSS$ + \")$\");\nconst URN_PARSE = /^([^\\:]+)\\:(.*)/;\nconst URN_EXCLUDED = /[\\x00-\\x20\\\\\\\"\\&\\<\\>\\[\\]\\^\\`\\{\\|\\}\\~\\x7F-\\xFF]/g;\n\n//RFC 2141\nconst handler:URISchemeHandler<URNComponents,URNOptions> = {\n\tscheme : \"urn\",\n\n\tparse : function (components:URIComponents, options:URNOptions):URNComponents {\n\t\tconst matches = components.path && components.path.match(URN_PARSE);\n\t\tlet urnComponents = components as URNComponents;\n\n\t\tif (matches) {\n\t\t\tconst scheme = options.scheme || urnComponents.scheme || \"urn\";\n\t\t\tconst nid = matches[1].toLowerCase();\n\t\t\tconst nss = matches[2];\n\t\t\tconst urnScheme = `${scheme}:${options.nid || nid}`;\n\t\t\tconst schemeHandler = SCHEMES[urnScheme];\n\n\t\t\turnComponents.nid = nid;\n\t\t\turnComponents.nss = nss;\n\t\t\turnComponents.path = undefined;\n\n\t\t\tif (schemeHandler) {\n\t\t\t\turnComponents = schemeHandler.parse(urnComponents, options) as URNComponents;\n\t\t\t}\n\t\t} else {\n\t\t\turnComponents.error = urnComponents.error || \"URN can not be parsed.\";\n\t\t}\n\n\t\treturn urnComponents;\n\t},\n\n\tserialize : function (urnComponents:URNComponents, options:URNOptions):URIComponents {\n\t\tconst scheme = options.scheme || urnComponents.scheme || \"urn\";\n\t\tconst nid = urnComponents.nid;\n\t\tconst urnScheme = `${scheme}:${options.nid || nid}`;\n\t\tconst schemeHandler = SCHEMES[urnScheme];\n\n\t\tif (schemeHandler) {\n\t\t\turnComponents = schemeHandler.serialize(urnComponents, options) as URNComponents;\n\t\t}\n\n\t\tconst uriComponents = urnComponents as URIComponents;\n\t\tconst nss = urnComponents.nss;\n\t\turiComponents.path = `${nid || options.nid}:${nss}`;\n\n\t\treturn uriComponents;\n\t},\n};\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport { pctEncChar, pctDecChars, unescapeComponent } from \"../uri\";\nimport punycode from \"punycode\";\nimport { merge, subexp, toUpperCase, toArray } from \"../util\";\n\nexport interface MailtoHeaders {\n\t[hfname:string]:string\n}\n\nexport interface MailtoComponents extends URIComponents {\n\tto:Array<string>,\n\theaders?:MailtoHeaders,\n\tsubject?:string,\n\tbody?:string\n}\n\nconst O:MailtoHeaders = {};\nconst isIRI = true;\n\n//RFC 3986\nconst UNRESERVED$$ = \"[A-Za-z0-9\\\\-\\\\.\\\\_\\\\~\" + (isIRI ? \"\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\" : \"\") + \"]\";\nconst HEXDIG$$ = \"[0-9A-Fa-f]\";  //case-insensitive\nconst PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$));  //expanded\n\n//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =\n//const ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\#\\\\$\\\\%\\\\&\\\\'\\\\*\\\\+\\\\-\\\\/\\\\=\\\\?\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QTEXT$$ = \"[\\\\x01-\\\\x08\\\\x0B\\\\x0C\\\\x0E-\\\\x1F\\\\x7F]\";  //(%d1-8 / %d11-12 / %d14-31 / %d127)\n//const QTEXT$$ = merge(\"[\\\\x21\\\\x23-\\\\x5B\\\\x5D-\\\\x7E]\", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext\n//const VCHAR$$ = \"[\\\\x21-\\\\x7E]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QP$ = subexp(\"\\\\\\\\\" + merge(\"[\\\\x00\\\\x0D\\\\x0A]\", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext\n//const FWS$ = subexp(subexp(WSP$$ + \"*\" + \"\\\\x0D\\\\x0A\") + \"?\" + WSP$$ + \"+\");\n//const QUOTED_PAIR$ = subexp(subexp(\"\\\\\\\\\" + subexp(VCHAR$$ + \"|\" + WSP$$)) + \"|\" + OBS_QP$);\n//const QUOTED_STRING$ = subexp('\\\\\"' + subexp(FWS$ + \"?\" + QCONTENT$) + \"*\" + FWS$ + \"?\" + '\\\\\"');\nconst ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\$\\\\%\\\\'\\\\*\\\\+\\\\-\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\nconst QTEXT$$ = \"[\\\\!\\\\$\\\\%\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\-\\\\.0-9\\\\<\\\\>A-Z\\\\x5E-\\\\x7E]\";\nconst VCHAR$$ = merge(QTEXT$$, \"[\\\\\\\"\\\\\\\\]\");\nconst DOT_ATOM_TEXT$ = subexp(ATEXT$$ + \"+\" + subexp(\"\\\\.\" + ATEXT$$ + \"+\") + \"*\");\nconst QUOTED_PAIR$ = subexp(\"\\\\\\\\\" + VCHAR$$);\nconst QCONTENT$ = subexp(QTEXT$$ + \"|\" + QUOTED_PAIR$);\nconst QUOTED_STRING$ = subexp('\\\\\"' + QCONTENT$ + \"*\" + '\\\\\"');\n\n//RFC 6068\nconst DTEXT_NO_OBS$$ = \"[\\\\x21-\\\\x5A\\\\x5E-\\\\x7E]\";  //%d33-90 / %d94-126\nconst SOME_DELIMS$$ = \"[\\\\!\\\\$\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\:\\\\@]\";\nconst QCHAR$ = subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$ + \"|\" + SOME_DELIMS$$);\nconst DOMAIN$ = subexp(DOT_ATOM_TEXT$ + \"|\" + \"\\\\[\" + DTEXT_NO_OBS$$ + \"*\" + \"\\\\]\");\nconst LOCAL_PART$ = subexp(DOT_ATOM_TEXT$ + \"|\" + QUOTED_STRING$);\nconst ADDR_SPEC$ = subexp(LOCAL_PART$ + \"\\\\@\" + DOMAIN$);\nconst TO$ = subexp(ADDR_SPEC$ + subexp(\"\\\\,\" + ADDR_SPEC$) + \"*\");\nconst HFNAME$ = subexp(QCHAR$ + \"*\");\nconst HFVALUE$ = HFNAME$;\nconst HFIELD$ = subexp(HFNAME$ + \"\\\\=\" + HFVALUE$);\nconst HFIELDS2$ = subexp(HFIELD$ + subexp(\"\\\\&\" + HFIELD$) + \"*\");\nconst HFIELDS$ = subexp(\"\\\\?\" + HFIELDS2$);\nconst MAILTO_URI = new RegExp(\"^mailto\\\\:\" + TO$ + \"?\" + HFIELDS$ + \"?$\");\n\nconst UNRESERVED = new RegExp(UNRESERVED$$, \"g\");\nconst PCT_ENCODED = new RegExp(PCT_ENCODED$, \"g\");\nconst NOT_LOCAL_PART = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", '[\\\\\"]', VCHAR$$), \"g\");\nconst NOT_DOMAIN = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", \"[\\\\[]\", DTEXT_NO_OBS$$, \"[\\\\]]\"), \"g\");\nconst NOT_HFNAME = new RegExp(merge(\"[^]\", UNRESERVED$$, SOME_DELIMS$$), \"g\");\nconst NOT_HFVALUE = NOT_HFNAME;\nconst TO = new RegExp(\"^\" + TO$ + \"$\");\nconst HFIELDS = new RegExp(\"^\" + HFIELDS2$ + \"$\");\n\nfunction decodeUnreserved(str:string):string {\n\tconst decStr = pctDecChars(str);\n\treturn (!decStr.match(UNRESERVED) ? str : decStr);\n}\n\nconst handler:URISchemeHandler<MailtoComponents> =  {\n\tscheme : \"mailto\",\n\n\tparse : function (components:URIComponents, options:URIOptions):MailtoComponents {\n\t\tconst mailtoComponents = components as MailtoComponents;\n\t\tconst to = mailtoComponents.to = (mailtoComponents.path ? mailtoComponents.path.split(\",\") : []);\n\t\tmailtoComponents.path = undefined;\n\n\t\tif (mailtoComponents.query) {\n\t\t\tlet unknownHeaders = false\n\t\t\tconst headers:MailtoHeaders = {};\n\t\t\tconst hfields = mailtoComponents.query.split(\"&\");\n\n\t\t\tfor (let x = 0, xl = hfields.length; x < xl; ++x) {\n\t\t\t\tconst hfield = hfields[x].split(\"=\");\n\n\t\t\t\tswitch (hfield[0]) {\n\t\t\t\t\tcase \"to\":\n\t\t\t\t\t\tconst toAddrs = hfield[1].split(\",\");\n\t\t\t\t\t\tfor (let x = 0, xl = toAddrs.length; x < xl; ++x) {\n\t\t\t\t\t\t\tto.push(toAddrs[x]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"subject\":\n\t\t\t\t\t\tmailtoComponents.subject = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"body\":\n\t\t\t\t\t\tmailtoComponents.body = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tunknownHeaders = true;\n\t\t\t\t\t\theaders[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (unknownHeaders) mailtoComponents.headers = headers;\n\t\t}\n\n\t\tmailtoComponents.query = undefined;\n\n\t\tfor (let x = 0, xl = to.length; x < xl; ++x) {\n\t\t\tconst addr = to[x].split(\"@\");\n\n\t\t\taddr[0] = unescapeComponent(addr[0]);\n\n\t\t\tif (!options.unicodeSupport) {\n\t\t\t\t//convert Unicode IDN -> ASCII IDN\n\t\t\t\ttry {\n\t\t\t\t\taddr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());\n\t\t\t\t} catch (e) {\n\t\t\t\t\tmailtoComponents.error = mailtoComponents.error || \"Email address's domain name can not be converted to ASCII via punycode: \" + e;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\taddr[1] = unescapeComponent(addr[1], options).toLowerCase();\n\t\t\t}\n\n\t\t\tto[x] = addr.join(\"@\");\n\t\t}\n\n\t\treturn mailtoComponents;\n\t},\n\n\tserialize : function (mailtoComponents:MailtoComponents, options:URIOptions):URIComponents {\n\t\tconst components = mailtoComponents as URIComponents;\n\t\tconst to = toArray(mailtoComponents.to);\n\t\tif (to) {\n\t\t\tfor (let x = 0, xl = to.length; x < xl; ++x) {\n\t\t\t\tconst toAddr = String(to[x]);\n\t\t\t\tconst atIdx = toAddr.lastIndexOf(\"@\");\n\t\t\t\tconst localPart = (toAddr.slice(0, atIdx)).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);\n\t\t\t\tlet domain = toAddr.slice(atIdx + 1);\n\n\t\t\t\t//convert IDN via punycode\n\t\t\t\ttry {\n\t\t\t\t\tdomain = (!options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain));\n\t\t\t\t} catch (e) {\n\t\t\t\t\tcomponents.error = components.error || \"Email address's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n\t\t\t\t}\n\n\t\t\t\tto[x] = localPart + \"@\" + domain;\n\t\t\t}\n\n\t\t\tcomponents.path = to.join(\",\");\n\t\t}\n\n\t\tconst headers = mailtoComponents.headers = mailtoComponents.headers || {};\n\n\t\tif (mailtoComponents.subject) headers[\"subject\"] = mailtoComponents.subject;\n\t\tif (mailtoComponents.body) headers[\"body\"] = mailtoComponents.body;\n\n\t\tconst fields = [];\n\t\tfor (const name in headers) {\n\t\t\tif (headers[name] !== O[name]) {\n\t\t\t\tfields.push(\n\t\t\t\t\tname.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) +\n\t\t\t\t\t\"=\" +\n\t\t\t\t\theaders[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar)\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t\tif (fields.length) {\n\t\t\tcomponents.query = fields.join(\"&\");\n\t\t}\n\n\t\treturn components;\n\t}\n}\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport ws from \"./ws\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"wss\",\n\tdomainHost : ws.domainHost,\n\tparse : ws.parse,\n\tserialize : ws.serialize\n}\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\n\nexport interface WSComponents extends URIComponents {\n\tresourceName?: string;\n\tsecure?: boolean;\n}\n\nfunction isSecure(wsComponents:WSComponents):boolean {\n\treturn typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === \"wss\";\n}\n\n//RFC 6455\nconst handler:URISchemeHandler = {\n\tscheme : \"ws\",\n\n\tdomainHost : true,\n\n\tparse : function (components:URIComponents, options:URIOptions):WSComponents {\n\t\tconst wsComponents = components as WSComponents;\n\n\t\t//indicate if the secure flag is set\n\t\twsComponents.secure = isSecure(wsComponents);\n\n\t\t//construct resouce name\n\t\twsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');\n\t\twsComponents.path = undefined;\n\t\twsComponents.query = undefined;\n\n\t\treturn wsComponents;\n\t},\n\n\tserialize : function (wsComponents:WSComponents, options:URIOptions):URIComponents {\n\t\t//normalize the default port\n\t\tif (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === \"\") {\n\t\t\twsComponents.port = undefined;\n\t\t}\n\n\t\t//ensure scheme matches secure flag\n\t\tif (typeof wsComponents.secure === 'boolean') {\n\t\t\twsComponents.scheme = (wsComponents.secure ? 'wss' : 'ws');\n\t\t\twsComponents.secure = undefined;\n\t\t}\n\n\t\t//reconstruct path from resource name\n\t\tif (wsComponents.resourceName) {\n\t\t\tconst [path, query] = wsComponents.resourceName.split('?');\n\t\t\twsComponents.path = (path && path !== '/' ? path : undefined);\n\t\t\twsComponents.query = query;\n\t\t\twsComponents.resourceName = undefined;\n\t\t}\n\n\t\t//forbid fragment component\n\t\twsComponents.fragment = undefined;\n\n\t\treturn wsComponents;\n\t}\n};\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\nimport http from \"./http\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"https\",\n\tdomainHost : http.domainHost,\n\tparse : http.parse,\n\tserialize : http.serialize\n}\n\nexport default handler;", "import { URISchemeHandler, URIComponents, URIOptions } from \"../uri\";\n\nconst handler:URISchemeHandler = {\n\tscheme : \"http\",\n\n\tdomainHost : true,\n\n\tparse : function (components:URIComponents, options:URIOptions):URIComponents {\n\t\t//report missing host\n\t\tif (!components.host) {\n\t\t\tcomponents.error = components.error || \"HTTP URIs must have a host.\";\n\t\t}\n\n\t\treturn components;\n\t},\n\n\tserialize : function (components:URIComponents, options:URIOptions):URIComponents {\n\t\tconst secure = String(components.scheme).toLowerCase() === \"https\";\n\n\t\t//normalize the default port\n\t\tif (components.port === (secure ? 443 : 80) || components.port === \"\") {\n\t\t\tcomponents.port = undefined;\n\t\t}\n\t\t\n\t\t//normalize the empty path\n\t\tif (!components.path) {\n\t\t\tcomponents.path = \"/\";\n\t\t}\n\n\t\t//NOTE: We do not parse query strings for HTTP URIs\n\t\t//as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n\t\t//and not the HTTP spec.\n\n\t\treturn components;\n\t}\n};\n\nexport default handler;", "/**\n * URI.js\n *\n * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/uri-js\n */\n\n/**\n * Copyright 2011 Gary Court. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n *\n *    1. Redistributions of source code must retain the above copyright notice, this list of\n *       conditions and the following disclaimer.\n *\n *    2. Redistributions in binary form must reproduce the above copyright notice, this list\n *       of conditions and the following disclaimer in the documentation and/or other materials\n *       provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED\n * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\n * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * The views and conclusions contained in the software and documentation are those of the\n * authors and should not be interpreted as representing official policies, either expressed\n * or implied, of Gary Court.\n */\n\nimport URI_PROTOCOL from \"./regexps-uri\";\nimport IRI_PROTOCOL from \"./regexps-iri\";\nimport punycode from \"punycode\";\nimport { toUpperCase, typeOf, assign } from \"./util\";\n\nexport interface URIComponents {\n\tscheme?:string;\n\tuserinfo?:string;\n\thost?:string;\n\tport?:number|string;\n\tpath?:string;\n\tquery?:string;\n\tfragment?:string;\n\treference?:string;\n\terror?:string;\n}\n\nexport interface URIOptions {\n\tscheme?:string;\n\treference?:string;\n\ttolerant?:boolean;\n\tabsolutePath?:boolean;\n\tiri?:boolean;\n\tunicodeSupport?:boolean;\n\tdomainHost?:boolean;\n}\n\nexport interface URISchemeHandler<Components extends URIComponents = URIComponents, Options extends URIOptions = URIOptions, ParentComponents extends URIComponents = URIComponents> {\n\tscheme:string;\n\tparse(components:ParentComponents, options:Options):Components;\n\tserialize(components:Components, options:Options):ParentComponents;\n\tunicodeSupport?:boolean;\n\tdomainHost?:boolean;\n\tabsolutePath?:boolean;\n}\n\nexport interface URIRegExps {\n\tNOT_SCHEME : RegExp,\n\tNOT_USERINFO : RegExp,\n\tNOT_HOST : RegExp,\n\tNOT_PATH : RegExp,\n\tNOT_PATH_NOSCHEME : RegExp,\n\tNOT_QUERY : RegExp,\n\tNOT_FRAGMENT : RegExp,\n\tESCAPE : RegExp,\n\tUNRESERVED : RegExp,\n\tOTHER_CHARS : RegExp,\n\tPCT_ENCODED : RegExp,\n\tIPV4ADDRESS : RegExp,\n\tIPV6ADDRESS : RegExp,\n}\n\nexport const SCHEMES:{[scheme:string]:URISchemeHandler} = {};\n\nexport function pctEncChar(chr:string):string {\n\tconst c = chr.charCodeAt(0);\n\tlet e:string;\n\n\tif (c < 16) e = \"%0\" + c.toString(16).toUpperCase();\n\telse if (c < 128) e = \"%\" + c.toString(16).toUpperCase();\n\telse if (c < 2048) e = \"%\" + ((c >> 6) | 192).toString(16).toUpperCase() + \"%\" + ((c & 63) | 128).toString(16).toUpperCase();\n\telse e = \"%\" + ((c >> 12) | 224).toString(16).toUpperCase() + \"%\" + (((c >> 6) & 63) | 128).toString(16).toUpperCase() + \"%\" + ((c & 63) | 128).toString(16).toUpperCase();\n\n\treturn e;\n}\n\nexport function pctDecChars(str:string):string {\n\tlet newStr = \"\";\n\tlet i = 0;\n\tconst il = str.length;\n\n\twhile (i < il) {\n\t\tconst c = parseInt(str.substr(i + 1, 2), 16);\n\n\t\tif (c < 128) {\n\t\t\tnewStr += String.fromCharCode(c);\n\t\t\ti += 3;\n\t\t}\n\t\telse if (c >= 194 && c < 224) {\n\t\t\tif ((il - i) >= 6) {\n\t\t\t\tconst c2 = parseInt(str.substr(i + 4, 2), 16);\n\t\t\t\tnewStr += String.fromCharCode(((c & 31) << 6) | (c2 & 63));\n\t\t\t} else {\n\t\t\t\tnewStr += str.substr(i, 6);\n\t\t\t}\n\t\t\ti += 6;\n\t\t}\n\t\telse if (c >= 224) {\n\t\t\tif ((il - i) >= 9) {\n\t\t\t\tconst c2 = parseInt(str.substr(i + 4, 2), 16);\n\t\t\t\tconst c3 = parseInt(str.substr(i + 7, 2), 16);\n\t\t\t\tnewStr += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));\n\t\t\t} else {\n\t\t\t\tnewStr += str.substr(i, 9);\n\t\t\t}\n\t\t\ti += 9;\n\t\t}\n\t\telse {\n\t\t\tnewStr += str.substr(i, 3);\n\t\t\ti += 3;\n\t\t}\n\t}\n\n\treturn newStr;\n}\n\nfunction _normalizeComponentEncoding(components:URIComponents, protocol:URIRegExps) {\n\tfunction decodeUnreserved(str:string):string {\n\t\tconst decStr = pctDecChars(str);\n\t\treturn (!decStr.match(protocol.UNRESERVED) ? str : decStr);\n\t}\n\n\tif (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, \"\");\n\tif (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace((components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME), pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\tif (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n\n\treturn components;\n};\n\nfunction _stripLeadingZeros(str:string):string {\n\treturn str.replace(/^0*(.*)/, \"$1\") || \"0\";\n}\n\nfunction _normalizeIPv4(host:string, protocol:URIRegExps):string {\n\tconst matches = host.match(protocol.IPV4ADDRESS) || [];\n\tconst [, address] = matches;\n\t\n\tif (address) {\n\t\treturn address.split(\".\").map(_stripLeadingZeros).join(\".\");\n\t} else {\n\t\treturn host;\n\t}\n}\n\nfunction _normalizeIPv6(host:string, protocol:URIRegExps):string {\n\tconst matches = host.match(protocol.IPV6ADDRESS) || [];\n\tconst [, address, zone] = matches;\n\n\tif (address) {\n\t\tconst [last, first] = address.toLowerCase().split('::').reverse();\n\t\tconst firstFields = first ? first.split(\":\").map(_stripLeadingZeros) : [];\n\t\tconst lastFields = last.split(\":\").map(_stripLeadingZeros);\n\t\tconst isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);\n\t\tconst fieldCount = isLastFieldIPv4Address ? 7 : 8;\n\t\tconst lastFieldsStart = lastFields.length - fieldCount;\n\t\tconst fields = Array<string>(fieldCount);\n\n\t\tfor (let x = 0; x < fieldCount; ++x) {\n\t\t\tfields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';\n\t\t}\n\n\t\tif (isLastFieldIPv4Address) {\n\t\t\tfields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);\n\t\t}\n\n\t\tconst allZeroFields = fields.reduce<Array<{index:number,length:number}>>((acc, field, index) => {\n\t\t\tif (!field || field === \"0\") {\n\t\t\t\tconst lastLongest = acc[acc.length - 1];\n\t\t\t\tif (lastLongest && lastLongest.index + lastLongest.length === index) {\n\t\t\t\t\tlastLongest.length++;\n\t\t\t\t} else {\n\t\t\t\t\tacc.push({ index, length : 1 });\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn acc;\n\t\t}, []);\n\n\t\tconst longestZeroFields = allZeroFields.sort((a, b) => b.length - a.length)[0];\n\n\t\tlet newHost:string;\n\t\tif (longestZeroFields && longestZeroFields.length > 1) {\n\t\t\tconst newFirst = fields.slice(0, longestZeroFields.index) ;\n\t\t\tconst newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);\n\t\t\tnewHost = newFirst.join(\":\") + \"::\" + newLast.join(\":\");\n\t\t} else {\n\t\t\tnewHost = fields.join(\":\");\n\t\t}\n\n\t\tif (zone) {\n\t\t\tnewHost += \"%\" + zone;\n\t\t}\n\n\t\treturn newHost;\n\t} else {\n\t\treturn host;\n\t}\n}\n\nconst URI_PARSE = /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:([^\\/?#@]*)@)?(\\[[^\\/?#\\]]+\\]|[^\\/?#:]*)(?:\\:(\\d*))?))?([^?#]*)(?:\\?([^#]*))?(?:#((?:.|\\n|\\r)*))?/i;\nconst NO_MATCH_IS_UNDEFINED = (<RegExpMatchArray>(\"\").match(/(){0}/))[1] === undefined;\n\nexport function parse(uriString:string, options:URIOptions = {}):URIComponents {\n\tconst components:URIComponents = {};\n\tconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);\n\n\tif (options.reference === \"suffix\") uriString = (options.scheme ? options.scheme + \":\" : \"\") + \"//\" + uriString;\n\n\tconst matches = uriString.match(URI_PARSE);\n\n\tif (matches) {\n\t\tif (NO_MATCH_IS_UNDEFINED) {\n\t\t\t//store each component\n\t\t\tcomponents.scheme = matches[1];\n\t\t\tcomponents.userinfo = matches[3];\n\t\t\tcomponents.host = matches[4];\n\t\t\tcomponents.port = parseInt(matches[5], 10);\n\t\t\tcomponents.path = matches[6] || \"\";\n\t\t\tcomponents.query = matches[7];\n\t\t\tcomponents.fragment = matches[8];\n\n\t\t\t//fix port number\n\t\t\tif (isNaN(components.port)) {\n\t\t\t\tcomponents.port = matches[5];\n\t\t\t}\n\t\t} else {  //IE FIX for improper RegExp matching\n\t\t\t//store each component\n\t\t\tcomponents.scheme = matches[1] || undefined;\n\t\t\tcomponents.userinfo = (uriString.indexOf(\"@\") !== -1 ? matches[3] : undefined);\n\t\t\tcomponents.host = (uriString.indexOf(\"//\") !== -1 ? matches[4] : undefined);\n\t\t\tcomponents.port = parseInt(matches[5], 10);\n\t\t\tcomponents.path = matches[6] || \"\";\n\t\t\tcomponents.query = (uriString.indexOf(\"?\") !== -1 ? matches[7] : undefined);\n\t\t\tcomponents.fragment = (uriString.indexOf(\"#\") !== -1 ? matches[8] : undefined);\n\n\t\t\t//fix port number\n\t\t\tif (isNaN(components.port)) {\n\t\t\t\tcomponents.port = (uriString.match(/\\/\\/(?:.|\\n)*\\:(?:\\/|\\?|\\#|$)/) ? matches[4] : undefined);\n\t\t\t}\n\t\t}\n\n\t\tif (components.host) {\n\t\t\t//normalize IP hosts\n\t\t\tcomponents.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);\n\t\t}\n\n\t\t//determine reference type\n\t\tif (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {\n\t\t\tcomponents.reference = \"same-document\";\n\t\t} else if (components.scheme === undefined) {\n\t\t\tcomponents.reference = \"relative\";\n\t\t} else if (components.fragment === undefined) {\n\t\t\tcomponents.reference = \"absolute\";\n\t\t} else {\n\t\t\tcomponents.reference = \"uri\";\n\t\t}\n\n\t\t//check for reference errors\n\t\tif (options.reference && options.reference !== \"suffix\" && options.reference !== components.reference) {\n\t\t\tcomponents.error = components.error || \"URI is not a \" + options.reference + \" reference.\";\n\t\t}\n\n\t\t//find scheme handler\n\t\tconst schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n\n\t\t//check if scheme can't handle IRIs\n\t\tif (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n\t\t\t//if host component is a domain name\n\t\t\tif (components.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost))) {\n\t\t\t\t//convert Unicode IDN -> ASCII IDN\n\t\t\t\ttry {\n\t\t\t\t\tcomponents.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());\n\t\t\t\t} catch (e) {\n\t\t\t\t\tcomponents.error = components.error || \"Host's domain name can not be converted to ASCII via punycode: \" + e;\n\t\t\t\t}\n\t\t\t}\n\t\t\t//convert IRI -> URI\n\t\t\t_normalizeComponentEncoding(components, URI_PROTOCOL);\n\t\t} else {\n\t\t\t//normalize encodings\n\t\t\t_normalizeComponentEncoding(components, protocol);\n\t\t}\n\n\t\t//perform scheme specific parsing\n\t\tif (schemeHandler && schemeHandler.parse) {\n\t\t\tschemeHandler.parse(components, options);\n\t\t}\n\t} else {\n\t\tcomponents.error = components.error || \"URI can not be parsed.\";\n\t}\n\n\treturn components;\n};\n\nfunction _recomposeAuthority(components:URIComponents, options:URIOptions):string|undefined {\n\tconst protocol = (options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL);\n\tconst uriTokens:Array<string> = [];\n\n\tif (components.userinfo !== undefined) {\n\t\turiTokens.push(components.userinfo);\n\t\turiTokens.push(\"@\");\n\t}\n\n\tif (components.host !== undefined) {\n\t\t//normalize IP hosts, add brackets and escape zone separator for IPv6\n\t\turiTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, (_, $1, $2) => \"[\" + $1 + ($2 ? \"%25\" + $2 : \"\") + \"]\"));\n\t}\n\n\tif (typeof components.port === \"number\" || typeof components.port === \"string\") {\n\t\turiTokens.push(\":\");\n\t\turiTokens.push(String(components.port));\n\t}\n\n\treturn uriTokens.length ? uriTokens.join(\"\") : undefined;\n};\n\nconst RDS1 = /^\\.\\.?\\//;\nconst RDS2 = /^\\/\\.(\\/|$)/;\nconst RDS3 = /^\\/\\.\\.(\\/|$)/;\nconst RDS4 = /^\\.\\.?$/;\nconst RDS5 = /^\\/?(?:.|\\n)*?(?=\\/|$)/;\n\nexport function removeDotSegments(input:string):string {\n\tconst output:Array<string> = [];\n\n\twhile (input.length) {\n\t\tif (input.match(RDS1)) {\n\t\t\tinput = input.replace(RDS1, \"\");\n\t\t} else if (input.match(RDS2)) {\n\t\t\tinput = input.replace(RDS2, \"/\");\n\t\t} else if (input.match(RDS3)) {\n\t\t\tinput = input.replace(RDS3, \"/\");\n\t\t\toutput.pop();\n\t\t} else if (input === \".\" || input === \"..\") {\n\t\t\tinput = \"\";\n\t\t} else {\n\t\t\tconst im = input.match(RDS5);\n\t\t\tif (im) {\n\t\t\t\tconst s = im[0];\n\t\t\t\tinput = input.slice(s.length);\n\t\t\t\toutput.push(s);\n\t\t\t} else {\n\t\t\t\tthrow new Error(\"Unexpected dot segment condition\");\n\t\t\t}\n\t\t}\n\t}\n\n\treturn output.join(\"\");\n};\n\nexport function serialize(components:URIComponents, options:URIOptions = {}):string {\n\tconst protocol = (options.iri ? IRI_PROTOCOL : URI_PROTOCOL);\n\tconst uriTokens:Array<string> = [];\n\n\t//find scheme handler\n\tconst schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n\n\t//perform scheme specific serialization\n\tif (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);\n\n\tif (components.host) {\n\t\t//if host component is an IPv6 address\n\t\tif (protocol.IPV6ADDRESS.test(components.host)) {\n\t\t\t//TODO: normalize IPv6 address as per RFC 5952\n\t\t}\n\n\t\t//if host component is a domain name\n\t\telse if (options.domainHost || (schemeHandler && schemeHandler.domainHost)) {\n\t\t\t//convert IDN via punycode\n\t\t\ttry {\n\t\t\t\tcomponents.host = (!options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host));\n\t\t\t} catch (e) {\n\t\t\t\tcomponents.error = components.error || \"Host's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n\t\t\t}\n\t\t}\n\t}\n\n\t//normalize encoding\n\t_normalizeComponentEncoding(components, protocol);\n\n\tif (options.reference !== \"suffix\" && components.scheme) {\n\t\turiTokens.push(components.scheme);\n\t\turiTokens.push(\":\");\n\t}\n\n\tconst authority = _recomposeAuthority(components, options);\n\tif (authority !== undefined) {\n\t\tif (options.reference !== \"suffix\") {\n\t\t\turiTokens.push(\"//\");\n\t\t}\n\n\t\turiTokens.push(authority);\n\n\t\tif (components.path && components.path.charAt(0) !== \"/\") {\n\t\t\turiTokens.push(\"/\");\n\t\t}\n\t}\n\n\tif (components.path !== undefined) {\n\t\tlet s = components.path;\n\n\t\tif (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n\t\t\ts = removeDotSegments(s);\n\t\t}\n\n\t\tif (authority === undefined) {\n\t\t\ts = s.replace(/^\\/\\//, \"/%2F\");  //don't allow the path to start with \"//\"\n\t\t}\n\n\t\turiTokens.push(s);\n\t}\n\n\tif (components.query !== undefined) {\n\t\turiTokens.push(\"?\");\n\t\turiTokens.push(components.query);\n\t}\n\n\tif (components.fragment !== undefined) {\n\t\turiTokens.push(\"#\");\n\t\turiTokens.push(components.fragment);\n\t}\n\n\treturn uriTokens.join(\"\");  //merge tokens into a string\n};\n\nexport function resolveComponents(base:URIComponents, relative:URIComponents, options:URIOptions = {}, skipNormalization?:boolean):URIComponents {\n\tconst target:URIComponents = {};\n\n\tif (!skipNormalization) {\n\t\tbase = parse(serialize(base, options), options);  //normalize base components\n\t\trelative = parse(serialize(relative, options), options);  //normalize relative components\n\t}\n\toptions = options || {};\n\n\tif (!options.tolerant && relative.scheme) {\n\t\ttarget.scheme = relative.scheme;\n\t\t//target.authority = relative.authority;\n\t\ttarget.userinfo = relative.userinfo;\n\t\ttarget.host = relative.host;\n\t\ttarget.port = relative.port;\n\t\ttarget.path = removeDotSegments(relative.path || \"\");\n\t\ttarget.query = relative.query;\n\t} else {\n\t\tif (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n\t\t\t//target.authority = relative.authority;\n\t\t\ttarget.userinfo = relative.userinfo;\n\t\t\ttarget.host = relative.host;\n\t\t\ttarget.port = relative.port;\n\t\t\ttarget.path = removeDotSegments(relative.path || \"\");\n\t\t\ttarget.query = relative.query;\n\t\t} else {\n\t\t\tif (!relative.path) {\n\t\t\t\ttarget.path = base.path;\n\t\t\t\tif (relative.query !== undefined) {\n\t\t\t\t\ttarget.query = relative.query;\n\t\t\t\t} else {\n\t\t\t\t\ttarget.query = base.query;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (relative.path.charAt(0) === \"/\") {\n\t\t\t\t\ttarget.path = removeDotSegments(relative.path);\n\t\t\t\t} else {\n\t\t\t\t\tif ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n\t\t\t\t\t\ttarget.path = \"/\" + relative.path;\n\t\t\t\t\t} else if (!base.path) {\n\t\t\t\t\t\ttarget.path = relative.path;\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttarget.path = base.path.slice(0, base.path.lastIndexOf(\"/\") + 1) + relative.path;\n\t\t\t\t\t}\n\t\t\t\t\ttarget.path = removeDotSegments(target.path);\n\t\t\t\t}\n\t\t\t\ttarget.query = relative.query;\n\t\t\t}\n\t\t\t//target.authority = base.authority;\n\t\t\ttarget.userinfo = base.userinfo;\n\t\t\ttarget.host = base.host;\n\t\t\ttarget.port = base.port;\n\t\t}\n\t\ttarget.scheme = base.scheme;\n\t}\n\n\ttarget.fragment = relative.fragment;\n\n\treturn target;\n};\n\nexport function resolve(baseURI:string, relativeURI:string, options?:URIOptions):string {\n\tconst schemelessOptions = assign({ scheme : 'null' }, options);\n\treturn serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);\n};\n\nexport function normalize(uri:string, options?:URIOptions):string;\nexport function normalize(uri:URIComponents, options?:URIOptions):URIComponents;\nexport function normalize(uri:any, options?:URIOptions):any {\n\tif (typeof uri === \"string\") {\n\t\turi = serialize(parse(uri, options), options);\n\t} else if (typeOf(uri) === \"object\") {\n\t\turi = parse(serialize(<URIComponents>uri, options), options);\n\t}\n\n\treturn uri;\n};\n\nexport function equal(uriA:string, uriB:string, options?: URIOptions):boolean;\nexport function equal(uriA:URIComponents, uriB:URIComponents, options?:URIOptions):boolean;\nexport function equal(uriA:any, uriB:any, options?:URIOptions):boolean {\n\tif (typeof uriA === \"string\") {\n\t\turiA = serialize(parse(uriA, options), options);\n\t} else if (typeOf(uriA) === \"object\") {\n\t\turiA = serialize(<URIComponents>uriA, options);\n\t}\n\n\tif (typeof uriB === \"string\") {\n\t\turiB = serialize(parse(uriB, options), options);\n\t} else if (typeOf(uriB) === \"object\") {\n\t\turiB = serialize(<URIComponents>uriB, options);\n\t}\n\n\treturn uriA === uriB;\n};\n\nexport function escapeComponent(str:string, options?:URIOptions):string {\n\treturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE), pctEncChar);\n};\n\nexport function unescapeComponent(str:string, options?:URIOptions):string {\n\treturn str && str.toString().replace((!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED), pctDecChars);\n};\n", "'use strict';\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7E]/; // non-ASCII chars\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, fn) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = fn(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {Array} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(string, fn) {\n\tconst parts = string.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tstring = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tstring = string.replace(regexSeparators, '\\x2E');\n\tconst labels = string.split('.');\n\tconst encoded = map(labels, fn).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = array => String.fromCodePoint(...array);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint - 0x30 < 0x0A) {\n\t\treturn codePoint - 0x16;\n\t}\n\tif (codePoint - 0x41 < 0x1A) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint - 0x61 < 0x1A) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tlet oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tlet inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tlet basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue == n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.1.0',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\nexport default punycode;\n", "import { URIRegExps } from \"./uri\";\nimport { buildExps } from \"./regexps-uri\";\n\nexport default buildExps(true);\n", "import { URIRegExps } from \"./uri\";\nimport { merge, subexp } from \"./util\";\n\nexport function buildExps(isIRI:boolean):URIRegExps {\n\tconst\n\t\tALPHA$$ = \"[A-Za-z]\",\n\t\tCR$ = \"[\\\\x0D]\",\n\t\tDIGIT$$ = \"[0-9]\",\n\t\tDQUOTE$$ = \"[\\\\x22]\",\n\t\tHEXDIG$$ = merge(DIGIT$$, \"[A-Fa-f]\"),  //case-insensitive\n\t\tLF$$ = \"[\\\\x0A]\",\n\t\tSP$$ = \"[\\\\x20]\",\n\t\tPCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)),  //expanded\n\t\tGEN_DELIMS$$ = \"[\\\\:\\\\/\\\\?\\\\#\\\\[\\\\]\\\\@]\",\n\t\tSUB_DELIMS$$ = \"[\\\\!\\\\$\\\\&\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\=]\",\n\t\tRESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),\n\t\tUCSCHAR$$ = isIRI ? \"[\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF]\" : \"[]\",  //subset, excludes bidi control characters\n\t\tIPRIVATE$$ = isIRI ? \"[\\\\uE000-\\\\uF8FF]\" : \"[]\",  //subset\n\t\tUNRESERVED$$ = merge(ALPHA$$, DIGIT$$, \"[\\\\-\\\\.\\\\_\\\\~]\", UCSCHAR$$),\n\t\tSCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\") + \"*\"),\n\t\tUSERINFO$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\")) + \"*\"),\n\t\tDEC_OCTET$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"[1-9]\" + DIGIT$$) + \"|\" + DIGIT$$),\n\t\tDEC_OCTET_RELAXED$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"0?[1-9]\" + DIGIT$$) + \"|0?0?\" + DIGIT$$),  //relaxed parsing rules\n\t\tIPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$),\n\t\tH16$ = subexp(HEXDIG$$ + \"{1,4}\"),\n\t\tLS32$ = subexp(subexp(H16$ + \"\\\\:\" + H16$) + \"|\" + IPV4ADDRESS$),\n\t\tIPV6ADDRESS1$ = subexp(                                                            subexp(H16$ + \"\\\\:\") + \"{6}\" + LS32$), //                           6( h16 \":\" ) ls32\n\t\tIPV6ADDRESS2$ = subexp(                                                 \"\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{5}\" + LS32$), //                      \"::\" 5( h16 \":\" ) ls32\n\t\tIPV6ADDRESS3$ = subexp(subexp(                                 H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{4}\" + LS32$), //[               h16 ] \"::\" 4( h16 \":\" ) ls32\n\t\tIPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,1}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{3}\" + LS32$), //[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n\t\tIPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,2}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{2}\" + LS32$), //[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n\t\tIPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,3}\" + H16$) + \"?\\\\:\\\\:\" +        H16$ + \"\\\\:\"          + LS32$), //[ *3( h16 \":\" ) h16 ] \"::\"    h16 \":\"   ls32\n\t\tIPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,4}\" + H16$) + \"?\\\\:\\\\:\"                                + LS32$), //[ *4( h16 \":\" ) h16 ] \"::\"              ls32\n\t\tIPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,5}\" + H16$) + \"?\\\\:\\\\:\"                                + H16$ ), //[ *5( h16 \":\" ) h16 ] \"::\"              h16\n\t\tIPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,6}\" + H16$) + \"?\\\\:\\\\:\"                                       ), //[ *6( h16 \":\" ) h16 ] \"::\"\n\t\tIPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join(\"|\")),\n\t\tZONEID$ = subexp(subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$) + \"+\"),  //RFC 6874\n\t\tIPV6ADDRZ$ = subexp(IPV6ADDRESS$ + \"\\\\%25\" + ZONEID$),  //RFC 6874\n\t\tIPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + ZONEID$),  //RFC 6874, with relaxed parsing rules\n\t\tIPVFUTURE$ = subexp(\"[vV]\" + HEXDIG$$ + \"+\\\\.\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\") + \"+\"),\n\t\tIP_LITERAL$ = subexp(\"\\\\[\" + subexp(IPV6ADDRZ_RELAXED$ + \"|\" + IPV6ADDRESS$ + \"|\" + IPVFUTURE$) + \"\\\\]\"),  //RFC 6874\n\t\tREG_NAME$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$)) + \"*\"),\n\t\tHOST$ = subexp(IP_LITERAL$ + \"|\" + IPV4ADDRESS$ + \"(?!\" + REG_NAME$ + \")\" + \"|\" + REG_NAME$),\n\t\tPORT$ = subexp(DIGIT$$ + \"*\"),\n\t\tAUTHORITY$ = subexp(subexp(USERINFO$ + \"@\") + \"?\" + HOST$ + subexp(\"\\\\:\" + PORT$) + \"?\"),\n\t\tPCHAR$ = subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@]\")),\n\t\tSEGMENT$ = subexp(PCHAR$ + \"*\"),\n\t\tSEGMENT_NZ$ = subexp(PCHAR$ + \"+\"),\n\t\tSEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\@]\")) + \"+\"),\n\t\tPATH_ABEMPTY$ = subexp(subexp(\"\\\\/\" + SEGMENT$) + \"*\"),\n\t\tPATH_ABSOLUTE$ = subexp(\"\\\\/\" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + \"?\"),  //simplified\n\t\tPATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$),  //simplified\n\t\tPATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$),  //simplified\n\t\tPATH_EMPTY$ = \"(?!\" + PCHAR$ + \")\",\n\t\tPATH$ = subexp(PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n\t\tQUERY$ = subexp(subexp(PCHAR$ + \"|\" + merge(\"[\\\\/\\\\?]\", IPRIVATE$$)) + \"*\"),\n\t\tFRAGMENT$ = subexp(subexp(PCHAR$ + \"|[\\\\/\\\\?]\") + \"*\"),\n\t\tHIER_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n\t\tURI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n\t\tRELATIVE_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$),\n\t\tRELATIVE$ = subexp(RELATIVE_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n\t\tURI_REFERENCE$ = subexp(URI$ + \"|\" + RELATIVE$),\n\t\tABSOLUTE_URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\"),\n\n\t\tGENERIC_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tRELATIVE_REF$ = \"^(){0}\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tABSOLUTE_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?$\",\n\t\tSAMEDOC_REF$ = \"^\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n\t\tAUTHORITY_REF$ = \"^\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?$\"\n\t;\n\n\treturn {\n\t\tNOT_SCHEME : new RegExp(merge(\"[^]\", ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\"), \"g\"),\n\t\tNOT_USERINFO : new RegExp(merge(\"[^\\\\%\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_HOST : new RegExp(merge(\"[^\\\\%\\\\[\\\\]\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_PATH : new RegExp(merge(\"[^\\\\%\\\\/\\\\:\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_PATH_NOSCHEME : new RegExp(merge(\"[^\\\\%\\\\/\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tNOT_QUERY : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\", IPRIVATE$$), \"g\"),\n\t\tNOT_FRAGMENT : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\"), \"g\"),\n\t\tESCAPE : new RegExp(merge(\"[^]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n\t\tUNRESERVED : new RegExp(UNRESERVED$$, \"g\"),\n\t\tOTHER_CHARS : new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, RESERVED$$), \"g\"),\n\t\tPCT_ENCODED : new RegExp(PCT_ENCODED$, \"g\"),\n\t\tIPV4ADDRESS : new RegExp(\"^(\" + IPV4ADDRESS$ + \")$\"),\n\t\tIPV6ADDRESS : new RegExp(\"^\\\\[?(\" + IPV6ADDRESS$ + \")\" + subexp(subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + \"(\" + ZONEID$ + \")\") + \"?\\\\]?$\")  //RFC 6874, with relaxed parsing rules\n\t};\n}\n\nexport default buildExps(false);\n", "export function merge(...sets:Array<string>):string {\n\tif (sets.length > 1) {\n\t\tsets[0] = sets[0].slice(0, -1);\n\t\tconst xl = sets.length - 1;\n\t\tfor (let x = 1; x < xl; ++x) {\n\t\t\tsets[x] = sets[x].slice(1, -1);\n\t\t}\n\t\tsets[xl] = sets[xl].slice(1);\n\t\treturn sets.join('');\n\t} else {\n\t\treturn sets[0];\n\t}\n}\n\nexport function subexp(str:string):string {\n\treturn \"(?:\" + str + \")\";\n}\n\nexport function typeOf(o:any):string {\n\treturn o === undefined ? \"undefined\" : (o === null ? \"null\" : Object.prototype.toString.call(o).split(\" \").pop().split(\"]\").shift().toLowerCase());\n}\n\nexport function toUpperCase(str:string):string {\n\treturn str.toUpperCase();\n}\n\nexport function toArray(obj:any):Array<any> {\n\treturn obj !== undefined && obj !== null ? (obj instanceof Array ? obj : (typeof obj.length !== \"number\" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj))) : [];\n}\n\n\nexport function assign(target: object, source: any): any {\n\tconst obj = target as any;\n\tif (source) {\n\t\tfor (const key in source) {\n\t\t\tobj[key] = source[key];\n\t\t}\n\t}\n\treturn obj;\n}", "'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n", "'use strict';\n\n// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nmodule.exports = function ucs2length(str) {\n  var length = 0\n    , len = str.length\n    , pos = 0\n    , value;\n  while (pos < len) {\n    length++;\n    value = str.charCodeAt(pos++);\n    if (value >= 0xD800 && value <= 0xDBFF && pos < len) {\n      // high surrogate, and there is a next character\n      value = str.charCodeAt(pos);\n      if ((value & 0xFC00) == 0xDC00) pos++; // low surrogate\n    }\n  }\n  return length;\n};\n", "'use strict';\n\n\nmodule.exports = {\n  copy: copy,\n  checkDataType: checkDataType,\n  checkDataTypes: checkDataTypes,\n  coerceToTypes: coerceToTypes,\n  toHash: toHash,\n  getProperty: getProperty,\n  escapeQuotes: escapeQuotes,\n  equal: require('fast-deep-equal'),\n  ucs2length: require('./ucs2length'),\n  varOccurences: varOccurences,\n  varReplace: varReplace,\n  schemaHasRules: schemaHasRules,\n  schemaHasRulesExcept: schemaHasRulesExcept,\n  schemaUnknownRules: schemaUnknownRules,\n  toQuotedString: toQuotedString,\n  getPathExpr: getPathExpr,\n  getPath: getPath,\n  getData: getData,\n  unescapeFragment: unescapeFragment,\n  unescapeJsonPointer: unescapeJsonPointer,\n  escapeFragment: escapeFragment,\n  escapeJsonPointer: escapeJsonPointer\n};\n\n\nfunction copy(o, to) {\n  to = to || {};\n  for (var key in o) to[key] = o[key];\n  return to;\n}\n\n\nfunction checkDataType(dataType, data, strictNumbers, negate) {\n  var EQUAL = negate ? ' !== ' : ' === '\n    , AND = negate ? ' || ' : ' && '\n    , OK = negate ? '!' : ''\n    , NOT = negate ? '' : '!';\n  switch (dataType) {\n    case 'null': return data + EQUAL + 'null';\n    case 'array': return OK + 'Array.isArray(' + data + ')';\n    case 'object': return '(' + OK + data + AND +\n                          'typeof ' + data + EQUAL + '\"object\"' + AND +\n                          NOT + 'Array.isArray(' + data + '))';\n    case 'integer': return '(typeof ' + data + EQUAL + '\"number\"' + AND +\n                           NOT + '(' + data + ' % 1)' +\n                           AND + data + EQUAL + data +\n                           (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')';\n    case 'number': return '(typeof ' + data + EQUAL + '\"' + dataType + '\"' +\n                          (strictNumbers ? (AND + OK + 'isFinite(' + data + ')') : '') + ')';\n    default: return 'typeof ' + data + EQUAL + '\"' + dataType + '\"';\n  }\n}\n\n\nfunction checkDataTypes(dataTypes, data, strictNumbers) {\n  switch (dataTypes.length) {\n    case 1: return checkDataType(dataTypes[0], data, strictNumbers, true);\n    default:\n      var code = '';\n      var types = toHash(dataTypes);\n      if (types.array && types.object) {\n        code = types.null ? '(': '(!' + data + ' || ';\n        code += 'typeof ' + data + ' !== \"object\")';\n        delete types.null;\n        delete types.array;\n        delete types.object;\n      }\n      if (types.number) delete types.integer;\n      for (var t in types)\n        code += (code ? ' && ' : '' ) + checkDataType(t, data, strictNumbers, true);\n\n      return code;\n  }\n}\n\n\nvar COERCE_TO_TYPES = toHash([ 'string', 'number', 'integer', 'boolean', 'null' ]);\nfunction coerceToTypes(optionCoerceTypes, dataTypes) {\n  if (Array.isArray(dataTypes)) {\n    var types = [];\n    for (var i=0; i<dataTypes.length; i++) {\n      var t = dataTypes[i];\n      if (COERCE_TO_TYPES[t]) types[types.length] = t;\n      else if (optionCoerceTypes === 'array' && t === 'array') types[types.length] = t;\n    }\n    if (types.length) return types;\n  } else if (COERCE_TO_TYPES[dataTypes]) {\n    return [dataTypes];\n  } else if (optionCoerceTypes === 'array' && dataTypes === 'array') {\n    return ['array'];\n  }\n}\n\n\nfunction toHash(arr) {\n  var hash = {};\n  for (var i=0; i<arr.length; i++) hash[arr[i]] = true;\n  return hash;\n}\n\n\nvar IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;\nvar SINGLE_QUOTE = /'|\\\\/g;\nfunction getProperty(key) {\n  return typeof key == 'number'\n          ? '[' + key + ']'\n          : IDENTIFIER.test(key)\n            ? '.' + key\n            : \"['\" + escapeQuotes(key) + \"']\";\n}\n\n\nfunction escapeQuotes(str) {\n  return str.replace(SINGLE_QUOTE, '\\\\$&')\n            .replace(/\\n/g, '\\\\n')\n            .replace(/\\r/g, '\\\\r')\n            .replace(/\\f/g, '\\\\f')\n            .replace(/\\t/g, '\\\\t');\n}\n\n\nfunction varOccurences(str, dataVar) {\n  dataVar += '[^0-9]';\n  var matches = str.match(new RegExp(dataVar, 'g'));\n  return matches ? matches.length : 0;\n}\n\n\nfunction varReplace(str, dataVar, expr) {\n  dataVar += '([^0-9])';\n  expr = expr.replace(/\\$/g, '$$$$');\n  return str.replace(new RegExp(dataVar, 'g'), expr + '$1');\n}\n\n\nfunction schemaHasRules(schema, rules) {\n  if (typeof schema == 'boolean') return !schema;\n  for (var key in schema) if (rules[key]) return true;\n}\n\n\nfunction schemaHasRulesExcept(schema, rules, exceptKeyword) {\n  if (typeof schema == 'boolean') return !schema && exceptKeyword != 'not';\n  for (var key in schema) if (key != exceptKeyword && rules[key]) return true;\n}\n\n\nfunction schemaUnknownRules(schema, rules) {\n  if (typeof schema == 'boolean') return;\n  for (var key in schema) if (!rules[key]) return key;\n}\n\n\nfunction toQuotedString(str) {\n  return '\\'' + escapeQuotes(str) + '\\'';\n}\n\n\nfunction getPathExpr(currentPath, expr, jsonPointers, isNumber) {\n  var path = jsonPointers // false by default\n              ? '\\'/\\' + ' + expr + (isNumber ? '' : '.replace(/~/g, \\'~0\\').replace(/\\\\//g, \\'~1\\')')\n              : (isNumber ? '\\'[\\' + ' + expr + ' + \\']\\'' : '\\'[\\\\\\'\\' + ' + expr + ' + \\'\\\\\\']\\'');\n  return joinPaths(currentPath, path);\n}\n\n\nfunction getPath(currentPath, prop, jsonPointers) {\n  var path = jsonPointers // false by default\n              ? toQuotedString('/' + escapeJsonPointer(prop))\n              : toQuotedString(getProperty(prop));\n  return joinPaths(currentPath, path);\n}\n\n\nvar JSON_POINTER = /^\\/(?:[^~]|~0|~1)*$/;\nvar RELATIVE_JSON_POINTER = /^([0-9]+)(#|\\/(?:[^~]|~0|~1)*)?$/;\nfunction getData($data, lvl, paths) {\n  var up, jsonPointer, data, matches;\n  if ($data === '') return 'rootData';\n  if ($data[0] == '/') {\n    if (!JSON_POINTER.test($data)) throw new Error('Invalid JSON-pointer: ' + $data);\n    jsonPointer = $data;\n    data = 'rootData';\n  } else {\n    matches = $data.match(RELATIVE_JSON_POINTER);\n    if (!matches) throw new Error('Invalid JSON-pointer: ' + $data);\n    up = +matches[1];\n    jsonPointer = matches[2];\n    if (jsonPointer == '#') {\n      if (up >= lvl) throw new Error('Cannot access property/index ' + up + ' levels up, current level is ' + lvl);\n      return paths[lvl - up];\n    }\n\n    if (up > lvl) throw new Error('Cannot access data ' + up + ' levels up, current level is ' + lvl);\n    data = 'data' + ((lvl - up) || '');\n    if (!jsonPointer) return data;\n  }\n\n  var expr = data;\n  var segments = jsonPointer.split('/');\n  for (var i=0; i<segments.length; i++) {\n    var segment = segments[i];\n    if (segment) {\n      data += getProperty(unescapeJsonPointer(segment));\n      expr += ' && ' + data;\n    }\n  }\n  return expr;\n}\n\n\nfunction joinPaths (a, b) {\n  if (a == '\"\"') return b;\n  return (a + ' + ' + b).replace(/([^\\\\])' \\+ '/g, '$1');\n}\n\n\nfunction unescapeFragment(str) {\n  return unescapeJsonPointer(decodeURIComponent(str));\n}\n\n\nfunction escapeFragment(str) {\n  return encodeURIComponent(escapeJsonPointer(str));\n}\n\n\nfunction escapeJsonPointer(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n\n\nfunction unescapeJsonPointer(str) {\n  return str.replace(/~1/g, '/').replace(/~0/g, '~');\n}\n", "'use strict';\n\nvar util = require('./util');\n\nmodule.exports = SchemaObject;\n\nfunction SchemaObject(obj) {\n  util.copy(obj, this);\n}\n", "'use strict';\n\nvar traverse = module.exports = function (schema, opts, cb) {\n  // Legacy support for v0.3.1 and earlier.\n  if (typeof opts == 'function') {\n    cb = opts;\n    opts = {};\n  }\n\n  cb = opts.cb || cb;\n  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};\n  var post = cb.post || function() {};\n\n  _traverse(opts, pre, post, schema, '', schema);\n};\n\n\ntraverse.keywords = {\n  additionalItems: true,\n  items: true,\n  contains: true,\n  additionalProperties: true,\n  propertyNames: true,\n  not: true\n};\n\ntraverse.arrayKeywords = {\n  items: true,\n  allOf: true,\n  anyOf: true,\n  oneOf: true\n};\n\ntraverse.propsKeywords = {\n  definitions: true,\n  properties: true,\n  patternProperties: true,\n  dependencies: true\n};\n\ntraverse.skipKeywords = {\n  default: true,\n  enum: true,\n  const: true,\n  required: true,\n  maximum: true,\n  minimum: true,\n  exclusiveMaximum: true,\n  exclusiveMinimum: true,\n  multipleOf: true,\n  maxLength: true,\n  minLength: true,\n  pattern: true,\n  format: true,\n  maxItems: true,\n  minItems: true,\n  uniqueItems: true,\n  maxProperties: true,\n  minProperties: true\n};\n\n\nfunction _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {\n    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n    for (var key in schema) {\n      var sch = schema[key];\n      if (Array.isArray(sch)) {\n        if (key in traverse.arrayKeywords) {\n          for (var i=0; i<sch.length; i++)\n            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);\n        }\n      } else if (key in traverse.propsKeywords) {\n        if (sch && typeof sch == 'object') {\n          for (var prop in sch)\n            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);\n        }\n      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {\n        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);\n      }\n    }\n    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);\n  }\n}\n\n\nfunction escapeJsonPtr(str) {\n  return str.replace(/~/g, '~0').replace(/\\//g, '~1');\n}\n", "'use strict';\n\nvar URI = require('uri-js')\n  , equal = require('fast-deep-equal')\n  , util = require('./util')\n  , SchemaObject = require('./schema_obj')\n  , traverse = require('json-schema-traverse');\n\nmodule.exports = resolve;\n\nresolve.normalizeId = normalizeId;\nresolve.fullPath = getFullPath;\nresolve.url = resolveUrl;\nresolve.ids = resolveIds;\nresolve.inlineRef = inlineRef;\nresolve.schema = resolveSchema;\n\n/**\n * [resolve and compile the references ($ref)]\n * @this   Ajv\n * @param  {Function} compile reference to schema compilation funciton (localCompile)\n * @param  {Object} root object with information about the root schema for the current schema\n * @param  {String} ref reference to resolve\n * @return {Object|Function} schema object (if the schema can be inlined) or validation function\n */\nfunction resolve(compile, root, ref) {\n  /* jshint validthis: true */\n  var refVal = this._refs[ref];\n  if (typeof refVal == 'string') {\n    if (this._refs[refVal]) refVal = this._refs[refVal];\n    else return resolve.call(this, compile, root, refVal);\n  }\n\n  refVal = refVal || this._schemas[ref];\n  if (refVal instanceof SchemaObject) {\n    return inlineRef(refVal.schema, this._opts.inlineRefs)\n            ? refVal.schema\n            : refVal.validate || this._compile(refVal);\n  }\n\n  var res = resolveSchema.call(this, root, ref);\n  var schema, v, baseId;\n  if (res) {\n    schema = res.schema;\n    root = res.root;\n    baseId = res.baseId;\n  }\n\n  if (schema instanceof SchemaObject) {\n    v = schema.validate || compile.call(this, schema.schema, root, undefined, baseId);\n  } else if (schema !== undefined) {\n    v = inlineRef(schema, this._opts.inlineRefs)\n        ? schema\n        : compile.call(this, schema, root, undefined, baseId);\n  }\n\n  return v;\n}\n\n\n/**\n * Resolve schema, its root and baseId\n * @this Ajv\n * @param  {Object} root root object with properties schema, refVal, refs\n * @param  {String} ref  reference to resolve\n * @return {Object} object with properties schema, root, baseId\n */\nfunction resolveSchema(root, ref) {\n  /* jshint validthis: true */\n  var p = URI.parse(ref)\n    , refPath = _getFullPath(p)\n    , baseId = getFullPath(this._getId(root.schema));\n  if (Object.keys(root.schema).length === 0 || refPath !== baseId) {\n    var id = normalizeId(refPath);\n    var refVal = this._refs[id];\n    if (typeof refVal == 'string') {\n      return resolveRecursive.call(this, root, refVal, p);\n    } else if (refVal instanceof SchemaObject) {\n      if (!refVal.validate) this._compile(refVal);\n      root = refVal;\n    } else {\n      refVal = this._schemas[id];\n      if (refVal instanceof SchemaObject) {\n        if (!refVal.validate) this._compile(refVal);\n        if (id == normalizeId(ref))\n          return { schema: refVal, root: root, baseId: baseId };\n        root = refVal;\n      } else {\n        return;\n      }\n    }\n    if (!root.schema) return;\n    baseId = getFullPath(this._getId(root.schema));\n  }\n  return getJsonPointer.call(this, p, baseId, root.schema, root);\n}\n\n\n/* @this Ajv */\nfunction resolveRecursive(root, ref, parsedRef) {\n  /* jshint validthis: true */\n  var res = resolveSchema.call(this, root, ref);\n  if (res) {\n    var schema = res.schema;\n    var baseId = res.baseId;\n    root = res.root;\n    var id = this._getId(schema);\n    if (id) baseId = resolveUrl(baseId, id);\n    return getJsonPointer.call(this, parsedRef, baseId, schema, root);\n  }\n}\n\n\nvar PREVENT_SCOPE_CHANGE = util.toHash(['properties', 'patternProperties', 'enum', 'dependencies', 'definitions']);\n/* @this Ajv */\nfunction getJsonPointer(parsedRef, baseId, schema, root) {\n  /* jshint validthis: true */\n  parsedRef.fragment = parsedRef.fragment || '';\n  if (parsedRef.fragment.slice(0,1) != '/') return;\n  var parts = parsedRef.fragment.split('/');\n\n  for (var i = 1; i < parts.length; i++) {\n    var part = parts[i];\n    if (part) {\n      part = util.unescapeFragment(part);\n      schema = schema[part];\n      if (schema === undefined) break;\n      var id;\n      if (!PREVENT_SCOPE_CHANGE[part]) {\n        id = this._getId(schema);\n        if (id) baseId = resolveUrl(baseId, id);\n        if (schema.$ref) {\n          var $ref = resolveUrl(baseId, schema.$ref);\n          var res = resolveSchema.call(this, root, $ref);\n          if (res) {\n            schema = res.schema;\n            root = res.root;\n            baseId = res.baseId;\n          }\n        }\n      }\n    }\n  }\n  if (schema !== undefined && schema !== root.schema)\n    return { schema: schema, root: root, baseId: baseId };\n}\n\n\nvar SIMPLE_INLINED = util.toHash([\n  'type', 'format', 'pattern',\n  'maxLength', 'minLength',\n  'maxProperties', 'minProperties',\n  'maxItems', 'minItems',\n  'maximum', 'minimum',\n  'uniqueItems', 'multipleOf',\n  'required', 'enum'\n]);\nfunction inlineRef(schema, limit) {\n  if (limit === false) return false;\n  if (limit === undefined || limit === true) return checkNoRef(schema);\n  else if (limit) return countKeys(schema) <= limit;\n}\n\n\nfunction checkNoRef(schema) {\n  var item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return false;\n      item = schema[key];\n      if (typeof item == 'object' && !checkNoRef(item)) return false;\n    }\n  }\n  return true;\n}\n\n\nfunction countKeys(schema) {\n  var count = 0, item;\n  if (Array.isArray(schema)) {\n    for (var i=0; i<schema.length; i++) {\n      item = schema[i];\n      if (typeof item == 'object') count += countKeys(item);\n      if (count == Infinity) return Infinity;\n    }\n  } else {\n    for (var key in schema) {\n      if (key == '$ref') return Infinity;\n      if (SIMPLE_INLINED[key]) {\n        count++;\n      } else {\n        item = schema[key];\n        if (typeof item == 'object') count += countKeys(item) + 1;\n        if (count == Infinity) return Infinity;\n      }\n    }\n  }\n  return count;\n}\n\n\nfunction getFullPath(id, normalize) {\n  if (normalize !== false) id = normalizeId(id);\n  var p = URI.parse(id);\n  return _getFullPath(p);\n}\n\n\nfunction _getFullPath(p) {\n  return URI.serialize(p).split('#')[0] + '#';\n}\n\n\nvar TRAILING_SLASH_HASH = /#\\/?$/;\nfunction normalizeId(id) {\n  return id ? id.replace(TRAILING_SLASH_HASH, '') : '';\n}\n\n\nfunction resolveUrl(baseId, id) {\n  id = normalizeId(id);\n  return URI.resolve(baseId, id);\n}\n\n\n/* @this Ajv */\nfunction resolveIds(schema) {\n  var schemaId = normalizeId(this._getId(schema));\n  var baseIds = {'': schemaId};\n  var fullPaths = {'': getFullPath(schemaId, false)};\n  var localRefs = {};\n  var self = this;\n\n  traverse(schema, {allKeys: true}, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {\n    if (jsonPtr === '') return;\n    var id = self._getId(sch);\n    var baseId = baseIds[parentJsonPtr];\n    var fullPath = fullPaths[parentJsonPtr] + '/' + parentKeyword;\n    if (keyIndex !== undefined)\n      fullPath += '/' + (typeof keyIndex == 'number' ? keyIndex : util.escapeFragment(keyIndex));\n\n    if (typeof id == 'string') {\n      id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id);\n\n      var refVal = self._refs[id];\n      if (typeof refVal == 'string') refVal = self._refs[refVal];\n      if (refVal && refVal.schema) {\n        if (!equal(sch, refVal.schema))\n          throw new Error('id \"' + id + '\" resolves to more than one schema');\n      } else if (id != normalizeId(fullPath)) {\n        if (id[0] == '#') {\n          if (localRefs[id] && !equal(sch, localRefs[id]))\n            throw new Error('id \"' + id + '\" resolves to more than one schema');\n          localRefs[id] = sch;\n        } else {\n          self._refs[id] = fullPath;\n        }\n      }\n    }\n    baseIds[jsonPtr] = baseId;\n    fullPaths[jsonPtr] = fullPath;\n  });\n\n  return localRefs;\n}\n", "'use strict';\n\nvar resolve = require('./resolve');\n\nmodule.exports = {\n  Validation: errorSubclass(ValidationError),\n  MissingRef: errorSubclass(MissingRefError)\n};\n\n\nfunction ValidationError(errors) {\n  this.message = 'validation failed';\n  this.errors = errors;\n  this.ajv = this.validation = true;\n}\n\n\nMissingRefError.message = function (baseId, ref) {\n  return 'can\\'t resolve reference ' + ref + ' from id ' + baseId;\n};\n\n\nfunction MissingRefError(baseId, ref, message) {\n  this.message = message || MissingRefError.message(baseId, ref);\n  this.missingRef = resolve.url(baseId, ref);\n  this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef));\n}\n\n\nfunction errorSubclass(Subclass) {\n  Subclass.prototype = Object.create(Error.prototype);\n  Subclass.prototype.constructor = Subclass;\n  return Subclass;\n}\n", "'use strict';\n\nmodule.exports = function (data, opts) {\n    if (!opts) opts = {};\n    if (typeof opts === 'function') opts = { cmp: opts };\n    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;\n\n    var cmp = opts.cmp && (function (f) {\n        return function (node) {\n            return function (a, b) {\n                var aobj = { key: a, value: node[a] };\n                var bobj = { key: b, value: node[b] };\n                return f(aobj, bobj);\n            };\n        };\n    })(opts.cmp);\n\n    var seen = [];\n    return (function stringify (node) {\n        if (node && node.toJSON && typeof node.toJSON === 'function') {\n            node = node.toJSON();\n        }\n\n        if (node === undefined) return;\n        if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';\n        if (typeof node !== 'object') return JSON.stringify(node);\n\n        var i, out;\n        if (Array.isArray(node)) {\n            out = '[';\n            for (i = 0; i < node.length; i++) {\n                if (i) out += ',';\n                out += stringify(node[i]) || 'null';\n            }\n            return out + ']';\n        }\n\n        if (node === null) return 'null';\n\n        if (seen.indexOf(node) !== -1) {\n            if (cycles) return JSON.stringify('__cycle__');\n            throw new TypeError('Converting circular structure to JSON');\n        }\n\n        var seenIndex = seen.push(node) - 1;\n        var keys = Object.keys(node).sort(cmp && cmp(node));\n        out = '';\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            var value = stringify(node[key]);\n\n            if (!value) continue;\n            if (out) out += ',';\n            out += JSON.stringify(key) + ':' + value;\n        }\n        seen.splice(seenIndex, 1);\n        return '{' + out + '}';\n    })(data);\n};\n", "'use strict';\nmodule.exports = function generate_validate(it, $keyword, $ruleType) {\n  var out = '';\n  var $async = it.schema.$async === true,\n    $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, '$ref'),\n    $id = it.self._getId(it.schema);\n  if (it.opts.strictKeywords) {\n    var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords);\n    if ($unknownKwd) {\n      var $keywordsMsg = 'unknown keyword: ' + $unknownKwd;\n      if (it.opts.strictKeywords === 'log') it.logger.warn($keywordsMsg);\n      else throw new Error($keywordsMsg);\n    }\n  }\n  if (it.isTop) {\n    out += ' var validate = ';\n    if ($async) {\n      it.async = true;\n      out += 'async ';\n    }\n    out += 'function(data, dataPath, parentData, parentDataProperty, rootData) { \\'use strict\\'; ';\n    if ($id && (it.opts.sourceCode || it.opts.processCode)) {\n      out += ' ' + ('/\\*# sourceURL=' + $id + ' */') + ' ';\n    }\n  }\n  if (typeof it.schema == 'boolean' || !($refKeywords || it.schema.$ref)) {\n    var $keyword = 'false schema';\n    var $lvl = it.level;\n    var $dataLvl = it.dataLevel;\n    var $schema = it.schema[$keyword];\n    var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n    var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n    var $breakOnError = !it.opts.allErrors;\n    var $errorKeyword;\n    var $data = 'data' + ($dataLvl || '');\n    var $valid = 'valid' + $lvl;\n    if (it.schema === false) {\n      if (it.isTop) {\n        $breakOnError = true;\n      } else {\n        out += ' var ' + ($valid) + ' = false; ';\n      }\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'false schema') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'boolean schema is false\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n    } else {\n      if (it.isTop) {\n        if ($async) {\n          out += ' return data; ';\n        } else {\n          out += ' validate.errors = null; return true; ';\n        }\n      } else {\n        out += ' var ' + ($valid) + ' = true; ';\n      }\n    }\n    if (it.isTop) {\n      out += ' }; return validate; ';\n    }\n    return out;\n  }\n  if (it.isTop) {\n    var $top = it.isTop,\n      $lvl = it.level = 0,\n      $dataLvl = it.dataLevel = 0,\n      $data = 'data';\n    it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema));\n    it.baseId = it.baseId || it.rootId;\n    delete it.isTop;\n    it.dataPathArr = [\"\"];\n    if (it.schema.default !== undefined && it.opts.useDefaults && it.opts.strictDefaults) {\n      var $defaultMsg = 'default is ignored in the schema root';\n      if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n      else throw new Error($defaultMsg);\n    }\n    out += ' var vErrors = null; ';\n    out += ' var errors = 0;     ';\n    out += ' if (rootData === undefined) rootData = data; ';\n  } else {\n    var $lvl = it.level,\n      $dataLvl = it.dataLevel,\n      $data = 'data' + ($dataLvl || '');\n    if ($id) it.baseId = it.resolve.url(it.baseId, $id);\n    if ($async && !it.async) throw new Error('async schema in sync schema');\n    out += ' var errs_' + ($lvl) + ' = errors;';\n  }\n  var $valid = 'valid' + $lvl,\n    $breakOnError = !it.opts.allErrors,\n    $closingBraces1 = '',\n    $closingBraces2 = '';\n  var $errorKeyword;\n  var $typeSchema = it.schema.type,\n    $typeIsArray = Array.isArray($typeSchema);\n  if ($typeSchema && it.opts.nullable && it.schema.nullable === true) {\n    if ($typeIsArray) {\n      if ($typeSchema.indexOf('null') == -1) $typeSchema = $typeSchema.concat('null');\n    } else if ($typeSchema != 'null') {\n      $typeSchema = [$typeSchema, 'null'];\n      $typeIsArray = true;\n    }\n  }\n  if ($typeIsArray && $typeSchema.length == 1) {\n    $typeSchema = $typeSchema[0];\n    $typeIsArray = false;\n  }\n  if (it.schema.$ref && $refKeywords) {\n    if (it.opts.extendRefs == 'fail') {\n      throw new Error('$ref: validation keywords used in schema at path \"' + it.errSchemaPath + '\" (see option extendRefs)');\n    } else if (it.opts.extendRefs !== true) {\n      $refKeywords = false;\n      it.logger.warn('$ref: keywords ignored in schema at path \"' + it.errSchemaPath + '\"');\n    }\n  }\n  if (it.schema.$comment && it.opts.$comment) {\n    out += ' ' + (it.RULES.all.$comment.code(it, '$comment'));\n  }\n  if ($typeSchema) {\n    if (it.opts.coerceTypes) {\n      var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema);\n    }\n    var $rulesGroup = it.RULES.types[$typeSchema];\n    if ($coerceToTypes || $typeIsArray || $rulesGroup === true || ($rulesGroup && !$shouldUseGroup($rulesGroup))) {\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type';\n      var $schemaPath = it.schemaPath + '.type',\n        $errSchemaPath = it.errSchemaPath + '/type',\n        $method = $typeIsArray ? 'checkDataTypes' : 'checkDataType';\n      out += ' if (' + (it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true)) + ') { ';\n      if ($coerceToTypes) {\n        var $dataType = 'dataType' + $lvl,\n          $coerced = 'coerced' + $lvl;\n        out += ' var ' + ($dataType) + ' = typeof ' + ($data) + '; var ' + ($coerced) + ' = undefined; ';\n        if (it.opts.coerceTypes == 'array') {\n          out += ' if (' + ($dataType) + ' == \\'object\\' && Array.isArray(' + ($data) + ') && ' + ($data) + '.length == 1) { ' + ($data) + ' = ' + ($data) + '[0]; ' + ($dataType) + ' = typeof ' + ($data) + '; if (' + (it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers)) + ') ' + ($coerced) + ' = ' + ($data) + '; } ';\n        }\n        out += ' if (' + ($coerced) + ' !== undefined) ; ';\n        var arr1 = $coerceToTypes;\n        if (arr1) {\n          var $type, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $type = arr1[$i += 1];\n            if ($type == 'string') {\n              out += ' else if (' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\') ' + ($coerced) + ' = \\'\\' + ' + ($data) + '; else if (' + ($data) + ' === null) ' + ($coerced) + ' = \\'\\'; ';\n            } else if ($type == 'number' || $type == 'integer') {\n              out += ' else if (' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' === null || (' + ($dataType) + ' == \\'string\\' && ' + ($data) + ' && ' + ($data) + ' == +' + ($data) + ' ';\n              if ($type == 'integer') {\n                out += ' && !(' + ($data) + ' % 1)';\n              }\n              out += ')) ' + ($coerced) + ' = +' + ($data) + '; ';\n            } else if ($type == 'boolean') {\n              out += ' else if (' + ($data) + ' === \\'false\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === null) ' + ($coerced) + ' = false; else if (' + ($data) + ' === \\'true\\' || ' + ($data) + ' === 1) ' + ($coerced) + ' = true; ';\n            } else if ($type == 'null') {\n              out += ' else if (' + ($data) + ' === \\'\\' || ' + ($data) + ' === 0 || ' + ($data) + ' === false) ' + ($coerced) + ' = null; ';\n            } else if (it.opts.coerceTypes == 'array' && $type == 'array') {\n              out += ' else if (' + ($dataType) + ' == \\'string\\' || ' + ($dataType) + ' == \\'number\\' || ' + ($dataType) + ' == \\'boolean\\' || ' + ($data) + ' == null) ' + ($coerced) + ' = [' + ($data) + ']; ';\n            }\n          }\n        }\n        out += ' else {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } if (' + ($coerced) + ' !== undefined) {  ';\n        var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n          $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n        out += ' ' + ($data) + ' = ' + ($coerced) + '; ';\n        if (!$dataLvl) {\n          out += 'if (' + ($parentData) + ' !== undefined)';\n        }\n        out += ' ' + ($parentData) + '[' + ($parentDataProperty) + '] = ' + ($coerced) + '; } ';\n      } else {\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n          if ($typeIsArray) {\n            out += '' + ($typeSchema.join(\",\"));\n          } else {\n            out += '' + ($typeSchema);\n          }\n          out += '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should be ';\n            if ($typeIsArray) {\n              out += '' + ($typeSchema.join(\",\"));\n            } else {\n              out += '' + ($typeSchema);\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      }\n      out += ' } ';\n    }\n  }\n  if (it.schema.$ref && !$refKeywords) {\n    out += ' ' + (it.RULES.all.$ref.code(it, '$ref')) + ' ';\n    if ($breakOnError) {\n      out += ' } if (errors === ';\n      if ($top) {\n        out += '0';\n      } else {\n        out += 'errs_' + ($lvl);\n      }\n      out += ') { ';\n      $closingBraces2 += '}';\n    }\n  } else {\n    var arr2 = it.RULES;\n    if (arr2) {\n      var $rulesGroup, i2 = -1,\n        l2 = arr2.length - 1;\n      while (i2 < l2) {\n        $rulesGroup = arr2[i2 += 1];\n        if ($shouldUseGroup($rulesGroup)) {\n          if ($rulesGroup.type) {\n            out += ' if (' + (it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers)) + ') { ';\n          }\n          if (it.opts.useDefaults) {\n            if ($rulesGroup.type == 'object' && it.schema.properties) {\n              var $schema = it.schema.properties,\n                $schemaKeys = Object.keys($schema);\n              var arr3 = $schemaKeys;\n              if (arr3) {\n                var $propertyKey, i3 = -1,\n                  l3 = arr3.length - 1;\n                while (i3 < l3) {\n                  $propertyKey = arr3[i3 += 1];\n                  var $sch = $schema[$propertyKey];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + it.util.getProperty($propertyKey);\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            } else if ($rulesGroup.type == 'array' && Array.isArray(it.schema.items)) {\n              var arr4 = it.schema.items;\n              if (arr4) {\n                var $sch, $i = -1,\n                  l4 = arr4.length - 1;\n                while ($i < l4) {\n                  $sch = arr4[$i += 1];\n                  if ($sch.default !== undefined) {\n                    var $passData = $data + '[' + $i + ']';\n                    if (it.compositeRule) {\n                      if (it.opts.strictDefaults) {\n                        var $defaultMsg = 'default is ignored for: ' + $passData;\n                        if (it.opts.strictDefaults === 'log') it.logger.warn($defaultMsg);\n                        else throw new Error($defaultMsg);\n                      }\n                    } else {\n                      out += ' if (' + ($passData) + ' === undefined ';\n                      if (it.opts.useDefaults == 'empty') {\n                        out += ' || ' + ($passData) + ' === null || ' + ($passData) + ' === \\'\\' ';\n                      }\n                      out += ' ) ' + ($passData) + ' = ';\n                      if (it.opts.useDefaults == 'shared') {\n                        out += ' ' + (it.useDefault($sch.default)) + ' ';\n                      } else {\n                        out += ' ' + (JSON.stringify($sch.default)) + ' ';\n                      }\n                      out += '; ';\n                    }\n                  }\n                }\n              }\n            }\n          }\n          var arr5 = $rulesGroup.rules;\n          if (arr5) {\n            var $rule, i5 = -1,\n              l5 = arr5.length - 1;\n            while (i5 < l5) {\n              $rule = arr5[i5 += 1];\n              if ($shouldUseRule($rule)) {\n                var $code = $rule.code(it, $rule.keyword, $rulesGroup.type);\n                if ($code) {\n                  out += ' ' + ($code) + ' ';\n                  if ($breakOnError) {\n                    $closingBraces1 += '}';\n                  }\n                }\n              }\n            }\n          }\n          if ($breakOnError) {\n            out += ' ' + ($closingBraces1) + ' ';\n            $closingBraces1 = '';\n          }\n          if ($rulesGroup.type) {\n            out += ' } ';\n            if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) {\n              out += ' else { ';\n              var $schemaPath = it.schemaPath + '.type',\n                $errSchemaPath = it.errSchemaPath + '/type';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ($errorKeyword || 'type') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { type: \\'';\n                if ($typeIsArray) {\n                  out += '' + ($typeSchema.join(\",\"));\n                } else {\n                  out += '' + ($typeSchema);\n                }\n                out += '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'should be ';\n                  if ($typeIsArray) {\n                    out += '' + ($typeSchema.join(\",\"));\n                  } else {\n                    out += '' + ($typeSchema);\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              out += ' } ';\n            }\n          }\n          if ($breakOnError) {\n            out += ' if (errors === ';\n            if ($top) {\n              out += '0';\n            } else {\n              out += 'errs_' + ($lvl);\n            }\n            out += ') { ';\n            $closingBraces2 += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces2) + ' ';\n  }\n  if ($top) {\n    if ($async) {\n      out += ' if (errors === 0) return data;           ';\n      out += ' else throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; ';\n      out += ' return errors === 0;       ';\n    }\n    out += ' }; return validate;';\n  } else {\n    out += ' var ' + ($valid) + ' = errors === errs_' + ($lvl) + ';';\n  }\n\n  function $shouldUseGroup($rulesGroup) {\n    var rules = $rulesGroup.rules;\n    for (var i = 0; i < rules.length; i++)\n      if ($shouldUseRule(rules[i])) return true;\n  }\n\n  function $shouldUseRule($rule) {\n    return it.schema[$rule.keyword] !== undefined || ($rule.implements && $ruleImplementsSomeKeyword($rule));\n  }\n\n  function $ruleImplementsSomeKeyword($rule) {\n    var impl = $rule.implements;\n    for (var i = 0; i < impl.length; i++)\n      if (it.schema[impl[i]] !== undefined) return true;\n  }\n  return out;\n}\n", "'use strict';\n\nvar resolve = require('./resolve')\n  , util = require('./util')\n  , errorClasses = require('./error_classes')\n  , stableStringify = require('fast-json-stable-stringify');\n\nvar validateGenerator = require('../dotjs/validate');\n\n/**\n * Functions below are used inside compiled validations function\n */\n\nvar ucs2length = util.ucs2length;\nvar equal = require('fast-deep-equal');\n\n// this error is thrown by async schemas to return validation errors via exception\nvar ValidationError = errorClasses.Validation;\n\nmodule.exports = compile;\n\n\n/**\n * Compiles schema to validation function\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Object} root object with information about the root schema for this schema\n * @param  {Object} localRefs the hash of local references inside the schema (created by resolve.id), used for inline resolution\n * @param  {String} baseId base ID for IDs in the schema\n * @return {Function} validation function\n */\nfunction compile(schema, root, localRefs, baseId) {\n  /* jshint validthis: true, evil: true */\n  /* eslint no-shadow: 0 */\n  var self = this\n    , opts = this._opts\n    , refVal = [ undefined ]\n    , refs = {}\n    , patterns = []\n    , patternsHash = {}\n    , defaults = []\n    , defaultsHash = {}\n    , customRules = [];\n\n  root = root || { schema: schema, refVal: refVal, refs: refs };\n\n  var c = checkCompiling.call(this, schema, root, baseId);\n  var compilation = this._compilations[c.index];\n  if (c.compiling) return (compilation.callValidate = callValidate);\n\n  var formats = this._formats;\n  var RULES = this.RULES;\n\n  try {\n    var v = localCompile(schema, root, localRefs, baseId);\n    compilation.validate = v;\n    var cv = compilation.callValidate;\n    if (cv) {\n      cv.schema = v.schema;\n      cv.errors = null;\n      cv.refs = v.refs;\n      cv.refVal = v.refVal;\n      cv.root = v.root;\n      cv.$async = v.$async;\n      if (opts.sourceCode) cv.source = v.source;\n    }\n    return v;\n  } finally {\n    endCompiling.call(this, schema, root, baseId);\n  }\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var validate = compilation.validate;\n    var result = validate.apply(this, arguments);\n    callValidate.errors = validate.errors;\n    return result;\n  }\n\n  function localCompile(_schema, _root, localRefs, baseId) {\n    var isRoot = !_root || (_root && _root.schema == _schema);\n    if (_root.schema != root.schema)\n      return compile.call(self, _schema, _root, localRefs, baseId);\n\n    var $async = _schema.$async === true;\n\n    var sourceCode = validateGenerator({\n      isTop: true,\n      schema: _schema,\n      isRoot: isRoot,\n      baseId: baseId,\n      root: _root,\n      schemaPath: '',\n      errSchemaPath: '#',\n      errorPath: '\"\"',\n      MissingRefError: errorClasses.MissingRef,\n      RULES: RULES,\n      validate: validateGenerator,\n      util: util,\n      resolve: resolve,\n      resolveRef: resolveRef,\n      usePattern: usePattern,\n      useDefault: useDefault,\n      useCustomRule: useCustomRule,\n      opts: opts,\n      formats: formats,\n      logger: self.logger,\n      self: self\n    });\n\n    sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode)\n                   + vars(defaults, defaultCode) + vars(customRules, customRuleCode)\n                   + sourceCode;\n\n    if (opts.processCode) sourceCode = opts.processCode(sourceCode, _schema);\n    // console.log('\\n\\n\\n *** \\n', JSON.stringify(sourceCode));\n    var validate;\n    try {\n      var makeValidate = new Function(\n        'self',\n        'RULES',\n        'formats',\n        'root',\n        'refVal',\n        'defaults',\n        'customRules',\n        'equal',\n        'ucs2length',\n        'ValidationError',\n        sourceCode\n      );\n\n      validate = makeValidate(\n        self,\n        RULES,\n        formats,\n        root,\n        refVal,\n        defaults,\n        customRules,\n        equal,\n        ucs2length,\n        ValidationError\n      );\n\n      refVal[0] = validate;\n    } catch(e) {\n      self.logger.error('Error compiling schema, function code:', sourceCode);\n      throw e;\n    }\n\n    validate.schema = _schema;\n    validate.errors = null;\n    validate.refs = refs;\n    validate.refVal = refVal;\n    validate.root = isRoot ? validate : _root;\n    if ($async) validate.$async = true;\n    if (opts.sourceCode === true) {\n      validate.source = {\n        code: sourceCode,\n        patterns: patterns,\n        defaults: defaults\n      };\n    }\n\n    return validate;\n  }\n\n  function resolveRef(baseId, ref, isRoot) {\n    ref = resolve.url(baseId, ref);\n    var refIndex = refs[ref];\n    var _refVal, refCode;\n    if (refIndex !== undefined) {\n      _refVal = refVal[refIndex];\n      refCode = 'refVal[' + refIndex + ']';\n      return resolvedRef(_refVal, refCode);\n    }\n    if (!isRoot && root.refs) {\n      var rootRefId = root.refs[ref];\n      if (rootRefId !== undefined) {\n        _refVal = root.refVal[rootRefId];\n        refCode = addLocalRef(ref, _refVal);\n        return resolvedRef(_refVal, refCode);\n      }\n    }\n\n    refCode = addLocalRef(ref);\n    var v = resolve.call(self, localCompile, root, ref);\n    if (v === undefined) {\n      var localSchema = localRefs && localRefs[ref];\n      if (localSchema) {\n        v = resolve.inlineRef(localSchema, opts.inlineRefs)\n            ? localSchema\n            : compile.call(self, localSchema, root, localRefs, baseId);\n      }\n    }\n\n    if (v === undefined) {\n      removeLocalRef(ref);\n    } else {\n      replaceLocalRef(ref, v);\n      return resolvedRef(v, refCode);\n    }\n  }\n\n  function addLocalRef(ref, v) {\n    var refId = refVal.length;\n    refVal[refId] = v;\n    refs[ref] = refId;\n    return 'refVal' + refId;\n  }\n\n  function removeLocalRef(ref) {\n    delete refs[ref];\n  }\n\n  function replaceLocalRef(ref, v) {\n    var refId = refs[ref];\n    refVal[refId] = v;\n  }\n\n  function resolvedRef(refVal, code) {\n    return typeof refVal == 'object' || typeof refVal == 'boolean'\n            ? { code: code, schema: refVal, inline: true }\n            : { code: code, $async: refVal && !!refVal.$async };\n  }\n\n  function usePattern(regexStr) {\n    var index = patternsHash[regexStr];\n    if (index === undefined) {\n      index = patternsHash[regexStr] = patterns.length;\n      patterns[index] = regexStr;\n    }\n    return 'pattern' + index;\n  }\n\n  function useDefault(value) {\n    switch (typeof value) {\n      case 'boolean':\n      case 'number':\n        return '' + value;\n      case 'string':\n        return util.toQuotedString(value);\n      case 'object':\n        if (value === null) return 'null';\n        var valueStr = stableStringify(value);\n        var index = defaultsHash[valueStr];\n        if (index === undefined) {\n          index = defaultsHash[valueStr] = defaults.length;\n          defaults[index] = value;\n        }\n        return 'default' + index;\n    }\n  }\n\n  function useCustomRule(rule, schema, parentSchema, it) {\n    if (self._opts.validateSchema !== false) {\n      var deps = rule.definition.dependencies;\n      if (deps && !deps.every(function(keyword) {\n        return Object.prototype.hasOwnProperty.call(parentSchema, keyword);\n      }))\n        throw new Error('parent schema must have all required keywords: ' + deps.join(','));\n\n      var validateSchema = rule.definition.validateSchema;\n      if (validateSchema) {\n        var valid = validateSchema(schema);\n        if (!valid) {\n          var message = 'keyword schema is invalid: ' + self.errorsText(validateSchema.errors);\n          if (self._opts.validateSchema == 'log') self.logger.error(message);\n          else throw new Error(message);\n        }\n      }\n    }\n\n    var compile = rule.definition.compile\n      , inline = rule.definition.inline\n      , macro = rule.definition.macro;\n\n    var validate;\n    if (compile) {\n      validate = compile.call(self, schema, parentSchema, it);\n    } else if (macro) {\n      validate = macro.call(self, schema, parentSchema, it);\n      if (opts.validateSchema !== false) self.validateSchema(validate, true);\n    } else if (inline) {\n      validate = inline.call(self, it, rule.keyword, schema, parentSchema);\n    } else {\n      validate = rule.definition.validate;\n      if (!validate) return;\n    }\n\n    if (validate === undefined)\n      throw new Error('custom keyword \"' + rule.keyword + '\"failed to compile');\n\n    var index = customRules.length;\n    customRules[index] = validate;\n\n    return {\n      code: 'customRule' + index,\n      validate: validate\n    };\n  }\n}\n\n\n/**\n * Checks if the schema is currently compiled\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Object} object with properties \"index\" (compilation index) and \"compiling\" (boolean)\n */\nfunction checkCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var index = compIndex.call(this, schema, root, baseId);\n  if (index >= 0) return { index: index, compiling: true };\n  index = this._compilations.length;\n  this._compilations[index] = {\n    schema: schema,\n    root: root,\n    baseId: baseId\n  };\n  return { index: index, compiling: false };\n}\n\n\n/**\n * Removes the schema from the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n */\nfunction endCompiling(schema, root, baseId) {\n  /* jshint validthis: true */\n  var i = compIndex.call(this, schema, root, baseId);\n  if (i >= 0) this._compilations.splice(i, 1);\n}\n\n\n/**\n * Index of schema compilation in the currently compiled list\n * @this   Ajv\n * @param  {Object} schema schema to compile\n * @param  {Object} root root object\n * @param  {String} baseId base schema ID\n * @return {Integer} compilation index\n */\nfunction compIndex(schema, root, baseId) {\n  /* jshint validthis: true */\n  for (var i=0; i<this._compilations.length; i++) {\n    var c = this._compilations[i];\n    if (c.schema == schema && c.root == root && c.baseId == baseId) return i;\n  }\n  return -1;\n}\n\n\nfunction patternCode(i, patterns) {\n  return 'var pattern' + i + ' = new RegExp(' + util.toQuotedString(patterns[i]) + ');';\n}\n\n\nfunction defaultCode(i) {\n  return 'var default' + i + ' = defaults[' + i + '];';\n}\n\n\nfunction refValCode(i, refVal) {\n  return refVal[i] === undefined ? '' : 'var refVal' + i + ' = refVal[' + i + '];';\n}\n\n\nfunction customRuleCode(i) {\n  return 'var customRule' + i + ' = customRules[' + i + '];';\n}\n\n\nfunction vars(arr, statement) {\n  if (!arr.length) return '';\n  var code = '';\n  for (var i=0; i<arr.length; i++)\n    code += statement(i, arr);\n  return code;\n}\n", "'use strict';\n\n\nvar Cache = module.exports = function Cache() {\n  this._cache = {};\n};\n\n\nCache.prototype.put = function Cache_put(key, value) {\n  this._cache[key] = value;\n};\n\n\nCache.prototype.get = function Cache_get(key) {\n  return this._cache[key];\n};\n\n\nCache.prototype.del = function Cache_del(key) {\n  delete this._cache[key];\n};\n\n\nCache.prototype.clear = function Cache_clear() {\n  this._cache = {};\n};\n", "'use strict';\n\nvar util = require('./util');\n\nvar DATE = /^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)$/;\nvar DAYS = [0,31,28,31,30,31,30,31,31,30,31,30,31];\nvar TIME = /^(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?(z|[+-]\\d\\d(?::?\\d\\d)?)?$/i;\nvar HOSTNAME = /^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i;\nvar URI = /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;\nvar URIREF = /^(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'\"()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;\n// uri-template: https://tools.ietf.org/html/rfc6570\nvar URITEMPLATE = /^(?:(?:[^\\x00-\\x20\"'<>%\\\\^`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i;\n// For the source: https://gist.github.com/dperini/729294\n// For test cases: https://mathiasbynens.be/demo/url-regex\n// @todo Delete current URL in favour of the commented out URL rule when this issue is fixed https://github.com/eslint/eslint/issues/7983.\n// var URL = /^(?:(?:https?|ftp):\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!10(?:\\.\\d{1,3}){3})(?!127(?:\\.\\d{1,3}){3})(?!169\\.254(?:\\.\\d{1,3}){2})(?!192\\.168(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-)*[a-z\\u{00a1}-\\u{ffff}0-9]+)(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-)*[a-z\\u{00a1}-\\u{ffff}0-9]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu;\nvar URL = /^(?:(?:http[s\\u017F]?|ftp):\\/\\/)(?:(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+(?::(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?@)?(?:(?!10(?:\\.[0-9]{1,3}){3})(?!127(?:\\.[0-9]{1,3}){3})(?!169\\.254(?:\\.[0-9]{1,3}){2})(?!192\\.168(?:\\.[0-9]{1,3}){2})(?!172\\.(?:1[6-9]|2[0-9]|3[01])(?:\\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-)*(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)(?:\\.(?:(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-)*(?:[0-9a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)*(?:\\.(?:(?:[a-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\\/(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?$/i;\nvar UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;\nvar JSON_POINTER = /^(?:\\/(?:[^~/]|~0|~1)*)*$/;\nvar JSON_POINTER_URI_FRAGMENT = /^#(?:\\/(?:[a-z0-9_\\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;\nvar RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/;\n\n\nmodule.exports = formats;\n\nfunction formats(mode) {\n  mode = mode == 'full' ? 'full' : 'fast';\n  return util.copy(formats[mode]);\n}\n\n\nformats.fast = {\n  // date: http://tools.ietf.org/html/rfc3339#section-5.6\n  date: /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/,\n  // date-time: http://tools.ietf.org/html/rfc3339#section-5.6\n  time: /^(?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)?$/i,\n  'date-time': /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s](?:[0-2]\\d:[0-5]\\d:[0-5]\\d|23:59:60)(?:\\.\\d+)?(?:z|[+-]\\d\\d(?::?\\d\\d)?)$/i,\n  // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js\n  uri: /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/)?[^\\s]*$/i,\n  'uri-reference': /^(?:(?:[a-z][a-z0-9+\\-.]*:)?\\/?\\/)?(?:[^\\\\\\s#][^\\s#]*)?(?:#[^\\\\\\s]*)?$/i,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  // email (sources from jsen validator):\n  // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363\n  // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')\n  email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,\n  hostname: HOSTNAME,\n  // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses\n  ipv6: /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i,\n  regex: regex,\n  // uuid: http://tools.ietf.org/html/rfc4122\n  uuid: UUID,\n  // JSON-pointer: https://tools.ietf.org/html/rfc6901\n  // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A\n  'json-pointer': JSON_POINTER,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00\n  'relative-json-pointer': RELATIVE_JSON_POINTER\n};\n\n\nformats.full = {\n  date: date,\n  time: time,\n  'date-time': date_time,\n  uri: uri,\n  'uri-reference': URIREF,\n  'uri-template': URITEMPLATE,\n  url: URL,\n  email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,\n  hostname: HOSTNAME,\n  ipv4: /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\n  ipv6: /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i,\n  regex: regex,\n  uuid: UUID,\n  'json-pointer': JSON_POINTER,\n  'json-pointer-uri-fragment': JSON_POINTER_URI_FRAGMENT,\n  'relative-json-pointer': RELATIVE_JSON_POINTER\n};\n\n\nfunction isLeapYear(year) {\n  // https://tools.ietf.org/html/rfc3339#appendix-C\n  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n}\n\n\nfunction date(str) {\n  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6\n  var matches = str.match(DATE);\n  if (!matches) return false;\n\n  var year = +matches[1];\n  var month = +matches[2];\n  var day = +matches[3];\n\n  return month >= 1 && month <= 12 && day >= 1 &&\n          day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);\n}\n\n\nfunction time(str, full) {\n  var matches = str.match(TIME);\n  if (!matches) return false;\n\n  var hour = matches[1];\n  var minute = matches[2];\n  var second = matches[3];\n  var timeZone = matches[5];\n  return ((hour <= 23 && minute <= 59 && second <= 59) ||\n          (hour == 23 && minute == 59 && second == 60)) &&\n         (!full || timeZone);\n}\n\n\nvar DATE_TIME_SEPARATOR = /t|\\s/i;\nfunction date_time(str) {\n  // http://tools.ietf.org/html/rfc3339#section-5.6\n  var dateTime = str.split(DATE_TIME_SEPARATOR);\n  return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true);\n}\n\n\nvar NOT_URI_FRAGMENT = /\\/|:/;\nfunction uri(str) {\n  // http://jmrware.com/articles/2009/uri_regexp/URI_regex.html + optional protocol + required \".\"\n  return NOT_URI_FRAGMENT.test(str) && URI.test(str);\n}\n\n\nvar Z_ANCHOR = /[^\\\\]\\\\Z/;\nfunction regex(str) {\n  if (Z_ANCHOR.test(str)) return false;\n  try {\n    new RegExp(str);\n    return true;\n  } catch(e) {\n    return false;\n  }\n}\n", "'use strict';\nmodule.exports = function generate_ref(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $async, $refCode;\n  if ($schema == '#' || $schema == '#/') {\n    if (it.isRoot) {\n      $async = it.async;\n      $refCode = 'validate';\n    } else {\n      $async = it.root.schema.$async === true;\n      $refCode = 'root.refVal[0]';\n    }\n  } else {\n    var $refVal = it.resolveRef(it.baseId, $schema, it.isRoot);\n    if ($refVal === undefined) {\n      var $message = it.MissingRefError.message(it.baseId, $schema);\n      if (it.opts.missingRefs == 'fail') {\n        it.logger.error($message);\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('$ref') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { ref: \\'' + (it.util.escapeQuotes($schema)) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'can\\\\\\'t resolve reference ' + (it.util.escapeQuotes($schema)) + '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: ' + (it.util.toQuotedString($schema)) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        if ($breakOnError) {\n          out += ' if (false) { ';\n        }\n      } else if (it.opts.missingRefs == 'ignore') {\n        it.logger.warn($message);\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n      } else {\n        throw new it.MissingRefError(it.baseId, $schema, $message);\n      }\n    } else if ($refVal.inline) {\n      var $it = it.util.copy(it);\n      $it.level++;\n      var $nextValid = 'valid' + $it.level;\n      $it.schema = $refVal.schema;\n      $it.schemaPath = '';\n      $it.errSchemaPath = $schema;\n      var $code = it.validate($it).replace(/validate\\.schema/g, $refVal.code);\n      out += ' ' + ($code) + ' ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n      }\n    } else {\n      $async = $refVal.$async === true || (it.async && $refVal.$async !== false);\n      $refCode = $refVal.code;\n    }\n  }\n  if ($refCode) {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    if (it.opts.passContext) {\n      out += ' ' + ($refCode) + '.call(this, ';\n    } else {\n      out += ' ' + ($refCode) + '( ';\n    }\n    out += ' ' + ($data) + ', (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ', rootData)  ';\n    var __callValidate = out;\n    out = $$outStack.pop();\n    if ($async) {\n      if (!it.async) throw new Error('async schema referenced by sync schema');\n      if ($breakOnError) {\n        out += ' var ' + ($valid) + '; ';\n      }\n      out += ' try { await ' + (__callValidate) + '; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = true; ';\n      }\n      out += ' } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; ';\n      if ($breakOnError) {\n        out += ' ' + ($valid) + ' = false; ';\n      }\n      out += ' } ';\n      if ($breakOnError) {\n        out += ' if (' + ($valid) + ') { ';\n      }\n    } else {\n      out += ' if (!' + (__callValidate) + ') { if (vErrors === null) vErrors = ' + ($refCode) + '.errors; else vErrors = vErrors.concat(' + ($refCode) + '.errors); errors = vErrors.length; } ';\n      if ($breakOnError) {\n        out += ' else { ';\n      }\n    }\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_allOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $allSchemasEmpty = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $allSchemasEmpty = false;\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    if ($allSchemasEmpty) {\n      out += ' if (true) { ';\n    } else {\n      out += ' ' + ($closingBraces.slice(0, -1)) + ' ';\n    }\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_anyOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $noEmptySchema = $schema.every(function($sch) {\n    return (it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all));\n  });\n  if ($noEmptySchema) {\n    var $currentBaseId = $it.baseId;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = false;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n        out += ' ' + ($valid) + ' = ' + ($valid) + ' || ' + ($nextValid) + '; if (!' + ($valid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('anyOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match some schema in anyOf\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_comment(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $schema = it.schema[$keyword];\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $comment = it.util.toQuotedString($schema);\n  if (it.opts.$comment === true) {\n    out += ' console.log(' + ($comment) + ');';\n  } else if (typeof it.opts.$comment == 'function') {\n    out += ' self._opts.$comment(' + ($comment) + ', ' + (it.util.toQuotedString($errSchemaPath)) + ', validate.root.schema);';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_const(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!$isData) {\n    out += ' var schema' + ($lvl) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ' = equal(' + ($data) + ', schema' + ($lvl) + '); if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('const') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValue: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to constant\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_contains(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId,\n    $nonEmptySchema = (it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all));\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($nonEmptySchema) {\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($nextValid) + ' = false; for (var ' + ($idx) + ' = 0; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    out += ' if (' + ($nextValid) + ') break; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($closingBraces) + ' if (!' + ($nextValid) + ') {';\n  } else {\n    out += ' if (' + ($data) + '.length == 0) {';\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('contains') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should contain a valid item\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } else { ';\n  if ($nonEmptySchema) {\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n  }\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_dependencies(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $schemaDeps = {},\n    $propertyDeps = {},\n    $ownProperties = it.opts.ownProperties;\n  for ($property in $schema) {\n    if ($property == '__proto__') continue;\n    var $sch = $schema[$property];\n    var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;\n    $deps[$property] = $sch;\n  }\n  out += 'var ' + ($errs) + ' = errors;';\n  var $currentErrorPath = it.errorPath;\n  out += 'var missing' + ($lvl) + ';';\n  for (var $property in $propertyDeps) {\n    $deps = $propertyDeps[$property];\n    if ($deps.length) {\n      out += ' if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      if ($breakOnError) {\n        out += ' && ( ';\n        var arr1 = $deps;\n        if (arr1) {\n          var $propertyKey, $i = -1,\n            l1 = arr1.length - 1;\n          while ($i < l1) {\n            $propertyKey = arr1[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ')) {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('dependencies') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \\'' + (it.util.escapeQuotes($property)) + '\\', missingProperty: \\'' + ($missingProperty) + '\\', depsCount: ' + ($deps.length) + ', deps: \\'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(\", \"))) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'should have ';\n            if ($deps.length == 1) {\n              out += 'property ' + (it.util.escapeQuotes($deps[0]));\n            } else {\n              out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n            }\n            out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n      } else {\n        out += ' ) { ';\n        var arr2 = $deps;\n        if (arr2) {\n          var $propertyKey, i2 = -1,\n            l2 = arr2.length - 1;\n          while (i2 < l2) {\n            $propertyKey = arr2[i2 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              out += ' { keyword: \\'' + ('dependencies') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { property: \\'' + (it.util.escapeQuotes($property)) + '\\', missingProperty: \\'' + ($missingProperty) + '\\', depsCount: ' + ($deps.length) + ', deps: \\'' + (it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(\", \"))) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'should have ';\n                if ($deps.length == 1) {\n                  out += 'property ' + (it.util.escapeQuotes($deps[0]));\n                } else {\n                  out += 'properties ' + (it.util.escapeQuotes($deps.join(\", \")));\n                }\n                out += ' when property ' + (it.util.escapeQuotes($property)) + ' is present\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n      out += ' }   ';\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n  }\n  it.errorPath = $currentErrorPath;\n  var $currentBaseId = $it.baseId;\n  for (var $property in $schemaDeps) {\n    var $sch = $schemaDeps[$property];\n    if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n      out += ' ' + ($nextValid) + ' = true; if ( ' + ($data) + (it.util.getProperty($property)) + ' !== undefined ';\n      if ($ownProperties) {\n        out += ' && Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($property)) + '\\') ';\n      }\n      out += ') { ';\n      $it.schema = $sch;\n      $it.schemaPath = $schemaPath + it.util.getProperty($property);\n      $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property);\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += '   ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_enum(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $i = 'i' + $lvl,\n    $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + ';';\n  }\n  out += 'var ' + ($valid) + ';';\n  if ($isData) {\n    out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n  }\n  out += '' + ($valid) + ' = false;for (var ' + ($i) + '=0; ' + ($i) + '<' + ($vSchema) + '.length; ' + ($i) + '++) if (equal(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + '])) { ' + ($valid) + ' = true; break; }';\n  if ($isData) {\n    out += '  }  ';\n  }\n  out += ' if (!' + ($valid) + ') {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('enum') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { allowedValues: schema' + ($lvl) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be equal to one of the allowed values\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' }';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_format(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  if (it.opts.format === false) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n    return out;\n  }\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $unknownFormats = it.opts.unknownFormats,\n    $allowUnknown = Array.isArray($unknownFormats);\n  if ($isData) {\n    var $format = 'format' + $lvl,\n      $isObject = 'isObject' + $lvl,\n      $formatType = 'formatType' + $lvl;\n    out += ' var ' + ($format) + ' = formats[' + ($schemaValue) + ']; var ' + ($isObject) + ' = typeof ' + ($format) + ' == \\'object\\' && !(' + ($format) + ' instanceof RegExp) && ' + ($format) + '.validate; var ' + ($formatType) + ' = ' + ($isObject) + ' && ' + ($format) + '.type || \\'string\\'; if (' + ($isObject) + ') { ';\n    if (it.async) {\n      out += ' var async' + ($lvl) + ' = ' + ($format) + '.async; ';\n    }\n    out += ' ' + ($format) + ' = ' + ($format) + '.validate; } if (  ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n    }\n    out += ' (';\n    if ($unknownFormats != 'ignore') {\n      out += ' (' + ($schemaValue) + ' && !' + ($format) + ' ';\n      if ($allowUnknown) {\n        out += ' && self._opts.unknownFormats.indexOf(' + ($schemaValue) + ') == -1 ';\n      }\n      out += ') || ';\n    }\n    out += ' (' + ($format) + ' && ' + ($formatType) + ' == \\'' + ($ruleType) + '\\' && !(typeof ' + ($format) + ' == \\'function\\' ? ';\n    if (it.async) {\n      out += ' (async' + ($lvl) + ' ? await ' + ($format) + '(' + ($data) + ') : ' + ($format) + '(' + ($data) + ')) ';\n    } else {\n      out += ' ' + ($format) + '(' + ($data) + ') ';\n    }\n    out += ' : ' + ($format) + '.test(' + ($data) + '))))) {';\n  } else {\n    var $format = it.formats[$schema];\n    if (!$format) {\n      if ($unknownFormats == 'ignore') {\n        it.logger.warn('unknown format \"' + $schema + '\" ignored in schema at path \"' + it.errSchemaPath + '\"');\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) {\n        if ($breakOnError) {\n          out += ' if (true) { ';\n        }\n        return out;\n      } else {\n        throw new Error('unknown format \"' + $schema + '\" is used in schema at path \"' + it.errSchemaPath + '\"');\n      }\n    }\n    var $isObject = typeof $format == 'object' && !($format instanceof RegExp) && $format.validate;\n    var $formatType = $isObject && $format.type || 'string';\n    if ($isObject) {\n      var $async = $format.async === true;\n      $format = $format.validate;\n    }\n    if ($formatType != $ruleType) {\n      if ($breakOnError) {\n        out += ' if (true) { ';\n      }\n      return out;\n    }\n    if ($async) {\n      if (!it.async) throw new Error('async format in sync schema');\n      var $formatRef = 'formats' + it.util.getProperty($schema) + '.validate';\n      out += ' if (!(await ' + ($formatRef) + '(' + ($data) + '))) { ';\n    } else {\n      out += ' if (! ';\n      var $formatRef = 'formats' + it.util.getProperty($schema);\n      if ($isObject) $formatRef += '.validate';\n      if (typeof $format == 'function') {\n        out += ' ' + ($formatRef) + '(' + ($data) + ') ';\n      } else {\n        out += ' ' + ($formatRef) + '.test(' + ($data) + ') ';\n      }\n      out += ') { ';\n    }\n  }\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('format') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { format:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match format \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_if(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $thenSch = it.schema['then'],\n    $elseSch = it.schema['else'],\n    $thenPresent = $thenSch !== undefined && (it.opts.strictKeywords ? (typeof $thenSch == 'object' && Object.keys($thenSch).length > 0) || $thenSch === false : it.util.schemaHasRules($thenSch, it.RULES.all)),\n    $elsePresent = $elseSch !== undefined && (it.opts.strictKeywords ? (typeof $elseSch == 'object' && Object.keys($elseSch).length > 0) || $elseSch === false : it.util.schemaHasRules($elseSch, it.RULES.all)),\n    $currentBaseId = $it.baseId;\n  if ($thenPresent || $elsePresent) {\n    var $ifClause;\n    $it.createErrors = false;\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors; var ' + ($valid) + ' = true;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    out += '  ' + (it.validate($it)) + ' ';\n    $it.baseId = $currentBaseId;\n    $it.createErrors = true;\n    out += '  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }  ';\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    if ($thenPresent) {\n      out += ' if (' + ($nextValid) + ') {  ';\n      $it.schema = it.schema['then'];\n      $it.schemaPath = it.schemaPath + '.then';\n      $it.errSchemaPath = it.errSchemaPath + '/then';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'then\\'; ';\n      } else {\n        $ifClause = '\\'then\\'';\n      }\n      out += ' } ';\n      if ($elsePresent) {\n        out += ' else { ';\n      }\n    } else {\n      out += ' if (!' + ($nextValid) + ') { ';\n    }\n    if ($elsePresent) {\n      $it.schema = it.schema['else'];\n      $it.schemaPath = it.schemaPath + '.else';\n      $it.errSchemaPath = it.errSchemaPath + '/else';\n      out += '  ' + (it.validate($it)) + ' ';\n      $it.baseId = $currentBaseId;\n      out += ' ' + ($valid) + ' = ' + ($nextValid) + '; ';\n      if ($thenPresent && $elsePresent) {\n        $ifClause = 'ifClause' + $lvl;\n        out += ' var ' + ($ifClause) + ' = \\'else\\'; ';\n      } else {\n        $ifClause = '\\'else\\'';\n      }\n      out += ' } ';\n    }\n    out += ' if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('if') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { failingKeyword: ' + ($ifClause) + ' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should match \"\\' + ' + ($ifClause) + ' + \\'\" schema\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    out += ' }   ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_items(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $idx = 'i' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $currentBaseId = it.baseId;\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if (Array.isArray($schema)) {\n    var $additionalItems = it.schema.additionalItems;\n    if ($additionalItems === false) {\n      out += ' ' + ($valid) + ' = ' + ($data) + '.length <= ' + ($schema.length) + '; ';\n      var $currErrSchemaPath = $errSchemaPath;\n      $errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += '  if (!' + ($valid) + ') {   ';\n      var $$outStack = $$outStack || [];\n      $$outStack.push(out);\n      out = ''; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ('additionalItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schema.length) + ' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should NOT have more than ' + ($schema.length) + ' items\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      var __err = out;\n      out = $$outStack.pop();\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError([' + (__err) + ']); ';\n        } else {\n          out += ' validate.errors = [' + (__err) + ']; return false; ';\n        }\n      } else {\n        out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      }\n      out += ' } ';\n      $errSchemaPath = $currErrSchemaPath;\n      if ($breakOnError) {\n        $closingBraces += '}';\n        out += ' else { ';\n      }\n    }\n    var arr1 = $schema;\n    if (arr1) {\n      var $sch, $i = -1,\n        l1 = arr1.length - 1;\n      while ($i < l1) {\n        $sch = arr1[$i += 1];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($i) + ') { ';\n          var $passData = $data + '[' + $i + ']';\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + '[' + $i + ']';\n          $it.errSchemaPath = $errSchemaPath + '/' + $i;\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true);\n          $it.dataPathArr[$dataNxt] = $i;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n    if (typeof $additionalItems == 'object' && (it.opts.strictKeywords ? (typeof $additionalItems == 'object' && Object.keys($additionalItems).length > 0) || $additionalItems === false : it.util.schemaHasRules($additionalItems, it.RULES.all))) {\n      $it.schema = $additionalItems;\n      $it.schemaPath = it.schemaPath + '.additionalItems';\n      $it.errSchemaPath = it.errSchemaPath + '/additionalItems';\n      out += ' ' + ($nextValid) + ' = true; if (' + ($data) + '.length > ' + ($schema.length) + ') {  for (var ' + ($idx) + ' = ' + ($schema.length) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n      $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n      var $passData = $data + '[' + $idx + ']';\n      $it.dataPathArr[$dataNxt] = $idx;\n      var $code = it.validate($it);\n      $it.baseId = $currentBaseId;\n      if (it.util.varOccurences($code, $nextData) < 2) {\n        out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n      } else {\n        out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n      }\n      if ($breakOnError) {\n        out += ' if (!' + ($nextValid) + ') break; ';\n      }\n      out += ' } }  ';\n      if ($breakOnError) {\n        out += ' if (' + ($nextValid) + ') { ';\n        $closingBraces += '}';\n      }\n    }\n  } else if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += '  for (var ' + ($idx) + ' = ' + (0) + '; ' + ($idx) + ' < ' + ($data) + '.length; ' + ($idx) + '++) { ';\n    $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);\n    var $passData = $data + '[' + $idx + ']';\n    $it.dataPathArr[$dataNxt] = $idx;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    if ($breakOnError) {\n      out += ' if (!' + ($nextValid) + ') break; ';\n    }\n    out += ' }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate__limit(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $isMax = $keyword == 'maximum',\n    $exclusiveKeyword = $isMax ? 'exclusiveMaximum' : 'exclusiveMinimum',\n    $schemaExcl = it.schema[$exclusiveKeyword],\n    $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data,\n    $op = $isMax ? '<' : '>',\n    $notOp = $isMax ? '>' : '<',\n    $errorKeyword = undefined;\n  if (!($isData || typeof $schema == 'number' || $schema === undefined)) {\n    throw new Error($keyword + ' must be number');\n  }\n  if (!($isDataExcl || $schemaExcl === undefined || typeof $schemaExcl == 'number' || typeof $schemaExcl == 'boolean')) {\n    throw new Error($exclusiveKeyword + ' must be number or boolean');\n  }\n  if ($isDataExcl) {\n    var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr),\n      $exclusive = 'exclusive' + $lvl,\n      $exclType = 'exclType' + $lvl,\n      $exclIsNumber = 'exclIsNumber' + $lvl,\n      $opExpr = 'op' + $lvl,\n      $opStr = '\\' + ' + $opExpr + ' + \\'';\n    out += ' var schemaExcl' + ($lvl) + ' = ' + ($schemaValueExcl) + '; ';\n    $schemaValueExcl = 'schemaExcl' + $lvl;\n    out += ' var ' + ($exclusive) + '; var ' + ($exclType) + ' = typeof ' + ($schemaValueExcl) + '; if (' + ($exclType) + ' != \\'boolean\\' && ' + ($exclType) + ' != \\'undefined\\' && ' + ($exclType) + ' != \\'number\\') { ';\n    var $errorKeyword = $exclusiveKeyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || '_exclusiveLimit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'' + ($exclusiveKeyword) + ' should be boolean\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else if ( ';\n    if ($isData) {\n      out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n    }\n    out += ' ' + ($exclType) + ' == \\'number\\' ? ( (' + ($exclusive) + ' = ' + ($schemaValue) + ' === undefined || ' + ($schemaValueExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ') ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValueExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) : ( (' + ($exclusive) + ' = ' + ($schemaValueExcl) + ' === true) ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaValue) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { var op' + ($lvl) + ' = ' + ($exclusive) + ' ? \\'' + ($op) + '\\' : \\'' + ($op) + '=\\'; ';\n    if ($schema === undefined) {\n      $errorKeyword = $exclusiveKeyword;\n      $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n      $schemaValue = $schemaValueExcl;\n      $isData = $isDataExcl;\n    }\n  } else {\n    var $exclIsNumber = typeof $schemaExcl == 'number',\n      $opStr = $op;\n    if ($exclIsNumber && $isData) {\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ( ' + ($schemaValue) + ' === undefined || ' + ($schemaExcl) + ' ' + ($op) + '= ' + ($schemaValue) + ' ? ' + ($data) + ' ' + ($notOp) + '= ' + ($schemaExcl) + ' : ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' ) || ' + ($data) + ' !== ' + ($data) + ') { ';\n    } else {\n      if ($exclIsNumber && $schema === undefined) {\n        $exclusive = true;\n        $errorKeyword = $exclusiveKeyword;\n        $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n        $schemaValue = $schemaExcl;\n        $notOp += '=';\n      } else {\n        if ($exclIsNumber) $schemaValue = Math[$isMax ? 'min' : 'max']($schemaExcl, $schema);\n        if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {\n          $exclusive = true;\n          $errorKeyword = $exclusiveKeyword;\n          $errSchemaPath = it.errSchemaPath + '/' + $exclusiveKeyword;\n          $notOp += '=';\n        } else {\n          $exclusive = false;\n          $opStr += '=';\n        }\n      }\n      var $opExpr = '\\'' + $opStr + '\\'';\n      out += ' if ( ';\n      if ($isData) {\n        out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n      }\n      out += ' ' + ($data) + ' ' + ($notOp) + ' ' + ($schemaValue) + ' || ' + ($data) + ' !== ' + ($data) + ') { ';\n    }\n  }\n  $errorKeyword = $errorKeyword || $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limit') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { comparison: ' + ($opExpr) + ', limit: ' + ($schemaValue) + ', exclusive: ' + ($exclusive) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be ' + ($opStr) + ' ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += ' } ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate__limitItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxItems' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxItems') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' items\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate__limitLength(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxLength' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  if (it.opts.unicode === false) {\n    out += ' ' + ($data) + '.length ';\n  } else {\n    out += ' ucs2length(' + ($data) + ') ';\n  }\n  out += ' ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitLength') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT be ';\n      if ($keyword == 'maxLength') {\n        out += 'longer';\n      } else {\n        out += 'shorter';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' characters\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate__limitProperties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  var $op = $keyword == 'maxProperties' ? '>' : '<';\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'number\\') || ';\n  }\n  out += ' Object.keys(' + ($data) + ').length ' + ($op) + ' ' + ($schemaValue) + ') { ';\n  var $errorKeyword = $keyword;\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ($errorKeyword || '_limitProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should NOT have ';\n      if ($keyword == 'maxProperties') {\n        out += 'more';\n      } else {\n        out += 'fewer';\n      }\n      out += ' than ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + ($schema);\n      }\n      out += ' properties\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_multipleOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (!($isData || typeof $schema == 'number')) {\n    throw new Error($keyword + ' must be number');\n  }\n  out += 'var division' + ($lvl) + ';if (';\n  if ($isData) {\n    out += ' ' + ($schemaValue) + ' !== undefined && ( typeof ' + ($schemaValue) + ' != \\'number\\' || ';\n  }\n  out += ' (division' + ($lvl) + ' = ' + ($data) + ' / ' + ($schemaValue) + ', ';\n  if (it.opts.multipleOfPrecision) {\n    out += ' Math.abs(Math.round(division' + ($lvl) + ') - division' + ($lvl) + ') > 1e-' + (it.opts.multipleOfPrecision) + ' ';\n  } else {\n    out += ' division' + ($lvl) + ' !== parseInt(division' + ($lvl) + ') ';\n  }\n  out += ' ) ';\n  if ($isData) {\n    out += '  )  ';\n  }\n  out += ' ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('multipleOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { multipleOf: ' + ($schemaValue) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should be multiple of ';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue);\n      } else {\n        out += '' + ($schemaValue) + '\\'';\n      }\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + ($schema);\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_not(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    out += ' var ' + ($errs) + ' = errors;  ';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    $it.createErrors = false;\n    var $allErrorsOption;\n    if ($it.opts.allErrors) {\n      $allErrorsOption = $it.opts.allErrors;\n      $it.opts.allErrors = false;\n    }\n    out += ' ' + (it.validate($it)) + ' ';\n    $it.createErrors = true;\n    if ($allErrorsOption) $it.opts.allErrors = $allErrorsOption;\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (' + ($nextValid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; } ';\n    if (it.opts.allErrors) {\n      out += ' } ';\n    }\n  } else {\n    out += '  var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('not') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: {} ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT be valid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if ($breakOnError) {\n      out += ' if (false) { ';\n    }\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_oneOf(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $currentBaseId = $it.baseId,\n    $prevValid = 'prevValid' + $lvl,\n    $passingSchemas = 'passingSchemas' + $lvl;\n  out += 'var ' + ($errs) + ' = errors , ' + ($prevValid) + ' = false , ' + ($valid) + ' = false , ' + ($passingSchemas) + ' = null; ';\n  var $wasComposite = it.compositeRule;\n  it.compositeRule = $it.compositeRule = true;\n  var arr1 = $schema;\n  if (arr1) {\n    var $sch, $i = -1,\n      l1 = arr1.length - 1;\n    while ($i < l1) {\n      $sch = arr1[$i += 1];\n      if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n        $it.schema = $sch;\n        $it.schemaPath = $schemaPath + '[' + $i + ']';\n        $it.errSchemaPath = $errSchemaPath + '/' + $i;\n        out += '  ' + (it.validate($it)) + ' ';\n        $it.baseId = $currentBaseId;\n      } else {\n        out += ' var ' + ($nextValid) + ' = true; ';\n      }\n      if ($i) {\n        out += ' if (' + ($nextValid) + ' && ' + ($prevValid) + ') { ' + ($valid) + ' = false; ' + ($passingSchemas) + ' = [' + ($passingSchemas) + ', ' + ($i) + ']; } else { ';\n        $closingBraces += '}';\n      }\n      out += ' if (' + ($nextValid) + ') { ' + ($valid) + ' = ' + ($prevValid) + ' = true; ' + ($passingSchemas) + ' = ' + ($i) + '; }';\n    }\n  }\n  it.compositeRule = $it.compositeRule = $wasComposite;\n  out += '' + ($closingBraces) + 'if (!' + ($valid) + ') {   var err =   '; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('oneOf') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { passingSchemas: ' + ($passingSchemas) + ' } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match exactly one schema in oneOf\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError(vErrors); ';\n    } else {\n      out += ' validate.errors = vErrors; return false; ';\n    }\n  }\n  out += '} else {  errors = ' + ($errs) + '; if (vErrors !== null) { if (' + ($errs) + ') vErrors.length = ' + ($errs) + '; else vErrors = null; }';\n  if (it.opts.allErrors) {\n    out += ' } ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_pattern(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $regexp = $isData ? '(new RegExp(' + $schemaValue + '))' : it.usePattern($schema);\n  out += 'if ( ';\n  if ($isData) {\n    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \\'string\\') || ';\n  }\n  out += ' !' + ($regexp) + '.test(' + ($data) + ') ) {   ';\n  var $$outStack = $$outStack || [];\n  $$outStack.push(out);\n  out = ''; /* istanbul ignore else */\n  if (it.createErrors !== false) {\n    out += ' { keyword: \\'' + ('pattern') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { pattern:  ';\n    if ($isData) {\n      out += '' + ($schemaValue);\n    } else {\n      out += '' + (it.util.toQuotedString($schema));\n    }\n    out += '  } ';\n    if (it.opts.messages !== false) {\n      out += ' , message: \\'should match pattern \"';\n      if ($isData) {\n        out += '\\' + ' + ($schemaValue) + ' + \\'';\n      } else {\n        out += '' + (it.util.escapeQuotes($schema));\n      }\n      out += '\"\\' ';\n    }\n    if (it.opts.verbose) {\n      out += ' , schema:  ';\n      if ($isData) {\n        out += 'validate.schema' + ($schemaPath);\n      } else {\n        out += '' + (it.util.toQuotedString($schema));\n      }\n      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n    }\n    out += ' } ';\n  } else {\n    out += ' {} ';\n  }\n  var __err = out;\n  out = $$outStack.pop();\n  if (!it.compositeRule && $breakOnError) {\n    /* istanbul ignore if */\n    if (it.async) {\n      out += ' throw new ValidationError([' + (__err) + ']); ';\n    } else {\n      out += ' validate.errors = [' + (__err) + ']; return false; ';\n    }\n  } else {\n    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n  }\n  out += '} ';\n  if ($breakOnError) {\n    out += ' else { ';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_properties(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  var $key = 'key' + $lvl,\n    $idx = 'idx' + $lvl,\n    $dataNxt = $it.dataLevel = it.dataLevel + 1,\n    $nextData = 'data' + $dataNxt,\n    $dataProperties = 'dataProperties' + $lvl;\n  var $schemaKeys = Object.keys($schema || {}).filter(notProto),\n    $pProperties = it.schema.patternProperties || {},\n    $pPropertyKeys = Object.keys($pProperties).filter(notProto),\n    $aProperties = it.schema.additionalProperties,\n    $someProperties = $schemaKeys.length || $pPropertyKeys.length,\n    $noAdditional = $aProperties === false,\n    $additionalIsSchema = typeof $aProperties == 'object' && Object.keys($aProperties).length,\n    $removeAdditional = it.opts.removeAdditional,\n    $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional,\n    $ownProperties = it.opts.ownProperties,\n    $currentBaseId = it.baseId;\n  var $required = it.schema.required;\n  if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) {\n    var $requiredHash = it.util.toHash($required);\n  }\n\n  function notProto(p) {\n    return p !== '__proto__';\n  }\n  out += 'var ' + ($errs) + ' = errors;var ' + ($nextValid) + ' = true;';\n  if ($ownProperties) {\n    out += ' var ' + ($dataProperties) + ' = undefined;';\n  }\n  if ($checkAdditional) {\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    if ($someProperties) {\n      out += ' var isAdditional' + ($lvl) + ' = !(false ';\n      if ($schemaKeys.length) {\n        if ($schemaKeys.length > 8) {\n          out += ' || validate.schema' + ($schemaPath) + '.hasOwnProperty(' + ($key) + ') ';\n        } else {\n          var arr1 = $schemaKeys;\n          if (arr1) {\n            var $propertyKey, i1 = -1,\n              l1 = arr1.length - 1;\n            while (i1 < l1) {\n              $propertyKey = arr1[i1 += 1];\n              out += ' || ' + ($key) + ' == ' + (it.util.toQuotedString($propertyKey)) + ' ';\n            }\n          }\n        }\n      }\n      if ($pPropertyKeys.length) {\n        var arr2 = $pPropertyKeys;\n        if (arr2) {\n          var $pProperty, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $pProperty = arr2[$i += 1];\n            out += ' || ' + (it.usePattern($pProperty)) + '.test(' + ($key) + ') ';\n          }\n        }\n      }\n      out += ' ); if (isAdditional' + ($lvl) + ') { ';\n    }\n    if ($removeAdditional == 'all') {\n      out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n    } else {\n      var $currentErrorPath = it.errorPath;\n      var $additionalProperty = '\\' + ' + $key + ' + \\'';\n      if (it.opts._errorDataPathProperty) {\n        it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n      }\n      if ($noAdditional) {\n        if ($removeAdditional) {\n          out += ' delete ' + ($data) + '[' + ($key) + ']; ';\n        } else {\n          out += ' ' + ($nextValid) + ' = false; ';\n          var $currErrSchemaPath = $errSchemaPath;\n          $errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          var $$outStack = $$outStack || [];\n          $$outStack.push(out);\n          out = ''; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('additionalProperties') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { additionalProperty: \\'' + ($additionalProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is an invalid additional property';\n              } else {\n                out += 'should NOT have additional properties';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: false , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          var __err = out;\n          out = $$outStack.pop();\n          if (!it.compositeRule && $breakOnError) {\n            /* istanbul ignore if */\n            if (it.async) {\n              out += ' throw new ValidationError([' + (__err) + ']); ';\n            } else {\n              out += ' validate.errors = [' + (__err) + ']; return false; ';\n            }\n          } else {\n            out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n          }\n          $errSchemaPath = $currErrSchemaPath;\n          if ($breakOnError) {\n            out += ' break; ';\n          }\n        }\n      } else if ($additionalIsSchema) {\n        if ($removeAdditional == 'failing') {\n          out += ' var ' + ($errs) + ' = errors;  ';\n          var $wasComposite = it.compositeRule;\n          it.compositeRule = $it.compositeRule = true;\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          out += ' if (!' + ($nextValid) + ') { errors = ' + ($errs) + '; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete ' + ($data) + '[' + ($key) + ']; }  ';\n          it.compositeRule = $it.compositeRule = $wasComposite;\n        } else {\n          $it.schema = $aProperties;\n          $it.schemaPath = it.schemaPath + '.additionalProperties';\n          $it.errSchemaPath = it.errSchemaPath + '/additionalProperties';\n          $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n        }\n      }\n      it.errorPath = $currentErrorPath;\n    }\n    if ($someProperties) {\n      out += ' } ';\n    }\n    out += ' }  ';\n    if ($breakOnError) {\n      out += ' if (' + ($nextValid) + ') { ';\n      $closingBraces += '}';\n    }\n  }\n  var $useDefaults = it.opts.useDefaults && !it.compositeRule;\n  if ($schemaKeys.length) {\n    var arr3 = $schemaKeys;\n    if (arr3) {\n      var $propertyKey, i3 = -1,\n        l3 = arr3.length - 1;\n      while (i3 < l3) {\n        $propertyKey = arr3[i3 += 1];\n        var $sch = $schema[$propertyKey];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          var $prop = it.util.getProperty($propertyKey),\n            $passData = $data + $prop,\n            $hasDefault = $useDefaults && $sch.default !== undefined;\n          $it.schema = $sch;\n          $it.schemaPath = $schemaPath + $prop;\n          $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($propertyKey);\n          $it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers);\n          $it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey);\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            $code = it.util.varReplace($code, $nextData, $passData);\n            var $useData = $passData;\n          } else {\n            var $useData = $nextData;\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ';\n          }\n          if ($hasDefault) {\n            out += ' ' + ($code) + ' ';\n          } else {\n            if ($requiredHash && $requiredHash[$propertyKey]) {\n              out += ' if ( ' + ($useData) + ' === undefined ';\n              if ($ownProperties) {\n                out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n              }\n              out += ') { ' + ($nextValid) + ' = false; ';\n              var $currentErrorPath = it.errorPath,\n                $currErrSchemaPath = $errSchemaPath,\n                $missingProperty = it.util.escapeQuotes($propertyKey);\n              if (it.opts._errorDataPathProperty) {\n                it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n              }\n              $errSchemaPath = it.errSchemaPath + '/required';\n              var $$outStack = $$outStack || [];\n              $$outStack.push(out);\n              out = ''; /* istanbul ignore else */\n              if (it.createErrors !== false) {\n                out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n                if (it.opts.messages !== false) {\n                  out += ' , message: \\'';\n                  if (it.opts._errorDataPathProperty) {\n                    out += 'is a required property';\n                  } else {\n                    out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                  }\n                  out += '\\' ';\n                }\n                if (it.opts.verbose) {\n                  out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n                }\n                out += ' } ';\n              } else {\n                out += ' {} ';\n              }\n              var __err = out;\n              out = $$outStack.pop();\n              if (!it.compositeRule && $breakOnError) {\n                /* istanbul ignore if */\n                if (it.async) {\n                  out += ' throw new ValidationError([' + (__err) + ']); ';\n                } else {\n                  out += ' validate.errors = [' + (__err) + ']; return false; ';\n                }\n              } else {\n                out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n              }\n              $errSchemaPath = $currErrSchemaPath;\n              it.errorPath = $currentErrorPath;\n              out += ' } else { ';\n            } else {\n              if ($breakOnError) {\n                out += ' if ( ' + ($useData) + ' === undefined ';\n                if ($ownProperties) {\n                  out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ') { ' + ($nextValid) + ' = true; } else { ';\n              } else {\n                out += ' if (' + ($useData) + ' !== undefined ';\n                if ($ownProperties) {\n                  out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n                }\n                out += ' ) { ';\n              }\n            }\n            out += ' ' + ($code) + ' } ';\n          }\n        }\n        if ($breakOnError) {\n          out += ' if (' + ($nextValid) + ') { ';\n          $closingBraces += '}';\n        }\n      }\n    }\n  }\n  if ($pPropertyKeys.length) {\n    var arr4 = $pPropertyKeys;\n    if (arr4) {\n      var $pProperty, i4 = -1,\n        l4 = arr4.length - 1;\n      while (i4 < l4) {\n        $pProperty = arr4[i4 += 1];\n        var $sch = $pProperties[$pProperty];\n        if ((it.opts.strictKeywords ? (typeof $sch == 'object' && Object.keys($sch).length > 0) || $sch === false : it.util.schemaHasRules($sch, it.RULES.all))) {\n          $it.schema = $sch;\n          $it.schemaPath = it.schemaPath + '.patternProperties' + it.util.getProperty($pProperty);\n          $it.errSchemaPath = it.errSchemaPath + '/patternProperties/' + it.util.escapeFragment($pProperty);\n          if ($ownProperties) {\n            out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n          } else {\n            out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n          }\n          out += ' if (' + (it.usePattern($pProperty)) + '.test(' + ($key) + ')) { ';\n          $it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);\n          var $passData = $data + '[' + $key + ']';\n          $it.dataPathArr[$dataNxt] = $key;\n          var $code = it.validate($it);\n          $it.baseId = $currentBaseId;\n          if (it.util.varOccurences($code, $nextData) < 2) {\n            out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n          } else {\n            out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n          }\n          if ($breakOnError) {\n            out += ' if (!' + ($nextValid) + ') break; ';\n          }\n          out += ' } ';\n          if ($breakOnError) {\n            out += ' else ' + ($nextValid) + ' = true; ';\n          }\n          out += ' }  ';\n          if ($breakOnError) {\n            out += ' if (' + ($nextValid) + ') { ';\n            $closingBraces += '}';\n          }\n        }\n      }\n    }\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_propertyNames(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $errs = 'errs__' + $lvl;\n  var $it = it.util.copy(it);\n  var $closingBraces = '';\n  $it.level++;\n  var $nextValid = 'valid' + $it.level;\n  out += 'var ' + ($errs) + ' = errors;';\n  if ((it.opts.strictKeywords ? (typeof $schema == 'object' && Object.keys($schema).length > 0) || $schema === false : it.util.schemaHasRules($schema, it.RULES.all))) {\n    $it.schema = $schema;\n    $it.schemaPath = $schemaPath;\n    $it.errSchemaPath = $errSchemaPath;\n    var $key = 'key' + $lvl,\n      $idx = 'idx' + $lvl,\n      $i = 'i' + $lvl,\n      $invalidName = '\\' + ' + $key + ' + \\'',\n      $dataNxt = $it.dataLevel = it.dataLevel + 1,\n      $nextData = 'data' + $dataNxt,\n      $dataProperties = 'dataProperties' + $lvl,\n      $ownProperties = it.opts.ownProperties,\n      $currentBaseId = it.baseId;\n    if ($ownProperties) {\n      out += ' var ' + ($dataProperties) + ' = undefined; ';\n    }\n    if ($ownProperties) {\n      out += ' ' + ($dataProperties) + ' = ' + ($dataProperties) + ' || Object.keys(' + ($data) + '); for (var ' + ($idx) + '=0; ' + ($idx) + '<' + ($dataProperties) + '.length; ' + ($idx) + '++) { var ' + ($key) + ' = ' + ($dataProperties) + '[' + ($idx) + ']; ';\n    } else {\n      out += ' for (var ' + ($key) + ' in ' + ($data) + ') { ';\n    }\n    out += ' var startErrs' + ($lvl) + ' = errors; ';\n    var $passData = $key;\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it);\n    $it.baseId = $currentBaseId;\n    if (it.util.varOccurences($code, $nextData) < 2) {\n      out += ' ' + (it.util.varReplace($code, $nextData, $passData)) + ' ';\n    } else {\n      out += ' var ' + ($nextData) + ' = ' + ($passData) + '; ' + ($code) + ' ';\n    }\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' if (!' + ($nextValid) + ') { for (var ' + ($i) + '=startErrs' + ($lvl) + '; ' + ($i) + '<errors; ' + ($i) + '++) { vErrors[' + ($i) + '].propertyName = ' + ($key) + '; }   var err =   '; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('propertyNames') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { propertyName: \\'' + ($invalidName) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'property name \\\\\\'' + ($invalidName) + '\\\\\\' is invalid\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError(vErrors); ';\n      } else {\n        out += ' validate.errors = vErrors; return false; ';\n      }\n    }\n    if ($breakOnError) {\n      out += ' break; ';\n    }\n    out += ' } }';\n  }\n  if ($breakOnError) {\n    out += ' ' + ($closingBraces) + ' if (' + ($errs) + ' == errors) {';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_required(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $vSchema = 'schema' + $lvl;\n  if (!$isData) {\n    if ($schema.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) {\n      var $required = [];\n      var arr1 = $schema;\n      if (arr1) {\n        var $property, i1 = -1,\n          l1 = arr1.length - 1;\n        while (i1 < l1) {\n          $property = arr1[i1 += 1];\n          var $propertySch = it.schema.properties[$property];\n          if (!($propertySch && (it.opts.strictKeywords ? (typeof $propertySch == 'object' && Object.keys($propertySch).length > 0) || $propertySch === false : it.util.schemaHasRules($propertySch, it.RULES.all)))) {\n            $required[$required.length] = $property;\n          }\n        }\n      }\n    } else {\n      var $required = $schema;\n    }\n  }\n  if ($isData || $required.length) {\n    var $currentErrorPath = it.errorPath,\n      $loopRequired = $isData || $required.length >= it.opts.loopRequired,\n      $ownProperties = it.opts.ownProperties;\n    if ($breakOnError) {\n      out += ' var missing' + ($lvl) + '; ';\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        out += ' var ' + ($valid) + ' = true; ';\n        if ($isData) {\n          out += ' if (schema' + ($lvl) + ' === undefined) ' + ($valid) + ' = true; else if (!Array.isArray(schema' + ($lvl) + ')) ' + ($valid) + ' = false; else {';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { ' + ($valid) + ' = ' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] !== undefined ';\n        if ($ownProperties) {\n          out += ' &&   Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += '; if (!' + ($valid) + ') break; } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n        out += '  if (!' + ($valid) + ') {   ';\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      } else {\n        out += ' if ( ';\n        var arr2 = $required;\n        if (arr2) {\n          var $propertyKey, $i = -1,\n            l2 = arr2.length - 1;\n          while ($i < l2) {\n            $propertyKey = arr2[$i += 1];\n            if ($i) {\n              out += ' || ';\n            }\n            var $prop = it.util.getProperty($propertyKey),\n              $useData = $data + $prop;\n            out += ' ( ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') && (missing' + ($lvl) + ' = ' + (it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop)) + ') ) ';\n          }\n        }\n        out += ') {  ';\n        var $propertyPath = 'missing' + $lvl,\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + ' + ' + $propertyPath;\n        }\n        var $$outStack = $$outStack || [];\n        $$outStack.push(out);\n        out = ''; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        var __err = out;\n        out = $$outStack.pop();\n        if (!it.compositeRule && $breakOnError) {\n          /* istanbul ignore if */\n          if (it.async) {\n            out += ' throw new ValidationError([' + (__err) + ']); ';\n          } else {\n            out += ' validate.errors = [' + (__err) + ']; return false; ';\n          }\n        } else {\n          out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n        }\n        out += ' } else { ';\n      }\n    } else {\n      if ($loopRequired) {\n        if (!$isData) {\n          out += ' var ' + ($vSchema) + ' = validate.schema' + ($schemaPath) + '; ';\n        }\n        var $i = 'i' + $lvl,\n          $propertyPath = 'schema' + $lvl + '[' + $i + ']',\n          $missingProperty = '\\' + ' + $propertyPath + ' + \\'';\n        if (it.opts._errorDataPathProperty) {\n          it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);\n        }\n        if ($isData) {\n          out += ' if (' + ($vSchema) + ' && !Array.isArray(' + ($vSchema) + ')) {  var err =   '; /* istanbul ignore else */\n          if (it.createErrors !== false) {\n            out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n            if (it.opts.messages !== false) {\n              out += ' , message: \\'';\n              if (it.opts._errorDataPathProperty) {\n                out += 'is a required property';\n              } else {\n                out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n              }\n              out += '\\' ';\n            }\n            if (it.opts.verbose) {\n              out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n            }\n            out += ' } ';\n          } else {\n            out += ' {} ';\n          }\n          out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (' + ($vSchema) + ' !== undefined) { ';\n        }\n        out += ' for (var ' + ($i) + ' = 0; ' + ($i) + ' < ' + ($vSchema) + '.length; ' + ($i) + '++) { if (' + ($data) + '[' + ($vSchema) + '[' + ($i) + ']] === undefined ';\n        if ($ownProperties) {\n          out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', ' + ($vSchema) + '[' + ($i) + ']) ';\n        }\n        out += ') {  var err =   '; /* istanbul ignore else */\n        if (it.createErrors !== false) {\n          out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n          if (it.opts.messages !== false) {\n            out += ' , message: \\'';\n            if (it.opts._errorDataPathProperty) {\n              out += 'is a required property';\n            } else {\n              out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n            }\n            out += '\\' ';\n          }\n          if (it.opts.verbose) {\n            out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n          }\n          out += ' } ';\n        } else {\n          out += ' {} ';\n        }\n        out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } ';\n        if ($isData) {\n          out += '  }  ';\n        }\n      } else {\n        var arr3 = $required;\n        if (arr3) {\n          var $propertyKey, i3 = -1,\n            l3 = arr3.length - 1;\n          while (i3 < l3) {\n            $propertyKey = arr3[i3 += 1];\n            var $prop = it.util.getProperty($propertyKey),\n              $missingProperty = it.util.escapeQuotes($propertyKey),\n              $useData = $data + $prop;\n            if (it.opts._errorDataPathProperty) {\n              it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);\n            }\n            out += ' if ( ' + ($useData) + ' === undefined ';\n            if ($ownProperties) {\n              out += ' || ! Object.prototype.hasOwnProperty.call(' + ($data) + ', \\'' + (it.util.escapeQuotes($propertyKey)) + '\\') ';\n            }\n            out += ') {  var err =   '; /* istanbul ignore else */\n            if (it.createErrors !== false) {\n              out += ' { keyword: \\'' + ('required') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { missingProperty: \\'' + ($missingProperty) + '\\' } ';\n              if (it.opts.messages !== false) {\n                out += ' , message: \\'';\n                if (it.opts._errorDataPathProperty) {\n                  out += 'is a required property';\n                } else {\n                  out += 'should have required property \\\\\\'' + ($missingProperty) + '\\\\\\'';\n                }\n                out += '\\' ';\n              }\n              if (it.opts.verbose) {\n                out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n              }\n              out += ' } ';\n            } else {\n              out += ' {} ';\n            }\n            out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ';\n          }\n        }\n      }\n    }\n    it.errorPath = $currentErrorPath;\n  } else if ($breakOnError) {\n    out += ' if (true) {';\n  }\n  return out;\n}\n", "'use strict';\nmodule.exports = function generate_uniqueItems(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  if (($schema || $isData) && it.opts.uniqueItems !== false) {\n    if ($isData) {\n      out += ' var ' + ($valid) + '; if (' + ($schemaValue) + ' === false || ' + ($schemaValue) + ' === undefined) ' + ($valid) + ' = true; else if (typeof ' + ($schemaValue) + ' != \\'boolean\\') ' + ($valid) + ' = false; else { ';\n    }\n    out += ' var i = ' + ($data) + '.length , ' + ($valid) + ' = true , j; if (i > 1) { ';\n    var $itemType = it.schema.items && it.schema.items.type,\n      $typeIsArray = Array.isArray($itemType);\n    if (!$itemType || $itemType == 'object' || $itemType == 'array' || ($typeIsArray && ($itemType.indexOf('object') >= 0 || $itemType.indexOf('array') >= 0))) {\n      out += ' outer: for (;i--;) { for (j = i; j--;) { if (equal(' + ($data) + '[i], ' + ($data) + '[j])) { ' + ($valid) + ' = false; break outer; } } } ';\n    } else {\n      out += ' var itemIndices = {}, item; for (;i--;) { var item = ' + ($data) + '[i]; ';\n      var $method = 'checkDataType' + ($typeIsArray ? 's' : '');\n      out += ' if (' + (it.util[$method]($itemType, 'item', it.opts.strictNumbers, true)) + ') continue; ';\n      if ($typeIsArray) {\n        out += ' if (typeof item == \\'string\\') item = \\'\"\\' + item; ';\n      }\n      out += ' if (typeof itemIndices[item] == \\'number\\') { ' + ($valid) + ' = false; j = itemIndices[item]; break; } itemIndices[item] = i; } ';\n    }\n    out += ' } ';\n    if ($isData) {\n      out += '  }  ';\n    }\n    out += ' if (!' + ($valid) + ') {   ';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ('uniqueItems') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { i: i, j: j } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should NOT have duplicate items (items ## \\' + j + \\' and \\' + i + \\' are identical)\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema:  ';\n        if ($isData) {\n          out += 'validate.schema' + ($schemaPath);\n        } else {\n          out += '' + ($schema);\n        }\n        out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  } else {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  }\n  return out;\n}\n", "'use strict';\n\n//all requires must be explicit because browserify won't work with dynamic requires\nmodule.exports = {\n  '$ref': require('./ref'),\n  allOf: require('./allOf'),\n  anyOf: require('./anyOf'),\n  '$comment': require('./comment'),\n  const: require('./const'),\n  contains: require('./contains'),\n  dependencies: require('./dependencies'),\n  'enum': require('./enum'),\n  format: require('./format'),\n  'if': require('./if'),\n  items: require('./items'),\n  maximum: require('./_limit'),\n  minimum: require('./_limit'),\n  maxItems: require('./_limitItems'),\n  minItems: require('./_limitItems'),\n  maxLength: require('./_limitLength'),\n  minLength: require('./_limitLength'),\n  maxProperties: require('./_limitProperties'),\n  minProperties: require('./_limitProperties'),\n  multipleOf: require('./multipleOf'),\n  not: require('./not'),\n  oneOf: require('./oneOf'),\n  pattern: require('./pattern'),\n  properties: require('./properties'),\n  propertyNames: require('./propertyNames'),\n  required: require('./required'),\n  uniqueItems: require('./uniqueItems'),\n  validate: require('./validate')\n};\n", "'use strict';\n\nvar ruleModules = require('../dotjs')\n  , toHash = require('./util').toHash;\n\nmodule.exports = function rules() {\n  var RULES = [\n    { type: 'number',\n      rules: [ { 'maximum': ['exclusiveMaximum'] },\n               { 'minimum': ['exclusiveMinimum'] }, 'multipleOf', 'format'] },\n    { type: 'string',\n      rules: [ 'maxLength', 'minLength', 'pattern', 'format' ] },\n    { type: 'array',\n      rules: [ 'maxItems', 'minItems', 'items', 'contains', 'uniqueItems' ] },\n    { type: 'object',\n      rules: [ 'maxProperties', 'minProperties', 'required', 'dependencies', 'propertyNames',\n               { 'properties': ['additionalProperties', 'patternProperties'] } ] },\n    { rules: [ '$ref', 'const', 'enum', 'not', 'anyOf', 'oneOf', 'allOf', 'if' ] }\n  ];\n\n  var ALL = [ 'type', '$comment' ];\n  var KEYWORDS = [\n    '$schema', '$id', 'id', '$data', '$async', 'title',\n    'description', 'default', 'definitions',\n    'examples', 'readOnly', 'writeOnly',\n    'contentMediaType', 'contentEncoding',\n    'additionalItems', 'then', 'else'\n  ];\n  var TYPES = [ 'number', 'integer', 'string', 'array', 'object', 'boolean', 'null' ];\n  RULES.all = toHash(ALL);\n  RULES.types = toHash(TYPES);\n\n  RULES.forEach(function (group) {\n    group.rules = group.rules.map(function (keyword) {\n      var implKeywords;\n      if (typeof keyword == 'object') {\n        var key = Object.keys(keyword)[0];\n        implKeywords = keyword[key];\n        keyword = key;\n        implKeywords.forEach(function (k) {\n          ALL.push(k);\n          RULES.all[k] = true;\n        });\n      }\n      ALL.push(keyword);\n      var rule = RULES.all[keyword] = {\n        keyword: keyword,\n        code: ruleModules[keyword],\n        implements: implKeywords\n      };\n      return rule;\n    });\n\n    RULES.all.$comment = {\n      keyword: '$comment',\n      code: ruleModules.$comment\n    };\n\n    if (group.type) RULES.types[group.type] = group;\n  });\n\n  RULES.keywords = toHash(ALL.concat(KEYWORDS));\n  RULES.custom = {};\n\n  return RULES;\n};\n", "'use strict';\n\nvar KEYWORDS = [\n  'multipleOf',\n  'maximum',\n  'exclusiveMaximum',\n  'minimum',\n  'exclusiveMinimum',\n  'maxLength',\n  'minLength',\n  'pattern',\n  'additionalItems',\n  'maxItems',\n  'minItems',\n  'uniqueItems',\n  'maxProperties',\n  'minProperties',\n  'required',\n  'additionalProperties',\n  'enum',\n  'format',\n  'const'\n];\n\nmodule.exports = function (metaSchema, keywordsJsonPointers) {\n  for (var i=0; i<keywordsJsonPointers.length; i++) {\n    metaSchema = JSON.parse(JSON.stringify(metaSchema));\n    var segments = keywordsJsonPointers[i].split('/');\n    var keywords = metaSchema;\n    var j;\n    for (j=1; j<segments.length; j++)\n      keywords = keywords[segments[j]];\n\n    for (j=0; j<KEYWORDS.length; j++) {\n      var key = KEYWORDS[j];\n      var schema = keywords[key];\n      if (schema) {\n        keywords[key] = {\n          anyOf: [\n            schema,\n            { $ref: 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n    }\n  }\n\n  return metaSchema;\n};\n", "'use strict';\n\nvar MissingRefError = require('./error_classes').MissingRef;\n\nmodule.exports = compileAsync;\n\n\n/**\n * Creates validating function for passed schema with asynchronous loading of missing schemas.\n * `loadSchema` option should be a function that accepts schema uri and returns promise that resolves with the schema.\n * @this  Ajv\n * @param {Object}   schema schema object\n * @param {Boolean}  meta optional true to compile meta-schema; this parameter can be skipped\n * @param {Function} callback an optional node-style callback, it is called with 2 parameters: error (or null) and validating function.\n * @return {Promise} promise that resolves with a validating function.\n */\nfunction compileAsync(schema, meta, callback) {\n  /* eslint no-shadow: 0 */\n  /* global Promise */\n  /* jshint validthis: true */\n  var self = this;\n  if (typeof this._opts.loadSchema != 'function')\n    throw new Error('options.loadSchema should be a function');\n\n  if (typeof meta == 'function') {\n    callback = meta;\n    meta = undefined;\n  }\n\n  var p = loadMetaSchemaOf(schema).then(function () {\n    var schemaObj = self._addSchema(schema, undefined, meta);\n    return schemaObj.validate || _compileAsync(schemaObj);\n  });\n\n  if (callback) {\n    p.then(\n      function(v) { callback(null, v); },\n      callback\n    );\n  }\n\n  return p;\n\n\n  function loadMetaSchemaOf(sch) {\n    var $schema = sch.$schema;\n    return $schema && !self.getSchema($schema)\n            ? compileAsync.call(self, { $ref: $schema }, true)\n            : Promise.resolve();\n  }\n\n\n  function _compileAsync(schemaObj) {\n    try { return self._compile(schemaObj); }\n    catch(e) {\n      if (e instanceof MissingRefError) return loadMissingSchema(e);\n      throw e;\n    }\n\n\n    function loadMissingSchema(e) {\n      var ref = e.missingSchema;\n      if (added(ref)) throw new Error('Schema ' + ref + ' is loaded but ' + e.missingRef + ' cannot be resolved');\n\n      var schemaPromise = self._loadingSchemas[ref];\n      if (!schemaPromise) {\n        schemaPromise = self._loadingSchemas[ref] = self._opts.loadSchema(ref);\n        schemaPromise.then(removePromise, removePromise);\n      }\n\n      return schemaPromise.then(function (sch) {\n        if (!added(ref)) {\n          return loadMetaSchemaOf(sch).then(function () {\n            if (!added(ref)) self.addSchema(sch, ref, undefined, meta);\n          });\n        }\n      }).then(function() {\n        return _compileAsync(schemaObj);\n      });\n\n      function removePromise() {\n        delete self._loadingSchemas[ref];\n      }\n\n      function added(ref) {\n        return self._refs[ref] || self._schemas[ref];\n      }\n    }\n  }\n}\n", "'use strict';\nmodule.exports = function generate_custom(it, $keyword, $ruleType) {\n  var out = ' ';\n  var $lvl = it.level;\n  var $dataLvl = it.dataLevel;\n  var $schema = it.schema[$keyword];\n  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);\n  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;\n  var $breakOnError = !it.opts.allErrors;\n  var $errorKeyword;\n  var $data = 'data' + ($dataLvl || '');\n  var $valid = 'valid' + $lvl;\n  var $errs = 'errs__' + $lvl;\n  var $isData = it.opts.$data && $schema && $schema.$data,\n    $schemaValue;\n  if ($isData) {\n    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';\n    $schemaValue = 'schema' + $lvl;\n  } else {\n    $schemaValue = $schema;\n  }\n  var $rule = this,\n    $definition = 'definition' + $lvl,\n    $rDef = $rule.definition,\n    $closingBraces = '';\n  var $compile, $inline, $macro, $ruleValidate, $validateCode;\n  if ($isData && $rDef.$data) {\n    $validateCode = 'keywordValidate' + $lvl;\n    var $validateSchema = $rDef.validateSchema;\n    out += ' var ' + ($definition) + ' = RULES.custom[\\'' + ($keyword) + '\\'].definition; var ' + ($validateCode) + ' = ' + ($definition) + '.validate;';\n  } else {\n    $ruleValidate = it.useCustomRule($rule, $schema, it.schema, it);\n    if (!$ruleValidate) return;\n    $schemaValue = 'validate.schema' + $schemaPath;\n    $validateCode = $ruleValidate.code;\n    $compile = $rDef.compile;\n    $inline = $rDef.inline;\n    $macro = $rDef.macro;\n  }\n  var $ruleErrs = $validateCode + '.errors',\n    $i = 'i' + $lvl,\n    $ruleErr = 'ruleErr' + $lvl,\n    $asyncKeyword = $rDef.async;\n  if ($asyncKeyword && !it.async) throw new Error('async keyword in sync schema');\n  if (!($inline || $macro)) {\n    out += '' + ($ruleErrs) + ' = null;';\n  }\n  out += 'var ' + ($errs) + ' = errors;var ' + ($valid) + ';';\n  if ($isData && $rDef.$data) {\n    $closingBraces += '}';\n    out += ' if (' + ($schemaValue) + ' === undefined) { ' + ($valid) + ' = true; } else { ';\n    if ($validateSchema) {\n      $closingBraces += '}';\n      out += ' ' + ($valid) + ' = ' + ($definition) + '.validateSchema(' + ($schemaValue) + '); if (' + ($valid) + ') { ';\n    }\n  }\n  if ($inline) {\n    if ($rDef.statements) {\n      out += ' ' + ($ruleValidate.validate) + ' ';\n    } else {\n      out += ' ' + ($valid) + ' = ' + ($ruleValidate.validate) + '; ';\n    }\n  } else if ($macro) {\n    var $it = it.util.copy(it);\n    var $closingBraces = '';\n    $it.level++;\n    var $nextValid = 'valid' + $it.level;\n    $it.schema = $ruleValidate.validate;\n    $it.schemaPath = '';\n    var $wasComposite = it.compositeRule;\n    it.compositeRule = $it.compositeRule = true;\n    var $code = it.validate($it).replace(/validate\\.schema/g, $validateCode);\n    it.compositeRule = $it.compositeRule = $wasComposite;\n    out += ' ' + ($code);\n  } else {\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    out += '  ' + ($validateCode) + '.call( ';\n    if (it.opts.passContext) {\n      out += 'this';\n    } else {\n      out += 'self';\n    }\n    if ($compile || $rDef.schema === false) {\n      out += ' , ' + ($data) + ' ';\n    } else {\n      out += ' , ' + ($schemaValue) + ' , ' + ($data) + ' , validate.schema' + (it.schemaPath) + ' ';\n    }\n    out += ' , (dataPath || \\'\\')';\n    if (it.errorPath != '\"\"') {\n      out += ' + ' + (it.errorPath);\n    }\n    var $parentData = $dataLvl ? 'data' + (($dataLvl - 1) || '') : 'parentData',\n      $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : 'parentDataProperty';\n    out += ' , ' + ($parentData) + ' , ' + ($parentDataProperty) + ' , rootData )  ';\n    var def_callRuleValidate = out;\n    out = $$outStack.pop();\n    if ($rDef.errors === false) {\n      out += ' ' + ($valid) + ' = ';\n      if ($asyncKeyword) {\n        out += 'await ';\n      }\n      out += '' + (def_callRuleValidate) + '; ';\n    } else {\n      if ($asyncKeyword) {\n        $ruleErrs = 'customErrors' + $lvl;\n        out += ' var ' + ($ruleErrs) + ' = null; try { ' + ($valid) + ' = await ' + (def_callRuleValidate) + '; } catch (e) { ' + ($valid) + ' = false; if (e instanceof ValidationError) ' + ($ruleErrs) + ' = e.errors; else throw e; } ';\n      } else {\n        out += ' ' + ($ruleErrs) + ' = null; ' + ($valid) + ' = ' + (def_callRuleValidate) + '; ';\n      }\n    }\n  }\n  if ($rDef.modifying) {\n    out += ' if (' + ($parentData) + ') ' + ($data) + ' = ' + ($parentData) + '[' + ($parentDataProperty) + '];';\n  }\n  out += '' + ($closingBraces);\n  if ($rDef.valid) {\n    if ($breakOnError) {\n      out += ' if (true) { ';\n    }\n  } else {\n    out += ' if ( ';\n    if ($rDef.valid === undefined) {\n      out += ' !';\n      if ($macro) {\n        out += '' + ($nextValid);\n      } else {\n        out += '' + ($valid);\n      }\n    } else {\n      out += ' ' + (!$rDef.valid) + ' ';\n    }\n    out += ') { ';\n    $errorKeyword = $rule.keyword;\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = '';\n    var $$outStack = $$outStack || [];\n    $$outStack.push(out);\n    out = ''; /* istanbul ignore else */\n    if (it.createErrors !== false) {\n      out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n      if (it.opts.messages !== false) {\n        out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n      }\n      if (it.opts.verbose) {\n        out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n      }\n      out += ' } ';\n    } else {\n      out += ' {} ';\n    }\n    var __err = out;\n    out = $$outStack.pop();\n    if (!it.compositeRule && $breakOnError) {\n      /* istanbul ignore if */\n      if (it.async) {\n        out += ' throw new ValidationError([' + (__err) + ']); ';\n      } else {\n        out += ' validate.errors = [' + (__err) + ']; return false; ';\n      }\n    } else {\n      out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n    }\n    var def_customError = out;\n    out = $$outStack.pop();\n    if ($inline) {\n      if ($rDef.errors) {\n        if ($rDef.errors != 'full') {\n          out += '  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } ';\n        }\n      } else {\n        if ($rDef.errors === false) {\n          out += ' ' + (def_customError) + ' ';\n        } else {\n          out += ' if (' + ($errs) + ' == errors) { ' + (def_customError) + ' } else {  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + '; if (' + ($ruleErr) + '.schemaPath === undefined) { ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\"; } ';\n          if (it.opts.verbose) {\n            out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n          }\n          out += ' } } ';\n        }\n      }\n    } else if ($macro) {\n      out += '   var err =   '; /* istanbul ignore else */\n      if (it.createErrors !== false) {\n        out += ' { keyword: \\'' + ($errorKeyword || 'custom') + '\\' , dataPath: (dataPath || \\'\\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { keyword: \\'' + ($rule.keyword) + '\\' } ';\n        if (it.opts.messages !== false) {\n          out += ' , message: \\'should pass \"' + ($rule.keyword) + '\" keyword validation\\' ';\n        }\n        if (it.opts.verbose) {\n          out += ' , schema: validate.schema' + ($schemaPath) + ' , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';\n        }\n        out += ' } ';\n      } else {\n        out += ' {} ';\n      }\n      out += ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';\n      if (!it.compositeRule && $breakOnError) {\n        /* istanbul ignore if */\n        if (it.async) {\n          out += ' throw new ValidationError(vErrors); ';\n        } else {\n          out += ' validate.errors = vErrors; return false; ';\n        }\n      }\n    } else {\n      if ($rDef.errors === false) {\n        out += ' ' + (def_customError) + ' ';\n      } else {\n        out += ' if (Array.isArray(' + ($ruleErrs) + ')) { if (vErrors === null) vErrors = ' + ($ruleErrs) + '; else vErrors = vErrors.concat(' + ($ruleErrs) + '); errors = vErrors.length;  for (var ' + ($i) + '=' + ($errs) + '; ' + ($i) + '<errors; ' + ($i) + '++) { var ' + ($ruleErr) + ' = vErrors[' + ($i) + ']; if (' + ($ruleErr) + '.dataPath === undefined) ' + ($ruleErr) + '.dataPath = (dataPath || \\'\\') + ' + (it.errorPath) + ';  ' + ($ruleErr) + '.schemaPath = \"' + ($errSchemaPath) + '\";  ';\n        if (it.opts.verbose) {\n          out += ' ' + ($ruleErr) + '.schema = ' + ($schemaValue) + '; ' + ($ruleErr) + '.data = ' + ($data) + '; ';\n        }\n        out += ' } } else { ' + (def_customError) + ' } ';\n      }\n    }\n    out += ' } ';\n    if ($breakOnError) {\n      out += ' else { ';\n    }\n  }\n  return out;\n}\n", "{\n    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n    \"$id\": \"http://json-schema.org/draft-07/schema#\",\n    \"title\": \"Core schema meta-schema\",\n    \"definitions\": {\n        \"schemaArray\": {\n            \"type\": \"array\",\n            \"minItems\": 1,\n            \"items\": { \"$ref\": \"#\" }\n        },\n        \"nonNegativeInteger\": {\n            \"type\": \"integer\",\n            \"minimum\": 0\n        },\n        \"nonNegativeIntegerDefault0\": {\n            \"allOf\": [\n                { \"$ref\": \"#/definitions/nonNegativeInteger\" },\n                { \"default\": 0 }\n            ]\n        },\n        \"simpleTypes\": {\n            \"enum\": [\n                \"array\",\n                \"boolean\",\n                \"integer\",\n                \"null\",\n                \"number\",\n                \"object\",\n                \"string\"\n            ]\n        },\n        \"stringArray\": {\n            \"type\": \"array\",\n            \"items\": { \"type\": \"string\" },\n            \"uniqueItems\": true,\n            \"default\": []\n        }\n    },\n    \"type\": [\"object\", \"boolean\"],\n    \"properties\": {\n        \"$id\": {\n            \"type\": \"string\",\n            \"format\": \"uri-reference\"\n        },\n        \"$schema\": {\n            \"type\": \"string\",\n            \"format\": \"uri\"\n        },\n        \"$ref\": {\n            \"type\": \"string\",\n            \"format\": \"uri-reference\"\n        },\n        \"$comment\": {\n            \"type\": \"string\"\n        },\n        \"title\": {\n            \"type\": \"string\"\n        },\n        \"description\": {\n            \"type\": \"string\"\n        },\n        \"default\": true,\n        \"readOnly\": {\n            \"type\": \"boolean\",\n            \"default\": false\n        },\n        \"examples\": {\n            \"type\": \"array\",\n            \"items\": true\n        },\n        \"multipleOf\": {\n            \"type\": \"number\",\n            \"exclusiveMinimum\": 0\n        },\n        \"maximum\": {\n            \"type\": \"number\"\n        },\n        \"exclusiveMaximum\": {\n            \"type\": \"number\"\n        },\n        \"minimum\": {\n            \"type\": \"number\"\n        },\n        \"exclusiveMinimum\": {\n            \"type\": \"number\"\n        },\n        \"maxLength\": { \"$ref\": \"#/definitions/nonNegativeInteger\" },\n        \"minLength\": { \"$ref\": \"#/definitions/nonNegativeIntegerDefault0\" },\n        \"pattern\": {\n            \"type\": \"string\",\n            \"format\": \"regex\"\n        },\n        \"additionalItems\": { \"$ref\": \"#\" },\n        \"items\": {\n            \"anyOf\": [\n                { \"$ref\": \"#\" },\n                { \"$ref\": \"#/definitions/schemaArray\" }\n            ],\n            \"default\": true\n        },\n        \"maxItems\": { \"$ref\": \"#/definitions/nonNegativeInteger\" },\n        \"minItems\": { \"$ref\": \"#/definitions/nonNegativeIntegerDefault0\" },\n        \"uniqueItems\": {\n            \"type\": \"boolean\",\n            \"default\": false\n        },\n        \"contains\": { \"$ref\": \"#\" },\n        \"maxProperties\": { \"$ref\": \"#/definitions/nonNegativeInteger\" },\n        \"minProperties\": { \"$ref\": \"#/definitions/nonNegativeIntegerDefault0\" },\n        \"required\": { \"$ref\": \"#/definitions/stringArray\" },\n        \"additionalProperties\": { \"$ref\": \"#\" },\n        \"definitions\": {\n            \"type\": \"object\",\n            \"additionalProperties\": { \"$ref\": \"#\" },\n            \"default\": {}\n        },\n        \"properties\": {\n            \"type\": \"object\",\n            \"additionalProperties\": { \"$ref\": \"#\" },\n            \"default\": {}\n        },\n        \"patternProperties\": {\n            \"type\": \"object\",\n            \"additionalProperties\": { \"$ref\": \"#\" },\n            \"propertyNames\": { \"format\": \"regex\" },\n            \"default\": {}\n        },\n        \"dependencies\": {\n            \"type\": \"object\",\n            \"additionalProperties\": {\n                \"anyOf\": [\n                    { \"$ref\": \"#\" },\n                    { \"$ref\": \"#/definitions/stringArray\" }\n                ]\n            }\n        },\n        \"propertyNames\": { \"$ref\": \"#\" },\n        \"const\": true,\n        \"enum\": {\n            \"type\": \"array\",\n            \"items\": true,\n            \"minItems\": 1,\n            \"uniqueItems\": true\n        },\n        \"type\": {\n            \"anyOf\": [\n                { \"$ref\": \"#/definitions/simpleTypes\" },\n                {\n                    \"type\": \"array\",\n                    \"items\": { \"$ref\": \"#/definitions/simpleTypes\" },\n                    \"minItems\": 1,\n                    \"uniqueItems\": true\n                }\n            ]\n        },\n        \"format\": { \"type\": \"string\" },\n        \"contentMediaType\": { \"type\": \"string\" },\n        \"contentEncoding\": { \"type\": \"string\" },\n        \"if\": {\"$ref\": \"#\"},\n        \"then\": {\"$ref\": \"#\"},\n        \"else\": {\"$ref\": \"#\"},\n        \"allOf\": { \"$ref\": \"#/definitions/schemaArray\" },\n        \"anyOf\": { \"$ref\": \"#/definitions/schemaArray\" },\n        \"oneOf\": { \"$ref\": \"#/definitions/schemaArray\" },\n        \"not\": { \"$ref\": \"#\" }\n    },\n    \"default\": true\n}\n", "'use strict';\n\nvar metaSchema = require('./refs/json-schema-draft-07.json');\n\nmodule.exports = {\n  $id: 'https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js',\n  definitions: {\n    simpleTypes: metaSchema.definitions.simpleTypes\n  },\n  type: 'object',\n  dependencies: {\n    schema: ['validate'],\n    $data: ['validate'],\n    statements: ['inline'],\n    valid: {not: {required: ['macro']}}\n  },\n  properties: {\n    type: metaSchema.properties.type,\n    schema: {type: 'boolean'},\n    statements: {type: 'boolean'},\n    dependencies: {\n      type: 'array',\n      items: {type: 'string'}\n    },\n    metaSchema: {type: 'object'},\n    modifying: {type: 'boolean'},\n    valid: {type: 'boolean'},\n    $data: {type: 'boolean'},\n    async: {type: 'boolean'},\n    errors: {\n      anyOf: [\n        {type: 'boolean'},\n        {const: 'full'}\n      ]\n    }\n  }\n};\n", "'use strict';\n\nvar IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;\nvar customRuleCode = require('./dotjs/custom');\nvar definitionSchema = require('./definition_schema');\n\nmodule.exports = {\n  add: addKeyword,\n  get: getKeyword,\n  remove: removeKeyword,\n  validate: validateKeyword\n};\n\n\n/**\n * Define custom keyword\n * @this  Ajv\n * @param {String} keyword custom keyword, should be unique (including different from all standard, custom and macro keywords).\n * @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.\n * @return {Ajv} this for method chaining\n */\nfunction addKeyword(keyword, definition) {\n  /* jshint validthis: true */\n  /* eslint no-shadow: 0 */\n  var RULES = this.RULES;\n  if (RULES.keywords[keyword])\n    throw new Error('Keyword ' + keyword + ' is already defined');\n\n  if (!IDENTIFIER.test(keyword))\n    throw new Error('Keyword ' + keyword + ' is not a valid identifier');\n\n  if (definition) {\n    this.validateKeyword(definition, true);\n\n    var dataType = definition.type;\n    if (Array.isArray(dataType)) {\n      for (var i=0; i<dataType.length; i++)\n        _addRule(keyword, dataType[i], definition);\n    } else {\n      _addRule(keyword, dataType, definition);\n    }\n\n    var metaSchema = definition.metaSchema;\n    if (metaSchema) {\n      if (definition.$data && this._opts.$data) {\n        metaSchema = {\n          anyOf: [\n            metaSchema,\n            { '$ref': 'https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#' }\n          ]\n        };\n      }\n      definition.validateSchema = this.compile(metaSchema, true);\n    }\n  }\n\n  RULES.keywords[keyword] = RULES.all[keyword] = true;\n\n\n  function _addRule(keyword, dataType, definition) {\n    var ruleGroup;\n    for (var i=0; i<RULES.length; i++) {\n      var rg = RULES[i];\n      if (rg.type == dataType) {\n        ruleGroup = rg;\n        break;\n      }\n    }\n\n    if (!ruleGroup) {\n      ruleGroup = { type: dataType, rules: [] };\n      RULES.push(ruleGroup);\n    }\n\n    var rule = {\n      keyword: keyword,\n      definition: definition,\n      custom: true,\n      code: customRuleCode,\n      implements: definition.implements\n    };\n    ruleGroup.rules.push(rule);\n    RULES.custom[keyword] = rule;\n  }\n\n  return this;\n}\n\n\n/**\n * Get keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.\n */\nfunction getKeyword(keyword) {\n  /* jshint validthis: true */\n  var rule = this.RULES.custom[keyword];\n  return rule ? rule.definition : this.RULES.keywords[keyword] || false;\n}\n\n\n/**\n * Remove keyword\n * @this  Ajv\n * @param {String} keyword pre-defined or custom keyword.\n * @return {Ajv} this for method chaining\n */\nfunction removeKeyword(keyword) {\n  /* jshint validthis: true */\n  var RULES = this.RULES;\n  delete RULES.keywords[keyword];\n  delete RULES.all[keyword];\n  delete RULES.custom[keyword];\n  for (var i=0; i<RULES.length; i++) {\n    var rules = RULES[i].rules;\n    for (var j=0; j<rules.length; j++) {\n      if (rules[j].keyword == keyword) {\n        rules.splice(j, 1);\n        break;\n      }\n    }\n  }\n  return this;\n}\n\n\n/**\n * Validate keyword definition\n * @this  Ajv\n * @param {Object} definition keyword definition object.\n * @param {Boolean} throwError true to throw exception if definition is invalid\n * @return {boolean} validation result\n */\nfunction validateKeyword(definition, throwError) {\n  validateKeyword.errors = null;\n  var v = this._validateKeyword = this._validateKeyword\n                                  || this.compile(definitionSchema, true);\n\n  if (v(definition)) return true;\n  validateKeyword.errors = v.errors;\n  if (throwError)\n    throw new Error('custom keyword definition is invalid: '  + this.errorsText(v.errors));\n  else\n    return false;\n}\n", "{\n    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n    \"$id\": \"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#\",\n    \"description\": \"Meta-schema for $data reference (JSON Schema extension proposal)\",\n    \"type\": \"object\",\n    \"required\": [ \"$data\" ],\n    \"properties\": {\n        \"$data\": {\n            \"type\": \"string\",\n            \"anyOf\": [\n                { \"format\": \"relative-json-pointer\" }, \n                { \"format\": \"json-pointer\" }\n            ]\n        }\n    },\n    \"additionalProperties\": false\n}\n", "'use strict';\n\nvar compileSchema = require('./compile')\n  , resolve = require('./compile/resolve')\n  , Cache = require('./cache')\n  , SchemaObject = require('./compile/schema_obj')\n  , stableStringify = require('fast-json-stable-stringify')\n  , formats = require('./compile/formats')\n  , rules = require('./compile/rules')\n  , $dataMetaSchema = require('./data')\n  , util = require('./compile/util');\n\nmodule.exports = Ajv;\n\nAjv.prototype.validate = validate;\nAjv.prototype.compile = compile;\nAjv.prototype.addSchema = addSchema;\nAjv.prototype.addMetaSchema = addMetaSchema;\nAjv.prototype.validateSchema = validateSchema;\nAjv.prototype.getSchema = getSchema;\nAjv.prototype.removeSchema = removeSchema;\nAjv.prototype.addFormat = addFormat;\nAjv.prototype.errorsText = errorsText;\n\nAjv.prototype._addSchema = _addSchema;\nAjv.prototype._compile = _compile;\n\nAjv.prototype.compileAsync = require('./compile/async');\nvar customKeyword = require('./keyword');\nAjv.prototype.addKeyword = customKeyword.add;\nAjv.prototype.getKeyword = customKeyword.get;\nAjv.prototype.removeKeyword = customKeyword.remove;\nAjv.prototype.validateKeyword = customKeyword.validate;\n\nvar errorClasses = require('./compile/error_classes');\nAjv.ValidationError = errorClasses.Validation;\nAjv.MissingRefError = errorClasses.MissingRef;\nAjv.$dataMetaSchema = $dataMetaSchema;\n\nvar META_SCHEMA_ID = 'http://json-schema.org/draft-07/schema';\n\nvar META_IGNORE_OPTIONS = [ 'removeAdditional', 'useDefaults', 'coerceTypes', 'strictDefaults' ];\nvar META_SUPPORT_DATA = ['/properties'];\n\n/**\n * Creates validator instance.\n * Usage: `Ajv(opts)`\n * @param {Object} opts optional options\n * @return {Object} ajv instance\n */\nfunction Ajv(opts) {\n  if (!(this instanceof Ajv)) return new Ajv(opts);\n  opts = this._opts = util.copy(opts) || {};\n  setLogger(this);\n  this._schemas = {};\n  this._refs = {};\n  this._fragments = {};\n  this._formats = formats(opts.format);\n\n  this._cache = opts.cache || new Cache;\n  this._loadingSchemas = {};\n  this._compilations = [];\n  this.RULES = rules();\n  this._getId = chooseGetId(opts);\n\n  opts.loopRequired = opts.loopRequired || Infinity;\n  if (opts.errorDataPath == 'property') opts._errorDataPathProperty = true;\n  if (opts.serialize === undefined) opts.serialize = stableStringify;\n  this._metaOpts = getMetaSchemaOptions(this);\n\n  if (opts.formats) addInitialFormats(this);\n  if (opts.keywords) addInitialKeywords(this);\n  addDefaultMetaSchema(this);\n  if (typeof opts.meta == 'object') this.addMetaSchema(opts.meta);\n  if (opts.nullable) this.addKeyword('nullable', {metaSchema: {type: 'boolean'}});\n  addInitialSchemas(this);\n}\n\n\n\n/**\n * Validate data using schema\n * Schema will be compiled and cached (using serialized JSON as key. [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used to serialize.\n * @this   Ajv\n * @param  {String|Object} schemaKeyRef key, ref or schema object\n * @param  {Any} data to be validated\n * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).\n */\nfunction validate(schemaKeyRef, data) {\n  var v;\n  if (typeof schemaKeyRef == 'string') {\n    v = this.getSchema(schemaKeyRef);\n    if (!v) throw new Error('no schema with key or ref \"' + schemaKeyRef + '\"');\n  } else {\n    var schemaObj = this._addSchema(schemaKeyRef);\n    v = schemaObj.validate || this._compile(schemaObj);\n  }\n\n  var valid = v(data);\n  if (v.$async !== true) this.errors = v.errors;\n  return valid;\n}\n\n\n/**\n * Create validating function for passed schema.\n * @this   Ajv\n * @param  {Object} schema schema object\n * @param  {Boolean} _meta true if schema is a meta-schema. Used internally to compile meta schemas of custom keywords.\n * @return {Function} validating function\n */\nfunction compile(schema, _meta) {\n  var schemaObj = this._addSchema(schema, undefined, _meta);\n  return schemaObj.validate || this._compile(schemaObj);\n}\n\n\n/**\n * Adds schema to the instance.\n * @this   Ajv\n * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.\n * @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.\n * @param {Boolean} _skipValidation true to skip schema validation. Used internally, option validateSchema should be used instead.\n * @param {Boolean} _meta true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.\n * @return {Ajv} this for method chaining\n */\nfunction addSchema(schema, key, _skipValidation, _meta) {\n  if (Array.isArray(schema)){\n    for (var i=0; i<schema.length; i++) this.addSchema(schema[i], undefined, _skipValidation, _meta);\n    return this;\n  }\n  var id = this._getId(schema);\n  if (id !== undefined && typeof id != 'string')\n    throw new Error('schema id must be string');\n  key = resolve.normalizeId(key || id);\n  checkUnique(this, key);\n  this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);\n  return this;\n}\n\n\n/**\n * Add schema that will be used to validate other schemas\n * options in META_IGNORE_OPTIONS are alway set to false\n * @this   Ajv\n * @param {Object} schema schema object\n * @param {String} key optional schema key\n * @param {Boolean} skipValidation true to skip schema validation, can be used to override validateSchema option for meta-schema\n * @return {Ajv} this for method chaining\n */\nfunction addMetaSchema(schema, key, skipValidation) {\n  this.addSchema(schema, key, skipValidation, true);\n  return this;\n}\n\n\n/**\n * Validate schema\n * @this   Ajv\n * @param {Object} schema schema to validate\n * @param {Boolean} throwOrLogError pass true to throw (or log) an error if invalid\n * @return {Boolean} true if schema is valid\n */\nfunction validateSchema(schema, throwOrLogError) {\n  var $schema = schema.$schema;\n  if ($schema !== undefined && typeof $schema != 'string')\n    throw new Error('$schema must be a string');\n  $schema = $schema || this._opts.defaultMeta || defaultMeta(this);\n  if (!$schema) {\n    this.logger.warn('meta-schema not available');\n    this.errors = null;\n    return true;\n  }\n  var valid = this.validate($schema, schema);\n  if (!valid && throwOrLogError) {\n    var message = 'schema is invalid: ' + this.errorsText();\n    if (this._opts.validateSchema == 'log') this.logger.error(message);\n    else throw new Error(message);\n  }\n  return valid;\n}\n\n\nfunction defaultMeta(self) {\n  var meta = self._opts.meta;\n  self._opts.defaultMeta = typeof meta == 'object'\n                            ? self._getId(meta) || meta\n                            : self.getSchema(META_SCHEMA_ID)\n                              ? META_SCHEMA_ID\n                              : undefined;\n  return self._opts.defaultMeta;\n}\n\n\n/**\n * Get compiled schema from the instance by `key` or `ref`.\n * @this   Ajv\n * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).\n * @return {Function} schema validating function (with property `schema`).\n */\nfunction getSchema(keyRef) {\n  var schemaObj = _getSchemaObj(this, keyRef);\n  switch (typeof schemaObj) {\n    case 'object': return schemaObj.validate || this._compile(schemaObj);\n    case 'string': return this.getSchema(schemaObj);\n    case 'undefined': return _getSchemaFragment(this, keyRef);\n  }\n}\n\n\nfunction _getSchemaFragment(self, ref) {\n  var res = resolve.schema.call(self, { schema: {} }, ref);\n  if (res) {\n    var schema = res.schema\n      , root = res.root\n      , baseId = res.baseId;\n    var v = compileSchema.call(self, schema, root, undefined, baseId);\n    self._fragments[ref] = new SchemaObject({\n      ref: ref,\n      fragment: true,\n      schema: schema,\n      root: root,\n      baseId: baseId,\n      validate: v\n    });\n    return v;\n  }\n}\n\n\nfunction _getSchemaObj(self, keyRef) {\n  keyRef = resolve.normalizeId(keyRef);\n  return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];\n}\n\n\n/**\n * Remove cached schema(s).\n * If no parameter is passed all schemas but meta-schemas are removed.\n * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.\n * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.\n * @this   Ajv\n * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object\n * @return {Ajv} this for method chaining\n */\nfunction removeSchema(schemaKeyRef) {\n  if (schemaKeyRef instanceof RegExp) {\n    _removeAllSchemas(this, this._schemas, schemaKeyRef);\n    _removeAllSchemas(this, this._refs, schemaKeyRef);\n    return this;\n  }\n  switch (typeof schemaKeyRef) {\n    case 'undefined':\n      _removeAllSchemas(this, this._schemas);\n      _removeAllSchemas(this, this._refs);\n      this._cache.clear();\n      return this;\n    case 'string':\n      var schemaObj = _getSchemaObj(this, schemaKeyRef);\n      if (schemaObj) this._cache.del(schemaObj.cacheKey);\n      delete this._schemas[schemaKeyRef];\n      delete this._refs[schemaKeyRef];\n      return this;\n    case 'object':\n      var serialize = this._opts.serialize;\n      var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;\n      this._cache.del(cacheKey);\n      var id = this._getId(schemaKeyRef);\n      if (id) {\n        id = resolve.normalizeId(id);\n        delete this._schemas[id];\n        delete this._refs[id];\n      }\n  }\n  return this;\n}\n\n\nfunction _removeAllSchemas(self, schemas, regex) {\n  for (var keyRef in schemas) {\n    var schemaObj = schemas[keyRef];\n    if (!schemaObj.meta && (!regex || regex.test(keyRef))) {\n      self._cache.del(schemaObj.cacheKey);\n      delete schemas[keyRef];\n    }\n  }\n}\n\n\n/* @this   Ajv */\nfunction _addSchema(schema, skipValidation, meta, shouldAddSchema) {\n  if (typeof schema != 'object' && typeof schema != 'boolean')\n    throw new Error('schema should be object or boolean');\n  var serialize = this._opts.serialize;\n  var cacheKey = serialize ? serialize(schema) : schema;\n  var cached = this._cache.get(cacheKey);\n  if (cached) return cached;\n\n  shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;\n\n  var id = resolve.normalizeId(this._getId(schema));\n  if (id && shouldAddSchema) checkUnique(this, id);\n\n  var willValidate = this._opts.validateSchema !== false && !skipValidation;\n  var recursiveMeta;\n  if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema)))\n    this.validateSchema(schema, true);\n\n  var localRefs = resolve.ids.call(this, schema);\n\n  var schemaObj = new SchemaObject({\n    id: id,\n    schema: schema,\n    localRefs: localRefs,\n    cacheKey: cacheKey,\n    meta: meta\n  });\n\n  if (id[0] != '#' && shouldAddSchema) this._refs[id] = schemaObj;\n  this._cache.put(cacheKey, schemaObj);\n\n  if (willValidate && recursiveMeta) this.validateSchema(schema, true);\n\n  return schemaObj;\n}\n\n\n/* @this   Ajv */\nfunction _compile(schemaObj, root) {\n  if (schemaObj.compiling) {\n    schemaObj.validate = callValidate;\n    callValidate.schema = schemaObj.schema;\n    callValidate.errors = null;\n    callValidate.root = root ? root : callValidate;\n    if (schemaObj.schema.$async === true)\n      callValidate.$async = true;\n    return callValidate;\n  }\n  schemaObj.compiling = true;\n\n  var currentOpts;\n  if (schemaObj.meta) {\n    currentOpts = this._opts;\n    this._opts = this._metaOpts;\n  }\n\n  var v;\n  try { v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs); }\n  catch(e) {\n    delete schemaObj.validate;\n    throw e;\n  }\n  finally {\n    schemaObj.compiling = false;\n    if (schemaObj.meta) this._opts = currentOpts;\n  }\n\n  schemaObj.validate = v;\n  schemaObj.refs = v.refs;\n  schemaObj.refVal = v.refVal;\n  schemaObj.root = v.root;\n  return v;\n\n\n  /* @this   {*} - custom context, see passContext option */\n  function callValidate() {\n    /* jshint validthis: true */\n    var _validate = schemaObj.validate;\n    var result = _validate.apply(this, arguments);\n    callValidate.errors = _validate.errors;\n    return result;\n  }\n}\n\n\nfunction chooseGetId(opts) {\n  switch (opts.schemaId) {\n    case 'auto': return _get$IdOrId;\n    case 'id': return _getId;\n    default: return _get$Id;\n  }\n}\n\n/* @this   Ajv */\nfunction _getId(schema) {\n  if (schema.$id) this.logger.warn('schema $id ignored', schema.$id);\n  return schema.id;\n}\n\n/* @this   Ajv */\nfunction _get$Id(schema) {\n  if (schema.id) this.logger.warn('schema id ignored', schema.id);\n  return schema.$id;\n}\n\n\nfunction _get$IdOrId(schema) {\n  if (schema.$id && schema.id && schema.$id != schema.id)\n    throw new Error('schema $id is different from id');\n  return schema.$id || schema.id;\n}\n\n\n/**\n * Convert array of error message objects to string\n * @this   Ajv\n * @param  {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used.\n * @param  {Object} options optional options with properties `separator` and `dataVar`.\n * @return {String} human readable string with all errors descriptions\n */\nfunction errorsText(errors, options) {\n  errors = errors || this.errors;\n  if (!errors) return 'No errors';\n  options = options || {};\n  var separator = options.separator === undefined ? ', ' : options.separator;\n  var dataVar = options.dataVar === undefined ? 'data' : options.dataVar;\n\n  var text = '';\n  for (var i=0; i<errors.length; i++) {\n    var e = errors[i];\n    if (e) text += dataVar + e.dataPath + ' ' + e.message + separator;\n  }\n  return text.slice(0, -separator.length);\n}\n\n\n/**\n * Add custom format\n * @this   Ajv\n * @param {String} name format name\n * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)\n * @return {Ajv} this for method chaining\n */\nfunction addFormat(name, format) {\n  if (typeof format == 'string') format = new RegExp(format);\n  this._formats[name] = format;\n  return this;\n}\n\n\nfunction addDefaultMetaSchema(self) {\n  var $dataSchema;\n  if (self._opts.$data) {\n    $dataSchema = require('./refs/data.json');\n    self.addMetaSchema($dataSchema, $dataSchema.$id, true);\n  }\n  if (self._opts.meta === false) return;\n  var metaSchema = require('./refs/json-schema-draft-07.json');\n  if (self._opts.$data) metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA);\n  self.addMetaSchema(metaSchema, META_SCHEMA_ID, true);\n  self._refs['http://json-schema.org/schema'] = META_SCHEMA_ID;\n}\n\n\nfunction addInitialSchemas(self) {\n  var optsSchemas = self._opts.schemas;\n  if (!optsSchemas) return;\n  if (Array.isArray(optsSchemas)) self.addSchema(optsSchemas);\n  else for (var key in optsSchemas) self.addSchema(optsSchemas[key], key);\n}\n\n\nfunction addInitialFormats(self) {\n  for (var name in self._opts.formats) {\n    var format = self._opts.formats[name];\n    self.addFormat(name, format);\n  }\n}\n\n\nfunction addInitialKeywords(self) {\n  for (var name in self._opts.keywords) {\n    var keyword = self._opts.keywords[name];\n    self.addKeyword(name, keyword);\n  }\n}\n\n\nfunction checkUnique(self, id) {\n  if (self._schemas[id] || self._refs[id])\n    throw new Error('schema with key or id \"' + id + '\" already exists');\n}\n\n\nfunction getMetaSchemaOptions(self) {\n  var metaOpts = util.copy(self._opts);\n  for (var i=0; i<META_IGNORE_OPTIONS.length; i++)\n    delete metaOpts[META_IGNORE_OPTIONS[i]];\n  return metaOpts;\n}\n\n\nfunction setLogger(self) {\n  var logger = self._opts.logger;\n  if (logger === false) {\n    self.logger = {log: noop, warn: noop, error: noop};\n  } else {\n    if (logger === undefined) logger = console;\n    if (!(typeof logger == 'object' && logger.log && logger.warn && logger.error))\n      throw new Error('logger must implement log, warn and error methods');\n    self.logger = logger;\n  }\n}\n\n\nfunction noop() {}\n", null, "export const ignoreOverride = Symbol(\"Let zodToJsonSchema decide on which parser to use\");\nexport const jsonDescription = (jsonSchema, def) => {\n    if (def.description) {\n        try {\n            return {\n                ...jsonSchema,\n                ...JSON.parse(def.description),\n            };\n        }\n        catch { }\n    }\n    return jsonSchema;\n};\nexport const defaultOptions = {\n    name: undefined,\n    $refStrategy: \"root\",\n    basePath: [\"#\"],\n    effectStrategy: \"input\",\n    pipeStrategy: \"all\",\n    dateStrategy: \"format:date-time\",\n    mapStrategy: \"entries\",\n    removeAdditionalStrategy: \"passthrough\",\n    allowedAdditionalProperties: true,\n    rejectedAdditionalProperties: false,\n    definitionPath: \"definitions\",\n    target: \"jsonSchema7\",\n    strictUnions: false,\n    definitions: {},\n    errorMessages: false,\n    markdownDescription: false,\n    patternStrategy: \"escape\",\n    applyRegexFlags: false,\n    emailStrategy: \"format:email\",\n    base64Strategy: \"contentEncoding:base64\",\n    nameStrategy: \"ref\",\n    openAiAnyTypeName: \"OpenAiAnyType\"\n};\nexport const getDefaultOptions = (options) => (typeof options === \"string\"\n    ? {\n        ...defaultOptions,\n        name: options,\n    }\n    : {\n        ...defaultOptions,\n        ...options,\n    });\n", "import { getDefaultOptions } from \"./Options.js\";\nexport const getRefs = (options) => {\n    const _options = getDefaultOptions(options);\n    const currentPath = _options.name !== undefined\n        ? [..._options.basePath, _options.definitionPath, _options.name]\n        : _options.basePath;\n    return {\n        ..._options,\n        flags: { hasReferencedOpenAiAnyType: false },\n        currentPath: currentPath,\n        propertyPath: undefined,\n        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [\n            def._def,\n            {\n                def: def._def,\n                path: [..._options.basePath, _options.definitionPath, name],\n                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.\n                jsonSchema: undefined,\n            },\n        ])),\n    };\n};\n", "export function addErrorMessage(res, key, errorMessage, refs) {\n    if (!refs?.errorMessages)\n        return;\n    if (errorMessage) {\n        res.errorMessage = {\n            ...res.errorMessage,\n            [key]: errorMessage,\n        };\n    }\n}\nexport function setResponseValueAndErrors(res, key, value, errorMessage, refs) {\n    res[key] = value;\n    addErrorMessage(res, key, errorMessage, refs);\n}\n", "export const getRelativePath = (pathA, pathB) => {\n    let i = 0;\n    for (; i < pathA.length && i < pathB.length; i++) {\n        if (pathA[i] !== pathB[i])\n            break;\n    }\n    return [(pathA.length - i).toString(), ...pathB.slice(i)].join(\"/\");\n};\n", "import { getRelativePath } from \"../getRelativePath.js\";\nexport function parseAnyDef(refs) {\n    if (refs.target !== \"openAi\") {\n        return {};\n    }\n    const anyDefinitionPath = [\n        ...refs.basePath,\n        refs.definitionPath,\n        refs.openAiAnyTypeName,\n    ];\n    refs.flags.hasReferencedOpenAiAnyType = true;\n    return {\n        $ref: refs.$refStrategy === \"relative\"\n            ? getRelativePath(anyDefinitionPath, refs.currentPath)\n            : anyDefinitionPath.join(\"/\"),\n    };\n}\n", "import { ZodFirstPartyTypeKind } from \"zod\";\nimport { setResponseValueAndErrors } from \"../errorMessages.js\";\nimport { parseDef } from \"../parseDef.js\";\nexport function parseArrayDef(def, refs) {\n    const res = {\n        type: \"array\",\n    };\n    if (def.type?._def &&\n        def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {\n        res.items = parseDef(def.type._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"items\"],\n        });\n    }\n    if (def.minLength) {\n        setResponseValueAndErrors(res, \"minItems\", def.minLength.value, def.minLength.message, refs);\n    }\n    if (def.maxLength) {\n        setResponseValueAndErrors(res, \"maxItems\", def.maxLength.value, def.maxLength.message, refs);\n    }\n    if (def.exactLength) {\n        setResponseValueAndErrors(res, \"minItems\", def.exactLength.value, def.exactLength.message, refs);\n        setResponseValueAndErrors(res, \"maxItems\", def.exactLength.value, def.exactLength.message, refs);\n    }\n    return res;\n}\n", "import { setResponseValueAndErrors } from \"../errorMessages.js\";\nexport function parseBigintDef(def, refs) {\n    const res = {\n        type: \"integer\",\n        format: \"int64\",\n    };\n    if (!def.checks)\n        return res;\n    for (const check of def.checks) {\n        switch (check.kind) {\n            case \"min\":\n                if (refs.target === \"jsonSchema7\") {\n                    if (check.inclusive) {\n                        setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n                    }\n                    else {\n                        setResponseValueAndErrors(res, \"exclusiveMinimum\", check.value, check.message, refs);\n                    }\n                }\n                else {\n                    if (!check.inclusive) {\n                        res.exclusiveMinimum = true;\n                    }\n                    setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n                }\n                break;\n            case \"max\":\n                if (refs.target === \"jsonSchema7\") {\n                    if (check.inclusive) {\n                        setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n                    }\n                    else {\n                        setResponseValueAndErrors(res, \"exclusiveMaximum\", check.value, check.message, refs);\n                    }\n                }\n                else {\n                    if (!check.inclusive) {\n                        res.exclusiveMaximum = true;\n                    }\n                    setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n                }\n                break;\n            case \"multipleOf\":\n                setResponseValueAndErrors(res, \"multipleOf\", check.value, check.message, refs);\n                break;\n        }\n    }\n    return res;\n}\n", "export function parseBooleanDef() {\n    return {\n        type: \"boolean\",\n    };\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport function parseBrandedDef(_def, refs) {\n    return parseDef(_def.type._def, refs);\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport const parseCatchDef = (def, refs) => {\n    return parseDef(def.innerType._def, refs);\n};\n", "import { setResponseValueAndErrors } from \"../errorMessages.js\";\nexport function parseDateDef(def, refs, overrideDateStrategy) {\n    const strategy = overrideDateStrategy ?? refs.dateStrategy;\n    if (Array.isArray(strategy)) {\n        return {\n            anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),\n        };\n    }\n    switch (strategy) {\n        case \"string\":\n        case \"format:date-time\":\n            return {\n                type: \"string\",\n                format: \"date-time\",\n            };\n        case \"format:date\":\n            return {\n                type: \"string\",\n                format: \"date\",\n            };\n        case \"integer\":\n            return integerDateParser(def, refs);\n    }\n}\nconst integerDateParser = (def, refs) => {\n    const res = {\n        type: \"integer\",\n        format: \"unix-time\",\n    };\n    if (refs.target === \"openApi3\") {\n        return res;\n    }\n    for (const check of def.checks) {\n        switch (check.kind) {\n            case \"min\":\n                setResponseValueAndErrors(res, \"minimum\", check.value, // This is in milliseconds\n                check.message, refs);\n                break;\n            case \"max\":\n                setResponseValueAndErrors(res, \"maximum\", check.value, // This is in milliseconds\n                check.message, refs);\n                break;\n        }\n    }\n    return res;\n};\n", "import { parseDef } from \"../parseDef.js\";\nexport function parseDefaultDef(_def, refs) {\n    return {\n        ...parseDef(_def.innerType._def, refs),\n        default: _def.defaultValue(),\n    };\n}\n", "import { parseDef } from \"../parseDef.js\";\nimport { parseAnyDef } from \"./any.js\";\nexport function parseEffectsDef(_def, refs) {\n    return refs.effectStrategy === \"input\"\n        ? parseDef(_def.schema._def, refs)\n        : parseAnyDef(refs);\n}\n", "export function parseEnumDef(def) {\n    return {\n        type: \"string\",\n        enum: Array.from(def.values),\n    };\n}\n", "import { parseDef } from \"../parseDef.js\";\nconst isJsonSchema7AllOfType = (type) => {\n    if (\"type\" in type && type.type === \"string\")\n        return false;\n    return \"allOf\" in type;\n};\nexport function parseIntersectionDef(def, refs) {\n    const allOf = [\n        parseDef(def.left._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"allOf\", \"0\"],\n        }),\n        parseDef(def.right._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"allOf\", \"1\"],\n        }),\n    ].filter((x) => !!x);\n    let unevaluatedProperties = refs.target === \"jsonSchema2019-09\"\n        ? { unevaluatedProperties: false }\n        : undefined;\n    const mergedAllOf = [];\n    // If either of the schemas is an allOf, merge them into a single allOf\n    allOf.forEach((schema) => {\n        if (isJsonSchema7AllOfType(schema)) {\n            mergedAllOf.push(...schema.allOf);\n            if (schema.unevaluatedProperties === undefined) {\n                // If one of the schemas has no unevaluatedProperties set,\n                // the merged schema should also have no unevaluatedProperties set\n                unevaluatedProperties = undefined;\n            }\n        }\n        else {\n            let nestedSchema = schema;\n            if (\"additionalProperties\" in schema &&\n                schema.additionalProperties === false) {\n                const { additionalProperties, ...rest } = schema;\n                nestedSchema = rest;\n            }\n            else {\n                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties\n                unevaluatedProperties = undefined;\n            }\n            mergedAllOf.push(nestedSchema);\n        }\n    });\n    return mergedAllOf.length\n        ? {\n            allOf: mergedAllOf,\n            ...unevaluatedProperties,\n        }\n        : undefined;\n}\n", "export function parseLiteralDef(def, refs) {\n    const parsedType = typeof def.value;\n    if (parsedType !== \"bigint\" &&\n        parsedType !== \"number\" &&\n        parsedType !== \"boolean\" &&\n        parsedType !== \"string\") {\n        return {\n            type: Array.isArray(def.value) ? \"array\" : \"object\",\n        };\n    }\n    if (refs.target === \"openApi3\") {\n        return {\n            type: parsedType === \"bigint\" ? \"integer\" : parsedType,\n            enum: [def.value],\n        };\n    }\n    return {\n        type: parsedType === \"bigint\" ? \"integer\" : parsedType,\n        const: def.value,\n    };\n}\n", "import { setResponseValueAndErrors } from \"../errorMessages.js\";\nlet emojiRegex = undefined;\n/**\n * Generated from the regular expressions found here as of 2024-05-22:\n * https://github.com/colinhacks/zod/blob/master/src/types.ts.\n *\n * Expressions with /i flag have been changed accordingly.\n */\nexport const zodPatterns = {\n    /**\n     * `c` was changed to `[cC]` to replicate /i flag\n     */\n    cuid: /^[cC][^\\s-]{8,}$/,\n    cuid2: /^[0-9a-z]+$/,\n    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,\n    /**\n     * `a-z` was added to replicate /i flag\n     */\n    email: /^(?!\\.)(?!.*\\.\\.)([a-zA-Z0-9_'+\\-\\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\\-]*\\.)+[a-zA-Z]{2,}$/,\n    /**\n     * Constructed a valid Unicode RegExp\n     *\n     * Lazily instantiate since this type of regex isn't supported\n     * in all envs (e.g. React Native).\n     *\n     * See:\n     * https://github.com/colinhacks/zod/issues/2433\n     * Fix in Zod:\n     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b\n     */\n    emoji: () => {\n        if (emojiRegex === undefined) {\n            emojiRegex = RegExp(\"^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$\", \"u\");\n        }\n        return emojiRegex;\n    },\n    /**\n     * Unused\n     */\n    uuid: /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/,\n    /**\n     * Unused\n     */\n    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,\n    ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/,\n    /**\n     * Unused\n     */\n    ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,\n    ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,\n    base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,\n    base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,\n    nanoid: /^[a-zA-Z0-9_-]{21}$/,\n    jwt: /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/,\n};\nexport function parseStringDef(def, refs) {\n    const res = {\n        type: \"string\",\n    };\n    if (def.checks) {\n        for (const check of def.checks) {\n            switch (check.kind) {\n                case \"min\":\n                    setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\"\n                        ? Math.max(res.minLength, check.value)\n                        : check.value, check.message, refs);\n                    break;\n                case \"max\":\n                    setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\"\n                        ? Math.min(res.maxLength, check.value)\n                        : check.value, check.message, refs);\n                    break;\n                case \"email\":\n                    switch (refs.emailStrategy) {\n                        case \"format:email\":\n                            addFormat(res, \"email\", check.message, refs);\n                            break;\n                        case \"format:idn-email\":\n                            addFormat(res, \"idn-email\", check.message, refs);\n                            break;\n                        case \"pattern:zod\":\n                            addPattern(res, zodPatterns.email, check.message, refs);\n                            break;\n                    }\n                    break;\n                case \"url\":\n                    addFormat(res, \"uri\", check.message, refs);\n                    break;\n                case \"uuid\":\n                    addFormat(res, \"uuid\", check.message, refs);\n                    break;\n                case \"regex\":\n                    addPattern(res, check.regex, check.message, refs);\n                    break;\n                case \"cuid\":\n                    addPattern(res, zodPatterns.cuid, check.message, refs);\n                    break;\n                case \"cuid2\":\n                    addPattern(res, zodPatterns.cuid2, check.message, refs);\n                    break;\n                case \"startsWith\":\n                    addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);\n                    break;\n                case \"endsWith\":\n                    addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);\n                    break;\n                case \"datetime\":\n                    addFormat(res, \"date-time\", check.message, refs);\n                    break;\n                case \"date\":\n                    addFormat(res, \"date\", check.message, refs);\n                    break;\n                case \"time\":\n                    addFormat(res, \"time\", check.message, refs);\n                    break;\n                case \"duration\":\n                    addFormat(res, \"duration\", check.message, refs);\n                    break;\n                case \"length\":\n                    setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\"\n                        ? Math.max(res.minLength, check.value)\n                        : check.value, check.message, refs);\n                    setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\"\n                        ? Math.min(res.maxLength, check.value)\n                        : check.value, check.message, refs);\n                    break;\n                case \"includes\": {\n                    addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);\n                    break;\n                }\n                case \"ip\": {\n                    if (check.version !== \"v6\") {\n                        addFormat(res, \"ipv4\", check.message, refs);\n                    }\n                    if (check.version !== \"v4\") {\n                        addFormat(res, \"ipv6\", check.message, refs);\n                    }\n                    break;\n                }\n                case \"base64url\":\n                    addPattern(res, zodPatterns.base64url, check.message, refs);\n                    break;\n                case \"jwt\":\n                    addPattern(res, zodPatterns.jwt, check.message, refs);\n                    break;\n                case \"cidr\": {\n                    if (check.version !== \"v6\") {\n                        addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);\n                    }\n                    if (check.version !== \"v4\") {\n                        addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);\n                    }\n                    break;\n                }\n                case \"emoji\":\n                    addPattern(res, zodPatterns.emoji(), check.message, refs);\n                    break;\n                case \"ulid\": {\n                    addPattern(res, zodPatterns.ulid, check.message, refs);\n                    break;\n                }\n                case \"base64\": {\n                    switch (refs.base64Strategy) {\n                        case \"format:binary\": {\n                            addFormat(res, \"binary\", check.message, refs);\n                            break;\n                        }\n                        case \"contentEncoding:base64\": {\n                            setResponseValueAndErrors(res, \"contentEncoding\", \"base64\", check.message, refs);\n                            break;\n                        }\n                        case \"pattern:zod\": {\n                            addPattern(res, zodPatterns.base64, check.message, refs);\n                            break;\n                        }\n                    }\n                    break;\n                }\n                case \"nanoid\": {\n                    addPattern(res, zodPatterns.nanoid, check.message, refs);\n                }\n                case \"toLowerCase\":\n                case \"toUpperCase\":\n                case \"trim\":\n                    break;\n                default:\n                    /* c8 ignore next */\n                    ((_) => { })(check);\n            }\n        }\n    }\n    return res;\n}\nfunction escapeLiteralCheckValue(literal, refs) {\n    return refs.patternStrategy === \"escape\"\n        ? escapeNonAlphaNumeric(literal)\n        : literal;\n}\nconst ALPHA_NUMERIC = new Set(\"ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789\");\nfunction escapeNonAlphaNumeric(source) {\n    let result = \"\";\n    for (let i = 0; i < source.length; i++) {\n        if (!ALPHA_NUMERIC.has(source[i])) {\n            result += \"\\\\\";\n        }\n        result += source[i];\n    }\n    return result;\n}\n// Adds a \"format\" keyword to the schema. If a format exists, both formats will be joined in an allOf-node, along with subsequent ones.\nfunction addFormat(schema, value, message, refs) {\n    if (schema.format || schema.anyOf?.some((x) => x.format)) {\n        if (!schema.anyOf) {\n            schema.anyOf = [];\n        }\n        if (schema.format) {\n            schema.anyOf.push({\n                format: schema.format,\n                ...(schema.errorMessage &&\n                    refs.errorMessages && {\n                    errorMessage: { format: schema.errorMessage.format },\n                }),\n            });\n            delete schema.format;\n            if (schema.errorMessage) {\n                delete schema.errorMessage.format;\n                if (Object.keys(schema.errorMessage).length === 0) {\n                    delete schema.errorMessage;\n                }\n            }\n        }\n        schema.anyOf.push({\n            format: value,\n            ...(message &&\n                refs.errorMessages && { errorMessage: { format: message } }),\n        });\n    }\n    else {\n        setResponseValueAndErrors(schema, \"format\", value, message, refs);\n    }\n}\n// Adds a \"pattern\" keyword to the schema. If a pattern exists, both patterns will be joined in an allOf-node, along with subsequent ones.\nfunction addPattern(schema, regex, message, refs) {\n    if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {\n        if (!schema.allOf) {\n            schema.allOf = [];\n        }\n        if (schema.pattern) {\n            schema.allOf.push({\n                pattern: schema.pattern,\n                ...(schema.errorMessage &&\n                    refs.errorMessages && {\n                    errorMessage: { pattern: schema.errorMessage.pattern },\n                }),\n            });\n            delete schema.pattern;\n            if (schema.errorMessage) {\n                delete schema.errorMessage.pattern;\n                if (Object.keys(schema.errorMessage).length === 0) {\n                    delete schema.errorMessage;\n                }\n            }\n        }\n        schema.allOf.push({\n            pattern: stringifyRegExpWithFlags(regex, refs),\n            ...(message &&\n                refs.errorMessages && { errorMessage: { pattern: message } }),\n        });\n    }\n    else {\n        setResponseValueAndErrors(schema, \"pattern\", stringifyRegExpWithFlags(regex, refs), message, refs);\n    }\n}\n// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true\nfunction stringifyRegExpWithFlags(regex, refs) {\n    if (!refs.applyRegexFlags || !regex.flags) {\n        return regex.source;\n    }\n    // Currently handled flags\n    const flags = {\n        i: regex.flags.includes(\"i\"),\n        m: regex.flags.includes(\"m\"),\n        s: regex.flags.includes(\"s\"), // `.` matches newlines\n    };\n    // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!\n    const source = flags.i ? regex.source.toLowerCase() : regex.source;\n    let pattern = \"\";\n    let isEscaped = false;\n    let inCharGroup = false;\n    let inCharRange = false;\n    for (let i = 0; i < source.length; i++) {\n        if (isEscaped) {\n            pattern += source[i];\n            isEscaped = false;\n            continue;\n        }\n        if (flags.i) {\n            if (inCharGroup) {\n                if (source[i].match(/[a-z]/)) {\n                    if (inCharRange) {\n                        pattern += source[i];\n                        pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();\n                        inCharRange = false;\n                    }\n                    else if (source[i + 1] === \"-\" && source[i + 2]?.match(/[a-z]/)) {\n                        pattern += source[i];\n                        inCharRange = true;\n                    }\n                    else {\n                        pattern += `${source[i]}${source[i].toUpperCase()}`;\n                    }\n                    continue;\n                }\n            }\n            else if (source[i].match(/[a-z]/)) {\n                pattern += `[${source[i]}${source[i].toUpperCase()}]`;\n                continue;\n            }\n        }\n        if (flags.m) {\n            if (source[i] === \"^\") {\n                pattern += `(^|(?<=[\\r\\n]))`;\n                continue;\n            }\n            else if (source[i] === \"$\") {\n                pattern += `($|(?=[\\r\\n]))`;\n                continue;\n            }\n        }\n        if (flags.s && source[i] === \".\") {\n            pattern += inCharGroup ? `${source[i]}\\r\\n` : `[${source[i]}\\r\\n]`;\n            continue;\n        }\n        pattern += source[i];\n        if (source[i] === \"\\\\\") {\n            isEscaped = true;\n        }\n        else if (inCharGroup && source[i] === \"]\") {\n            inCharGroup = false;\n        }\n        else if (!inCharGroup && source[i] === \"[\") {\n            inCharGroup = true;\n        }\n    }\n    try {\n        new RegExp(pattern);\n    }\n    catch {\n        console.warn(`Could not convert regex pattern at ${refs.currentPath.join(\"/\")} to a flag-independent form! Falling back to the flag-ignorant source`);\n        return regex.source;\n    }\n    return pattern;\n}\n", "import { ZodFirstPartyTypeKind, } from \"zod\";\nimport { parseDef } from \"../parseDef.js\";\nimport { parseStringDef } from \"./string.js\";\nimport { parseBrandedDef } from \"./branded.js\";\nimport { parseAnyDef } from \"./any.js\";\nexport function parseRecordDef(def, refs) {\n    if (refs.target === \"openAi\") {\n        console.warn(\"Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.\");\n    }\n    if (refs.target === \"openApi3\" &&\n        def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {\n        return {\n            type: \"object\",\n            required: def.keyType._def.values,\n            properties: def.keyType._def.values.reduce((acc, key) => ({\n                ...acc,\n                [key]: parseDef(def.valueType._def, {\n                    ...refs,\n                    currentPath: [...refs.currentPath, \"properties\", key],\n                }) ?? parseAnyDef(refs),\n            }), {}),\n            additionalProperties: refs.rejectedAdditionalProperties,\n        };\n    }\n    const schema = {\n        type: \"object\",\n        additionalProperties: parseDef(def.valueType._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"additionalProperties\"],\n        }) ?? refs.allowedAdditionalProperties,\n    };\n    if (refs.target === \"openApi3\") {\n        return schema;\n    }\n    if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString &&\n        def.keyType._def.checks?.length) {\n        const { type, ...keyType } = parseStringDef(def.keyType._def, refs);\n        return {\n            ...schema,\n            propertyNames: keyType,\n        };\n    }\n    else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {\n        return {\n            ...schema,\n            propertyNames: {\n                enum: def.keyType._def.values,\n            },\n        };\n    }\n    else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded &&\n        def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString &&\n        def.keyType._def.type._def.checks?.length) {\n        const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);\n        return {\n            ...schema,\n            propertyNames: keyType,\n        };\n    }\n    return schema;\n}\n", "import { parseDef } from \"../parseDef.js\";\nimport { parseRecordDef } from \"./record.js\";\nimport { parseAnyDef } from \"./any.js\";\nexport function parseMapDef(def, refs) {\n    if (refs.mapStrategy === \"record\") {\n        return parseRecordDef(def, refs);\n    }\n    const keys = parseDef(def.keyType._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"items\", \"items\", \"0\"],\n    }) || parseAnyDef(refs);\n    const values = parseDef(def.valueType._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"items\", \"items\", \"1\"],\n    }) || parseAnyDef(refs);\n    return {\n        type: \"array\",\n        maxItems: 125,\n        items: {\n            type: \"array\",\n            items: [keys, values],\n            minItems: 2,\n            maxItems: 2,\n        },\n    };\n}\n", "export function parseNativeEnumDef(def) {\n    const object = def.values;\n    const actualKeys = Object.keys(def.values).filter((key) => {\n        return typeof object[object[key]] !== \"number\";\n    });\n    const actualValues = actualKeys.map((key) => object[key]);\n    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));\n    return {\n        type: parsedTypes.length === 1\n            ? parsedTypes[0] === \"string\"\n                ? \"string\"\n                : \"number\"\n            : [\"string\", \"number\"],\n        enum: actualValues,\n    };\n}\n", "import { parseAnyDef } from \"./any.js\";\nexport function parseNeverDef(refs) {\n    return refs.target === \"openAi\"\n        ? undefined\n        : {\n            not: parseAnyDef({\n                ...refs,\n                currentPath: [...refs.currentPath, \"not\"],\n            }),\n        };\n}\n", "export function parseNullDef(refs) {\n    return refs.target === \"openApi3\"\n        ? {\n            enum: [\"null\"],\n            nullable: true,\n        }\n        : {\n            type: \"null\",\n        };\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport const primitiveMappings = {\n    ZodString: \"string\",\n    ZodNumber: \"number\",\n    ZodBigInt: \"integer\",\n    ZodBoolean: \"boolean\",\n    ZodNull: \"null\",\n};\nexport function parseUnionDef(def, refs) {\n    if (refs.target === \"openApi3\")\n        return asAnyOf(def, refs);\n    const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;\n    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.\n    if (options.every((x) => x._def.typeName in primitiveMappings &&\n        (!x._def.checks || !x._def.checks.length))) {\n        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}\n        const types = options.reduce((types, x) => {\n            const type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43\n            return type && !types.includes(type) ? [...types, type] : types;\n        }, []);\n        return {\n            type: types.length > 1 ? types : types[0],\n        };\n    }\n    else if (options.every((x) => x._def.typeName === \"ZodLiteral\" && !x.description)) {\n        // all options literals\n        const types = options.reduce((acc, x) => {\n            const type = typeof x._def.value;\n            switch (type) {\n                case \"string\":\n                case \"number\":\n                case \"boolean\":\n                    return [...acc, type];\n                case \"bigint\":\n                    return [...acc, \"integer\"];\n                case \"object\":\n                    if (x._def.value === null)\n                        return [...acc, \"null\"];\n                case \"symbol\":\n                case \"undefined\":\n                case \"function\":\n                default:\n                    return acc;\n            }\n        }, []);\n        if (types.length === options.length) {\n            // all the literals are primitive, as far as null can be considered primitive\n            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);\n            return {\n                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],\n                enum: options.reduce((acc, x) => {\n                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];\n                }, []),\n            };\n        }\n    }\n    else if (options.every((x) => x._def.typeName === \"ZodEnum\")) {\n        return {\n            type: \"string\",\n            enum: options.reduce((acc, x) => [\n                ...acc,\n                ...x._def.values.filter((x) => !acc.includes(x)),\n            ], []),\n        };\n    }\n    return asAnyOf(def, refs);\n}\nconst asAnyOf = (def, refs) => {\n    const anyOf = (def.options instanceof Map\n        ? Array.from(def.options.values())\n        : def.options)\n        .map((x, i) => parseDef(x._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"anyOf\", `${i}`],\n    }))\n        .filter((x) => !!x &&\n        (!refs.strictUnions ||\n            (typeof x === \"object\" && Object.keys(x).length > 0)));\n    return anyOf.length ? { anyOf } : undefined;\n};\n", "import { parseDef } from \"../parseDef.js\";\nimport { primitiveMappings } from \"./union.js\";\nexport function parseNullableDef(def, refs) {\n    if ([\"ZodString\", \"ZodNumber\", \"ZodBigInt\", \"ZodBoolean\", \"ZodNull\"].includes(def.innerType._def.typeName) &&\n        (!def.innerType._def.checks || !def.innerType._def.checks.length)) {\n        if (refs.target === \"openApi3\") {\n            return {\n                type: primitiveMappings[def.innerType._def.typeName],\n                nullable: true,\n            };\n        }\n        return {\n            type: [\n                primitiveMappings[def.innerType._def.typeName],\n                \"null\",\n            ],\n        };\n    }\n    if (refs.target === \"openApi3\") {\n        const base = parseDef(def.innerType._def, {\n            ...refs,\n            currentPath: [...refs.currentPath],\n        });\n        if (base && \"$ref\" in base)\n            return { allOf: [base], nullable: true };\n        return base && { ...base, nullable: true };\n    }\n    const base = parseDef(def.innerType._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"anyOf\", \"0\"],\n    });\n    return base && { anyOf: [base, { type: \"null\" }] };\n}\n", "import { addErrorMessage, setResponseValueAndErrors, } from \"../errorMessages.js\";\nexport function parseNumberDef(def, refs) {\n    const res = {\n        type: \"number\",\n    };\n    if (!def.checks)\n        return res;\n    for (const check of def.checks) {\n        switch (check.kind) {\n            case \"int\":\n                res.type = \"integer\";\n                addErrorMessage(res, \"type\", check.message, refs);\n                break;\n            case \"min\":\n                if (refs.target === \"jsonSchema7\") {\n                    if (check.inclusive) {\n                        setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n                    }\n                    else {\n                        setResponseValueAndErrors(res, \"exclusiveMinimum\", check.value, check.message, refs);\n                    }\n                }\n                else {\n                    if (!check.inclusive) {\n                        res.exclusiveMinimum = true;\n                    }\n                    setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n                }\n                break;\n            case \"max\":\n                if (refs.target === \"jsonSchema7\") {\n                    if (check.inclusive) {\n                        setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n                    }\n                    else {\n                        setResponseValueAndErrors(res, \"exclusiveMaximum\", check.value, check.message, refs);\n                    }\n                }\n                else {\n                    if (!check.inclusive) {\n                        res.exclusiveMaximum = true;\n                    }\n                    setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n                }\n                break;\n            case \"multipleOf\":\n                setResponseValueAndErrors(res, \"multipleOf\", check.value, check.message, refs);\n                break;\n        }\n    }\n    return res;\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport function parseObjectDef(def, refs) {\n    const forceOptionalIntoNullable = refs.target === \"openAi\";\n    const result = {\n        type: \"object\",\n        properties: {},\n    };\n    const required = [];\n    const shape = def.shape();\n    for (const propName in shape) {\n        let propDef = shape[propName];\n        if (propDef === undefined || propDef._def === undefined) {\n            continue;\n        }\n        let propOptional = safeIsOptional(propDef);\n        if (propOptional && forceOptionalIntoNullable) {\n            if (propDef._def.typeName === \"ZodOptional\") {\n                propDef = propDef._def.innerType;\n            }\n            if (!propDef.isNullable()) {\n                propDef = propDef.nullable();\n            }\n            propOptional = false;\n        }\n        const parsedDef = parseDef(propDef._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"properties\", propName],\n            propertyPath: [...refs.currentPath, \"properties\", propName],\n        });\n        if (parsedDef === undefined) {\n            continue;\n        }\n        result.properties[propName] = parsedDef;\n        if (!propOptional) {\n            required.push(propName);\n        }\n    }\n    if (required.length) {\n        result.required = required;\n    }\n    const additionalProperties = decideAdditionalProperties(def, refs);\n    if (additionalProperties !== undefined) {\n        result.additionalProperties = additionalProperties;\n    }\n    return result;\n}\nfunction decideAdditionalProperties(def, refs) {\n    if (def.catchall._def.typeName !== \"ZodNever\") {\n        return parseDef(def.catchall._def, {\n            ...refs,\n            currentPath: [...refs.currentPath, \"additionalProperties\"],\n        });\n    }\n    switch (def.unknownKeys) {\n        case \"passthrough\":\n            return refs.allowedAdditionalProperties;\n        case \"strict\":\n            return refs.rejectedAdditionalProperties;\n        case \"strip\":\n            return refs.removeAdditionalStrategy === \"strict\"\n                ? refs.allowedAdditionalProperties\n                : refs.rejectedAdditionalProperties;\n    }\n}\nfunction safeIsOptional(schema) {\n    try {\n        return schema.isOptional();\n    }\n    catch {\n        return true;\n    }\n}\n", "import { parseDef } from \"../parseDef.js\";\nimport { parseAnyDef } from \"./any.js\";\nexport const parseOptionalDef = (def, refs) => {\n    if (refs.currentPath.toString() === refs.propertyPath?.toString()) {\n        return parseDef(def.innerType._def, refs);\n    }\n    const innerSchema = parseDef(def.innerType._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"anyOf\", \"1\"],\n    });\n    return innerSchema\n        ? {\n            anyOf: [\n                {\n                    not: parseAnyDef(refs),\n                },\n                innerSchema,\n            ],\n        }\n        : parseAnyDef(refs);\n};\n", "import { parseDef } from \"../parseDef.js\";\nexport const parsePipelineDef = (def, refs) => {\n    if (refs.pipeStrategy === \"input\") {\n        return parseDef(def.in._def, refs);\n    }\n    else if (refs.pipeStrategy === \"output\") {\n        return parseDef(def.out._def, refs);\n    }\n    const a = parseDef(def.in._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"allOf\", \"0\"],\n    });\n    const b = parseDef(def.out._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"allOf\", a ? \"1\" : \"0\"],\n    });\n    return {\n        allOf: [a, b].filter((x) => x !== undefined),\n    };\n};\n", "import { parseDef } from \"../parseDef.js\";\nexport function parsePromiseDef(def, refs) {\n    return parseDef(def.type._def, refs);\n}\n", "import { setResponseValueAndErrors } from \"../errorMessages.js\";\nimport { parseDef } from \"../parseDef.js\";\nexport function parseSetDef(def, refs) {\n    const items = parseDef(def.valueType._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"items\"],\n    });\n    const schema = {\n        type: \"array\",\n        uniqueItems: true,\n        items,\n    };\n    if (def.minSize) {\n        setResponseValueAndErrors(schema, \"minItems\", def.minSize.value, def.minSize.message, refs);\n    }\n    if (def.maxSize) {\n        setResponseValueAndErrors(schema, \"maxItems\", def.maxSize.value, def.maxSize.message, refs);\n    }\n    return schema;\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport function parseTupleDef(def, refs) {\n    if (def.rest) {\n        return {\n            type: \"array\",\n            minItems: def.items.length,\n            items: def.items\n                .map((x, i) => parseDef(x._def, {\n                ...refs,\n                currentPath: [...refs.currentPath, \"items\", `${i}`],\n            }))\n                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),\n            additionalItems: parseDef(def.rest._def, {\n                ...refs,\n                currentPath: [...refs.currentPath, \"additionalItems\"],\n            }),\n        };\n    }\n    else {\n        return {\n            type: \"array\",\n            minItems: def.items.length,\n            maxItems: def.items.length,\n            items: def.items\n                .map((x, i) => parseDef(x._def, {\n                ...refs,\n                currentPath: [...refs.currentPath, \"items\", `${i}`],\n            }))\n                .reduce((acc, x) => (x === undefined ? acc : [...acc, x]), []),\n        };\n    }\n}\n", "import { parseAnyDef } from \"./any.js\";\nexport function parseUndefinedDef(refs) {\n    return {\n        not: parseAnyDef(refs),\n    };\n}\n", "import { parseAnyDef } from \"./any.js\";\nexport function parseUnknownDef(refs) {\n    return parseAnyDef(refs);\n}\n", "import { parseDef } from \"../parseDef.js\";\nexport const parseReadonlyDef = (def, refs) => {\n    return parseDef(def.innerType._def, refs);\n};\n", "import { ZodFirstPartyTypeKind } from \"zod\";\nimport { parseAnyDef } from \"./parsers/any.js\";\nimport { parseArrayDef } from \"./parsers/array.js\";\nimport { parseBigintDef } from \"./parsers/bigint.js\";\nimport { parseBooleanDef } from \"./parsers/boolean.js\";\nimport { parseBrandedDef } from \"./parsers/branded.js\";\nimport { parseCatchDef } from \"./parsers/catch.js\";\nimport { parseDateDef } from \"./parsers/date.js\";\nimport { parseDefaultDef } from \"./parsers/default.js\";\nimport { parseEffectsDef } from \"./parsers/effects.js\";\nimport { parseEnumDef } from \"./parsers/enum.js\";\nimport { parseIntersectionDef } from \"./parsers/intersection.js\";\nimport { parseLiteralDef } from \"./parsers/literal.js\";\nimport { parseMapDef } from \"./parsers/map.js\";\nimport { parseNativeEnumDef } from \"./parsers/nativeEnum.js\";\nimport { parseNeverDef } from \"./parsers/never.js\";\nimport { parseNullDef } from \"./parsers/null.js\";\nimport { parseNullableDef } from \"./parsers/nullable.js\";\nimport { parseNumberDef } from \"./parsers/number.js\";\nimport { parseObjectDef } from \"./parsers/object.js\";\nimport { parseOptionalDef } from \"./parsers/optional.js\";\nimport { parsePipelineDef } from \"./parsers/pipeline.js\";\nimport { parsePromiseDef } from \"./parsers/promise.js\";\nimport { parseRecordDef } from \"./parsers/record.js\";\nimport { parseSetDef } from \"./parsers/set.js\";\nimport { parseStringDef } from \"./parsers/string.js\";\nimport { parseTupleDef } from \"./parsers/tuple.js\";\nimport { parseUndefinedDef } from \"./parsers/undefined.js\";\nimport { parseUnionDef } from \"./parsers/union.js\";\nimport { parseUnknownDef } from \"./parsers/unknown.js\";\nimport { parseReadonlyDef } from \"./parsers/readonly.js\";\nexport const selectParser = (def, typeName, refs) => {\n    switch (typeName) {\n        case ZodFirstPartyTypeKind.ZodString:\n            return parseStringDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodNumber:\n            return parseNumberDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodObject:\n            return parseObjectDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodBigInt:\n            return parseBigintDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodBoolean:\n            return parseBooleanDef();\n        case ZodFirstPartyTypeKind.ZodDate:\n            return parseDateDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodUndefined:\n            return parseUndefinedDef(refs);\n        case ZodFirstPartyTypeKind.ZodNull:\n            return parseNullDef(refs);\n        case ZodFirstPartyTypeKind.ZodArray:\n            return parseArrayDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodUnion:\n        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:\n            return parseUnionDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodIntersection:\n            return parseIntersectionDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodTuple:\n            return parseTupleDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodRecord:\n            return parseRecordDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodLiteral:\n            return parseLiteralDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodEnum:\n            return parseEnumDef(def);\n        case ZodFirstPartyTypeKind.ZodNativeEnum:\n            return parseNativeEnumDef(def);\n        case ZodFirstPartyTypeKind.ZodNullable:\n            return parseNullableDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodOptional:\n            return parseOptionalDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodMap:\n            return parseMapDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodSet:\n            return parseSetDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodLazy:\n            return () => def.getter()._def;\n        case ZodFirstPartyTypeKind.ZodPromise:\n            return parsePromiseDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodNaN:\n        case ZodFirstPartyTypeKind.ZodNever:\n            return parseNeverDef(refs);\n        case ZodFirstPartyTypeKind.ZodEffects:\n            return parseEffectsDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodAny:\n            return parseAnyDef(refs);\n        case ZodFirstPartyTypeKind.ZodUnknown:\n            return parseUnknownDef(refs);\n        case ZodFirstPartyTypeKind.ZodDefault:\n            return parseDefaultDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodBranded:\n            return parseBrandedDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodReadonly:\n            return parseReadonlyDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodCatch:\n            return parseCatchDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodPipeline:\n            return parsePipelineDef(def, refs);\n        case ZodFirstPartyTypeKind.ZodFunction:\n        case ZodFirstPartyTypeKind.ZodVoid:\n        case ZodFirstPartyTypeKind.ZodSymbol:\n            return undefined;\n        default:\n            /* c8 ignore next */\n            return ((_) => undefined)(typeName);\n    }\n};\n", "import { ignoreOverride } from \"./Options.js\";\nimport { selectParser } from \"./selectParser.js\";\nimport { getRelativePath } from \"./getRelativePath.js\";\nimport { parseAnyDef } from \"./parsers/any.js\";\nexport function parseDef(def, refs, forceResolution = false) {\n    const seenItem = refs.seen.get(def);\n    if (refs.override) {\n        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);\n        if (overrideResult !== ignoreOverride) {\n            return overrideResult;\n        }\n    }\n    if (seenItem && !forceResolution) {\n        const seenSchema = get$ref(seenItem, refs);\n        if (seenSchema !== undefined) {\n            return seenSchema;\n        }\n    }\n    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };\n    refs.seen.set(def, newItem);\n    const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);\n    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)\n    const jsonSchema = typeof jsonSchemaOrGetter === \"function\"\n        ? parseDef(jsonSchemaOrGetter(), refs)\n        : jsonSchemaOrGetter;\n    if (jsonSchema) {\n        addMeta(def, refs, jsonSchema);\n    }\n    if (refs.postProcess) {\n        const postProcessResult = refs.postProcess(jsonSchema, def, refs);\n        newItem.jsonSchema = jsonSchema;\n        return postProcessResult;\n    }\n    newItem.jsonSchema = jsonSchema;\n    return jsonSchema;\n}\nconst get$ref = (item, refs) => {\n    switch (refs.$refStrategy) {\n        case \"root\":\n            return { $ref: item.path.join(\"/\") };\n        case \"relative\":\n            return { $ref: getRelativePath(refs.currentPath, item.path) };\n        case \"none\":\n        case \"seen\": {\n            if (item.path.length < refs.currentPath.length &&\n                item.path.every((value, index) => refs.currentPath[index] === value)) {\n                console.warn(`Recursive reference detected at ${refs.currentPath.join(\"/\")}! Defaulting to any`);\n                return parseAnyDef(refs);\n            }\n            return refs.$refStrategy === \"seen\" ? parseAnyDef(refs) : undefined;\n        }\n    }\n};\nconst addMeta = (def, refs, jsonSchema) => {\n    if (def.description) {\n        jsonSchema.description = def.description;\n        if (refs.markdownDescription) {\n            jsonSchema.markdownDescription = def.description;\n        }\n    }\n    return jsonSchema;\n};\n", "export {};\n", "import { parseDef } from \"./parseDef.js\";\nimport { getRefs } from \"./Refs.js\";\nimport { parseAnyDef } from \"./parsers/any.js\";\nconst zodToJsonSchema = (schema, options) => {\n    const refs = getRefs(options);\n    let definitions = typeof options === \"object\" && options.definitions\n        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({\n            ...acc,\n            [name]: parseDef(schema._def, {\n                ...refs,\n                currentPath: [...refs.basePath, refs.definitionPath, name],\n            }, true) ?? parseAnyDef(refs),\n        }), {})\n        : undefined;\n    const name = typeof options === \"string\"\n        ? options\n        : options?.nameStrategy === \"title\"\n            ? undefined\n            : options?.name;\n    const main = parseDef(schema._def, name === undefined\n        ? refs\n        : {\n            ...refs,\n            currentPath: [...refs.basePath, refs.definitionPath, name],\n        }, false) ?? parseAnyDef(refs);\n    const title = typeof options === \"object\" &&\n        options.name !== undefined &&\n        options.nameStrategy === \"title\"\n        ? options.name\n        : undefined;\n    if (title !== undefined) {\n        main.title = title;\n    }\n    if (refs.flags.hasReferencedOpenAiAnyType) {\n        if (!definitions) {\n            definitions = {};\n        }\n        if (!definitions[refs.openAiAnyTypeName]) {\n            definitions[refs.openAiAnyTypeName] = {\n                // Skipping \"object\" as no properties can be defined and additionalProperties must be \"false\"\n                type: [\"string\", \"number\", \"integer\", \"boolean\", \"array\", \"null\"],\n                items: {\n                    $ref: refs.$refStrategy === \"relative\"\n                        ? \"1\"\n                        : [\n                            ...refs.basePath,\n                            refs.definitionPath,\n                            refs.openAiAnyTypeName,\n                        ].join(\"/\"),\n                },\n            };\n        }\n    }\n    const combined = name === undefined\n        ? definitions\n            ? {\n                ...main,\n                [refs.definitionPath]: definitions,\n            }\n            : main\n        : {\n            $ref: [\n                ...(refs.$refStrategy === \"relative\" ? [] : refs.basePath),\n                refs.definitionPath,\n                name,\n            ].join(\"/\"),\n            [refs.definitionPath]: {\n                ...definitions,\n                [name]: main,\n            },\n        };\n    if (refs.target === \"jsonSchema7\") {\n        combined.$schema = \"http://json-schema.org/draft-07/schema#\";\n    }\n    else if (refs.target === \"jsonSchema2019-09\" || refs.target === \"openAi\") {\n        combined.$schema = \"https://json-schema.org/draft/2019-09/schema#\";\n    }\n    if (refs.target === \"openAi\" &&\n        (\"anyOf\" in combined ||\n            \"oneOf\" in combined ||\n            \"allOf\" in combined ||\n            (\"type\" in combined && Array.isArray(combined.type)))) {\n        console.warn(\"Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.\");\n    }\n    return combined;\n};\nexport { zodToJsonSchema };\n", "export * from \"./Options.js\";\nexport * from \"./Refs.js\";\nexport * from \"./errorMessages.js\";\nexport * from \"./getRelativePath.js\";\nexport * from \"./parseDef.js\";\nexport * from \"./parseTypes.js\";\nexport * from \"./parsers/any.js\";\nexport * from \"./parsers/array.js\";\nexport * from \"./parsers/bigint.js\";\nexport * from \"./parsers/boolean.js\";\nexport * from \"./parsers/branded.js\";\nexport * from \"./parsers/catch.js\";\nexport * from \"./parsers/date.js\";\nexport * from \"./parsers/default.js\";\nexport * from \"./parsers/effects.js\";\nexport * from \"./parsers/enum.js\";\nexport * from \"./parsers/intersection.js\";\nexport * from \"./parsers/literal.js\";\nexport * from \"./parsers/map.js\";\nexport * from \"./parsers/nativeEnum.js\";\nexport * from \"./parsers/never.js\";\nexport * from \"./parsers/null.js\";\nexport * from \"./parsers/nullable.js\";\nexport * from \"./parsers/number.js\";\nexport * from \"./parsers/object.js\";\nexport * from \"./parsers/optional.js\";\nexport * from \"./parsers/pipeline.js\";\nexport * from \"./parsers/promise.js\";\nexport * from \"./parsers/readonly.js\";\nexport * from \"./parsers/record.js\";\nexport * from \"./parsers/set.js\";\nexport * from \"./parsers/string.js\";\nexport * from \"./parsers/tuple.js\";\nexport * from \"./parsers/undefined.js\";\nexport * from \"./parsers/union.js\";\nexport * from \"./parsers/unknown.js\";\nexport * from \"./selectParser.js\";\nexport * from \"./zodToJsonSchema.js\";\nimport { zodToJsonSchema } from \"./zodToJsonSchema.js\";\nexport default zodToJsonSchema;\n", "const ANSI_BACKGROUND_OFFSET = 10;\n\nconst wrapAnsi16 = (offset = 0) => code => `\\u001B[${code + offset}m`;\n\nconst wrapAnsi256 = (offset = 0) => code => `\\u001B[${38 + offset};5;${code}m`;\n\nconst wrapAnsi16m = (offset = 0) => (red, green, blue) => `\\u001B[${38 + offset};2;${red};${green};${blue}m`;\n\nconst styles = {\n\tmodifier: {\n\t\treset: [0, 0],\n\t\t// 21 isn't widely supported and 22 does the same thing\n\t\tbold: [1, 22],\n\t\tdim: [2, 22],\n\t\titalic: [3, 23],\n\t\tunderline: [4, 24],\n\t\toverline: [53, 55],\n\t\tinverse: [7, 27],\n\t\thidden: [8, 28],\n\t\tstrikethrough: [9, 29],\n\t},\n\tcolor: {\n\t\tblack: [30, 39],\n\t\tred: [31, 39],\n\t\tgreen: [32, 39],\n\t\tyellow: [33, 39],\n\t\tblue: [34, 39],\n\t\tmagenta: [35, 39],\n\t\tcyan: [36, 39],\n\t\twhite: [37, 39],\n\n\t\t// Bright color\n\t\tblackBright: [90, 39],\n\t\tgray: [90, 39], // Alias of `blackBright`\n\t\tgrey: [90, 39], // Alias of `blackBright`\n\t\tredBright: [91, 39],\n\t\tgreenBright: [92, 39],\n\t\tyellowBright: [93, 39],\n\t\tblueBright: [94, 39],\n\t\tmagentaBright: [95, 39],\n\t\tcyanBright: [96, 39],\n\t\twhiteBright: [97, 39],\n\t},\n\tbgColor: {\n\t\tbgBlack: [40, 49],\n\t\tbgRed: [41, 49],\n\t\tbgGreen: [42, 49],\n\t\tbgYellow: [43, 49],\n\t\tbgBlue: [44, 49],\n\t\tbgMagenta: [45, 49],\n\t\tbgCyan: [46, 49],\n\t\tbgWhite: [47, 49],\n\n\t\t// Bright color\n\t\tbgBlackBright: [100, 49],\n\t\tbgGray: [100, 49], // Alias of `bgBlackBright`\n\t\tbgGrey: [100, 49], // Alias of `bgBlackBright`\n\t\tbgRedBright: [101, 49],\n\t\tbgGreenBright: [102, 49],\n\t\tbgYellowBright: [103, 49],\n\t\tbgBlueBright: [104, 49],\n\t\tbgMagentaBright: [105, 49],\n\t\tbgCyanBright: [106, 49],\n\t\tbgWhiteBright: [107, 49],\n\t},\n};\n\nexport const modifierNames = Object.keys(styles.modifier);\nexport const foregroundColorNames = Object.keys(styles.color);\nexport const backgroundColorNames = Object.keys(styles.bgColor);\nexport const colorNames = [...foregroundColorNames, ...backgroundColorNames];\n\nfunction assembleStyles() {\n\tconst codes = new Map();\n\n\tfor (const [groupName, group] of Object.entries(styles)) {\n\t\tfor (const [styleName, style] of Object.entries(group)) {\n\t\t\tstyles[styleName] = {\n\t\t\t\topen: `\\u001B[${style[0]}m`,\n\t\t\t\tclose: `\\u001B[${style[1]}m`,\n\t\t\t};\n\n\t\t\tgroup[styleName] = styles[styleName];\n\n\t\t\tcodes.set(style[0], style[1]);\n\t\t}\n\n\t\tObject.defineProperty(styles, groupName, {\n\t\t\tvalue: group,\n\t\t\tenumerable: false,\n\t\t});\n\t}\n\n\tObject.defineProperty(styles, 'codes', {\n\t\tvalue: codes,\n\t\tenumerable: false,\n\t});\n\n\tstyles.color.close = '\\u001B[39m';\n\tstyles.bgColor.close = '\\u001B[49m';\n\n\tstyles.color.ansi = wrapAnsi16();\n\tstyles.color.ansi256 = wrapAnsi256();\n\tstyles.color.ansi16m = wrapAnsi16m();\n\tstyles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);\n\tstyles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);\n\tstyles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);\n\n\t// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js\n\tObject.defineProperties(styles, {\n\t\trgbToAnsi256: {\n\t\t\tvalue(red, green, blue) {\n\t\t\t\t// We use the extended greyscale palette here, with the exception of\n\t\t\t\t// black and white. normal palette only has 4 greyscale shades.\n\t\t\t\tif (red === green && green === blue) {\n\t\t\t\t\tif (red < 8) {\n\t\t\t\t\t\treturn 16;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (red > 248) {\n\t\t\t\t\t\treturn 231;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn Math.round(((red - 8) / 247) * 24) + 232;\n\t\t\t\t}\n\n\t\t\t\treturn 16\n\t\t\t\t\t+ (36 * Math.round(red / 255 * 5))\n\t\t\t\t\t+ (6 * Math.round(green / 255 * 5))\n\t\t\t\t\t+ Math.round(blue / 255 * 5);\n\t\t\t},\n\t\t\tenumerable: false,\n\t\t},\n\t\thexToRgb: {\n\t\t\tvalue(hex) {\n\t\t\t\tconst matches = /[a-f\\d]{6}|[a-f\\d]{3}/i.exec(hex.toString(16));\n\t\t\t\tif (!matches) {\n\t\t\t\t\treturn [0, 0, 0];\n\t\t\t\t}\n\n\t\t\t\tlet [colorString] = matches;\n\n\t\t\t\tif (colorString.length === 3) {\n\t\t\t\t\tcolorString = [...colorString].map(character => character + character).join('');\n\t\t\t\t}\n\n\t\t\t\tconst integer = Number.parseInt(colorString, 16);\n\n\t\t\t\treturn [\n\t\t\t\t\t/* eslint-disable no-bitwise */\n\t\t\t\t\t(integer >> 16) & 0xFF,\n\t\t\t\t\t(integer >> 8) & 0xFF,\n\t\t\t\t\tinteger & 0xFF,\n\t\t\t\t\t/* eslint-enable no-bitwise */\n\t\t\t\t];\n\t\t\t},\n\t\t\tenumerable: false,\n\t\t},\n\t\thexToAnsi256: {\n\t\t\tvalue: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),\n\t\t\tenumerable: false,\n\t\t},\n\t\tansi256ToAnsi: {\n\t\t\tvalue(code) {\n\t\t\t\tif (code < 8) {\n\t\t\t\t\treturn 30 + code;\n\t\t\t\t}\n\n\t\t\t\tif (code < 16) {\n\t\t\t\t\treturn 90 + (code - 8);\n\t\t\t\t}\n\n\t\t\t\tlet red;\n\t\t\t\tlet green;\n\t\t\t\tlet blue;\n\n\t\t\t\tif (code >= 232) {\n\t\t\t\t\tred = (((code - 232) * 10) + 8) / 255;\n\t\t\t\t\tgreen = red;\n\t\t\t\t\tblue = red;\n\t\t\t\t} else {\n\t\t\t\t\tcode -= 16;\n\n\t\t\t\t\tconst remainder = code % 36;\n\n\t\t\t\t\tred = Math.floor(code / 36) / 5;\n\t\t\t\t\tgreen = Math.floor(remainder / 6) / 5;\n\t\t\t\t\tblue = (remainder % 6) / 5;\n\t\t\t\t}\n\n\t\t\t\tconst value = Math.max(red, green, blue) * 2;\n\n\t\t\t\tif (value === 0) {\n\t\t\t\t\treturn 30;\n\t\t\t\t}\n\n\t\t\t\t// eslint-disable-next-line no-bitwise\n\t\t\t\tlet result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));\n\n\t\t\t\tif (value === 2) {\n\t\t\t\t\tresult += 60;\n\t\t\t\t}\n\n\t\t\t\treturn result;\n\t\t\t},\n\t\t\tenumerable: false,\n\t\t},\n\t\trgbToAnsi: {\n\t\t\tvalue: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),\n\t\t\tenumerable: false,\n\t\t},\n\t\thexToAnsi: {\n\t\t\tvalue: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),\n\t\t\tenumerable: false,\n\t\t},\n\t});\n\n\treturn styles;\n}\n\nconst ansiStyles = assembleStyles();\n\nexport default ansiStyles;\n", "import process from 'node:process';\nimport os from 'node:os';\nimport tty from 'node:tty';\n\n// From: https://github.com/sindresorhus/has-flag/blob/main/index.js\n/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {\nfunction hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {\n\tconst prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');\n\tconst position = argv.indexOf(prefix + flag);\n\tconst terminatorPosition = argv.indexOf('--');\n\treturn position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);\n}\n\nconst {env} = process;\n\nlet flagForceColor;\nif (\n\thasFlag('no-color')\n\t|| hasFlag('no-colors')\n\t|| hasFlag('color=false')\n\t|| hasFlag('color=never')\n) {\n\tflagForceColor = 0;\n} else if (\n\thasFlag('color')\n\t|| hasFlag('colors')\n\t|| hasFlag('color=true')\n\t|| hasFlag('color=always')\n) {\n\tflagForceColor = 1;\n}\n\nfunction envForceColor() {\n\tif ('FORCE_COLOR' in env) {\n\t\tif (env.FORCE_COLOR === 'true') {\n\t\t\treturn 1;\n\t\t}\n\n\t\tif (env.FORCE_COLOR === 'false') {\n\t\t\treturn 0;\n\t\t}\n\n\t\treturn env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);\n\t}\n}\n\nfunction translateLevel(level) {\n\tif (level === 0) {\n\t\treturn false;\n\t}\n\n\treturn {\n\t\tlevel,\n\t\thasBasic: true,\n\t\thas256: level >= 2,\n\t\thas16m: level >= 3,\n\t};\n}\n\nfunction _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) {\n\tconst noFlagForceColor = envForceColor();\n\tif (noFlagForceColor !== undefined) {\n\t\tflagForceColor = noFlagForceColor;\n\t}\n\n\tconst forceColor = sniffFlags ? flagForceColor : noFlagForceColor;\n\n\tif (forceColor === 0) {\n\t\treturn 0;\n\t}\n\n\tif (sniffFlags) {\n\t\tif (hasFlag('color=16m')\n\t\t\t|| hasFlag('color=full')\n\t\t\t|| hasFlag('color=truecolor')) {\n\t\t\treturn 3;\n\t\t}\n\n\t\tif (hasFlag('color=256')) {\n\t\t\treturn 2;\n\t\t}\n\t}\n\n\t// Check for Azure DevOps pipelines.\n\t// Has to be above the `!streamIsTTY` check.\n\tif ('TF_BUILD' in env && 'AGENT_NAME' in env) {\n\t\treturn 1;\n\t}\n\n\tif (haveStream && !streamIsTTY && forceColor === undefined) {\n\t\treturn 0;\n\t}\n\n\tconst min = forceColor || 0;\n\n\tif (env.TERM === 'dumb') {\n\t\treturn min;\n\t}\n\n\tif (process.platform === 'win32') {\n\t\t// Windows 10 build 10586 is the first Windows release that supports 256 colors.\n\t\t// Windows 10 build 14931 is the first release that supports 16m/TrueColor.\n\t\tconst osRelease = os.release().split('.');\n\t\tif (\n\t\t\tNumber(osRelease[0]) >= 10\n\t\t\t&& Number(osRelease[2]) >= 10_586\n\t\t) {\n\t\t\treturn Number(osRelease[2]) >= 14_931 ? 3 : 2;\n\t\t}\n\n\t\treturn 1;\n\t}\n\n\tif ('CI' in env) {\n\t\tif (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) {\n\t\t\treturn 3;\n\t\t}\n\n\t\tif (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {\n\t\t\treturn 1;\n\t\t}\n\n\t\treturn min;\n\t}\n\n\tif ('TEAMCITY_VERSION' in env) {\n\t\treturn /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;\n\t}\n\n\tif (env.COLORTERM === 'truecolor') {\n\t\treturn 3;\n\t}\n\n\tif (env.TERM === 'xterm-kitty') {\n\t\treturn 3;\n\t}\n\n\tif (env.TERM === 'xterm-ghostty') {\n\t\treturn 3;\n\t}\n\n\tif (env.TERM === 'wezterm') {\n\t\treturn 3;\n\t}\n\n\tif ('TERM_PROGRAM' in env) {\n\t\tconst version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);\n\n\t\tswitch (env.TERM_PROGRAM) {\n\t\t\tcase 'iTerm.app': {\n\t\t\t\treturn version >= 3 ? 3 : 2;\n\t\t\t}\n\n\t\t\tcase 'Apple_Terminal': {\n\t\t\t\treturn 2;\n\t\t\t}\n\t\t\t// No default\n\t\t}\n\t}\n\n\tif (/-256(color)?$/i.test(env.TERM)) {\n\t\treturn 2;\n\t}\n\n\tif (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {\n\t\treturn 1;\n\t}\n\n\tif ('COLORTERM' in env) {\n\t\treturn 1;\n\t}\n\n\treturn min;\n}\n\nexport function createSupportsColor(stream, options = {}) {\n\tconst level = _supportsColor(stream, {\n\t\tstreamIsTTY: stream && stream.isTTY,\n\t\t...options,\n\t});\n\n\treturn translateLevel(level);\n}\n\nconst supportsColor = {\n\tstdout: createSupportsColor({isTTY: tty.isatty(1)}),\n\tstderr: createSupportsColor({isTTY: tty.isatty(2)}),\n};\n\nexport default supportsColor;\n", "// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.\nexport function stringReplaceAll(string, substring, replacer) {\n\tlet index = string.indexOf(substring);\n\tif (index === -1) {\n\t\treturn string;\n\t}\n\n\tconst substringLength = substring.length;\n\tlet endIndex = 0;\n\tlet returnValue = '';\n\tdo {\n\t\treturnValue += string.slice(endIndex, index) + substring + replacer;\n\t\tendIndex = index + substringLength;\n\t\tindex = string.indexOf(substring, endIndex);\n\t} while (index !== -1);\n\n\treturnValue += string.slice(endIndex);\n\treturn returnValue;\n}\n\nexport function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {\n\tlet endIndex = 0;\n\tlet returnValue = '';\n\tdo {\n\t\tconst gotCR = string[index - 1] === '\\r';\n\t\treturnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\\r\\n' : '\\n') + postfix;\n\t\tendIndex = index + 1;\n\t\tindex = string.indexOf('\\n', endIndex);\n\t} while (index !== -1);\n\n\treturnValue += string.slice(endIndex);\n\treturn returnValue;\n}\n", "import ansiStyles from '#ansi-styles';\nimport supportsColor from '#supports-color';\nimport { // eslint-disable-line import/order\n\tstringReplaceAll,\n\tstringEncaseCRLFWithFirstIndex,\n} from './utilities.js';\n\nconst {stdout: stdoutColor, stderr: stderrColor} = supportsColor;\n\nconst GENERATOR = Symbol('GENERATOR');\nconst STYLER = Symbol('STYLER');\nconst IS_EMPTY = Symbol('IS_EMPTY');\n\n// `supportsColor.level` \u2192 `ansiStyles.color[name]` mapping\nconst levelMapping = [\n\t'ansi',\n\t'ansi',\n\t'ansi256',\n\t'ansi16m',\n];\n\nconst styles = Object.create(null);\n\nconst applyOptions = (object, options = {}) => {\n\tif (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {\n\t\tthrow new Error('The `level` option should be an integer from 0 to 3');\n\t}\n\n\t// Detect level if not set manually\n\tconst colorLevel = stdoutColor ? stdoutColor.level : 0;\n\tobject.level = options.level === undefined ? colorLevel : options.level;\n};\n\nexport class Chalk {\n\tconstructor(options) {\n\t\t// eslint-disable-next-line no-constructor-return\n\t\treturn chalkFactory(options);\n\t}\n}\n\nconst chalkFactory = options => {\n\tconst chalk = (...strings) => strings.join(' ');\n\tapplyOptions(chalk, options);\n\n\tObject.setPrototypeOf(chalk, createChalk.prototype);\n\n\treturn chalk;\n};\n\nfunction createChalk(options) {\n\treturn chalkFactory(options);\n}\n\nObject.setPrototypeOf(createChalk.prototype, Function.prototype);\n\nfor (const [styleName, style] of Object.entries(ansiStyles)) {\n\tstyles[styleName] = {\n\t\tget() {\n\t\t\tconst builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);\n\t\t\tObject.defineProperty(this, styleName, {value: builder});\n\t\t\treturn builder;\n\t\t},\n\t};\n}\n\nstyles.visible = {\n\tget() {\n\t\tconst builder = createBuilder(this, this[STYLER], true);\n\t\tObject.defineProperty(this, 'visible', {value: builder});\n\t\treturn builder;\n\t},\n};\n\nconst getModelAnsi = (model, level, type, ...arguments_) => {\n\tif (model === 'rgb') {\n\t\tif (level === 'ansi16m') {\n\t\t\treturn ansiStyles[type].ansi16m(...arguments_);\n\t\t}\n\n\t\tif (level === 'ansi256') {\n\t\t\treturn ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));\n\t\t}\n\n\t\treturn ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));\n\t}\n\n\tif (model === 'hex') {\n\t\treturn getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));\n\t}\n\n\treturn ansiStyles[type][model](...arguments_);\n};\n\nconst usedModels = ['rgb', 'hex', 'ansi256'];\n\nfor (const model of usedModels) {\n\tstyles[model] = {\n\t\tget() {\n\t\t\tconst {level} = this;\n\t\t\treturn function (...arguments_) {\n\t\t\t\tconst styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);\n\t\t\t\treturn createBuilder(this, styler, this[IS_EMPTY]);\n\t\t\t};\n\t\t},\n\t};\n\n\tconst bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);\n\tstyles[bgModel] = {\n\t\tget() {\n\t\t\tconst {level} = this;\n\t\t\treturn function (...arguments_) {\n\t\t\t\tconst styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);\n\t\t\t\treturn createBuilder(this, styler, this[IS_EMPTY]);\n\t\t\t};\n\t\t},\n\t};\n}\n\nconst proto = Object.defineProperties(() => {}, {\n\t...styles,\n\tlevel: {\n\t\tenumerable: true,\n\t\tget() {\n\t\t\treturn this[GENERATOR].level;\n\t\t},\n\t\tset(level) {\n\t\t\tthis[GENERATOR].level = level;\n\t\t},\n\t},\n});\n\nconst createStyler = (open, close, parent) => {\n\tlet openAll;\n\tlet closeAll;\n\tif (parent === undefined) {\n\t\topenAll = open;\n\t\tcloseAll = close;\n\t} else {\n\t\topenAll = parent.openAll + open;\n\t\tcloseAll = close + parent.closeAll;\n\t}\n\n\treturn {\n\t\topen,\n\t\tclose,\n\t\topenAll,\n\t\tcloseAll,\n\t\tparent,\n\t};\n};\n\nconst createBuilder = (self, _styler, _isEmpty) => {\n\t// Single argument is hot path, implicit coercion is faster than anything\n\t// eslint-disable-next-line no-implicit-coercion\n\tconst builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));\n\n\t// We alter the prototype because we must return a function, but there is\n\t// no way to create a function with a different prototype\n\tObject.setPrototypeOf(builder, proto);\n\n\tbuilder[GENERATOR] = self;\n\tbuilder[STYLER] = _styler;\n\tbuilder[IS_EMPTY] = _isEmpty;\n\n\treturn builder;\n};\n\nconst applyStyle = (self, string) => {\n\tif (self.level <= 0 || !string) {\n\t\treturn self[IS_EMPTY] ? '' : string;\n\t}\n\n\tlet styler = self[STYLER];\n\n\tif (styler === undefined) {\n\t\treturn string;\n\t}\n\n\tconst {openAll, closeAll} = styler;\n\tif (string.includes('\\u001B')) {\n\t\twhile (styler !== undefined) {\n\t\t\t// Replace any instances already present with a re-opening code\n\t\t\t// otherwise only the part of the string until said closing code\n\t\t\t// will be colored, and the rest will simply be 'plain'.\n\t\t\tstring = stringReplaceAll(string, styler.close, styler.open);\n\n\t\t\tstyler = styler.parent;\n\t\t}\n\t}\n\n\t// We can move both next actions out of loop, because remaining actions in loop won't have\n\t// any/visible effect on parts we add here. Close the styling before a linebreak and reopen\n\t// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92\n\tconst lfIndex = string.indexOf('\\n');\n\tif (lfIndex !== -1) {\n\t\tstring = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);\n\t}\n\n\treturn openAll + string + closeAll;\n};\n\nObject.defineProperties(createChalk.prototype, styles);\n\nconst chalk = createChalk();\nexport const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0});\n\nexport {\n\tmodifierNames,\n\tforegroundColorNames,\n\tbackgroundColorNames,\n\tcolorNames,\n\n\t// TODO: Remove these aliases in the next major version\n\tmodifierNames as modifiers,\n\tforegroundColorNames as foregroundColors,\n\tbackgroundColorNames as backgroundColors,\n\tcolorNames as colors,\n} from './vendor/ansi-styles/index.js';\n\nexport {\n\tstdoutColor as supportsColor,\n\tstderrColor as supportsColorStderr,\n};\n\nexport default chalk;\n", "import { Server } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport {\n  CallToolRequestSchema,\n  ListToolsRequestSchema,\n  McpError,\n  ErrorCode\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport { z } from \"zod\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\nimport chalk from 'chalk';\n\n// Define session configuration schema (optional - this server doesn't need config)\nexport const configSchema = z.object({});\n\n// Types\ninterface DomainElement {\n  id: string;\n  name: string;\n  type: \"entity\" | \"attribute\" | \"relation\" | \"process\";\n  description: string;\n}\n\ninterface AnalogicalMapping {\n  sourceElement: string; // ID of source domain element\n  targetElement: string; // ID of target domain element\n  mappingStrength: number; // 0.0-1.0\n  justification: string;\n  limitations?: string[];\n}\n\ninterface AnalogicalReasoningData {\n  // Core analogy components\n  sourceDomain: {\n    name: string;\n    elements: DomainElement[];\n  };\n  targetDomain: {\n    name: string;\n    elements: DomainElement[];\n  };\n  mappings: AnalogicalMapping[];\n  \n  // Analogy metadata\n  analogyId: string;\n  purpose: \"explanation\" | \"prediction\" | \"problem-solving\" | \"creative-generation\";\n  confidence: number; // 0.0-1.0\n  iteration: number;\n  \n  // Evaluation\n  strengths: string[];\n  limitations: string[];\n  inferences: Array<{\n    statement: string;\n    confidence: number;\n    basedOnMappings: string[]; // IDs of mappings supporting this inference\n  }>;\n  \n  // Next steps\n  nextOperationNeeded: boolean;\n  suggestedOperations?: Array<\"add-mapping\" | \"revise-mapping\" | \"draw-inference\" | \"evaluate-limitation\" | \"try-new-source\">;\n}\n\n// Type guard for DomainElement type\nconst allowedElementTypes = [\"entity\", \"attribute\", \"relation\", \"process\"] as const;\ntype DomainElementType = typeof allowedElementTypes[number];\n\nfunction isValidElementType(type: unknown): type is DomainElementType {\n  return typeof type === 'string' && allowedElementTypes.includes(type as DomainElementType);\n}\n\nclass AnalogicalReasoningServer {\n  private analogyHistory: Record<string, AnalogicalReasoningData[]> = {};\n  private domainRegistry: Record<string, {\n    name: string;\n    elements: DomainElement[];\n  }> = {};\n  private nextElementId = 1;\n\n  private validateAnalogicalReasoningData(input: unknown): AnalogicalReasoningData {\n    const data = input as Record<string, unknown>;\n    \n    // Validate required fields\n    if (!data.analogyId || typeof data.analogyId !== 'string') {\n      throw new Error('Invalid analogyId: must be a string');\n    }\n    \n    if (!data.purpose || typeof data.purpose !== 'string') {\n      throw new Error('Invalid purpose: must be a string');\n    }\n    \n    if (typeof data.confidence !== 'number' || data.confidence < 0 || data.confidence > 1) {\n      throw new Error('Invalid confidence: must be a number between 0 and 1');\n    }\n    \n    if (typeof data.iteration !== 'number' || data.iteration < 0) {\n      throw new Error('Invalid iteration: must be a non-negative number');\n    }\n    \n    if (typeof data.nextOperationNeeded !== 'boolean') {\n      throw new Error('Invalid nextOperationNeeded: must be a boolean');\n    }\n    \n    // Validate domains\n    const sourceDomain = data.sourceDomain as Record<string, unknown>;\n    const targetDomain = data.targetDomain as Record<string, unknown>;\n    \n    if (!sourceDomain || typeof sourceDomain !== 'object') {\n      throw new Error('Invalid sourceDomain: must be an object');\n    }\n    \n    if (!targetDomain || typeof targetDomain !== 'object') {\n      throw new Error('Invalid targetDomain: must be an object');\n    }\n    \n    if (!sourceDomain.name || typeof sourceDomain.name !== 'string') {\n      throw new Error('Invalid sourceDomain.name: must be a string');\n    }\n    \n    if (!targetDomain.name || typeof targetDomain.name !== 'string') {\n      throw new Error('Invalid targetDomain.name: must be a string');\n    }\n    \n    if (!Array.isArray(sourceDomain.elements)) {\n      throw new Error('Invalid sourceDomain.elements: must be an array');\n    }\n    \n    if (!Array.isArray(targetDomain.elements)) {\n      throw new Error('Invalid targetDomain.elements: must be an array');\n    }\n    \n    // Validate elements\n    const sourceElements: DomainElement[] = [];\n    for (const element of sourceDomain.elements as Array<Record<string, unknown>>) {\n      if (!element.id || typeof element.id !== 'string') {\n        element.id = `elem-${this.nextElementId++}`;\n      }\n      \n      if (!element.name || typeof element.name !== 'string') {\n        throw new Error(`Invalid element name for element ${element.id}: must be a string`);\n      }\n      \n      if (!element.type || typeof element.type !== 'string') {\n        throw new Error(`Invalid element type for element ${element.id}: must be a string`);\n      }\n      \n      if (!isValidElementType(element.type)) {\n        throw new Error(`Invalid element type for element ${element.id}: must be one of ${allowedElementTypes.join(', ')}`);\n      }\n      \n      if (!element.description || typeof element.description !== 'string') {\n        throw new Error(`Invalid element description for element ${element.id}: must be a string`);\n      }\n      \n      sourceElements.push({ id: element.id as string, name: element.name as string, type: element.type, description: element.description as string });\n    }\n    \n    const targetElements: DomainElement[] = [];\n    for (const element of targetDomain.elements as Array<Record<string, unknown>>) {\n      if (!element.id || typeof element.id !== 'string') {\n        element.id = `elem-${this.nextElementId++}`;\n      }\n      \n      if (!element.name || typeof element.name !== 'string') {\n        throw new Error(`Invalid element name for element ${element.id}: must be a string`);\n      }\n      \n      if (!element.type || typeof element.type !== 'string') {\n        throw new Error(`Invalid element type for element ${element.id}: must be a string`);\n      }\n      \n      if (!isValidElementType(element.type)) {\n        throw new Error(`Invalid element type for element ${element.id}: must be one of ${allowedElementTypes.join(', ')}`);\n      }\n      \n      if (!element.description || typeof element.description !== 'string') {\n        throw new Error(`Invalid element description for element ${element.id}: must be a string`);\n      }\n      \n      targetElements.push({ id: element.id as string, name: element.name as string, type: element.type, description: element.description as string });\n    }\n    \n    // Validate mappings\n    const mappings: AnalogicalMapping[] = [];\n    if (Array.isArray(data.mappings)) {\n      for (const mapping of data.mappings as Array<Record<string, unknown>>) {\n        if (!mapping.sourceElement || typeof mapping.sourceElement !== 'string') {\n          throw new Error('Invalid mapping sourceElement: must be a string');\n        }\n        \n        if (!mapping.targetElement || typeof mapping.targetElement !== 'string') {\n          throw new Error('Invalid mapping targetElement: must be a string');\n        }\n        \n        if (typeof mapping.mappingStrength !== 'number' || mapping.mappingStrength < 0 || mapping.mappingStrength > 1) {\n          throw new Error('Invalid mappingStrength: must be a number between 0 and 1');\n        }\n        \n        if (!mapping.justification || typeof mapping.justification !== 'string') {\n          throw new Error('Invalid mapping justification: must be a string');\n        }\n        \n        const limitations: string[] = [];\n        if (mapping.limitations && Array.isArray(mapping.limitations)) {\n          for (const limitation of mapping.limitations) {\n            if (typeof limitation === 'string') {\n              limitations.push(limitation);\n            }\n          }\n        }\n        \n        const mappingData: AnalogicalMapping = {\n          sourceElement: mapping.sourceElement as string,\n          targetElement: mapping.targetElement as string,\n          mappingStrength: mapping.mappingStrength as number,\n          justification: mapping.justification as string,\n          // limitations is added conditionally below\n        };\n        if (limitations.length > 0) {\n            mappingData.limitations = limitations;\n        }\n        mappings.push(mappingData);\n      }\n    }\n    \n    // Validate arrays\n    const strengths: string[] = [];\n    if (Array.isArray(data.strengths)) {\n      for (const strength of data.strengths) {\n        if (typeof strength === 'string') {\n          strengths.push(strength);\n        }\n      }\n    }\n    \n    const limitations: string[] = [];\n    if (Array.isArray(data.limitations)) {\n      for (const limitation of data.limitations) {\n        if (typeof limitation === 'string') {\n          limitations.push(limitation);\n        }\n      }\n    }\n    \n    const inferences: AnalogicalReasoningData['inferences'] = [];\n    if (Array.isArray(data.inferences)) {\n      for (const inference of data.inferences as Array<Record<string, unknown>>) {\n        if (!inference.statement || typeof inference.statement !== 'string') {\n          throw new Error('Invalid inference statement: must be a string');\n        }\n        \n        if (typeof inference.confidence !== 'number' || inference.confidence < 0 || inference.confidence > 1) {\n          throw new Error('Invalid inference confidence: must be a number between 0 and 1');\n        }\n        \n        if (!Array.isArray(inference.basedOnMappings)) {\n          throw new Error('Invalid inference basedOnMappings: must be an array of mapping IDs');\n        }\n        \n        const basedOnMappings: string[] = [];\n        for (const mappingId of inference.basedOnMappings) {\n          if (typeof mappingId === 'string') {\n            basedOnMappings.push(mappingId);\n          }\n        }\n        \n        inferences.push({\n          statement: inference.statement as string,\n          confidence: inference.confidence as number,\n          basedOnMappings\n        });\n      }\n    }\n    \n    const suggestedOperations: AnalogicalReasoningData['suggestedOperations'] = [];\n    if (Array.isArray(data.suggestedOperations)) {\n      for (const operation of data.suggestedOperations) {\n        if (typeof operation === 'string' && [\n          'add-mapping', 'revise-mapping', 'draw-inference', 'evaluate-limitation', 'try-new-source'\n        ].includes(operation)) {\n          suggestedOperations.push(operation as any);\n        }\n      }\n    }\n    \n    // Create validated data object with conditional suggestedOperations\n    const validatedData: AnalogicalReasoningData = {\n      sourceDomain: {\n        name: sourceDomain.name as string,\n        elements: sourceElements\n      },\n      targetDomain: {\n        name: targetDomain.name as string,\n        elements: targetElements\n      },\n      mappings,\n      analogyId: data.analogyId as string,\n      purpose: data.purpose as AnalogicalReasoningData['purpose'],\n      confidence: data.confidence as number,\n      iteration: data.iteration as number,\n      strengths,\n      limitations,\n      inferences,\n      nextOperationNeeded: data.nextOperationNeeded as boolean,\n      // suggestedOperations is added conditionally below\n    };\n\n    if (suggestedOperations.length > 0) {\n      validatedData.suggestedOperations = suggestedOperations;\n    }\n\n    return validatedData;\n  }\n\n  private updateDomainRegistry(domain: { name: string; elements: DomainElement[] }): void {\n    this.domainRegistry[domain.name] = {\n      name: domain.name,\n      elements: [...domain.elements]\n    };\n  }\n\n  private updateAnalogicalReasoning(data: AnalogicalReasoningData): void {\n    let historyEntry = this.analogyHistory[data.analogyId]; // Get potential entry\n    if (!historyEntry) { // Check if it exists\n      historyEntry = []; // Create new array if not\n      this.analogyHistory[data.analogyId] = historyEntry; // Assign it back to the object\n    }\n    // Now, historyEntry is guaranteed to be AnalogicalReasoningData[]\n    historyEntry.push(data);\n    \n    // Update domain registry\n    this.updateDomainRegistry(data.sourceDomain);\n    this.updateDomainRegistry(data.targetDomain);\n  }\n\n  private visualizeMapping(data: AnalogicalReasoningData): string {\n    const { sourceDomain, targetDomain, mappings } = data;\n    \n    let output = `\\n${chalk.bold(`ANALOGY: ${sourceDomain.name} \u0094 ${targetDomain.name}`)} (ID: ${data.analogyId})\\n\\n`;\n    \n    // Purpose and confidence\n    output += `${chalk.cyan('Purpose:')} ${data.purpose}\\n`;\n    output += `${chalk.cyan('Confidence:')} ${(data.confidence * 100).toFixed(0)}%\\n`;\n    output += `${chalk.cyan('Iteration:')} ${data.iteration}\\n\\n`;\n    \n    // Create mapping visualization\n    output += `${chalk.bold('STRUCTURAL MAPPINGS:')}\\n\\n`;\n    \n    const mappingsBySourceType = new Map<string, AnalogicalMapping[]>();\n    \n    for (const mapping of mappings) {\n      const sourceElement = sourceDomain.elements.find(e => e.id === mapping.sourceElement);\n      if (!sourceElement) continue;\n      \n      if (!mappingsBySourceType.has(sourceElement.type)) {\n        mappingsBySourceType.set(sourceElement.type, []);\n      }\n      \n      mappingsBySourceType.get(sourceElement.type)?.push(mapping);\n    }\n    \n    // Display mappings grouped by element type\n    for (const [type, typeMappings] of mappingsBySourceType.entries()) {\n      output += `${chalk.yellow(type.toUpperCase())} MAPPINGS:\\n`;\n      \n      for (const mapping of typeMappings) {\n        const sourceElement = sourceDomain.elements.find(e => e.id === mapping.sourceElement);\n        const targetElement = targetDomain.elements.find(e => e.id === mapping.targetElement);\n        \n        if (!sourceElement || !targetElement) continue;\n        \n        // Color-code based on mapping strength\n        let strengthIndicator: string;\n        if (mapping.mappingStrength >= 0.8) {\n          strengthIndicator = chalk.green('STRONG');\n        } else if (mapping.mappingStrength >= 0.5) {\n          strengthIndicator = chalk.yellow('MODERATE');\n        } else {\n          strengthIndicator = chalk.red('WEAK');\n        }\n        \n        output += `  ${chalk.bold(sourceElement.name)} ====[ ${strengthIndicator} ]===> ${chalk.bold(targetElement.name)}\\n`;\n        output += `    ${chalk.dim('Justification:')} ${mapping.justification}\\n`;\n        \n        if (mapping.limitations && mapping.limitations.length > 0) {\n          output += `    ${chalk.dim('Limitations:')} ${mapping.limitations.join(', ')}\\n`;\n        }\n        \n        output += '\\n';\n      }\n    }\n    \n    // Show unmapped elements\n    const mappedSourceIds = new Set(mappings.map(m => m.sourceElement));\n    const mappedTargetIds = new Set(mappings.map(m => m.targetElement));\n    \n    const unmappedSourceElements = sourceDomain.elements.filter(e => !mappedSourceIds.has(e.id));\n    const unmappedTargetElements = targetDomain.elements.filter(e => !mappedTargetIds.has(e.id));\n    \n    if (unmappedSourceElements.length > 0) {\n      output += `${chalk.red('UNMAPPED SOURCE ELEMENTS:')}\\n`;\n      for (const element of unmappedSourceElements) {\n        output += `  - ${element.name} (${element.type}): ${element.description}\\n`;\n      }\n      output += '\\n';\n    }\n    \n    if (unmappedTargetElements.length > 0) {\n      output += `${chalk.red('UNMAPPED TARGET ELEMENTS:')}\\n`;\n      for (const element of unmappedTargetElements) {\n        output += `  - ${element.name} (${element.type}): ${element.description}\\n`;\n      }\n      output += '\\n';\n    }\n    \n    // Show inferences\n    if (data.inferences.length > 0) {\n      output += `${chalk.bold('INFERENCES:')}\\n`;\n      for (const inference of data.inferences) {\n        const confidenceIndicator = inference.confidence >= 0.7 ? '\u0013' : '?';\n        output += `  ${confidenceIndicator} ${inference.statement}\\n`;\n        output += `    ${chalk.dim(`Confidence: ${(inference.confidence * 100).toFixed(0)}%`)}\\n`;\n        output += '\\n';\n      }\n    }\n    \n    // Show strengths and limitations\n    if (data.strengths.length > 0) {\n      output += `${chalk.green('STRENGTHS:')}\\n`;\n      for (const strength of data.strengths) {\n        output += `  + ${strength}\\n`;\n      }\n      output += '\\n';\n    }\n    \n    if (data.limitations.length > 0) {\n      output += `${chalk.red('LIMITATIONS:')}\\n`;\n      for (const limitation of data.limitations) {\n        output += `  - ${limitation}\\n`;\n      }\n      output += '\\n';\n    }\n    \n    // Next steps\n    if (data.nextOperationNeeded) {\n      output += `${chalk.blue('SUGGESTED NEXT OPERATIONS:')}\\n`;\n      const operations = data.suggestedOperations || [];\n      if (operations.length > 0) {\n        for (const operation of operations) {\n          output += `  \u0092 ${operation}\\n`;\n        }\n      } else {\n        output += `  \u0092 Continue refining the analogy\\n`;\n      }\n    }\n    \n    return output;\n  }\n\n  public processAnalogicalReasoning(input: unknown): { content: Array<{ type: \"text\"; text: string }>; isError?: boolean } {\n    try {\n      const validatedInput = this.validateAnalogicalReasoningData(input);\n      \n      // Update analogy state\n      this.updateAnalogicalReasoning(validatedInput);\n      \n      // Generate visualization\n      const visualization = this.visualizeMapping(validatedInput);\n      console.error(visualization);\n      \n      // Return the analysis result\n      return {\n        content: [{\n          type: \"text\" as const,\n          text: JSON.stringify({\n            analogyId: validatedInput.analogyId,\n            purpose: validatedInput.purpose,\n            iteration: validatedInput.iteration,\n            sourceDomain: validatedInput.sourceDomain.name,\n            targetDomain: validatedInput.targetDomain.name,\n            mappingCount: validatedInput.mappings.length,\n            inferenceCount: validatedInput.inferences.length,\n            nextOperationNeeded: validatedInput.nextOperationNeeded,\n            suggestedOperations: validatedInput.suggestedOperations\n          }, null, 2)\n        }]\n      };\n    } catch (error) {\n      return {\n        content: [{\n          type: \"text\" as const,\n          text: JSON.stringify({\n            error: error instanceof Error ? error.message : String(error),\n            status: 'failed'\n          }, null, 2)\n        }],\n        isError: true\n      };\n    }\n  }\n}\n\n// Tool input schema using Zod\nconst AnalogicalReasoningSchema = z.object({\n  sourceDomain: z.object({\n    name: z.string(),\n    elements: z.array(z.object({\n      id: z.string().optional(),\n      name: z.string(),\n      type: z.enum([\"entity\", \"attribute\", \"relation\", \"process\"]),\n      description: z.string()\n    }))\n  }),\n  targetDomain: z.object({\n    name: z.string(),\n    elements: z.array(z.object({\n      id: z.string().optional(),\n      name: z.string(),\n      type: z.enum([\"entity\", \"attribute\", \"relation\", \"process\"]),\n      description: z.string()\n    }))\n  }),\n  mappings: z.array(z.object({\n    sourceElement: z.string(),\n    targetElement: z.string(),\n    mappingStrength: z.number().min(0).max(1),\n    justification: z.string(),\n    limitations: z.array(z.string()).optional()\n  })),\n  analogyId: z.string(),\n  purpose: z.enum([\"explanation\", \"prediction\", \"problem-solving\", \"creative-generation\"]),\n  confidence: z.number().min(0).max(1),\n  iteration: z.number().int().min(0),\n  strengths: z.array(z.string()),\n  limitations: z.array(z.string()),\n  inferences: z.array(z.object({\n    statement: z.string(),\n    confidence: z.number().min(0).max(1),\n    basedOnMappings: z.array(z.string())\n  })),\n  nextOperationNeeded: z.boolean(),\n  suggestedOperations: z.array(\n    z.enum([\"add-mapping\", \"revise-mapping\", \"draw-inference\", \"evaluate-limitation\", \"try-new-source\"])\n  ).optional()\n});\n\n// Export createServer function for Smithery CLI\nexport default function createServer({\n  config,\n}: {\n  config: z.infer<typeof configSchema>;\n}): Server {\n  // Create a low-level Server instance\n  const server = new Server(\n    {\n      name: \"analogical-reasoning-server\",\n      version: \"0.1.3\",\n    },\n    {\n      capabilities: {\n        tools: {},\n      },\n    }\n  );\n\n  const analogicalReasoningServer = new AnalogicalReasoningServer();\n\n  // Register handlers\n  server.setRequestHandler(ListToolsRequestSchema, async () => ({\n    tools: [\n      {\n        name: \"analogicalReasoning\",\n        title: \"Analogical Reasoning\",\n        description: `A detailed tool for analogical thinking between source and target domains.\nThis tool helps models structure analogies systematically to improve understanding and reasoning.\nIt facilitates explicit mapping between domains, inference generation, and analogy evaluation.\n\nUse this tool to:\n- Map concepts between familiar and unfamiliar domains\n- Draw insights through structural alignment\n- Generate predictions based on analogical transfer\n- Solve problems by applying known solutions to new contexts`,\n        inputSchema: zodToJsonSchema(AnalogicalReasoningSchema) as any,\n      },\n    ],\n  }));\n\n  server.setRequestHandler(CallToolRequestSchema, async (request) => {\n    const { name, arguments: toolArgs } = request.params;\n\n    if (name === \"analogicalReasoning\") {\n      const parsed = AnalogicalReasoningSchema.safeParse(toolArgs);\n      if (!parsed.success) {\n        throw new McpError(\n          ErrorCode.InvalidParams,\n          `Invalid arguments: ${parsed.error.message}`\n        );\n      }\n\n      const result = await analogicalReasoningServer.processAnalogicalReasoning(parsed.data);\n      return result;\n    }\n\n    throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`);\n  });\n\n  return server;\n}", "\"use strict\";\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\n\n// node_modules/bytes/index.js\nvar require_bytes = __commonJS({\n  \"node_modules/bytes/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = bytes;\n    module2.exports.format = format;\n    module2.exports.parse = parse;\n    var formatThousandsRegExp = /\\B(?=(\\d{3})+(?!\\d))/g;\n    var formatDecimalsRegExp = /(?:\\.0*|(\\.[^0]+)0+)$/;\n    var map = {\n      b: 1,\n      kb: 1 << 10,\n      mb: 1 << 20,\n      gb: 1 << 30,\n      tb: Math.pow(1024, 4),\n      pb: Math.pow(1024, 5)\n    };\n    var parseRegExp = /^((-|\\+)?(\\d+(?:\\.\\d+)?)) *(kb|mb|gb|tb|pb)$/i;\n    function bytes(value, options) {\n      if (typeof value === \"string\") {\n        return parse(value);\n      }\n      if (typeof value === \"number\") {\n        return format(value, options);\n      }\n      return null;\n    }\n    function format(value, options) {\n      if (!Number.isFinite(value)) {\n        return null;\n      }\n      var mag = Math.abs(value);\n      var thousandsSeparator = options && options.thousandsSeparator || \"\";\n      var unitSeparator = options && options.unitSeparator || \"\";\n      var decimalPlaces = options && options.decimalPlaces !== void 0 ? options.decimalPlaces : 2;\n      var fixedDecimals = Boolean(options && options.fixedDecimals);\n      var unit = options && options.unit || \"\";\n      if (!unit || !map[unit.toLowerCase()]) {\n        if (mag >= map.pb) {\n          unit = \"PB\";\n        } else if (mag >= map.tb) {\n          unit = \"TB\";\n        } else if (mag >= map.gb) {\n          unit = \"GB\";\n        } else if (mag >= map.mb) {\n          unit = \"MB\";\n        } else if (mag >= map.kb) {\n          unit = \"KB\";\n        } else {\n          unit = \"B\";\n        }\n      }\n      var val = value / map[unit.toLowerCase()];\n      var str = val.toFixed(decimalPlaces);\n      if (!fixedDecimals) {\n        str = str.replace(formatDecimalsRegExp, \"$1\");\n      }\n      if (thousandsSeparator) {\n        str = str.split(\".\").map(function(s, i) {\n          return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;\n        }).join(\".\");\n      }\n      return str + unitSeparator + unit;\n    }\n    function parse(val) {\n      if (typeof val === \"number\" && !isNaN(val)) {\n        return val;\n      }\n      if (typeof val !== \"string\") {\n        return null;\n      }\n      var results = parseRegExp.exec(val);\n      var floatValue;\n      var unit = \"b\";\n      if (!results) {\n        floatValue = parseInt(val, 10);\n        unit = \"b\";\n      } else {\n        floatValue = parseFloat(results[1]);\n        unit = results[4].toLowerCase();\n      }\n      if (isNaN(floatValue)) {\n        return null;\n      }\n      return Math.floor(map[unit] * floatValue);\n    }\n  }\n});\n\n// node_modules/depd/index.js\nvar require_depd = __commonJS({\n  \"node_modules/depd/index.js\"(exports2, module2) {\n    var relative = require(\"path\").relative;\n    module2.exports = depd;\n    var basePath = process.cwd();\n    function containsNamespace(str, namespace) {\n      var vals = str.split(/[ ,]+/);\n      var ns = String(namespace).toLowerCase();\n      for (var i = 0; i < vals.length; i++) {\n        var val = vals[i];\n        if (val && (val === \"*\" || val.toLowerCase() === ns)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    function convertDataDescriptorToAccessor(obj, prop, message) {\n      var descriptor = Object.getOwnPropertyDescriptor(obj, prop);\n      var value = descriptor.value;\n      descriptor.get = function getter() {\n        return value;\n      };\n      if (descriptor.writable) {\n        descriptor.set = function setter(val) {\n          return value = val;\n        };\n      }\n      delete descriptor.value;\n      delete descriptor.writable;\n      Object.defineProperty(obj, prop, descriptor);\n      return descriptor;\n    }\n    function createArgumentsString(arity) {\n      var str = \"\";\n      for (var i = 0; i < arity; i++) {\n        str += \", arg\" + i;\n      }\n      return str.substr(2);\n    }\n    function createStackString(stack) {\n      var str = this.name + \": \" + this.namespace;\n      if (this.message) {\n        str += \" deprecated \" + this.message;\n      }\n      for (var i = 0; i < stack.length; i++) {\n        str += \"\\n    at \" + stack[i].toString();\n      }\n      return str;\n    }\n    function depd(namespace) {\n      if (!namespace) {\n        throw new TypeError(\"argument namespace is required\");\n      }\n      var stack = getStack();\n      var site = callSiteLocation(stack[1]);\n      var file = site[0];\n      function deprecate(message) {\n        log.call(deprecate, message);\n      }\n      deprecate._file = file;\n      deprecate._ignored = isignored(namespace);\n      deprecate._namespace = namespace;\n      deprecate._traced = istraced(namespace);\n      deprecate._warned = /* @__PURE__ */ Object.create(null);\n      deprecate.function = wrapfunction;\n      deprecate.property = wrapproperty;\n      return deprecate;\n    }\n    function eehaslisteners(emitter, type) {\n      var count = typeof emitter.listenerCount !== \"function\" ? emitter.listeners(type).length : emitter.listenerCount(type);\n      return count > 0;\n    }\n    function isignored(namespace) {\n      if (process.noDeprecation) {\n        return true;\n      }\n      var str = process.env.NO_DEPRECATION || \"\";\n      return containsNamespace(str, namespace);\n    }\n    function istraced(namespace) {\n      if (process.traceDeprecation) {\n        return true;\n      }\n      var str = process.env.TRACE_DEPRECATION || \"\";\n      return containsNamespace(str, namespace);\n    }\n    function log(message, site) {\n      var haslisteners = eehaslisteners(process, \"deprecation\");\n      if (!haslisteners && this._ignored) {\n        return;\n      }\n      var caller;\n      var callFile;\n      var callSite;\n      var depSite;\n      var i = 0;\n      var seen = false;\n      var stack = getStack();\n      var file = this._file;\n      if (site) {\n        depSite = site;\n        callSite = callSiteLocation(stack[1]);\n        callSite.name = depSite.name;\n        file = callSite[0];\n      } else {\n        i = 2;\n        depSite = callSiteLocation(stack[i]);\n        callSite = depSite;\n      }\n      for (; i < stack.length; i++) {\n        caller = callSiteLocation(stack[i]);\n        callFile = caller[0];\n        if (callFile === file) {\n          seen = true;\n        } else if (callFile === this._file) {\n          file = this._file;\n        } else if (seen) {\n          break;\n        }\n      }\n      var key = caller ? depSite.join(\":\") + \"__\" + caller.join(\":\") : void 0;\n      if (key !== void 0 && key in this._warned) {\n        return;\n      }\n      this._warned[key] = true;\n      var msg = message;\n      if (!msg) {\n        msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);\n      }\n      if (haslisteners) {\n        var err2 = DeprecationError(this._namespace, msg, stack.slice(i));\n        process.emit(\"deprecation\", err2);\n        return;\n      }\n      var format = process.stderr.isTTY ? formatColor : formatPlain;\n      var output = format.call(this, msg, caller, stack.slice(i));\n      process.stderr.write(output + \"\\n\", \"utf8\");\n    }\n    function callSiteLocation(callSite) {\n      var file = callSite.getFileName() || \"<anonymous>\";\n      var line = callSite.getLineNumber();\n      var colm = callSite.getColumnNumber();\n      if (callSite.isEval()) {\n        file = callSite.getEvalOrigin() + \", \" + file;\n      }\n      var site = [file, line, colm];\n      site.callSite = callSite;\n      site.name = callSite.getFunctionName();\n      return site;\n    }\n    function defaultMessage(site) {\n      var callSite = site.callSite;\n      var funcName = site.name;\n      if (!funcName) {\n        funcName = \"<anonymous@\" + formatLocation(site) + \">\";\n      }\n      var context = callSite.getThis();\n      var typeName = context && callSite.getTypeName();\n      if (typeName === \"Object\") {\n        typeName = void 0;\n      }\n      if (typeName === \"Function\") {\n        typeName = context.name || typeName;\n      }\n      return typeName && callSite.getMethodName() ? typeName + \".\" + funcName : funcName;\n    }\n    function formatPlain(msg, caller, stack) {\n      var timestamp = (/* @__PURE__ */ new Date()).toUTCString();\n      var formatted = timestamp + \" \" + this._namespace + \" deprecated \" + msg;\n      if (this._traced) {\n        for (var i = 0; i < stack.length; i++) {\n          formatted += \"\\n    at \" + stack[i].toString();\n        }\n        return formatted;\n      }\n      if (caller) {\n        formatted += \" at \" + formatLocation(caller);\n      }\n      return formatted;\n    }\n    function formatColor(msg, caller, stack) {\n      var formatted = \"\\x1B[36;1m\" + this._namespace + \"\\x1B[22;39m \\x1B[33;1mdeprecated\\x1B[22;39m \\x1B[0m\" + msg + \"\\x1B[39m\";\n      if (this._traced) {\n        for (var i = 0; i < stack.length; i++) {\n          formatted += \"\\n    \\x1B[36mat \" + stack[i].toString() + \"\\x1B[39m\";\n        }\n        return formatted;\n      }\n      if (caller) {\n        formatted += \" \\x1B[36m\" + formatLocation(caller) + \"\\x1B[39m\";\n      }\n      return formatted;\n    }\n    function formatLocation(callSite) {\n      return relative(basePath, callSite[0]) + \":\" + callSite[1] + \":\" + callSite[2];\n    }\n    function getStack() {\n      var limit = Error.stackTraceLimit;\n      var obj = {};\n      var prep = Error.prepareStackTrace;\n      Error.prepareStackTrace = prepareObjectStackTrace;\n      Error.stackTraceLimit = Math.max(10, limit);\n      Error.captureStackTrace(obj);\n      var stack = obj.stack.slice(1);\n      Error.prepareStackTrace = prep;\n      Error.stackTraceLimit = limit;\n      return stack;\n    }\n    function prepareObjectStackTrace(obj, stack) {\n      return stack;\n    }\n    function wrapfunction(fn, message) {\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"argument fn must be a function\");\n      }\n      var args = createArgumentsString(fn.length);\n      var stack = getStack();\n      var site = callSiteLocation(stack[1]);\n      site.name = fn.name;\n      var deprecatedfn = new Function(\n        \"fn\",\n        \"log\",\n        \"deprecate\",\n        \"message\",\n        \"site\",\n        '\"use strict\"\\nreturn function (' + args + \") {log.call(deprecate, message, site)\\nreturn fn.apply(this, arguments)\\n}\"\n      )(fn, log, this, message, site);\n      return deprecatedfn;\n    }\n    function wrapproperty(obj, prop, message) {\n      if (!obj || typeof obj !== \"object\" && typeof obj !== \"function\") {\n        throw new TypeError(\"argument obj must be object\");\n      }\n      var descriptor = Object.getOwnPropertyDescriptor(obj, prop);\n      if (!descriptor) {\n        throw new TypeError(\"must call property on owner object\");\n      }\n      if (!descriptor.configurable) {\n        throw new TypeError(\"property must be configurable\");\n      }\n      var deprecate = this;\n      var stack = getStack();\n      var site = callSiteLocation(stack[1]);\n      site.name = prop;\n      if (\"value\" in descriptor) {\n        descriptor = convertDataDescriptorToAccessor(obj, prop, message);\n      }\n      var get = descriptor.get;\n      var set = descriptor.set;\n      if (typeof get === \"function\") {\n        descriptor.get = function getter() {\n          log.call(deprecate, message, site);\n          return get.apply(this, arguments);\n        };\n      }\n      if (typeof set === \"function\") {\n        descriptor.set = function setter() {\n          log.call(deprecate, message, site);\n          return set.apply(this, arguments);\n        };\n      }\n      Object.defineProperty(obj, prop, descriptor);\n    }\n    function DeprecationError(namespace, message, stack) {\n      var error = new Error();\n      var stackString;\n      Object.defineProperty(error, \"constructor\", {\n        value: DeprecationError\n      });\n      Object.defineProperty(error, \"message\", {\n        configurable: true,\n        enumerable: false,\n        value: message,\n        writable: true\n      });\n      Object.defineProperty(error, \"name\", {\n        enumerable: false,\n        configurable: true,\n        value: \"DeprecationError\",\n        writable: true\n      });\n      Object.defineProperty(error, \"namespace\", {\n        configurable: true,\n        enumerable: false,\n        value: namespace,\n        writable: true\n      });\n      Object.defineProperty(error, \"stack\", {\n        configurable: true,\n        enumerable: false,\n        get: function() {\n          if (stackString !== void 0) {\n            return stackString;\n          }\n          return stackString = createStackString.call(this, stack);\n        },\n        set: function setter(val) {\n          stackString = val;\n        }\n      });\n      return error;\n    }\n  }\n});\n\n// node_modules/setprototypeof/index.js\nvar require_setprototypeof = __commonJS({\n  \"node_modules/setprototypeof/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);\n    function setProtoOf(obj, proto) {\n      obj.__proto__ = proto;\n      return obj;\n    }\n    function mixinProperties(obj, proto) {\n      for (var prop in proto) {\n        if (!Object.prototype.hasOwnProperty.call(obj, prop)) {\n          obj[prop] = proto[prop];\n        }\n      }\n      return obj;\n    }\n  }\n});\n\n// node_modules/statuses/codes.json\nvar require_codes = __commonJS({\n  \"node_modules/statuses/codes.json\"(exports2, module2) {\n    module2.exports = {\n      \"100\": \"Continue\",\n      \"101\": \"Switching Protocols\",\n      \"102\": \"Processing\",\n      \"103\": \"Early Hints\",\n      \"200\": \"OK\",\n      \"201\": \"Created\",\n      \"202\": \"Accepted\",\n      \"203\": \"Non-Authoritative Information\",\n      \"204\": \"No Content\",\n      \"205\": \"Reset Content\",\n      \"206\": \"Partial Content\",\n      \"207\": \"Multi-Status\",\n      \"208\": \"Already Reported\",\n      \"226\": \"IM Used\",\n      \"300\": \"Multiple Choices\",\n      \"301\": \"Moved Permanently\",\n      \"302\": \"Found\",\n      \"303\": \"See Other\",\n      \"304\": \"Not Modified\",\n      \"305\": \"Use Proxy\",\n      \"307\": \"Temporary Redirect\",\n      \"308\": \"Permanent Redirect\",\n      \"400\": \"Bad Request\",\n      \"401\": \"Unauthorized\",\n      \"402\": \"Payment Required\",\n      \"403\": \"Forbidden\",\n      \"404\": \"Not Found\",\n      \"405\": \"Method Not Allowed\",\n      \"406\": \"Not Acceptable\",\n      \"407\": \"Proxy Authentication Required\",\n      \"408\": \"Request Timeout\",\n      \"409\": \"Conflict\",\n      \"410\": \"Gone\",\n      \"411\": \"Length Required\",\n      \"412\": \"Precondition Failed\",\n      \"413\": \"Payload Too Large\",\n      \"414\": \"URI Too Long\",\n      \"415\": \"Unsupported Media Type\",\n      \"416\": \"Range Not Satisfiable\",\n      \"417\": \"Expectation Failed\",\n      \"418\": \"I'm a Teapot\",\n      \"421\": \"Misdirected Request\",\n      \"422\": \"Unprocessable Entity\",\n      \"423\": \"Locked\",\n      \"424\": \"Failed Dependency\",\n      \"425\": \"Too Early\",\n      \"426\": \"Upgrade Required\",\n      \"428\": \"Precondition Required\",\n      \"429\": \"Too Many Requests\",\n      \"431\": \"Request Header Fields Too Large\",\n      \"451\": \"Unavailable For Legal Reasons\",\n      \"500\": \"Internal Server Error\",\n      \"501\": \"Not Implemented\",\n      \"502\": \"Bad Gateway\",\n      \"503\": \"Service Unavailable\",\n      \"504\": \"Gateway Timeout\",\n      \"505\": \"HTTP Version Not Supported\",\n      \"506\": \"Variant Also Negotiates\",\n      \"507\": \"Insufficient Storage\",\n      \"508\": \"Loop Detected\",\n      \"509\": \"Bandwidth Limit Exceeded\",\n      \"510\": \"Not Extended\",\n      \"511\": \"Network Authentication Required\"\n    };\n  }\n});\n\n// node_modules/statuses/index.js\nvar require_statuses = __commonJS({\n  \"node_modules/statuses/index.js\"(exports2, module2) {\n    \"use strict\";\n    var codes = require_codes();\n    module2.exports = status;\n    status.message = codes;\n    status.code = createMessageToStatusCodeMap(codes);\n    status.codes = createStatusCodeList(codes);\n    status.redirect = {\n      300: true,\n      301: true,\n      302: true,\n      303: true,\n      305: true,\n      307: true,\n      308: true\n    };\n    status.empty = {\n      204: true,\n      205: true,\n      304: true\n    };\n    status.retry = {\n      502: true,\n      503: true,\n      504: true\n    };\n    function createMessageToStatusCodeMap(codes2) {\n      var map = {};\n      Object.keys(codes2).forEach(function forEachCode(code) {\n        var message = codes2[code];\n        var status2 = Number(code);\n        map[message.toLowerCase()] = status2;\n      });\n      return map;\n    }\n    function createStatusCodeList(codes2) {\n      return Object.keys(codes2).map(function mapCode(code) {\n        return Number(code);\n      });\n    }\n    function getStatusCode(message) {\n      var msg = message.toLowerCase();\n      if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {\n        throw new Error('invalid status message: \"' + message + '\"');\n      }\n      return status.code[msg];\n    }\n    function getStatusMessage(code) {\n      if (!Object.prototype.hasOwnProperty.call(status.message, code)) {\n        throw new Error(\"invalid status code: \" + code);\n      }\n      return status.message[code];\n    }\n    function status(code) {\n      if (typeof code === \"number\") {\n        return getStatusMessage(code);\n      }\n      if (typeof code !== \"string\") {\n        throw new TypeError(\"code must be a number or string\");\n      }\n      var n = parseInt(code, 10);\n      if (!isNaN(n)) {\n        return getStatusMessage(n);\n      }\n      return getStatusCode(code);\n    }\n  }\n});\n\n// node_modules/inherits/inherits_browser.js\nvar require_inherits_browser = __commonJS({\n  \"node_modules/inherits/inherits_browser.js\"(exports2, module2) {\n    if (typeof Object.create === \"function\") {\n      module2.exports = function inherits(ctor, superCtor) {\n        if (superCtor) {\n          ctor.super_ = superCtor;\n          ctor.prototype = Object.create(superCtor.prototype, {\n            constructor: {\n              value: ctor,\n              enumerable: false,\n              writable: true,\n              configurable: true\n            }\n          });\n        }\n      };\n    } else {\n      module2.exports = function inherits(ctor, superCtor) {\n        if (superCtor) {\n          ctor.super_ = superCtor;\n          var TempCtor = function() {\n          };\n          TempCtor.prototype = superCtor.prototype;\n          ctor.prototype = new TempCtor();\n          ctor.prototype.constructor = ctor;\n        }\n      };\n    }\n  }\n});\n\n// node_modules/inherits/inherits.js\nvar require_inherits = __commonJS({\n  \"node_modules/inherits/inherits.js\"(exports2, module2) {\n    try {\n      util2 = require(\"util\");\n      if (typeof util2.inherits !== \"function\") throw \"\";\n      module2.exports = util2.inherits;\n    } catch (e) {\n      module2.exports = require_inherits_browser();\n    }\n    var util2;\n  }\n});\n\n// node_modules/toidentifier/index.js\nvar require_toidentifier = __commonJS({\n  \"node_modules/toidentifier/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = toIdentifier;\n    function toIdentifier(str) {\n      return str.split(\" \").map(function(token) {\n        return token.slice(0, 1).toUpperCase() + token.slice(1);\n      }).join(\"\").replace(/[^ _0-9a-z]/gi, \"\");\n    }\n  }\n});\n\n// node_modules/http-errors/index.js\nvar require_http_errors = __commonJS({\n  \"node_modules/http-errors/index.js\"(exports2, module2) {\n    \"use strict\";\n    var deprecate = require_depd()(\"http-errors\");\n    var setPrototypeOf = require_setprototypeof();\n    var statuses = require_statuses();\n    var inherits = require_inherits();\n    var toIdentifier = require_toidentifier();\n    module2.exports = createError;\n    module2.exports.HttpError = createHttpErrorConstructor();\n    module2.exports.isHttpError = createIsHttpErrorFunction(module2.exports.HttpError);\n    populateConstructorExports(module2.exports, statuses.codes, module2.exports.HttpError);\n    function codeClass(status) {\n      return Number(String(status).charAt(0) + \"00\");\n    }\n    function createError() {\n      var err2;\n      var msg;\n      var status = 500;\n      var props = {};\n      for (var i = 0; i < arguments.length; i++) {\n        var arg = arguments[i];\n        var type = typeof arg;\n        if (type === \"object\" && arg instanceof Error) {\n          err2 = arg;\n          status = err2.status || err2.statusCode || status;\n        } else if (type === \"number\" && i === 0) {\n          status = arg;\n        } else if (type === \"string\") {\n          msg = arg;\n        } else if (type === \"object\") {\n          props = arg;\n        } else {\n          throw new TypeError(\"argument #\" + (i + 1) + \" unsupported type \" + type);\n        }\n      }\n      if (typeof status === \"number\" && (status < 400 || status >= 600)) {\n        deprecate(\"non-error status code; use only 4xx or 5xx status codes\");\n      }\n      if (typeof status !== \"number\" || !statuses.message[status] && (status < 400 || status >= 600)) {\n        status = 500;\n      }\n      var HttpError = createError[status] || createError[codeClass(status)];\n      if (!err2) {\n        err2 = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]);\n        Error.captureStackTrace(err2, createError);\n      }\n      if (!HttpError || !(err2 instanceof HttpError) || err2.status !== status) {\n        err2.expose = status < 500;\n        err2.status = err2.statusCode = status;\n      }\n      for (var key in props) {\n        if (key !== \"status\" && key !== \"statusCode\") {\n          err2[key] = props[key];\n        }\n      }\n      return err2;\n    }\n    function createHttpErrorConstructor() {\n      function HttpError() {\n        throw new TypeError(\"cannot construct abstract class\");\n      }\n      inherits(HttpError, Error);\n      return HttpError;\n    }\n    function createClientErrorConstructor(HttpError, name, code) {\n      var className = toClassName(name);\n      function ClientError(message) {\n        var msg = message != null ? message : statuses.message[code];\n        var err2 = new Error(msg);\n        Error.captureStackTrace(err2, ClientError);\n        setPrototypeOf(err2, ClientError.prototype);\n        Object.defineProperty(err2, \"message\", {\n          enumerable: true,\n          configurable: true,\n          value: msg,\n          writable: true\n        });\n        Object.defineProperty(err2, \"name\", {\n          enumerable: false,\n          configurable: true,\n          value: className,\n          writable: true\n        });\n        return err2;\n      }\n      inherits(ClientError, HttpError);\n      nameFunc(ClientError, className);\n      ClientError.prototype.status = code;\n      ClientError.prototype.statusCode = code;\n      ClientError.prototype.expose = true;\n      return ClientError;\n    }\n    function createIsHttpErrorFunction(HttpError) {\n      return function isHttpError(val) {\n        if (!val || typeof val !== \"object\") {\n          return false;\n        }\n        if (val instanceof HttpError) {\n          return true;\n        }\n        return val instanceof Error && typeof val.expose === \"boolean\" && typeof val.statusCode === \"number\" && val.status === val.statusCode;\n      };\n    }\n    function createServerErrorConstructor(HttpError, name, code) {\n      var className = toClassName(name);\n      function ServerError(message) {\n        var msg = message != null ? message : statuses.message[code];\n        var err2 = new Error(msg);\n        Error.captureStackTrace(err2, ServerError);\n        setPrototypeOf(err2, ServerError.prototype);\n        Object.defineProperty(err2, \"message\", {\n          enumerable: true,\n          configurable: true,\n          value: msg,\n          writable: true\n        });\n        Object.defineProperty(err2, \"name\", {\n          enumerable: false,\n          configurable: true,\n          value: className,\n          writable: true\n        });\n        return err2;\n      }\n      inherits(ServerError, HttpError);\n      nameFunc(ServerError, className);\n      ServerError.prototype.status = code;\n      ServerError.prototype.statusCode = code;\n      ServerError.prototype.expose = false;\n      return ServerError;\n    }\n    function nameFunc(func, name) {\n      var desc = Object.getOwnPropertyDescriptor(func, \"name\");\n      if (desc && desc.configurable) {\n        desc.value = name;\n        Object.defineProperty(func, \"name\", desc);\n      }\n    }\n    function populateConstructorExports(exports3, codes, HttpError) {\n      codes.forEach(function forEachCode(code) {\n        var CodeError;\n        var name = toIdentifier(statuses.message[code]);\n        switch (codeClass(code)) {\n          case 400:\n            CodeError = createClientErrorConstructor(HttpError, name, code);\n            break;\n          case 500:\n            CodeError = createServerErrorConstructor(HttpError, name, code);\n            break;\n        }\n        if (CodeError) {\n          exports3[code] = CodeError;\n          exports3[name] = CodeError;\n        }\n      });\n    }\n    function toClassName(name) {\n      return name.substr(-5) !== \"Error\" ? name + \"Error\" : name;\n    }\n  }\n});\n\n// node_modules/safer-buffer/safer.js\nvar require_safer = __commonJS({\n  \"node_modules/safer-buffer/safer.js\"(exports2, module2) {\n    \"use strict\";\n    var buffer = require(\"buffer\");\n    var Buffer2 = buffer.Buffer;\n    var safer = {};\n    var key;\n    for (key in buffer) {\n      if (!buffer.hasOwnProperty(key)) continue;\n      if (key === \"SlowBuffer\" || key === \"Buffer\") continue;\n      safer[key] = buffer[key];\n    }\n    var Safer = safer.Buffer = {};\n    for (key in Buffer2) {\n      if (!Buffer2.hasOwnProperty(key)) continue;\n      if (key === \"allocUnsafe\" || key === \"allocUnsafeSlow\") continue;\n      Safer[key] = Buffer2[key];\n    }\n    safer.Buffer.prototype = Buffer2.prototype;\n    if (!Safer.from || Safer.from === Uint8Array.from) {\n      Safer.from = function(value, encodingOrOffset, length) {\n        if (typeof value === \"number\") {\n          throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value);\n        }\n        if (value && typeof value.length === \"undefined\") {\n          throw new TypeError(\"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type \" + typeof value);\n        }\n        return Buffer2(value, encodingOrOffset, length);\n      };\n    }\n    if (!Safer.alloc) {\n      Safer.alloc = function(size, fill, encoding) {\n        if (typeof size !== \"number\") {\n          throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size);\n        }\n        if (size < 0 || size >= 2 * (1 << 30)) {\n          throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"');\n        }\n        var buf = Buffer2(size);\n        if (!fill || fill.length === 0) {\n          buf.fill(0);\n        } else if (typeof encoding === \"string\") {\n          buf.fill(fill, encoding);\n        } else {\n          buf.fill(fill);\n        }\n        return buf;\n      };\n    }\n    if (!safer.kStringMaxLength) {\n      try {\n        safer.kStringMaxLength = process.binding(\"buffer\").kStringMaxLength;\n      } catch (e) {\n      }\n    }\n    if (!safer.constants) {\n      safer.constants = {\n        MAX_LENGTH: safer.kMaxLength\n      };\n      if (safer.kStringMaxLength) {\n        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;\n      }\n    }\n    module2.exports = safer;\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/lib/bom-handling.js\nvar require_bom_handling = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/lib/bom-handling.js\"(exports2) {\n    \"use strict\";\n    var BOMChar = \"\\uFEFF\";\n    exports2.PrependBOM = PrependBOMWrapper;\n    function PrependBOMWrapper(encoder, options) {\n      this.encoder = encoder;\n      this.addBOM = true;\n    }\n    PrependBOMWrapper.prototype.write = function(str) {\n      if (this.addBOM) {\n        str = BOMChar + str;\n        this.addBOM = false;\n      }\n      return this.encoder.write(str);\n    };\n    PrependBOMWrapper.prototype.end = function() {\n      return this.encoder.end();\n    };\n    exports2.StripBOM = StripBOMWrapper;\n    function StripBOMWrapper(decoder, options) {\n      this.decoder = decoder;\n      this.pass = false;\n      this.options = options || {};\n    }\n    StripBOMWrapper.prototype.write = function(buf) {\n      var res = this.decoder.write(buf);\n      if (this.pass || !res)\n        return res;\n      if (res[0] === BOMChar) {\n        res = res.slice(1);\n        if (typeof this.options.stripBOM === \"function\")\n          this.options.stripBOM();\n      }\n      this.pass = true;\n      return res;\n    };\n    StripBOMWrapper.prototype.end = function() {\n      return this.decoder.end();\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/internal.js\nvar require_internal = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/internal.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    module2.exports = {\n      // Encodings\n      utf8: { type: \"_internal\", bomAware: true },\n      cesu8: { type: \"_internal\", bomAware: true },\n      unicode11utf8: \"utf8\",\n      ucs2: { type: \"_internal\", bomAware: true },\n      utf16le: \"ucs2\",\n      binary: { type: \"_internal\" },\n      base64: { type: \"_internal\" },\n      hex: { type: \"_internal\" },\n      // Codec.\n      _internal: InternalCodec\n    };\n    function InternalCodec(codecOptions, iconv) {\n      this.enc = codecOptions.encodingName;\n      this.bomAware = codecOptions.bomAware;\n      if (this.enc === \"base64\")\n        this.encoder = InternalEncoderBase64;\n      else if (this.enc === \"cesu8\") {\n        this.enc = \"utf8\";\n        this.encoder = InternalEncoderCesu8;\n        if (Buffer2.from(\"eda0bdedb2a9\", \"hex\").toString() !== \"\\u{1F4A9}\") {\n          this.decoder = InternalDecoderCesu8;\n          this.defaultCharUnicode = iconv.defaultCharUnicode;\n        }\n      }\n    }\n    InternalCodec.prototype.encoder = InternalEncoder;\n    InternalCodec.prototype.decoder = InternalDecoder;\n    var StringDecoder = require(\"string_decoder\").StringDecoder;\n    if (!StringDecoder.prototype.end)\n      StringDecoder.prototype.end = function() {\n      };\n    function InternalDecoder(options, codec) {\n      this.decoder = new StringDecoder(codec.enc);\n    }\n    InternalDecoder.prototype.write = function(buf) {\n      if (!Buffer2.isBuffer(buf)) {\n        buf = Buffer2.from(buf);\n      }\n      return this.decoder.write(buf);\n    };\n    InternalDecoder.prototype.end = function() {\n      return this.decoder.end();\n    };\n    function InternalEncoder(options, codec) {\n      this.enc = codec.enc;\n    }\n    InternalEncoder.prototype.write = function(str) {\n      return Buffer2.from(str, this.enc);\n    };\n    InternalEncoder.prototype.end = function() {\n    };\n    function InternalEncoderBase64(options, codec) {\n      this.prevStr = \"\";\n    }\n    InternalEncoderBase64.prototype.write = function(str) {\n      str = this.prevStr + str;\n      var completeQuads = str.length - str.length % 4;\n      this.prevStr = str.slice(completeQuads);\n      str = str.slice(0, completeQuads);\n      return Buffer2.from(str, \"base64\");\n    };\n    InternalEncoderBase64.prototype.end = function() {\n      return Buffer2.from(this.prevStr, \"base64\");\n    };\n    function InternalEncoderCesu8(options, codec) {\n    }\n    InternalEncoderCesu8.prototype.write = function(str) {\n      var buf = Buffer2.alloc(str.length * 3), bufIdx = 0;\n      for (var i = 0; i < str.length; i++) {\n        var charCode = str.charCodeAt(i);\n        if (charCode < 128)\n          buf[bufIdx++] = charCode;\n        else if (charCode < 2048) {\n          buf[bufIdx++] = 192 + (charCode >>> 6);\n          buf[bufIdx++] = 128 + (charCode & 63);\n        } else {\n          buf[bufIdx++] = 224 + (charCode >>> 12);\n          buf[bufIdx++] = 128 + (charCode >>> 6 & 63);\n          buf[bufIdx++] = 128 + (charCode & 63);\n        }\n      }\n      return buf.slice(0, bufIdx);\n    };\n    InternalEncoderCesu8.prototype.end = function() {\n    };\n    function InternalDecoderCesu8(options, codec) {\n      this.acc = 0;\n      this.contBytes = 0;\n      this.accBytes = 0;\n      this.defaultCharUnicode = codec.defaultCharUnicode;\n    }\n    InternalDecoderCesu8.prototype.write = function(buf) {\n      var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = \"\";\n      for (var i = 0; i < buf.length; i++) {\n        var curByte = buf[i];\n        if ((curByte & 192) !== 128) {\n          if (contBytes > 0) {\n            res += this.defaultCharUnicode;\n            contBytes = 0;\n          }\n          if (curByte < 128) {\n            res += String.fromCharCode(curByte);\n          } else if (curByte < 224) {\n            acc = curByte & 31;\n            contBytes = 1;\n            accBytes = 1;\n          } else if (curByte < 240) {\n            acc = curByte & 15;\n            contBytes = 2;\n            accBytes = 1;\n          } else {\n            res += this.defaultCharUnicode;\n          }\n        } else {\n          if (contBytes > 0) {\n            acc = acc << 6 | curByte & 63;\n            contBytes--;\n            accBytes++;\n            if (contBytes === 0) {\n              if (accBytes === 2 && acc < 128 && acc > 0)\n                res += this.defaultCharUnicode;\n              else if (accBytes === 3 && acc < 2048)\n                res += this.defaultCharUnicode;\n              else\n                res += String.fromCharCode(acc);\n            }\n          } else {\n            res += this.defaultCharUnicode;\n          }\n        }\n      }\n      this.acc = acc;\n      this.contBytes = contBytes;\n      this.accBytes = accBytes;\n      return res;\n    };\n    InternalDecoderCesu8.prototype.end = function() {\n      var res = 0;\n      if (this.contBytes > 0)\n        res += this.defaultCharUnicode;\n      return res;\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/utf32.js\nvar require_utf32 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/utf32.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._utf32 = Utf32Codec;\n    function Utf32Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n      this.bomAware = true;\n      this.isLE = codecOptions.isLE;\n    }\n    exports2.utf32le = { type: \"_utf32\", isLE: true };\n    exports2.utf32be = { type: \"_utf32\", isLE: false };\n    exports2.ucs4le = \"utf32le\";\n    exports2.ucs4be = \"utf32be\";\n    Utf32Codec.prototype.encoder = Utf32Encoder;\n    Utf32Codec.prototype.decoder = Utf32Decoder;\n    function Utf32Encoder(options, codec) {\n      this.isLE = codec.isLE;\n      this.highSurrogate = 0;\n    }\n    Utf32Encoder.prototype.write = function(str) {\n      var src = Buffer2.from(str, \"ucs2\");\n      var dst = Buffer2.alloc(src.length * 2);\n      var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;\n      var offset = 0;\n      for (var i = 0; i < src.length; i += 2) {\n        var code = src.readUInt16LE(i);\n        var isHighSurrogate = 55296 <= code && code < 56320;\n        var isLowSurrogate = 56320 <= code && code < 57344;\n        if (this.highSurrogate) {\n          if (isHighSurrogate || !isLowSurrogate) {\n            write32.call(dst, this.highSurrogate, offset);\n            offset += 4;\n          } else {\n            var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536;\n            write32.call(dst, codepoint, offset);\n            offset += 4;\n            this.highSurrogate = 0;\n            continue;\n          }\n        }\n        if (isHighSurrogate)\n          this.highSurrogate = code;\n        else {\n          write32.call(dst, code, offset);\n          offset += 4;\n          this.highSurrogate = 0;\n        }\n      }\n      if (offset < dst.length)\n        dst = dst.slice(0, offset);\n      return dst;\n    };\n    Utf32Encoder.prototype.end = function() {\n      if (!this.highSurrogate)\n        return;\n      var buf = Buffer2.alloc(4);\n      if (this.isLE)\n        buf.writeUInt32LE(this.highSurrogate, 0);\n      else\n        buf.writeUInt32BE(this.highSurrogate, 0);\n      this.highSurrogate = 0;\n      return buf;\n    };\n    function Utf32Decoder(options, codec) {\n      this.isLE = codec.isLE;\n      this.badChar = codec.iconv.defaultCharUnicode.charCodeAt(0);\n      this.overflow = [];\n    }\n    Utf32Decoder.prototype.write = function(src) {\n      if (src.length === 0)\n        return \"\";\n      var i = 0;\n      var codepoint = 0;\n      var dst = Buffer2.alloc(src.length + 4);\n      var offset = 0;\n      var isLE = this.isLE;\n      var overflow = this.overflow;\n      var badChar = this.badChar;\n      if (overflow.length > 0) {\n        for (; i < src.length && overflow.length < 4; i++)\n          overflow.push(src[i]);\n        if (overflow.length === 4) {\n          if (isLE) {\n            codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;\n          } else {\n            codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 24;\n          }\n          overflow.length = 0;\n          offset = _writeCodepoint(dst, offset, codepoint, badChar);\n        }\n      }\n      for (; i < src.length - 3; i += 4) {\n        if (isLE) {\n          codepoint = src[i] | src[i + 1] << 8 | src[i + 2] << 16 | src[i + 3] << 24;\n        } else {\n          codepoint = src[i + 3] | src[i + 2] << 8 | src[i + 1] << 16 | src[i] << 24;\n        }\n        offset = _writeCodepoint(dst, offset, codepoint, badChar);\n      }\n      for (; i < src.length; i++) {\n        overflow.push(src[i]);\n      }\n      return dst.slice(0, offset).toString(\"ucs2\");\n    };\n    function _writeCodepoint(dst, offset, codepoint, badChar) {\n      if (codepoint < 0 || codepoint > 1114111) {\n        codepoint = badChar;\n      }\n      if (codepoint >= 65536) {\n        codepoint -= 65536;\n        var high = 55296 | codepoint >> 10;\n        dst[offset++] = high & 255;\n        dst[offset++] = high >> 8;\n        var codepoint = 56320 | codepoint & 1023;\n      }\n      dst[offset++] = codepoint & 255;\n      dst[offset++] = codepoint >> 8;\n      return offset;\n    }\n    Utf32Decoder.prototype.end = function() {\n      this.overflow.length = 0;\n    };\n    exports2.utf32 = Utf32AutoCodec;\n    exports2.ucs4 = \"utf32\";\n    function Utf32AutoCodec(options, iconv) {\n      this.iconv = iconv;\n    }\n    Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;\n    Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;\n    function Utf32AutoEncoder(options, codec) {\n      options = options || {};\n      if (options.addBOM === void 0)\n        options.addBOM = true;\n      this.encoder = codec.iconv.getEncoder(options.defaultEncoding || \"utf-32le\", options);\n    }\n    Utf32AutoEncoder.prototype.write = function(str) {\n      return this.encoder.write(str);\n    };\n    Utf32AutoEncoder.prototype.end = function() {\n      return this.encoder.end();\n    };\n    function Utf32AutoDecoder(options, codec) {\n      this.decoder = null;\n      this.initialBufs = [];\n      this.initialBufsLen = 0;\n      this.options = options || {};\n      this.iconv = codec.iconv;\n    }\n    Utf32AutoDecoder.prototype.write = function(buf) {\n      if (!this.decoder) {\n        this.initialBufs.push(buf);\n        this.initialBufsLen += buf.length;\n        if (this.initialBufsLen < 32)\n          return \"\";\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.write(buf);\n    };\n    Utf32AutoDecoder.prototype.end = function() {\n      if (!this.decoder) {\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        var trail = this.decoder.end();\n        if (trail)\n          resStr += trail;\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.end();\n    };\n    function detectEncoding(bufs, defaultEncoding) {\n      var b = [];\n      var charsProcessed = 0;\n      var invalidLE = 0, invalidBE = 0;\n      var bmpCharsLE = 0, bmpCharsBE = 0;\n      outer_loop:\n        for (var i = 0; i < bufs.length; i++) {\n          var buf = bufs[i];\n          for (var j = 0; j < buf.length; j++) {\n            b.push(buf[j]);\n            if (b.length === 4) {\n              if (charsProcessed === 0) {\n                if (b[0] === 255 && b[1] === 254 && b[2] === 0 && b[3] === 0) {\n                  return \"utf-32le\";\n                }\n                if (b[0] === 0 && b[1] === 0 && b[2] === 254 && b[3] === 255) {\n                  return \"utf-32be\";\n                }\n              }\n              if (b[0] !== 0 || b[1] > 16) invalidBE++;\n              if (b[3] !== 0 || b[2] > 16) invalidLE++;\n              if (b[0] === 0 && b[1] === 0 && (b[2] !== 0 || b[3] !== 0)) bmpCharsBE++;\n              if ((b[0] !== 0 || b[1] !== 0) && b[2] === 0 && b[3] === 0) bmpCharsLE++;\n              b.length = 0;\n              charsProcessed++;\n              if (charsProcessed >= 100) {\n                break outer_loop;\n              }\n            }\n          }\n        }\n      if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return \"utf-32be\";\n      if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return \"utf-32le\";\n      return defaultEncoding || \"utf-32le\";\n    }\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/utf16.js\nvar require_utf16 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/utf16.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2.utf16be = Utf16BECodec;\n    function Utf16BECodec() {\n    }\n    Utf16BECodec.prototype.encoder = Utf16BEEncoder;\n    Utf16BECodec.prototype.decoder = Utf16BEDecoder;\n    Utf16BECodec.prototype.bomAware = true;\n    function Utf16BEEncoder() {\n    }\n    Utf16BEEncoder.prototype.write = function(str) {\n      var buf = Buffer2.from(str, \"ucs2\");\n      for (var i = 0; i < buf.length; i += 2) {\n        var tmp = buf[i];\n        buf[i] = buf[i + 1];\n        buf[i + 1] = tmp;\n      }\n      return buf;\n    };\n    Utf16BEEncoder.prototype.end = function() {\n    };\n    function Utf16BEDecoder() {\n      this.overflowByte = -1;\n    }\n    Utf16BEDecoder.prototype.write = function(buf) {\n      if (buf.length == 0)\n        return \"\";\n      var buf2 = Buffer2.alloc(buf.length + 1), i = 0, j = 0;\n      if (this.overflowByte !== -1) {\n        buf2[0] = buf[0];\n        buf2[1] = this.overflowByte;\n        i = 1;\n        j = 2;\n      }\n      for (; i < buf.length - 1; i += 2, j += 2) {\n        buf2[j] = buf[i + 1];\n        buf2[j + 1] = buf[i];\n      }\n      this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1;\n      return buf2.slice(0, j).toString(\"ucs2\");\n    };\n    Utf16BEDecoder.prototype.end = function() {\n      this.overflowByte = -1;\n    };\n    exports2.utf16 = Utf16Codec;\n    function Utf16Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf16Codec.prototype.encoder = Utf16Encoder;\n    Utf16Codec.prototype.decoder = Utf16Decoder;\n    function Utf16Encoder(options, codec) {\n      options = options || {};\n      if (options.addBOM === void 0)\n        options.addBOM = true;\n      this.encoder = codec.iconv.getEncoder(\"utf-16le\", options);\n    }\n    Utf16Encoder.prototype.write = function(str) {\n      return this.encoder.write(str);\n    };\n    Utf16Encoder.prototype.end = function() {\n      return this.encoder.end();\n    };\n    function Utf16Decoder(options, codec) {\n      this.decoder = null;\n      this.initialBufs = [];\n      this.initialBufsLen = 0;\n      this.options = options || {};\n      this.iconv = codec.iconv;\n    }\n    Utf16Decoder.prototype.write = function(buf) {\n      if (!this.decoder) {\n        this.initialBufs.push(buf);\n        this.initialBufsLen += buf.length;\n        if (this.initialBufsLen < 16)\n          return \"\";\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.write(buf);\n    };\n    Utf16Decoder.prototype.end = function() {\n      if (!this.decoder) {\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        var trail = this.decoder.end();\n        if (trail)\n          resStr += trail;\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.end();\n    };\n    function detectEncoding(bufs, defaultEncoding) {\n      var b = [];\n      var charsProcessed = 0;\n      var asciiCharsLE = 0, asciiCharsBE = 0;\n      outer_loop:\n        for (var i = 0; i < bufs.length; i++) {\n          var buf = bufs[i];\n          for (var j = 0; j < buf.length; j++) {\n            b.push(buf[j]);\n            if (b.length === 2) {\n              if (charsProcessed === 0) {\n                if (b[0] === 255 && b[1] === 254) return \"utf-16le\";\n                if (b[0] === 254 && b[1] === 255) return \"utf-16be\";\n              }\n              if (b[0] === 0 && b[1] !== 0) asciiCharsBE++;\n              if (b[0] !== 0 && b[1] === 0) asciiCharsLE++;\n              b.length = 0;\n              charsProcessed++;\n              if (charsProcessed >= 100) {\n                break outer_loop;\n              }\n            }\n          }\n        }\n      if (asciiCharsBE > asciiCharsLE) return \"utf-16be\";\n      if (asciiCharsBE < asciiCharsLE) return \"utf-16le\";\n      return defaultEncoding || \"utf-16le\";\n    }\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/utf7.js\nvar require_utf7 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/utf7.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2.utf7 = Utf7Codec;\n    exports2.unicode11utf7 = \"utf7\";\n    function Utf7Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf7Codec.prototype.encoder = Utf7Encoder;\n    Utf7Codec.prototype.decoder = Utf7Decoder;\n    Utf7Codec.prototype.bomAware = true;\n    var nonDirectChars = /[^A-Za-z0-9'\\(\\),-\\.\\/:\\? \\n\\r\\t]+/g;\n    function Utf7Encoder(options, codec) {\n      this.iconv = codec.iconv;\n    }\n    Utf7Encoder.prototype.write = function(str) {\n      return Buffer2.from(str.replace(nonDirectChars, function(chunk) {\n        return \"+\" + (chunk === \"+\" ? \"\" : this.iconv.encode(chunk, \"utf16-be\").toString(\"base64\").replace(/=+$/, \"\")) + \"-\";\n      }.bind(this)));\n    };\n    Utf7Encoder.prototype.end = function() {\n    };\n    function Utf7Decoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n    }\n    var base64Regex2 = /[A-Za-z0-9\\/+]/;\n    var base64Chars = [];\n    for (i = 0; i < 256; i++)\n      base64Chars[i] = base64Regex2.test(String.fromCharCode(i));\n    var i;\n    var plusChar = \"+\".charCodeAt(0);\n    var minusChar = \"-\".charCodeAt(0);\n    var andChar = \"&\".charCodeAt(0);\n    Utf7Decoder.prototype.write = function(buf) {\n      var res = \"\", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;\n      for (var i2 = 0; i2 < buf.length; i2++) {\n        if (!inBase64) {\n          if (buf[i2] == plusChar) {\n            res += this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n            lastI = i2 + 1;\n            inBase64 = true;\n          }\n        } else {\n          if (!base64Chars[buf[i2]]) {\n            if (i2 == lastI && buf[i2] == minusChar) {\n              res += \"+\";\n            } else {\n              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n              res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n            }\n            if (buf[i2] != minusChar)\n              i2--;\n            lastI = i2 + 1;\n            inBase64 = false;\n            base64Accum = \"\";\n          }\n        }\n      }\n      if (!inBase64) {\n        res += this.iconv.decode(buf.slice(lastI), \"ascii\");\n      } else {\n        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), \"ascii\");\n        var canBeDecoded = b64str.length - b64str.length % 8;\n        base64Accum = b64str.slice(canBeDecoded);\n        b64str = b64str.slice(0, canBeDecoded);\n        res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n      }\n      this.inBase64 = inBase64;\n      this.base64Accum = base64Accum;\n      return res;\n    };\n    Utf7Decoder.prototype.end = function() {\n      var res = \"\";\n      if (this.inBase64 && this.base64Accum.length > 0)\n        res = this.iconv.decode(Buffer2.from(this.base64Accum, \"base64\"), \"utf16-be\");\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n      return res;\n    };\n    exports2.utf7imap = Utf7IMAPCodec;\n    function Utf7IMAPCodec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;\n    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;\n    Utf7IMAPCodec.prototype.bomAware = true;\n    function Utf7IMAPEncoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = Buffer2.alloc(6);\n      this.base64AccumIdx = 0;\n    }\n    Utf7IMAPEncoder.prototype.write = function(str) {\n      var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer2.alloc(str.length * 5 + 10), bufIdx = 0;\n      for (var i2 = 0; i2 < str.length; i2++) {\n        var uChar = str.charCodeAt(i2);\n        if (32 <= uChar && uChar <= 126) {\n          if (inBase64) {\n            if (base64AccumIdx > 0) {\n              bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString(\"base64\").replace(/\\//g, \",\").replace(/=+$/, \"\"), bufIdx);\n              base64AccumIdx = 0;\n            }\n            buf[bufIdx++] = minusChar;\n            inBase64 = false;\n          }\n          if (!inBase64) {\n            buf[bufIdx++] = uChar;\n            if (uChar === andChar)\n              buf[bufIdx++] = minusChar;\n          }\n        } else {\n          if (!inBase64) {\n            buf[bufIdx++] = andChar;\n            inBase64 = true;\n          }\n          if (inBase64) {\n            base64Accum[base64AccumIdx++] = uChar >> 8;\n            base64Accum[base64AccumIdx++] = uChar & 255;\n            if (base64AccumIdx == base64Accum.length) {\n              bufIdx += buf.write(base64Accum.toString(\"base64\").replace(/\\//g, \",\"), bufIdx);\n              base64AccumIdx = 0;\n            }\n          }\n        }\n      }\n      this.inBase64 = inBase64;\n      this.base64AccumIdx = base64AccumIdx;\n      return buf.slice(0, bufIdx);\n    };\n    Utf7IMAPEncoder.prototype.end = function() {\n      var buf = Buffer2.alloc(10), bufIdx = 0;\n      if (this.inBase64) {\n        if (this.base64AccumIdx > 0) {\n          bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString(\"base64\").replace(/\\//g, \",\").replace(/=+$/, \"\"), bufIdx);\n          this.base64AccumIdx = 0;\n        }\n        buf[bufIdx++] = minusChar;\n        this.inBase64 = false;\n      }\n      return buf.slice(0, bufIdx);\n    };\n    function Utf7IMAPDecoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n    }\n    var base64IMAPChars = base64Chars.slice();\n    base64IMAPChars[\",\".charCodeAt(0)] = true;\n    Utf7IMAPDecoder.prototype.write = function(buf) {\n      var res = \"\", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;\n      for (var i2 = 0; i2 < buf.length; i2++) {\n        if (!inBase64) {\n          if (buf[i2] == andChar) {\n            res += this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n            lastI = i2 + 1;\n            inBase64 = true;\n          }\n        } else {\n          if (!base64IMAPChars[buf[i2]]) {\n            if (i2 == lastI && buf[i2] == minusChar) {\n              res += \"&\";\n            } else {\n              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), \"ascii\").replace(/,/g, \"/\");\n              res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n            }\n            if (buf[i2] != minusChar)\n              i2--;\n            lastI = i2 + 1;\n            inBase64 = false;\n            base64Accum = \"\";\n          }\n        }\n      }\n      if (!inBase64) {\n        res += this.iconv.decode(buf.slice(lastI), \"ascii\");\n      } else {\n        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), \"ascii\").replace(/,/g, \"/\");\n        var canBeDecoded = b64str.length - b64str.length % 8;\n        base64Accum = b64str.slice(canBeDecoded);\n        b64str = b64str.slice(0, canBeDecoded);\n        res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n      }\n      this.inBase64 = inBase64;\n      this.base64Accum = base64Accum;\n      return res;\n    };\n    Utf7IMAPDecoder.prototype.end = function() {\n      var res = \"\";\n      if (this.inBase64 && this.base64Accum.length > 0)\n        res = this.iconv.decode(Buffer2.from(this.base64Accum, \"base64\"), \"utf16-be\");\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n      return res;\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-codec.js\nvar require_sbcs_codec = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-codec.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._sbcs = SBCSCodec;\n    function SBCSCodec(codecOptions, iconv) {\n      if (!codecOptions)\n        throw new Error(\"SBCS codec is called without the data.\");\n      if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)\n        throw new Error(\"Encoding '\" + codecOptions.type + \"' has incorrect 'chars' (must be of len 128 or 256)\");\n      if (codecOptions.chars.length === 128) {\n        var asciiString = \"\";\n        for (var i = 0; i < 128; i++)\n          asciiString += String.fromCharCode(i);\n        codecOptions.chars = asciiString + codecOptions.chars;\n      }\n      this.decodeBuf = Buffer2.from(codecOptions.chars, \"ucs2\");\n      var encodeBuf = Buffer2.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));\n      for (var i = 0; i < codecOptions.chars.length; i++)\n        encodeBuf[codecOptions.chars.charCodeAt(i)] = i;\n      this.encodeBuf = encodeBuf;\n    }\n    SBCSCodec.prototype.encoder = SBCSEncoder;\n    SBCSCodec.prototype.decoder = SBCSDecoder;\n    function SBCSEncoder(options, codec) {\n      this.encodeBuf = codec.encodeBuf;\n    }\n    SBCSEncoder.prototype.write = function(str) {\n      var buf = Buffer2.alloc(str.length);\n      for (var i = 0; i < str.length; i++)\n        buf[i] = this.encodeBuf[str.charCodeAt(i)];\n      return buf;\n    };\n    SBCSEncoder.prototype.end = function() {\n    };\n    function SBCSDecoder(options, codec) {\n      this.decodeBuf = codec.decodeBuf;\n    }\n    SBCSDecoder.prototype.write = function(buf) {\n      var decodeBuf = this.decodeBuf;\n      var newBuf = Buffer2.alloc(buf.length * 2);\n      var idx1 = 0, idx2 = 0;\n      for (var i = 0; i < buf.length; i++) {\n        idx1 = buf[i] * 2;\n        idx2 = i * 2;\n        newBuf[idx2] = decodeBuf[idx1];\n        newBuf[idx2 + 1] = decodeBuf[idx1 + 1];\n      }\n      return newBuf.toString(\"ucs2\");\n    };\n    SBCSDecoder.prototype.end = function() {\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-data.js\nvar require_sbcs_data = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-data.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      // Not supported by iconv, not sure why.\n      \"10029\": \"maccenteuro\",\n      \"maccenteuro\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"808\": \"cp808\",\n      \"ibm808\": \"cp808\",\n      \"cp808\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"mik\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp720\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      // Aliases of generated encodings.\n      \"ascii8bit\": \"ascii\",\n      \"usascii\": \"ascii\",\n      \"ansix34\": \"ascii\",\n      \"ansix341968\": \"ascii\",\n      \"ansix341986\": \"ascii\",\n      \"csascii\": \"ascii\",\n      \"cp367\": \"ascii\",\n      \"ibm367\": \"ascii\",\n      \"isoir6\": \"ascii\",\n      \"iso646us\": \"ascii\",\n      \"iso646irv\": \"ascii\",\n      \"us\": \"ascii\",\n      \"latin1\": \"iso88591\",\n      \"latin2\": \"iso88592\",\n      \"latin3\": \"iso88593\",\n      \"latin4\": \"iso88594\",\n      \"latin5\": \"iso88599\",\n      \"latin6\": \"iso885910\",\n      \"latin7\": \"iso885913\",\n      \"latin8\": \"iso885914\",\n      \"latin9\": \"iso885915\",\n      \"latin10\": \"iso885916\",\n      \"csisolatin1\": \"iso88591\",\n      \"csisolatin2\": \"iso88592\",\n      \"csisolatin3\": \"iso88593\",\n      \"csisolatin4\": \"iso88594\",\n      \"csisolatincyrillic\": \"iso88595\",\n      \"csisolatinarabic\": \"iso88596\",\n      \"csisolatingreek\": \"iso88597\",\n      \"csisolatinhebrew\": \"iso88598\",\n      \"csisolatin5\": \"iso88599\",\n      \"csisolatin6\": \"iso885910\",\n      \"l1\": \"iso88591\",\n      \"l2\": \"iso88592\",\n      \"l3\": \"iso88593\",\n      \"l4\": \"iso88594\",\n      \"l5\": \"iso88599\",\n      \"l6\": \"iso885910\",\n      \"l7\": \"iso885913\",\n      \"l8\": \"iso885914\",\n      \"l9\": \"iso885915\",\n      \"l10\": \"iso885916\",\n      \"isoir14\": \"iso646jp\",\n      \"isoir57\": \"iso646cn\",\n      \"isoir100\": \"iso88591\",\n      \"isoir101\": \"iso88592\",\n      \"isoir109\": \"iso88593\",\n      \"isoir110\": \"iso88594\",\n      \"isoir144\": \"iso88595\",\n      \"isoir127\": \"iso88596\",\n      \"isoir126\": \"iso88597\",\n      \"isoir138\": \"iso88598\",\n      \"isoir148\": \"iso88599\",\n      \"isoir157\": \"iso885910\",\n      \"isoir166\": \"tis620\",\n      \"isoir179\": \"iso885913\",\n      \"isoir199\": \"iso885914\",\n      \"isoir203\": \"iso885915\",\n      \"isoir226\": \"iso885916\",\n      \"cp819\": \"iso88591\",\n      \"ibm819\": \"iso88591\",\n      \"cyrillic\": \"iso88595\",\n      \"arabic\": \"iso88596\",\n      \"arabic8\": \"iso88596\",\n      \"ecma114\": \"iso88596\",\n      \"asmo708\": \"iso88596\",\n      \"greek\": \"iso88597\",\n      \"greek8\": \"iso88597\",\n      \"ecma118\": \"iso88597\",\n      \"elot928\": \"iso88597\",\n      \"hebrew\": \"iso88598\",\n      \"hebrew8\": \"iso88598\",\n      \"turkish\": \"iso88599\",\n      \"turkish8\": \"iso88599\",\n      \"thai\": \"iso885911\",\n      \"thai8\": \"iso885911\",\n      \"celtic\": \"iso885914\",\n      \"celtic8\": \"iso885914\",\n      \"isoceltic\": \"iso885914\",\n      \"tis6200\": \"tis620\",\n      \"tis62025291\": \"tis620\",\n      \"tis62025330\": \"tis620\",\n      \"10000\": \"macroman\",\n      \"10006\": \"macgreek\",\n      \"10007\": \"maccyrillic\",\n      \"10079\": \"maciceland\",\n      \"10081\": \"macturkish\",\n      \"cspc8codepage437\": \"cp437\",\n      \"cspc775baltic\": \"cp775\",\n      \"cspc850multilingual\": \"cp850\",\n      \"cspcp852\": \"cp852\",\n      \"cspc862latinhebrew\": \"cp862\",\n      \"cpgr\": \"cp869\",\n      \"msee\": \"cp1250\",\n      \"mscyrl\": \"cp1251\",\n      \"msansi\": \"cp1252\",\n      \"msgreek\": \"cp1253\",\n      \"msturk\": \"cp1254\",\n      \"mshebr\": \"cp1255\",\n      \"msarab\": \"cp1256\",\n      \"winbaltrim\": \"cp1257\",\n      \"cp20866\": \"koi8r\",\n      \"20866\": \"koi8r\",\n      \"ibm878\": \"koi8r\",\n      \"cskoi8r\": \"koi8r\",\n      \"cp21866\": \"koi8u\",\n      \"21866\": \"koi8u\",\n      \"ibm1168\": \"koi8u\",\n      \"strk10482002\": \"rk1048\",\n      \"tcvn5712\": \"tcvn\",\n      \"tcvn57121\": \"tcvn\",\n      \"gb198880\": \"iso646cn\",\n      \"cn\": \"iso646cn\",\n      \"csiso14jisc6220ro\": \"iso646jp\",\n      \"jisc62201969ro\": \"iso646jp\",\n      \"jp\": \"iso646jp\",\n      \"cshproman8\": \"hproman8\",\n      \"r8\": \"hproman8\",\n      \"roman8\": \"hproman8\",\n      \"xroman8\": \"hproman8\",\n      \"ibm1051\": \"hproman8\",\n      \"mac\": \"macintosh\",\n      \"csmacintosh\": \"macintosh\"\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-data-generated.js\nvar require_sbcs_data_generated = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/sbcs-data-generated.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      \"437\": \"cp437\",\n      \"737\": \"cp737\",\n      \"775\": \"cp775\",\n      \"850\": \"cp850\",\n      \"852\": \"cp852\",\n      \"855\": \"cp855\",\n      \"856\": \"cp856\",\n      \"857\": \"cp857\",\n      \"858\": \"cp858\",\n      \"860\": \"cp860\",\n      \"861\": \"cp861\",\n      \"862\": \"cp862\",\n      \"863\": \"cp863\",\n      \"864\": \"cp864\",\n      \"865\": \"cp865\",\n      \"866\": \"cp866\",\n      \"869\": \"cp869\",\n      \"874\": \"windows874\",\n      \"922\": \"cp922\",\n      \"1046\": \"cp1046\",\n      \"1124\": \"cp1124\",\n      \"1125\": \"cp1125\",\n      \"1129\": \"cp1129\",\n      \"1133\": \"cp1133\",\n      \"1161\": \"cp1161\",\n      \"1162\": \"cp1162\",\n      \"1163\": \"cp1163\",\n      \"1250\": \"windows1250\",\n      \"1251\": \"windows1251\",\n      \"1252\": \"windows1252\",\n      \"1253\": \"windows1253\",\n      \"1254\": \"windows1254\",\n      \"1255\": \"windows1255\",\n      \"1256\": \"windows1256\",\n      \"1257\": \"windows1257\",\n      \"1258\": \"windows1258\",\n      \"28591\": \"iso88591\",\n      \"28592\": \"iso88592\",\n      \"28593\": \"iso88593\",\n      \"28594\": \"iso88594\",\n      \"28595\": \"iso88595\",\n      \"28596\": \"iso88596\",\n      \"28597\": \"iso88597\",\n      \"28598\": \"iso88598\",\n      \"28599\": \"iso88599\",\n      \"28600\": \"iso885910\",\n      \"28601\": \"iso885911\",\n      \"28603\": \"iso885913\",\n      \"28604\": \"iso885914\",\n      \"28605\": \"iso885915\",\n      \"28606\": \"iso885916\",\n      \"windows874\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win874\": \"windows874\",\n      \"cp874\": \"windows874\",\n      \"windows1250\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1250\": \"windows1250\",\n      \"cp1250\": \"windows1250\",\n      \"windows1251\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1251\": \"windows1251\",\n      \"cp1251\": \"windows1251\",\n      \"windows1252\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1252\": \"windows1252\",\n      \"cp1252\": \"windows1252\",\n      \"windows1253\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1253\": \"windows1253\",\n      \"cp1253\": \"windows1253\",\n      \"windows1254\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1254\": \"windows1254\",\n      \"cp1254\": \"windows1254\",\n      \"windows1255\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1255\": \"windows1255\",\n      \"cp1255\": \"windows1255\",\n      \"windows1256\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1256\": \"windows1256\",\n      \"cp1256\": \"windows1256\",\n      \"windows1257\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1257\": \"windows1257\",\n      \"cp1257\": \"windows1257\",\n      \"windows1258\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1258\": \"windows1258\",\n      \"cp1258\": \"windows1258\",\n      \"iso88591\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28591\": \"iso88591\",\n      \"iso88592\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28592\": \"iso88592\",\n      \"iso88593\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28593\": \"iso88593\",\n      \"iso88594\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28594\": \"iso88594\",\n      \"iso88595\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28595\": \"iso88595\",\n      \"iso88596\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28596\": \"iso88596\",\n      \"iso88597\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28597\": \"iso88597\",\n      \"iso88598\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28598\": \"iso88598\",\n      \"iso88599\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28599\": \"iso88599\",\n      \"iso885910\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28600\": \"iso885910\",\n      \"iso885911\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28601\": \"iso885911\",\n      \"iso885913\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28603\": \"iso885913\",\n      \"iso885914\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28604\": \"iso885914\",\n      \"iso885915\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28605\": \"iso885915\",\n      \"iso885916\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28606\": \"iso885916\",\n      \"cp437\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm437\": \"cp437\",\n      \"csibm437\": \"cp437\",\n      \"cp737\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm737\": \"cp737\",\n      \"csibm737\": \"cp737\",\n      \"cp775\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm775\": \"cp775\",\n      \"csibm775\": \"cp775\",\n      \"cp850\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm850\": \"cp850\",\n      \"csibm850\": \"cp850\",\n      \"cp852\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm852\": \"cp852\",\n      \"csibm852\": \"cp852\",\n      \"cp855\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm855\": \"cp855\",\n      \"csibm855\": \"cp855\",\n      \"cp856\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm856\": \"cp856\",\n      \"csibm856\": \"cp856\",\n      \"cp857\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm857\": \"cp857\",\n      \"csibm857\": \"cp857\",\n      \"cp858\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm858\": \"cp858\",\n      \"csibm858\": \"cp858\",\n      \"cp860\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm860\": \"cp860\",\n      \"csibm860\": \"cp860\",\n      \"cp861\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm861\": \"cp861\",\n      \"csibm861\": \"cp861\",\n      \"cp862\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm862\": \"cp862\",\n      \"csibm862\": \"cp862\",\n      \"cp863\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm863\": \"cp863\",\n      \"csibm863\": \"cp863\",\n      \"cp864\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$\\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\"\n      },\n      \"ibm864\": \"cp864\",\n      \"csibm864\": \"cp864\",\n      \"cp865\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm865\": \"cp865\",\n      \"csibm865\": \"cp865\",\n      \"cp866\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm866\": \"cp866\",\n      \"csibm866\": \"cp866\",\n      \"cp869\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm869\": \"cp869\",\n      \"csibm869\": \"cp869\",\n      \"cp922\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm922\": \"cp922\",\n      \"csibm922\": \"cp922\",\n      \"cp1046\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1046\": \"cp1046\",\n      \"csibm1046\": \"cp1046\",\n      \"cp1124\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1124\": \"cp1124\",\n      \"csibm1124\": \"cp1124\",\n      \"cp1125\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1125\": \"cp1125\",\n      \"csibm1125\": \"cp1125\",\n      \"cp1129\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1129\": \"cp1129\",\n      \"csibm1129\": \"cp1129\",\n      \"cp1133\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1133\": \"cp1133\",\n      \"csibm1133\": \"cp1133\",\n      \"cp1161\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1161\": \"cp1161\",\n      \"csibm1161\": \"cp1161\",\n      \"cp1162\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1162\": \"cp1162\",\n      \"csibm1162\": \"cp1162\",\n      \"cp1163\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1163\": \"cp1163\",\n      \"csibm1163\": \"cp1163\",\n      \"maccroatian\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"maccyrillic\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macgreek\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"maciceland\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macroman\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macromania\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macthai\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macturkish\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macukraine\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8r\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8u\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8ru\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8t\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"armscii8\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"rk1048\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"tcvn\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\\xDA\\u1EE4\u0003\\u1EEA\\u1EEC\\u1EEE\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\\u1EE8\\u1EF0\\u1EF2\\u1EF6\\u1EF8\\xDD\\u1EF4\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"georgianacademy\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"georgianps\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"pt154\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"viscii\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\\u1EB2\u0003\u0004\\u1EB4\\u1EAA\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\\u1EF6\u0015\u0016\u0017\u0018\\u1EF8\u001A\\x1B\u001C\u001D\\u1EF4\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"iso646cn\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#\\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\"\n      },\n      \"iso646jp\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"hproman8\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macintosh\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ascii\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"tis620\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      }\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/dbcs-codec.js\nvar require_dbcs_codec = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/dbcs-codec.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._dbcs = DBCSCodec;\n    var UNASSIGNED = -1;\n    var GB18030_CODE = -2;\n    var SEQ_START = -10;\n    var NODE_START = -1e3;\n    var UNASSIGNED_NODE = new Array(256);\n    var DEF_CHAR = -1;\n    for (i = 0; i < 256; i++)\n      UNASSIGNED_NODE[i] = UNASSIGNED;\n    var i;\n    function DBCSCodec(codecOptions, iconv) {\n      this.encodingName = codecOptions.encodingName;\n      if (!codecOptions)\n        throw new Error(\"DBCS codec is called without the data.\");\n      if (!codecOptions.table)\n        throw new Error(\"Encoding '\" + this.encodingName + \"' has no data.\");\n      var mappingTable = codecOptions.table();\n      this.decodeTables = [];\n      this.decodeTables[0] = UNASSIGNED_NODE.slice(0);\n      this.decodeTableSeq = [];\n      for (var i2 = 0; i2 < mappingTable.length; i2++)\n        this._addDecodeChunk(mappingTable[i2]);\n      if (typeof codecOptions.gb18030 === \"function\") {\n        this.gb18030 = codecOptions.gb18030();\n        var commonThirdByteNodeIdx = this.decodeTables.length;\n        this.decodeTables.push(UNASSIGNED_NODE.slice(0));\n        var commonFourthByteNodeIdx = this.decodeTables.length;\n        this.decodeTables.push(UNASSIGNED_NODE.slice(0));\n        var firstByteNode = this.decodeTables[0];\n        for (var i2 = 129; i2 <= 254; i2++) {\n          var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i2]];\n          for (var j = 48; j <= 57; j++) {\n            if (secondByteNode[j] === UNASSIGNED) {\n              secondByteNode[j] = NODE_START - commonThirdByteNodeIdx;\n            } else if (secondByteNode[j] > NODE_START) {\n              throw new Error(\"gb18030 decode tables conflict at byte 2\");\n            }\n            var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]];\n            for (var k = 129; k <= 254; k++) {\n              if (thirdByteNode[k] === UNASSIGNED) {\n                thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx;\n              } else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) {\n                continue;\n              } else if (thirdByteNode[k] > NODE_START) {\n                throw new Error(\"gb18030 decode tables conflict at byte 3\");\n              }\n              var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]];\n              for (var l = 48; l <= 57; l++) {\n                if (fourthByteNode[l] === UNASSIGNED)\n                  fourthByteNode[l] = GB18030_CODE;\n              }\n            }\n          }\n        }\n      }\n      this.defaultCharUnicode = iconv.defaultCharUnicode;\n      this.encodeTable = [];\n      this.encodeTableSeq = [];\n      var skipEncodeChars = {};\n      if (codecOptions.encodeSkipVals)\n        for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) {\n          var val = codecOptions.encodeSkipVals[i2];\n          if (typeof val === \"number\")\n            skipEncodeChars[val] = true;\n          else\n            for (var j = val.from; j <= val.to; j++)\n              skipEncodeChars[j] = true;\n        }\n      this._fillEncodeTable(0, 0, skipEncodeChars);\n      if (codecOptions.encodeAdd) {\n        for (var uChar in codecOptions.encodeAdd)\n          if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar))\n            this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);\n      }\n      this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];\n      if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0][\"?\"];\n      if (this.defCharSB === UNASSIGNED) this.defCharSB = \"?\".charCodeAt(0);\n    }\n    DBCSCodec.prototype.encoder = DBCSEncoder;\n    DBCSCodec.prototype.decoder = DBCSDecoder;\n    DBCSCodec.prototype._getDecodeTrieNode = function(addr) {\n      var bytes = [];\n      for (; addr > 0; addr >>>= 8)\n        bytes.push(addr & 255);\n      if (bytes.length == 0)\n        bytes.push(0);\n      var node = this.decodeTables[0];\n      for (var i2 = bytes.length - 1; i2 > 0; i2--) {\n        var val = node[bytes[i2]];\n        if (val == UNASSIGNED) {\n          node[bytes[i2]] = NODE_START - this.decodeTables.length;\n          this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));\n        } else if (val <= NODE_START) {\n          node = this.decodeTables[NODE_START - val];\n        } else\n          throw new Error(\"Overwrite byte in \" + this.encodingName + \", addr: \" + addr.toString(16));\n      }\n      return node;\n    };\n    DBCSCodec.prototype._addDecodeChunk = function(chunk) {\n      var curAddr = parseInt(chunk[0], 16);\n      var writeTable = this._getDecodeTrieNode(curAddr);\n      curAddr = curAddr & 255;\n      for (var k = 1; k < chunk.length; k++) {\n        var part = chunk[k];\n        if (typeof part === \"string\") {\n          for (var l = 0; l < part.length; ) {\n            var code = part.charCodeAt(l++);\n            if (55296 <= code && code < 56320) {\n              var codeTrail = part.charCodeAt(l++);\n              if (56320 <= codeTrail && codeTrail < 57344)\n                writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);\n              else\n                throw new Error(\"Incorrect surrogate pair in \" + this.encodingName + \" at chunk \" + chunk[0]);\n            } else if (4080 < code && code <= 4095) {\n              var len = 4095 - code + 2;\n              var seq = [];\n              for (var m = 0; m < len; m++)\n                seq.push(part.charCodeAt(l++));\n              writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;\n              this.decodeTableSeq.push(seq);\n            } else\n              writeTable[curAddr++] = code;\n          }\n        } else if (typeof part === \"number\") {\n          var charCode = writeTable[curAddr - 1] + 1;\n          for (var l = 0; l < part; l++)\n            writeTable[curAddr++] = charCode++;\n        } else\n          throw new Error(\"Incorrect type '\" + typeof part + \"' given in \" + this.encodingName + \" at chunk \" + chunk[0]);\n      }\n      if (curAddr > 255)\n        throw new Error(\"Incorrect chunk in \" + this.encodingName + \" at addr \" + chunk[0] + \": too long\" + curAddr);\n    };\n    DBCSCodec.prototype._getEncodeBucket = function(uCode) {\n      var high = uCode >> 8;\n      if (this.encodeTable[high] === void 0)\n        this.encodeTable[high] = UNASSIGNED_NODE.slice(0);\n      return this.encodeTable[high];\n    };\n    DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {\n      var bucket = this._getEncodeBucket(uCode);\n      var low = uCode & 255;\n      if (bucket[low] <= SEQ_START)\n        this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;\n      else if (bucket[low] == UNASSIGNED)\n        bucket[low] = dbcsCode;\n    };\n    DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {\n      var uCode = seq[0];\n      var bucket = this._getEncodeBucket(uCode);\n      var low = uCode & 255;\n      var node;\n      if (bucket[low] <= SEQ_START) {\n        node = this.encodeTableSeq[SEQ_START - bucket[low]];\n      } else {\n        node = {};\n        if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];\n        bucket[low] = SEQ_START - this.encodeTableSeq.length;\n        this.encodeTableSeq.push(node);\n      }\n      for (var j = 1; j < seq.length - 1; j++) {\n        var oldVal = node[uCode];\n        if (typeof oldVal === \"object\")\n          node = oldVal;\n        else {\n          node = node[uCode] = {};\n          if (oldVal !== void 0)\n            node[DEF_CHAR] = oldVal;\n        }\n      }\n      uCode = seq[seq.length - 1];\n      node[uCode] = dbcsCode;\n    };\n    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {\n      var node = this.decodeTables[nodeIdx];\n      var hasValues = false;\n      var subNodeEmpty = {};\n      for (var i2 = 0; i2 < 256; i2++) {\n        var uCode = node[i2];\n        var mbCode = prefix + i2;\n        if (skipEncodeChars[mbCode])\n          continue;\n        if (uCode >= 0) {\n          this._setEncodeChar(uCode, mbCode);\n          hasValues = true;\n        } else if (uCode <= NODE_START) {\n          var subNodeIdx = NODE_START - uCode;\n          if (!subNodeEmpty[subNodeIdx]) {\n            var newPrefix = mbCode << 8 >>> 0;\n            if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars))\n              hasValues = true;\n            else\n              subNodeEmpty[subNodeIdx] = true;\n          }\n        } else if (uCode <= SEQ_START) {\n          this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);\n          hasValues = true;\n        }\n      }\n      return hasValues;\n    };\n    function DBCSEncoder(options, codec) {\n      this.leadSurrogate = -1;\n      this.seqObj = void 0;\n      this.encodeTable = codec.encodeTable;\n      this.encodeTableSeq = codec.encodeTableSeq;\n      this.defaultCharSingleByte = codec.defCharSB;\n      this.gb18030 = codec.gb18030;\n    }\n    DBCSEncoder.prototype.write = function(str) {\n      var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0;\n      while (true) {\n        if (nextChar === -1) {\n          if (i2 == str.length) break;\n          var uCode = str.charCodeAt(i2++);\n        } else {\n          var uCode = nextChar;\n          nextChar = -1;\n        }\n        if (55296 <= uCode && uCode < 57344) {\n          if (uCode < 56320) {\n            if (leadSurrogate === -1) {\n              leadSurrogate = uCode;\n              continue;\n            } else {\n              leadSurrogate = uCode;\n              uCode = UNASSIGNED;\n            }\n          } else {\n            if (leadSurrogate !== -1) {\n              uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);\n              leadSurrogate = -1;\n            } else {\n              uCode = UNASSIGNED;\n            }\n          }\n        } else if (leadSurrogate !== -1) {\n          nextChar = uCode;\n          uCode = UNASSIGNED;\n          leadSurrogate = -1;\n        }\n        var dbcsCode = UNASSIGNED;\n        if (seqObj !== void 0 && uCode != UNASSIGNED) {\n          var resCode = seqObj[uCode];\n          if (typeof resCode === \"object\") {\n            seqObj = resCode;\n            continue;\n          } else if (typeof resCode == \"number\") {\n            dbcsCode = resCode;\n          } else if (resCode == void 0) {\n            resCode = seqObj[DEF_CHAR];\n            if (resCode !== void 0) {\n              dbcsCode = resCode;\n              nextChar = uCode;\n            } else {\n            }\n          }\n          seqObj = void 0;\n        } else if (uCode >= 0) {\n          var subtable = this.encodeTable[uCode >> 8];\n          if (subtable !== void 0)\n            dbcsCode = subtable[uCode & 255];\n          if (dbcsCode <= SEQ_START) {\n            seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];\n            continue;\n          }\n          if (dbcsCode == UNASSIGNED && this.gb18030) {\n            var idx = findIdx(this.gb18030.uChars, uCode);\n            if (idx != -1) {\n              var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);\n              newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);\n              dbcsCode = dbcsCode % 12600;\n              newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);\n              dbcsCode = dbcsCode % 1260;\n              newBuf[j++] = 129 + Math.floor(dbcsCode / 10);\n              dbcsCode = dbcsCode % 10;\n              newBuf[j++] = 48 + dbcsCode;\n              continue;\n            }\n          }\n        }\n        if (dbcsCode === UNASSIGNED)\n          dbcsCode = this.defaultCharSingleByte;\n        if (dbcsCode < 256) {\n          newBuf[j++] = dbcsCode;\n        } else if (dbcsCode < 65536) {\n          newBuf[j++] = dbcsCode >> 8;\n          newBuf[j++] = dbcsCode & 255;\n        } else if (dbcsCode < 16777216) {\n          newBuf[j++] = dbcsCode >> 16;\n          newBuf[j++] = dbcsCode >> 8 & 255;\n          newBuf[j++] = dbcsCode & 255;\n        } else {\n          newBuf[j++] = dbcsCode >>> 24;\n          newBuf[j++] = dbcsCode >>> 16 & 255;\n          newBuf[j++] = dbcsCode >>> 8 & 255;\n          newBuf[j++] = dbcsCode & 255;\n        }\n      }\n      this.seqObj = seqObj;\n      this.leadSurrogate = leadSurrogate;\n      return newBuf.slice(0, j);\n    };\n    DBCSEncoder.prototype.end = function() {\n      if (this.leadSurrogate === -1 && this.seqObj === void 0)\n        return;\n      var newBuf = Buffer2.alloc(10), j = 0;\n      if (this.seqObj) {\n        var dbcsCode = this.seqObj[DEF_CHAR];\n        if (dbcsCode !== void 0) {\n          if (dbcsCode < 256) {\n            newBuf[j++] = dbcsCode;\n          } else {\n            newBuf[j++] = dbcsCode >> 8;\n            newBuf[j++] = dbcsCode & 255;\n          }\n        } else {\n        }\n        this.seqObj = void 0;\n      }\n      if (this.leadSurrogate !== -1) {\n        newBuf[j++] = this.defaultCharSingleByte;\n        this.leadSurrogate = -1;\n      }\n      return newBuf.slice(0, j);\n    };\n    DBCSEncoder.prototype.findIdx = findIdx;\n    function DBCSDecoder(options, codec) {\n      this.nodeIdx = 0;\n      this.prevBytes = [];\n      this.decodeTables = codec.decodeTables;\n      this.decodeTableSeq = codec.decodeTableSeq;\n      this.defaultCharUnicode = codec.defaultCharUnicode;\n      this.gb18030 = codec.gb18030;\n    }\n    DBCSDecoder.prototype.write = function(buf) {\n      var newBuf = Buffer2.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, uCode;\n      for (var i2 = 0, j = 0; i2 < buf.length; i2++) {\n        var curByte = i2 >= 0 ? buf[i2] : prevBytes[i2 + prevOffset];\n        var uCode = this.decodeTables[nodeIdx][curByte];\n        if (uCode >= 0) {\n        } else if (uCode === UNASSIGNED) {\n          uCode = this.defaultCharUnicode.charCodeAt(0);\n          i2 = seqStart;\n        } else if (uCode === GB18030_CODE) {\n          if (i2 >= 3) {\n            var ptr = (buf[i2 - 3] - 129) * 12600 + (buf[i2 - 2] - 48) * 1260 + (buf[i2 - 1] - 129) * 10 + (curByte - 48);\n          } else {\n            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);\n          }\n          var idx = findIdx(this.gb18030.gbChars, ptr);\n          uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];\n        } else if (uCode <= NODE_START) {\n          nodeIdx = NODE_START - uCode;\n          continue;\n        } else if (uCode <= SEQ_START) {\n          var seq = this.decodeTableSeq[SEQ_START - uCode];\n          for (var k = 0; k < seq.length - 1; k++) {\n            uCode = seq[k];\n            newBuf[j++] = uCode & 255;\n            newBuf[j++] = uCode >> 8;\n          }\n          uCode = seq[seq.length - 1];\n        } else\n          throw new Error(\"iconv-lite internal error: invalid decoding table value \" + uCode + \" at \" + nodeIdx + \"/\" + curByte);\n        if (uCode >= 65536) {\n          uCode -= 65536;\n          var uCodeLead = 55296 | uCode >> 10;\n          newBuf[j++] = uCodeLead & 255;\n          newBuf[j++] = uCodeLead >> 8;\n          uCode = 56320 | uCode & 1023;\n        }\n        newBuf[j++] = uCode & 255;\n        newBuf[j++] = uCode >> 8;\n        nodeIdx = 0;\n        seqStart = i2 + 1;\n      }\n      this.nodeIdx = nodeIdx;\n      this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf));\n      return newBuf.slice(0, j).toString(\"ucs2\");\n    };\n    DBCSDecoder.prototype.end = function() {\n      var ret = \"\";\n      while (this.prevBytes.length > 0) {\n        ret += this.defaultCharUnicode;\n        var bytesArr = this.prevBytes.slice(1);\n        this.prevBytes = [];\n        this.nodeIdx = 0;\n        if (bytesArr.length > 0)\n          ret += this.write(bytesArr);\n      }\n      this.prevBytes = [];\n      this.nodeIdx = 0;\n      return ret;\n    };\n    function findIdx(table, val) {\n      if (table[0] > val)\n        return -1;\n      var l = 0, r = table.length;\n      while (l < r - 1) {\n        var mid = l + (r - l + 1 >> 1);\n        if (table[mid] <= val)\n          l = mid;\n        else\n          r = mid;\n      }\n      return l;\n    }\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/shiftjis.json\nvar require_shiftjis = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/shiftjis.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 128],\n      [\"a1\", \"\\uFF61\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"81b8\", \"\\u2208\\u220B\\u2286\\u2287\\u2282\\u2283\\u222A\\u2229\"],\n      [\"81c8\", \"\\u2227\\u2228\\uFFE2\\u21D2\\u21D4\\u2200\\u2203\"],\n      [\"81da\", \"\\u2220\\u22A5\\u2312\\u2202\\u2207\\u2261\\u2252\\u226A\\u226B\\u221A\\u223D\\u221D\\u2235\\u222B\\u222C\"],\n      [\"81f0\", \"\\u212B\\u2030\\u266F\\u266D\\u266A\\u2020\\u2021\\xB6\"],\n      [\"81fc\", \"\\u25EF\"],\n      [\"824f\", \"\\uFF10\", 9],\n      [\"8260\", \"\\uFF21\", 25],\n      [\"8281\", \"\\uFF41\", 25],\n      [\"829f\", \"\\u3041\", 82],\n      [\"8340\", \"\\u30A1\", 62],\n      [\"8380\", \"\\u30E0\", 22],\n      [\"839f\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"83bf\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"8440\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"8470\", \"\\u0430\", 5, \"\\u0451\\u0436\", 7],\n      [\"8480\", \"\\u043E\", 17],\n      [\"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\"],\n      [\"8740\", \"\\u2460\", 19, \"\\u2160\", 9],\n      [\"875f\", \"\\u3349\\u3314\\u3322\\u334D\\u3318\\u3327\\u3303\\u3336\\u3351\\u3357\\u330D\\u3326\\u3323\\u332B\\u334A\\u333B\\u339C\\u339D\\u339E\\u338E\\u338F\\u33C4\\u33A1\"],\n      [\"877e\", \"\\u337B\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"eeef\", \"\\u2170\", 9, \"\\uFFE2\\uFFE4\\uFF07\\uFF02\"],\n      [\"f040\", \"\\uE000\", 62],\n      [\"f080\", \"\\uE03F\", 124],\n      [\"f140\", \"\\uE0BC\", 62],\n      [\"f180\", \"\\uE0FB\", 124],\n      [\"f240\", \"\\uE178\", 62],\n      [\"f280\", \"\\uE1B7\", 124],\n      [\"f340\", \"\\uE234\", 62],\n      [\"f380\", \"\\uE273\", 124],\n      [\"f440\", \"\\uE2F0\", 62],\n      [\"f480\", \"\\uE32F\", 124],\n      [\"f540\", \"\\uE3AC\", 62],\n      [\"f580\", \"\\uE3EB\", 124],\n      [\"f640\", \"\\uE468\", 62],\n      [\"f680\", \"\\uE4A7\", 124],\n      [\"f740\", \"\\uE524\", 62],\n      [\"f780\", \"\\uE563\", 124],\n      [\"f840\", \"\\uE5E0\", 62],\n      [\"f880\", \"\\uE61F\", 124],\n      [\"f940\", \"\\uE69C\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"fc40\", \"\\u9ADC\\u9B75\\u9B72\\u9B8F\\u9BB1\\u9BBB\\u9C00\\u9D70\\u9D6B\\uFA2D\\u9E19\\u9ED1\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/eucjp.json\nvar require_eucjp = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/eucjp.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"8ea1\", \"\\uFF61\", 62],\n      [\"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\"],\n      [\"a2a1\", \"\\u25C6\\u25A1\\u25A0\\u25B3\\u25B2\\u25BD\\u25BC\\u203B\\u3012\\u2192\\u2190\\u2191\\u2193\\u3013\"],\n      [\"a2ba\", \"\\u2208\\u220B\\u2286\\u2287\\u2282\\u2283\\u222A\\u2229\"],\n      [\"a2ca\", \"\\u2227\\u2228\\uFFE2\\u21D2\\u21D4\\u2200\\u2203\"],\n      [\"a2dc\", \"\\u2220\\u22A5\\u2312\\u2202\\u2207\\u2261\\u2252\\u226A\\u226B\\u221A\\u223D\\u221D\\u2235\\u222B\\u222C\"],\n      [\"a2f2\", \"\\u212B\\u2030\\u266F\\u266D\\u266A\\u2020\\u2021\\xB6\"],\n      [\"a2fe\", \"\\u25EF\"],\n      [\"a3b0\", \"\\uFF10\", 9],\n      [\"a3c1\", \"\\uFF21\", 25],\n      [\"a3e1\", \"\\uFF41\", 25],\n      [\"a4a1\", \"\\u3041\", 82],\n      [\"a5a1\", \"\\u30A1\", 85],\n      [\"a6a1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a6c1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a7a1\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"a7d1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"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\"],\n      [\"ada1\", \"\\u2460\", 19, \"\\u2160\", 9],\n      [\"adc0\", \"\\u3349\\u3314\\u3322\\u334D\\u3318\\u3327\\u3303\\u3336\\u3351\\u3357\\u330D\\u3326\\u3323\\u332B\\u334A\\u333B\\u339C\\u339D\\u339E\\u338E\\u338F\\u33C4\\u33A1\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"f4a1\", \"\\u582F\\u69C7\\u9059\\u7464\\u51DC\\u7199\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"fcf1\", \"\\u2170\", 9, \"\\uFFE2\\uFFE4\\uFF07\\uFF02\"],\n      [\"8fa2af\", \"\\u02D8\\u02C7\\xB8\\u02D9\\u02DD\\xAF\\u02DB\\u02DA\\uFF5E\\u0384\\u0385\"],\n      [\"8fa2c2\", \"\\xA1\\xA6\\xBF\"],\n      [\"8fa2eb\", \"\\xBA\\xAA\\xA9\\xAE\\u2122\\xA4\\u2116\"],\n      [\"8fa6e1\", \"\\u0386\\u0388\\u0389\\u038A\\u03AA\"],\n      [\"8fa6e7\", \"\\u038C\"],\n      [\"8fa6e9\", \"\\u038E\\u03AB\"],\n      [\"8fa6ec\", \"\\u038F\"],\n      [\"8fa6f1\", \"\\u03AC\\u03AD\\u03AE\\u03AF\\u03CA\\u0390\\u03CC\\u03C2\\u03CD\\u03CB\\u03B0\\u03CE\"],\n      [\"8fa7c2\", \"\\u0402\", 10, \"\\u040E\\u040F\"],\n      [\"8fa7f2\", \"\\u0452\", 10, \"\\u045E\\u045F\"],\n      [\"8fa9a1\", \"\\xC6\\u0110\"],\n      [\"8fa9a4\", \"\\u0126\"],\n      [\"8fa9a6\", \"\\u0132\"],\n      [\"8fa9a8\", \"\\u0141\\u013F\"],\n      [\"8fa9ab\", \"\\u014A\\xD8\\u0152\"],\n      [\"8fa9af\", \"\\u0166\\xDE\"],\n      [\"8fa9c1\", \"\\xE6\\u0111\\xF0\\u0127\\u0131\\u0133\\u0138\\u0142\\u0140\\u0149\\u014B\\xF8\\u0153\\xDF\\u0167\\xFE\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8fabbd\", \"\\u0121\\u0125\\xED\\xEC\\xEF\\xEE\\u01D0\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp936.json\nvar require_cp936 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp936.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127, \"\\u20AC\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"8340\", \"\\u50BD\", 17, \"\\u50D0\", 5, \"\\u50D7\\u50D8\\u50D9\\u50DB\", 10, \"\\u50E8\\u50E9\\u50EA\\u50EB\\u50EF\\u50F0\\u50F1\\u50F2\\u50F4\\u50F6\", 4, \"\\u50FC\", 9, \"\\u5108\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"8b40\", \"\\u5A61\\u5A63\\u5A64\\u5A65\\u5A66\\u5A68\\u5A69\\u5A6B\", 8, \"\\u5A78\\u5A79\\u5A7B\\u5A7C\\u5A7D\\u5A7E\\u5A80\", 17, \"\\u5A93\", 6, \"\\u5A9C\", 13, \"\\u5AAB\\u5AAC\"],\n      [\"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],\n      [\"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\"],\n      [\"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],\n      [\"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],\n      [\"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\"],\n      [\"8e40\", \"\\u5DA1\", 21, \"\\u5DB8\", 12, \"\\u5DC6\", 6, \"\\u5DCE\", 12, \"\\u5DDC\\u5DDF\\u5DE0\\u5DE3\\u5DE4\\u5DEA\\u5DEC\\u5DED\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"9440\", \"\\u64DB\\u64DC\\u64DD\\u64DF\\u64E0\\u64E1\\u64E3\\u64E5\\u64E7\", 24, \"\\u6501\", 7, \"\\u650A\", 7, \"\\u6513\", 4, \"\\u6519\", 8],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"9980\", \"\\u6AA7\\u6AA8\\u6AAA\\u6AAD\", 114, \"\\u6B25\\u6B26\\u6B28\", 6],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"9e40\", \"\\u6FE6\", 7, \"\\u6FF0\", 32, \"\\u7012\", 7, \"\\u701C\", 6, \"\\u7024\", 6],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"a040\", \"\\u71D6\", 9, \"\\u71E1\\u71E2\\u71E3\\u71E4\\u71E6\\u71E8\", 5, \"\\u71EF\", 9, \"\\u71FA\", 11, \"\\u7207\", 19],\n      [\"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\"],\n      [\"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\"],\n      [\"a2a1\", \"\\u2170\", 9],\n      [\"a2b1\", \"\\u2488\", 19, \"\\u2474\", 19, \"\\u2460\", 9],\n      [\"a2e5\", \"\\u3220\", 9],\n      [\"a2f1\", \"\\u2160\", 11],\n      [\"a3a1\", \"\\uFF01\\uFF02\\uFF03\\uFFE5\\uFF05\", 88, \"\\uFFE3\"],\n      [\"a4a1\", \"\\u3041\", 82],\n      [\"a5a1\", \"\\u30A1\", 85],\n      [\"a6a1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a6c1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a6e0\", \"\\uFE35\\uFE36\\uFE39\\uFE3A\\uFE3F\\uFE40\\uFE3D\\uFE3E\\uFE41\\uFE42\\uFE43\\uFE44\"],\n      [\"a6ee\", \"\\uFE3B\\uFE3C\\uFE37\\uFE38\\uFE31\"],\n      [\"a6f4\", \"\\uFE33\\uFE34\"],\n      [\"a7a1\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"a7d1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"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],\n      [\"a880\", \"\\u2588\", 7, \"\\u2593\\u2594\\u2595\\u25BC\\u25BD\\u25E2\\u25E3\\u25E4\\u25E5\\u2609\\u2295\\u3012\\u301D\\u301E\"],\n      [\"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\"],\n      [\"a8bd\", \"\\u0144\\u0148\"],\n      [\"a8c0\", \"\\u0261\"],\n      [\"a8c5\", \"\\u3105\", 36],\n      [\"a940\", \"\\u3021\", 8, \"\\u32A3\\u338E\\u338F\\u339C\\u339D\\u339E\\u33A1\\u33C4\\u33CE\\u33D1\\u33D2\\u33D5\\uFE30\\uFFE2\\uFFE4\"],\n      [\"a959\", \"\\u2121\\u3231\"],\n      [\"a95c\", \"\\u2010\"],\n      [\"a960\", \"\\u30FC\\u309B\\u309C\\u30FD\\u30FE\\u3006\\u309D\\u309E\\uFE49\", 9, \"\\uFE54\\uFE55\\uFE56\\uFE57\\uFE59\", 8],\n      [\"a980\", \"\\uFE62\", 4, \"\\uFE68\\uFE69\\uFE6A\\uFE6B\"],\n      [\"a996\", \"\\u3007\"],\n      [\"a9a4\", \"\\u2500\", 75],\n      [\"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],\n      [\"aa80\", \"\\u7349\\u734A\\u734B\\u734C\\u734E\\u734F\\u7351\\u7353\\u7354\\u7355\\u7356\\u7358\", 7, \"\\u7361\", 10, \"\\u736E\\u7370\\u7371\"],\n      [\"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],\n      [\"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],\n      [\"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],\n      [\"ac80\", \"\\u744E\", 6, \"\\u7456\\u7458\\u745D\\u7460\", 12, \"\\u746E\\u746F\\u7471\", 4, \"\\u7478\\u7479\\u747A\"],\n      [\"ad40\", \"\\u747B\\u747C\\u747D\\u747F\\u7482\\u7484\\u7485\\u7486\\u7488\\u7489\\u748A\\u748C\\u748D\\u748F\\u7491\", 10, \"\\u749D\\u749F\", 7, \"\\u74AA\", 15, \"\\u74BB\", 12],\n      [\"ad80\", \"\\u74C8\", 9, \"\\u74D3\", 8, \"\\u74DD\\u74DF\\u74E1\\u74E5\\u74E7\", 6, \"\\u74F0\\u74F1\\u74F2\"],\n      [\"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\"],\n      [\"ae80\", \"\\u755D\", 7, \"\\u7567\\u7568\\u7569\\u756B\", 6, \"\\u7573\\u7575\\u7576\\u7577\\u757A\", 4, \"\\u7580\\u7581\\u7582\\u7584\\u7585\\u7587\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"b740\", \"\\u7A1D\\u7A1F\\u7A21\\u7A22\\u7A24\", 14, \"\\u7A34\\u7A35\\u7A36\\u7A38\\u7A3A\\u7A3E\\u7A40\", 5, \"\\u7A47\", 9, \"\\u7A52\", 4, \"\\u7A58\", 16],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"bb40\", \"\\u7C43\", 9, \"\\u7C4E\", 36, \"\\u7C75\", 5, \"\\u7C7E\", 9],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"bd40\", \"\\u7D37\", 54, \"\\u7D6F\", 7],\n      [\"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\"],\n      [\"be40\", \"\\u7D99\", 12, \"\\u7DA7\", 6, \"\\u7DAF\", 42],\n      [\"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\"],\n      [\"bf40\", \"\\u7DFB\", 62],\n      [\"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\"],\n      [\"c040\", \"\\u7E5E\", 35, \"\\u7E83\", 23, \"\\u7E9C\\u7E9D\\u7E9E\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"d240\", \"\\u8938\", 8, \"\\u8942\\u8943\\u8945\", 24, \"\\u8960\", 5, \"\\u8967\", 19, \"\\u897C\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"d440\", \"\\u8A1E\", 31, \"\\u8A3F\", 8, \"\\u8A49\", 21],\n      [\"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\"],\n      [\"d540\", \"\\u8A81\", 7, \"\\u8A8B\", 7, \"\\u8A94\", 46],\n      [\"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\"],\n      [\"d640\", \"\\u8AE4\", 34, \"\\u8B08\", 27],\n      [\"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\"],\n      [\"d740\", \"\\u8B46\", 31, \"\\u8B67\", 4, \"\\u8B6D\", 25],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"d940\", \"\\u8CAE\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"dd40\", \"\\u8EE5\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"e240\", \"\\u91E6\", 62],\n      [\"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\"],\n      [\"e340\", \"\\u9246\", 45, \"\\u9275\", 16],\n      [\"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\"],\n      [\"e440\", \"\\u92A8\", 5, \"\\u92AF\", 24, \"\\u92C9\", 31],\n      [\"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\"],\n      [\"e540\", \"\\u930A\", 51, \"\\u933F\", 10],\n      [\"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\"],\n      [\"e640\", \"\\u936C\", 34, \"\\u9390\", 27],\n      [\"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\"],\n      [\"e740\", \"\\u93CE\", 7, \"\\u93D7\", 54],\n      [\"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\"],\n      [\"e840\", \"\\u942F\", 14, \"\\u943F\", 43, \"\\u946C\\u946D\\u946E\\u946F\"],\n      [\"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\"],\n      [\"e940\", \"\\u9527\\u9533\\u953D\\u9543\\u9548\\u954B\\u9555\\u955A\\u9560\\u956E\\u9574\\u9575\\u9577\", 7, \"\\u9580\", 42],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"ed40\", \"\\u979E\\u979F\\u97A1\\u97A2\\u97A4\", 6, \"\\u97AC\\u97AE\\u97B0\\u97B1\\u97B3\\u97B5\", 46],\n      [\"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\"],\n      [\"ee40\", \"\\u980F\", 62],\n      [\"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\"],\n      [\"ef40\", \"\\u986F\", 5, \"\\u988B\\u988E\\u9892\\u9895\\u9899\\u98A3\\u98A8\", 37, \"\\u98CF\\u98D0\\u98D4\\u98D6\\u98D7\\u98DB\\u98DC\\u98DD\\u98E0\", 4],\n      [\"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\"],\n      [\"f040\", \"\\u9908\", 4, \"\\u990E\\u990F\\u9911\", 28, \"\\u992F\", 26],\n      [\"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\"],\n      [\"f140\", \"\\u998C\\u998E\\u999A\", 10, \"\\u99A6\\u99A7\\u99A9\", 47],\n      [\"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\"],\n      [\"f240\", \"\\u99FA\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"f540\", \"\\u9B7C\", 62],\n      [\"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\"],\n      [\"f640\", \"\\u9BDC\", 62],\n      [\"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\"],\n      [\"f740\", \"\\u9C3C\", 62],\n      [\"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\"],\n      [\"f840\", \"\\u9CE3\", 62],\n      [\"f880\", \"\\u9D22\", 32],\n      [\"f940\", \"\\u9D43\", 62],\n      [\"f980\", \"\\u9D82\", 32],\n      [\"fa40\", \"\\u9DA3\", 62],\n      [\"fa80\", \"\\u9DE2\", 32],\n      [\"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\"],\n      [\"fb80\", \"\\u9E81\\u9E83\\u9E84\\u9E85\\u9E86\\u9E89\\u9E8A\\u9E8C\", 5, \"\\u9E94\", 8, \"\\u9E9E\\u9EA0\", 5, \"\\u9EA7\\u9EA8\\u9EA9\\u9EAA\"],\n      [\"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],\n      [\"fc80\", \"\\u9F06\", 4, \"\\u9F0C\\u9F0F\\u9F11\\u9F12\\u9F14\\u9F15\\u9F16\\u9F18\\u9F1A\", 5, \"\\u9F21\\u9F23\", 8, \"\\u9F2D\\u9F2E\\u9F30\\u9F31\"],\n      [\"fd40\", \"\\u9F32\", 4, \"\\u9F38\\u9F3A\\u9F3C\\u9F3F\", 4, \"\\u9F45\", 10, \"\\u9F52\", 38],\n      [\"fd80\", \"\\u9F79\", 5, \"\\u9F81\\u9F82\\u9F8D\", 11, \"\\u9F9C\\u9F9D\\u9F9E\\u9FA1\", 4, \"\\uF92C\\uF979\\uF995\\uF9E7\\uF9F1\"],\n      [\"fe40\", \"\\uFA0C\\uFA0D\\uFA0E\\uFA0F\\uFA11\\uFA13\\uFA14\\uFA18\\uFA1F\\uFA20\\uFA21\\uFA23\\uFA24\\uFA27\\uFA28\\uFA29\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/gbk-added.json\nvar require_gbk_added = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/gbk-added.json\"(exports2, module2) {\n    module2.exports = [\n      [\"a140\", \"\\uE4C6\", 62],\n      [\"a180\", \"\\uE505\", 32],\n      [\"a240\", \"\\uE526\", 62],\n      [\"a280\", \"\\uE565\", 32],\n      [\"a2ab\", \"\\uE766\", 5],\n      [\"a2e3\", \"\\u20AC\\uE76D\"],\n      [\"a2ef\", \"\\uE76E\\uE76F\"],\n      [\"a2fd\", \"\\uE770\\uE771\"],\n      [\"a340\", \"\\uE586\", 62],\n      [\"a380\", \"\\uE5C5\", 31, \"\\u3000\"],\n      [\"a440\", \"\\uE5E6\", 62],\n      [\"a480\", \"\\uE625\", 32],\n      [\"a4f4\", \"\\uE772\", 10],\n      [\"a540\", \"\\uE646\", 62],\n      [\"a580\", \"\\uE685\", 32],\n      [\"a5f7\", \"\\uE77D\", 7],\n      [\"a640\", \"\\uE6A6\", 62],\n      [\"a680\", \"\\uE6E5\", 32],\n      [\"a6b9\", \"\\uE785\", 7],\n      [\"a6d9\", \"\\uE78D\", 6],\n      [\"a6ec\", \"\\uE794\\uE795\"],\n      [\"a6f3\", \"\\uE796\"],\n      [\"a6f6\", \"\\uE797\", 8],\n      [\"a740\", \"\\uE706\", 62],\n      [\"a780\", \"\\uE745\", 32],\n      [\"a7c2\", \"\\uE7A0\", 14],\n      [\"a7f2\", \"\\uE7AF\", 12],\n      [\"a896\", \"\\uE7BC\", 10],\n      [\"a8bc\", \"\\u1E3F\"],\n      [\"a8bf\", \"\\u01F9\"],\n      [\"a8c1\", \"\\uE7C9\\uE7CA\\uE7CB\\uE7CC\"],\n      [\"a8ea\", \"\\uE7CD\", 20],\n      [\"a958\", \"\\uE7E2\"],\n      [\"a95b\", \"\\uE7E3\"],\n      [\"a95d\", \"\\uE7E4\\uE7E5\\uE7E6\"],\n      [\"a989\", \"\\u303E\\u2FF0\", 11],\n      [\"a997\", \"\\uE7F4\", 12],\n      [\"a9f0\", \"\\uE801\", 14],\n      [\"aaa1\", \"\\uE000\", 93],\n      [\"aba1\", \"\\uE05E\", 93],\n      [\"aca1\", \"\\uE0BC\", 93],\n      [\"ada1\", \"\\uE11A\", 93],\n      [\"aea1\", \"\\uE178\", 93],\n      [\"afa1\", \"\\uE1D6\", 93],\n      [\"d7fa\", \"\\uE810\", 4],\n      [\"f8a1\", \"\\uE234\", 93],\n      [\"f9a1\", \"\\uE292\", 93],\n      [\"faa1\", \"\\uE2F0\", 93],\n      [\"fba1\", \"\\uE34E\", 93],\n      [\"fca1\", \"\\uE3AC\", 93],\n      [\"fda1\", \"\\uE40A\", 93],\n      [\"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\"],\n      [\"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],\n      [\"8135f437\", \"\\uE7C7\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json\nvar require_gb18030_ranges = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json\"(exports2, module2) {\n    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] };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp949.json\nvar require_cp949 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp949.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"8141\", \"\\uAC02\\uAC03\\uAC05\\uAC06\\uAC0B\", 4, \"\\uAC18\\uAC1E\\uAC1F\\uAC21\\uAC22\\uAC23\\uAC25\", 6, \"\\uAC2E\\uAC32\\uAC33\\uAC34\"],\n      [\"8161\", \"\\uAC35\\uAC36\\uAC37\\uAC3A\\uAC3B\\uAC3D\\uAC3E\\uAC3F\\uAC41\", 9, \"\\uAC4C\\uAC4E\", 5, \"\\uAC55\"],\n      [\"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\"],\n      [\"8241\", \"\\uAD14\\uAD15\\uAD16\\uAD17\\uAD19\\uAD1A\\uAD1B\\uAD1D\\uAD1E\\uAD1F\\uAD21\", 7, \"\\uAD2A\\uAD2B\\uAD2E\", 5],\n      [\"8261\", \"\\uAD36\\uAD37\\uAD39\\uAD3A\\uAD3B\\uAD3D\", 6, \"\\uAD46\\uAD48\\uAD4A\", 5, \"\\uAD51\\uAD52\\uAD53\\uAD55\\uAD56\\uAD57\"],\n      [\"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],\n      [\"8341\", \"\\uADFA\\uADFB\\uADFD\\uADFE\\uAE02\", 5, \"\\uAE0A\\uAE0C\\uAE0E\", 5, \"\\uAE15\", 7],\n      [\"8361\", \"\\uAE1D\", 18, \"\\uAE32\\uAE33\\uAE35\\uAE36\\uAE39\\uAE3B\\uAE3C\"],\n      [\"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],\n      [\"8441\", \"\\uAEE6\\uAEE7\\uAEE9\\uAEEA\\uAEEC\\uAEEE\", 5, \"\\uAEF5\\uAEF6\\uAEF7\\uAEF9\\uAEFA\\uAEFB\\uAEFD\", 8],\n      [\"8461\", \"\\uAF06\\uAF09\\uAF0A\\uAF0B\\uAF0C\\uAF0E\\uAF0F\\uAF11\", 18],\n      [\"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\"],\n      [\"8541\", \"\\uAFBF\\uAFC1\", 5, \"\\uAFCA\\uAFCC\\uAFCF\", 4, \"\\uAFD5\", 6, \"\\uAFDD\", 4],\n      [\"8561\", \"\\uAFE2\", 5, \"\\uAFEA\", 5, \"\\uAFF2\\uAFF3\\uAFF5\\uAFF6\\uAFF7\\uAFF9\", 6, \"\\uB002\\uB003\"],\n      [\"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\"],\n      [\"8641\", \"\\uB0A5\\uB0A6\\uB0A7\\uB0AA\\uB0B0\\uB0B2\\uB0B6\\uB0B7\\uB0B9\\uB0BA\\uB0BB\\uB0BD\", 6, \"\\uB0C6\\uB0CA\", 5, \"\\uB0D2\"],\n      [\"8661\", \"\\uB0D3\\uB0D5\\uB0D6\\uB0D7\\uB0D9\", 6, \"\\uB0E1\\uB0E2\\uB0E3\\uB0E4\\uB0E6\", 10],\n      [\"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\"],\n      [\"8741\", \"\\uB19E\", 9, \"\\uB1A9\", 15],\n      [\"8761\", \"\\uB1B9\", 18, \"\\uB1CD\\uB1CE\\uB1CF\\uB1D1\\uB1D2\\uB1D3\\uB1D5\"],\n      [\"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],\n      [\"8841\", \"\\uB26F\", 4, \"\\uB276\", 5, \"\\uB27D\", 6, \"\\uB286\\uB287\\uB288\\uB28A\", 4],\n      [\"8861\", \"\\uB28F\\uB292\\uB293\\uB295\\uB296\\uB297\\uB29B\", 4, \"\\uB2A2\\uB2A4\\uB2A7\\uB2A8\\uB2A9\\uB2AB\\uB2AD\\uB2AE\\uB2AF\\uB2B1\\uB2B2\\uB2B3\\uB2B5\\uB2B6\\uB2B7\"],\n      [\"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\"],\n      [\"8941\", \"\\uB366\\uB368\\uB36A\\uB36C\\uB36D\\uB36F\\uB372\\uB373\\uB375\\uB376\\uB377\\uB379\", 6, \"\\uB382\\uB386\", 5, \"\\uB38D\"],\n      [\"8961\", \"\\uB38E\\uB38F\\uB391\\uB392\\uB393\\uB395\", 10, \"\\uB3A2\", 5, \"\\uB3A9\\uB3AA\\uB3AB\\uB3AD\"],\n      [\"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],\n      [\"8a41\", \"\\uB445\", 10, \"\\uB452\\uB453\\uB455\\uB456\\uB457\\uB459\", 6, \"\\uB462\\uB464\\uB466\"],\n      [\"8a61\", \"\\uB467\", 4, \"\\uB46D\", 18, \"\\uB481\\uB482\"],\n      [\"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\"],\n      [\"8b41\", \"\\uB51E\", 5, \"\\uB526\\uB52B\", 4, \"\\uB532\\uB533\\uB535\\uB536\\uB537\\uB539\", 6, \"\\uB542\\uB546\"],\n      [\"8b61\", \"\\uB547\\uB548\\uB549\\uB54A\\uB54E\\uB54F\\uB551\\uB552\\uB553\\uB555\", 6, \"\\uB55E\\uB562\", 8],\n      [\"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],\n      [\"8c41\", \"\\uB600\", 15, \"\\uB612\\uB613\\uB615\\uB616\\uB617\\uB619\", 4],\n      [\"8c61\", \"\\uB61E\", 6, \"\\uB626\", 5, \"\\uB62D\", 6, \"\\uB635\", 5],\n      [\"8c81\", \"\\uB63B\", 12, \"\\uB649\", 26, \"\\uB665\\uB666\\uB667\\uB669\", 50, \"\\uB69E\\uB69F\\uB6A1\\uB6A2\\uB6A3\\uB6A5\", 5, \"\\uB6AD\\uB6AE\\uB6AF\\uB6B0\\uB6B2\", 16],\n      [\"8d41\", \"\\uB6C3\", 16, \"\\uB6D5\", 8],\n      [\"8d61\", \"\\uB6DE\", 17, \"\\uB6F1\\uB6F2\\uB6F3\\uB6F5\\uB6F6\\uB6F7\\uB6F9\\uB6FA\"],\n      [\"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\"],\n      [\"8e41\", \"\\uB79F\\uB7A1\", 6, \"\\uB7AA\\uB7AE\", 5, \"\\uB7B6\\uB7B7\\uB7B9\", 8],\n      [\"8e61\", \"\\uB7C2\", 4, \"\\uB7C8\\uB7CA\", 19],\n      [\"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],\n      [\"8f41\", \"\\uB885\", 7, \"\\uB88E\", 17],\n      [\"8f61\", \"\\uB8A0\", 7, \"\\uB8A9\", 6, \"\\uB8B1\\uB8B2\\uB8B3\\uB8B5\\uB8B6\\uB8B7\\uB8B9\", 4],\n      [\"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],\n      [\"9041\", \"\\uB95A\\uB95B\\uB95D\\uB95E\\uB95F\\uB961\", 6, \"\\uB96A\\uB96C\\uB96E\", 5, \"\\uB976\\uB977\\uB979\\uB97A\\uB97B\\uB97D\"],\n      [\"9061\", \"\\uB97E\", 5, \"\\uB986\\uB988\\uB98B\\uB98C\\uB98F\", 15],\n      [\"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\"],\n      [\"9141\", \"\\uBA47\\uBA4A\\uBA4C\\uBA4F\\uBA50\\uBA51\\uBA52\\uBA56\\uBA57\\uBA59\\uBA5A\\uBA5B\\uBA5D\", 6, \"\\uBA66\\uBA6A\", 5],\n      [\"9161\", \"\\uBA72\\uBA73\\uBA75\\uBA76\\uBA77\\uBA79\", 9, \"\\uBA86\\uBA88\\uBA89\\uBA8A\\uBA8B\\uBA8D\", 5],\n      [\"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],\n      [\"9241\", \"\\uBB28\\uBB2A\\uBB2C\", 7, \"\\uBB37\\uBB39\\uBB3A\\uBB3F\", 4, \"\\uBB46\\uBB48\\uBB4A\\uBB4B\\uBB4C\\uBB4E\\uBB51\\uBB52\"],\n      [\"9261\", \"\\uBB53\\uBB55\\uBB56\\uBB57\\uBB59\", 7, \"\\uBB62\\uBB64\", 7, \"\\uBB6D\", 4],\n      [\"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\"],\n      [\"9341\", \"\\uBC03\", 4, \"\\uBC0A\\uBC0E\\uBC10\\uBC12\\uBC13\\uBC19\\uBC1A\\uBC20\\uBC21\\uBC22\\uBC23\\uBC26\\uBC28\\uBC2A\\uBC2B\\uBC2C\\uBC2E\\uBC2F\\uBC32\\uBC33\\uBC35\"],\n      [\"9361\", \"\\uBC36\\uBC37\\uBC39\", 6, \"\\uBC42\\uBC46\\uBC47\\uBC48\\uBC4A\\uBC4B\\uBC4E\\uBC4F\\uBC51\", 8],\n      [\"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\"],\n      [\"9441\", \"\\uBCFE\", 5, \"\\uBD06\\uBD08\\uBD0A\", 5, \"\\uBD11\\uBD12\\uBD13\\uBD15\", 8],\n      [\"9461\", \"\\uBD1E\", 5, \"\\uBD25\", 6, \"\\uBD2D\", 12],\n      [\"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],\n      [\"9541\", \"\\uBDD2\\uBDD3\\uBDD6\\uBDD7\\uBDD9\\uBDDA\\uBDDB\\uBDDD\", 11, \"\\uBDEA\", 5, \"\\uBDF1\"],\n      [\"9561\", \"\\uBDF2\\uBDF3\\uBDF5\\uBDF6\\uBDF7\\uBDF9\", 6, \"\\uBE01\\uBE02\\uBE04\\uBE06\", 5, \"\\uBE0E\\uBE0F\\uBE11\\uBE12\\uBE13\"],\n      [\"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],\n      [\"9641\", \"\\uBEB8\", 23, \"\\uBED2\\uBED3\"],\n      [\"9661\", \"\\uBED5\\uBED6\\uBED9\", 6, \"\\uBEE1\\uBEE2\\uBEE6\", 5, \"\\uBEED\", 8],\n      [\"9681\", \"\\uBEF6\", 10, \"\\uBF02\", 5, \"\\uBF0A\", 13, \"\\uBF1A\\uBF1E\", 33, \"\\uBF42\\uBF43\\uBF45\\uBF46\\uBF47\\uBF49\", 6, \"\\uBF52\\uBF53\\uBF54\\uBF56\", 44],\n      [\"9741\", \"\\uBF83\", 16, \"\\uBF95\", 8],\n      [\"9761\", \"\\uBF9E\", 17, \"\\uBFB1\", 7],\n      [\"9781\", \"\\uBFB9\", 11, \"\\uBFC6\", 5, \"\\uBFCE\\uBFCF\\uBFD1\\uBFD2\\uBFD3\\uBFD5\", 6, \"\\uBFDD\\uBFDE\\uBFE0\\uBFE2\", 89, \"\\uC03D\\uC03E\\uC03F\"],\n      [\"9841\", \"\\uC040\", 16, \"\\uC052\", 5, \"\\uC059\\uC05A\\uC05B\"],\n      [\"9861\", \"\\uC05D\\uC05E\\uC05F\\uC061\", 6, \"\\uC06A\", 15],\n      [\"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\"],\n      [\"9941\", \"\\uC132\\uC133\\uC134\\uC135\\uC137\\uC13A\\uC13B\\uC13D\\uC13E\\uC13F\\uC141\", 6, \"\\uC14A\\uC14E\", 5, \"\\uC156\\uC157\"],\n      [\"9961\", \"\\uC159\\uC15A\\uC15B\\uC15D\", 6, \"\\uC166\\uC16A\", 5, \"\\uC171\\uC172\\uC173\\uC175\\uC176\\uC177\\uC179\\uC17A\\uC17B\"],\n      [\"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\"],\n      [\"9a41\", \"\\uC224\\uC225\\uC226\\uC227\\uC22A\\uC22C\\uC22E\\uC230\\uC233\\uC235\", 16],\n      [\"9a61\", \"\\uC246\\uC247\\uC249\", 6, \"\\uC252\\uC253\\uC255\\uC256\\uC257\\uC259\", 6, \"\\uC261\\uC262\\uC263\\uC264\\uC266\"],\n      [\"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\"],\n      [\"9b41\", \"\\uC310\\uC311\\uC312\\uC316\\uC317\\uC319\\uC31A\\uC31B\\uC31D\", 6, \"\\uC326\\uC327\\uC32A\", 8],\n      [\"9b61\", \"\\uC333\", 17, \"\\uC346\", 7],\n      [\"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\"],\n      [\"9c41\", \"\\uC3DB\\uC3DD\\uC3DE\\uC3E1\\uC3E3\", 4, \"\\uC3EA\\uC3EB\\uC3EC\\uC3EE\", 5, \"\\uC3F6\\uC3F7\\uC3F9\", 5],\n      [\"9c61\", \"\\uC3FF\", 8, \"\\uC409\", 6, \"\\uC411\", 9],\n      [\"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],\n      [\"9d41\", \"\\uC4AA\", 13, \"\\uC4B9\\uC4BA\\uC4BB\\uC4BD\", 8],\n      [\"9d61\", \"\\uC4C6\", 25],\n      [\"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\"],\n      [\"9e41\", \"\\uC596\\uC599\\uC59A\\uC59B\\uC59D\\uC59E\\uC59F\\uC5A1\", 7, \"\\uC5AA\", 9, \"\\uC5B6\"],\n      [\"9e61\", \"\\uC5B7\\uC5BA\\uC5BF\", 4, \"\\uC5CB\\uC5CD\\uC5CF\\uC5D2\\uC5D3\\uC5D5\\uC5D6\\uC5D7\\uC5D9\", 6, \"\\uC5E2\\uC5E4\\uC5E6\\uC5E7\"],\n      [\"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\"],\n      [\"9f41\", \"\\uC6A8\\uC6AA\", 5, \"\\uC6B2\\uC6B3\\uC6B5\\uC6B6\\uC6B7\\uC6BB\", 4, \"\\uC6C2\\uC6C4\\uC6C6\", 5, \"\\uC6CE\"],\n      [\"9f61\", \"\\uC6CF\\uC6D1\\uC6D2\\uC6D3\\uC6D5\", 6, \"\\uC6DE\\uC6DF\\uC6E2\", 5, \"\\uC6EA\\uC6EB\\uC6ED\\uC6EE\\uC6EF\\uC6F1\\uC6F2\"],\n      [\"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\"],\n      [\"a041\", \"\\uC7B8\\uC7B9\\uC7BA\\uC7BB\\uC7BE\\uC7C2\", 5, \"\\uC7CA\\uC7CB\\uC7CD\\uC7CF\\uC7D1\", 6, \"\\uC7D9\\uC7DA\\uC7DB\\uC7DC\"],\n      [\"a061\", \"\\uC7DE\", 5, \"\\uC7E5\\uC7E6\\uC7E7\\uC7E9\\uC7EA\\uC7EB\\uC7ED\", 13],\n      [\"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\"],\n      [\"a141\", \"\\uC8A5\\uC8A6\\uC8A7\\uC8A9\", 18, \"\\uC8BE\\uC8BF\\uC8C0\\uC8C1\"],\n      [\"a161\", \"\\uC8C2\\uC8C3\\uC8C5\\uC8C6\\uC8C7\\uC8C9\\uC8CA\\uC8CB\\uC8CD\", 6, \"\\uC8D6\\uC8D8\\uC8DA\", 5, \"\\uC8E2\\uC8E3\\uC8E5\"],\n      [\"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\"],\n      [\"a241\", \"\\uC910\\uC912\", 5, \"\\uC919\", 18],\n      [\"a261\", \"\\uC92D\", 6, \"\\uC935\", 18],\n      [\"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\"],\n      [\"a341\", \"\\uC971\\uC972\\uC973\\uC975\", 6, \"\\uC97D\", 10, \"\\uC98A\\uC98B\\uC98D\\uC98E\\uC98F\"],\n      [\"a361\", \"\\uC991\", 6, \"\\uC99A\\uC99C\\uC99E\", 16],\n      [\"a381\", \"\\uC9AF\", 16, \"\\uC9C2\\uC9C3\\uC9C5\\uC9C6\\uC9C9\\uC9CB\", 4, \"\\uC9D2\\uC9D4\\uC9D7\\uC9D8\\uC9DB\\uFF01\", 58, \"\\uFFE6\\uFF3D\", 32, \"\\uFFE3\"],\n      [\"a441\", \"\\uC9DE\\uC9DF\\uC9E1\\uC9E3\\uC9E5\\uC9E6\\uC9E8\\uC9E9\\uC9EA\\uC9EB\\uC9EE\\uC9F2\", 5, \"\\uC9FA\\uC9FB\\uC9FD\\uC9FE\\uC9FF\\uCA01\\uCA02\\uCA03\\uCA04\"],\n      [\"a461\", \"\\uCA05\\uCA06\\uCA07\\uCA0A\\uCA0E\", 5, \"\\uCA15\\uCA16\\uCA17\\uCA19\", 12],\n      [\"a481\", \"\\uCA26\\uCA27\\uCA28\\uCA2A\", 28, \"\\u3131\", 93],\n      [\"a541\", \"\\uCA47\", 4, \"\\uCA4E\\uCA4F\\uCA51\\uCA52\\uCA53\\uCA55\", 6, \"\\uCA5E\\uCA62\", 5, \"\\uCA69\\uCA6A\"],\n      [\"a561\", \"\\uCA6B\", 17, \"\\uCA7E\", 5, \"\\uCA85\\uCA86\"],\n      [\"a581\", \"\\uCA87\", 16, \"\\uCA99\", 14, \"\\u2170\", 9],\n      [\"a5b0\", \"\\u2160\", 9],\n      [\"a5c1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a5e1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a641\", \"\\uCAA8\", 19, \"\\uCABE\\uCABF\\uCAC1\\uCAC2\\uCAC3\\uCAC5\"],\n      [\"a661\", \"\\uCAC6\", 5, \"\\uCACE\\uCAD0\\uCAD2\\uCAD4\\uCAD5\\uCAD6\\uCAD7\\uCADA\", 5, \"\\uCAE1\", 6],\n      [\"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],\n      [\"a741\", \"\\uCB0B\", 4, \"\\uCB11\\uCB12\\uCB13\\uCB15\\uCB16\\uCB17\\uCB19\", 6, \"\\uCB22\", 7],\n      [\"a761\", \"\\uCB2A\", 22, \"\\uCB42\\uCB43\\uCB44\"],\n      [\"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\"],\n      [\"a841\", \"\\uCB6D\", 10, \"\\uCB7A\", 14],\n      [\"a861\", \"\\uCB89\", 18, \"\\uCB9D\", 6],\n      [\"a881\", \"\\uCBA4\", 19, \"\\uCBB9\", 11, \"\\xC6\\xD0\\xAA\\u0126\"],\n      [\"a8a6\", \"\\u0132\"],\n      [\"a8a8\", \"\\u013F\\u0141\\xD8\\u0152\\xBA\\xDE\\u0166\\u014A\"],\n      [\"a8b1\", \"\\u3260\", 27, \"\\u24D0\", 25, \"\\u2460\", 14, \"\\xBD\\u2153\\u2154\\xBC\\xBE\\u215B\\u215C\\u215D\\u215E\"],\n      [\"a941\", \"\\uCBC5\", 14, \"\\uCBD5\", 10],\n      [\"a961\", \"\\uCBE0\\uCBE1\\uCBE2\\uCBE3\\uCBE5\\uCBE6\\uCBE8\\uCBEA\", 18],\n      [\"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\"],\n      [\"aa41\", \"\\uCC25\\uCC26\\uCC2A\\uCC2B\\uCC2D\\uCC2F\\uCC31\", 6, \"\\uCC3A\\uCC3F\", 4, \"\\uCC46\\uCC47\\uCC49\\uCC4A\\uCC4B\\uCC4D\\uCC4E\"],\n      [\"aa61\", \"\\uCC4F\", 4, \"\\uCC56\\uCC5A\", 5, \"\\uCC61\\uCC62\\uCC63\\uCC65\\uCC67\\uCC69\", 6, \"\\uCC71\\uCC72\"],\n      [\"aa81\", \"\\uCC73\\uCC74\\uCC76\", 29, \"\\u3041\", 82],\n      [\"ab41\", \"\\uCC94\\uCC95\\uCC96\\uCC97\\uCC9A\\uCC9B\\uCC9D\\uCC9E\\uCC9F\\uCCA1\", 6, \"\\uCCAA\\uCCAE\", 5, \"\\uCCB6\\uCCB7\\uCCB9\"],\n      [\"ab61\", \"\\uCCBA\\uCCBB\\uCCBD\", 6, \"\\uCCC6\\uCCC8\\uCCCA\", 5, \"\\uCCD1\\uCCD2\\uCCD3\\uCCD5\", 5],\n      [\"ab81\", \"\\uCCDB\", 8, \"\\uCCE5\", 6, \"\\uCCED\\uCCEE\\uCCEF\\uCCF1\", 12, \"\\u30A1\", 85],\n      [\"ac41\", \"\\uCCFE\\uCCFF\\uCD00\\uCD02\", 5, \"\\uCD0A\\uCD0B\\uCD0D\\uCD0E\\uCD0F\\uCD11\", 6, \"\\uCD1A\\uCD1C\\uCD1E\\uCD1F\\uCD20\"],\n      [\"ac61\", \"\\uCD21\\uCD22\\uCD23\\uCD25\\uCD26\\uCD27\\uCD29\\uCD2A\\uCD2B\\uCD2D\", 11, \"\\uCD3A\", 4],\n      [\"ac81\", \"\\uCD3F\", 28, \"\\uCD5D\\uCD5E\\uCD5F\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"acd1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"ad41\", \"\\uCD61\\uCD62\\uCD63\\uCD65\", 6, \"\\uCD6E\\uCD70\\uCD72\", 5, \"\\uCD79\", 7],\n      [\"ad61\", \"\\uCD81\", 6, \"\\uCD89\", 10, \"\\uCD96\\uCD97\\uCD99\\uCD9A\\uCD9B\\uCD9D\\uCD9E\\uCD9F\"],\n      [\"ad81\", \"\\uCDA0\\uCDA1\\uCDA2\\uCDA3\\uCDA6\\uCDA8\\uCDAA\", 5, \"\\uCDB1\", 18, \"\\uCDC5\"],\n      [\"ae41\", \"\\uCDC6\", 5, \"\\uCDCD\\uCDCE\\uCDCF\\uCDD1\", 16],\n      [\"ae61\", \"\\uCDE2\", 5, \"\\uCDE9\\uCDEA\\uCDEB\\uCDED\\uCDEE\\uCDEF\\uCDF1\", 6, \"\\uCDFA\\uCDFC\\uCDFE\", 4],\n      [\"ae81\", \"\\uCE03\\uCE05\\uCE06\\uCE07\\uCE09\\uCE0A\\uCE0B\\uCE0D\", 6, \"\\uCE15\\uCE16\\uCE17\\uCE18\\uCE1A\", 5, \"\\uCE22\\uCE23\\uCE25\\uCE26\\uCE27\\uCE29\\uCE2A\\uCE2B\"],\n      [\"af41\", \"\\uCE2C\\uCE2D\\uCE2E\\uCE2F\\uCE32\\uCE34\\uCE36\", 19],\n      [\"af61\", \"\\uCE4A\", 13, \"\\uCE5A\\uCE5B\\uCE5D\\uCE5E\\uCE62\", 5, \"\\uCE6A\\uCE6C\"],\n      [\"af81\", \"\\uCE6E\", 5, \"\\uCE76\\uCE77\\uCE79\\uCE7A\\uCE7B\\uCE7D\", 6, \"\\uCE86\\uCE88\\uCE8A\", 5, \"\\uCE92\\uCE93\\uCE95\\uCE96\\uCE97\\uCE99\"],\n      [\"b041\", \"\\uCE9A\", 5, \"\\uCEA2\\uCEA6\", 5, \"\\uCEAE\", 12],\n      [\"b061\", \"\\uCEBB\", 5, \"\\uCEC2\", 19],\n      [\"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\"],\n      [\"b141\", \"\\uCF02\\uCF03\\uCF05\\uCF06\\uCF07\\uCF09\", 6, \"\\uCF12\\uCF14\\uCF16\", 5, \"\\uCF1D\\uCF1E\\uCF1F\\uCF21\\uCF22\\uCF23\"],\n      [\"b161\", \"\\uCF25\", 6, \"\\uCF2E\\uCF32\", 5, \"\\uCF39\", 11],\n      [\"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\"],\n      [\"b241\", \"\\uCF6D\\uCF6E\\uCF6F\\uCF72\\uCF73\\uCF75\\uCF76\\uCF77\\uCF79\", 6, \"\\uCF81\\uCF82\\uCF83\\uCF84\\uCF86\", 5, \"\\uCF8D\"],\n      [\"b261\", \"\\uCF8E\", 18, \"\\uCFA2\", 5, \"\\uCFA9\"],\n      [\"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\"],\n      [\"b341\", \"\\uCFCC\", 19, \"\\uCFE2\\uCFE3\\uCFE5\\uCFE6\\uCFE7\\uCFE9\"],\n      [\"b361\", \"\\uCFEA\", 5, \"\\uCFF2\\uCFF4\\uCFF6\", 5, \"\\uCFFD\\uCFFE\\uCFFF\\uD001\\uD002\\uD003\\uD005\", 5],\n      [\"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\"],\n      [\"b441\", \"\\uD02E\", 5, \"\\uD036\\uD037\\uD039\\uD03A\\uD03B\\uD03D\", 6, \"\\uD046\\uD048\\uD04A\", 5],\n      [\"b461\", \"\\uD051\\uD052\\uD053\\uD055\\uD056\\uD057\\uD059\", 6, \"\\uD061\", 10, \"\\uD06E\\uD06F\"],\n      [\"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\"],\n      [\"b541\", \"\\uD095\", 14, \"\\uD0A6\\uD0A7\\uD0A9\\uD0AA\\uD0AB\\uD0AD\", 5],\n      [\"b561\", \"\\uD0B3\\uD0B6\\uD0B8\\uD0BA\", 5, \"\\uD0C2\\uD0C3\\uD0C5\\uD0C6\\uD0C7\\uD0CA\", 5, \"\\uD0D2\\uD0D6\", 4],\n      [\"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\"],\n      [\"b641\", \"\\uD105\", 7, \"\\uD10E\", 17],\n      [\"b661\", \"\\uD120\", 15, \"\\uD132\\uD133\\uD135\\uD136\\uD137\\uD139\\uD13B\\uD13C\\uD13D\\uD13E\"],\n      [\"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\"],\n      [\"b741\", \"\\uD16E\", 13, \"\\uD17D\", 6, \"\\uD185\\uD186\\uD187\\uD189\\uD18A\"],\n      [\"b761\", \"\\uD18B\", 20, \"\\uD1A2\\uD1A3\\uD1A5\\uD1A6\\uD1A7\"],\n      [\"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\"],\n      [\"b841\", \"\\uD1D0\", 7, \"\\uD1D9\", 17],\n      [\"b861\", \"\\uD1EB\", 8, \"\\uD1F5\\uD1F6\\uD1F7\\uD1F9\", 13],\n      [\"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\"],\n      [\"b941\", \"\\uD22A\\uD22B\\uD22E\\uD22F\\uD231\\uD232\\uD233\\uD235\", 6, \"\\uD23E\\uD240\\uD242\", 5, \"\\uD249\\uD24A\\uD24B\\uD24C\"],\n      [\"b961\", \"\\uD24D\", 14, \"\\uD25D\", 6, \"\\uD265\\uD266\\uD267\\uD268\"],\n      [\"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\"],\n      [\"ba41\", \"\\uD28D\\uD28E\\uD28F\\uD292\\uD293\\uD294\\uD296\", 5, \"\\uD29D\\uD29E\\uD29F\\uD2A1\\uD2A2\\uD2A3\\uD2A5\", 6, \"\\uD2AD\"],\n      [\"ba61\", \"\\uD2AE\\uD2AF\\uD2B0\\uD2B2\", 5, \"\\uD2BA\\uD2BB\\uD2BD\\uD2BE\\uD2C1\\uD2C3\", 4, \"\\uD2CA\\uD2CC\", 5],\n      [\"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\"],\n      [\"bb41\", \"\\uD2FB\", 4, \"\\uD302\\uD304\\uD306\", 5, \"\\uD30F\\uD311\\uD312\\uD313\\uD315\\uD317\", 4, \"\\uD31E\\uD322\\uD323\"],\n      [\"bb61\", \"\\uD324\\uD326\\uD327\\uD32A\\uD32B\\uD32D\\uD32E\\uD32F\\uD331\", 6, \"\\uD33A\\uD33E\", 5, \"\\uD346\\uD347\\uD348\\uD349\"],\n      [\"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\"],\n      [\"bc41\", \"\\uD36A\", 17, \"\\uD37E\\uD37F\\uD381\\uD382\\uD383\\uD385\\uD386\\uD387\"],\n      [\"bc61\", \"\\uD388\\uD389\\uD38A\\uD38B\\uD38E\\uD392\", 5, \"\\uD39A\\uD39B\\uD39D\\uD39E\\uD39F\\uD3A1\", 6, \"\\uD3AA\\uD3AC\\uD3AE\"],\n      [\"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\"],\n      [\"bd41\", \"\\uD3D7\\uD3D9\", 7, \"\\uD3E2\\uD3E4\", 7, \"\\uD3EE\\uD3EF\\uD3F1\\uD3F2\\uD3F3\\uD3F5\\uD3F6\\uD3F7\"],\n      [\"bd61\", \"\\uD3F8\\uD3F9\\uD3FA\\uD3FB\\uD3FE\\uD400\\uD402\", 5, \"\\uD409\", 13],\n      [\"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\"],\n      [\"be41\", \"\\uD438\", 7, \"\\uD441\\uD442\\uD443\\uD445\", 14],\n      [\"be61\", \"\\uD454\", 7, \"\\uD45D\\uD45E\\uD45F\\uD461\\uD462\\uD463\\uD465\", 7, \"\\uD46E\\uD470\\uD471\\uD472\"],\n      [\"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\"],\n      [\"bf41\", \"\\uD49E\", 10, \"\\uD4AA\", 14],\n      [\"bf61\", \"\\uD4B9\", 18, \"\\uD4CD\\uD4CE\\uD4CF\\uD4D1\\uD4D2\\uD4D3\\uD4D5\"],\n      [\"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\"],\n      [\"c041\", \"\\uD4FE\", 5, \"\\uD505\\uD506\\uD507\\uD509\\uD50A\\uD50B\\uD50D\", 6, \"\\uD516\\uD518\", 5],\n      [\"c061\", \"\\uD51E\", 25],\n      [\"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\"],\n      [\"c141\", \"\\uD564\\uD566\\uD567\\uD56A\\uD56C\\uD56E\", 5, \"\\uD576\\uD577\\uD579\\uD57A\\uD57B\\uD57D\", 6, \"\\uD586\\uD58A\\uD58B\"],\n      [\"c161\", \"\\uD58C\\uD58D\\uD58E\\uD58F\\uD591\", 19, \"\\uD5A6\\uD5A7\"],\n      [\"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\"],\n      [\"c241\", \"\\uD5CA\\uD5CB\\uD5CD\\uD5CE\\uD5CF\\uD5D1\\uD5D3\", 4, \"\\uD5DA\\uD5DC\\uD5DE\", 5, \"\\uD5E6\\uD5E7\\uD5E9\\uD5EA\\uD5EB\\uD5ED\\uD5EE\"],\n      [\"c261\", \"\\uD5EF\", 4, \"\\uD5F6\\uD5F8\\uD5FA\", 5, \"\\uD602\\uD603\\uD605\\uD606\\uD607\\uD609\", 6, \"\\uD612\"],\n      [\"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\"],\n      [\"c341\", \"\\uD63D\\uD63E\\uD63F\\uD641\\uD642\\uD643\\uD644\\uD646\\uD647\\uD64A\\uD64C\\uD64E\\uD64F\\uD650\\uD652\\uD653\\uD656\\uD657\\uD659\\uD65A\\uD65B\\uD65D\", 4],\n      [\"c361\", \"\\uD662\", 4, \"\\uD668\\uD66A\", 5, \"\\uD672\\uD673\\uD675\", 11],\n      [\"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\"],\n      [\"c441\", \"\\uD6AB\\uD6AD\\uD6AE\\uD6AF\\uD6B1\", 7, \"\\uD6BA\\uD6BC\", 7, \"\\uD6C6\\uD6C7\\uD6C9\\uD6CA\\uD6CB\"],\n      [\"c461\", \"\\uD6CD\\uD6CE\\uD6CF\\uD6D0\\uD6D2\\uD6D3\\uD6D5\\uD6D6\\uD6D8\\uD6DA\", 5, \"\\uD6E1\\uD6E2\\uD6E3\\uD6E5\\uD6E6\\uD6E7\\uD6E9\", 4],\n      [\"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\"],\n      [\"c541\", \"\\uD715\\uD716\\uD717\\uD71A\\uD71B\\uD71D\\uD71E\\uD71F\\uD721\", 6, \"\\uD72A\\uD72C\\uD72E\", 5, \"\\uD736\\uD737\\uD739\"],\n      [\"c561\", \"\\uD73A\\uD73B\\uD73D\", 6, \"\\uD745\\uD746\\uD748\\uD74A\", 5, \"\\uD752\\uD753\\uD755\\uD75A\", 4],\n      [\"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\"],\n      [\"c641\", \"\\uD78D\\uD78E\\uD78F\\uD791\", 6, \"\\uD79A\\uD79C\\uD79E\", 5],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp950.json\nvar require_cp950 = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/cp950.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"a340\", \"\\uFF57\\uFF58\\uFF59\\uFF5A\\u0391\", 16, \"\\u03A3\", 6, \"\\u03B1\", 16, \"\\u03C3\", 6, \"\\u3105\", 10],\n      [\"a3a1\", \"\\u3110\", 25, \"\\u02D9\\u02C9\\u02CA\\u02C7\\u02CB\"],\n      [\"a3e1\", \"\\u20AC\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/tables/big5-added.json\nvar require_big5_added = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/tables/big5-added.json\"(exports2, module2) {\n    module2.exports = [\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"88a1\", \"\\u01DC\\xFC\\u0FFF\\xEA\\u0304\\u1EBF\\u0FFF\\xEA\\u030C\\u1EC1\\xEA\\u0261\\u23DA\\u23DB\"],\n      [\"8940\", \"\\u{2A3A9}\\u{21145}\"],\n      [\"8943\", \"\\u650A\"],\n      [\"8946\", \"\\u4E3D\\u6EDD\\u9D4E\\u91DF\"],\n      [\"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\"],\n      [\"89a1\", \"\\u7411\\u7CFC\\u7DCD\\u6946\\u7AC9\\u5227\"],\n      [\"89ab\", \"\\u918C\\u78B8\\u915E\\u80BC\"],\n      [\"89b0\", \"\\u8D0B\\u80F6\\u{209E7}\"],\n      [\"89b5\", \"\\u809F\\u9EC7\\u4CCD\\u9DC9\\u9E0C\\u4C3E\\u{29DF6}\\u{2700E}\\u9E0A\\u{2A133}\\u35C1\"],\n      [\"89c1\", \"\\u6E9A\\u823E\\u7519\"],\n      [\"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\"],\n      [\"8a40\", \"\\u{27D84}\\u5525\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"8a76\", \"\\u43D9\\u{260A5}\\u64B4\\u54E3\\u{22D4C}\\u{22BCA}\\u{21077}\\u39FB\\u{2106F}\"],\n      [\"8aa1\", \"\\u{266DA}\\u{26716}\\u{279A0}\\u64EA\\u{25052}\\u{20C43}\\u8E68\\u{221A1}\\u{28B4C}\\u{20731}\"],\n      [\"8aac\", \"\\u480B\\u{201A9}\\u3FFA\\u5873\\u{22D8D}\"],\n      [\"8ab2\", \"\\u{245C8}\\u{204FC}\\u{26097}\\u{20F4C}\\u{20D96}\\u5579\\u40BB\\u43BA\"],\n      [\"8abb\", \"\\u4AB4\\u{22A66}\\u{2109D}\\u81AA\\u98F5\\u{20D9C}\\u6379\\u39FE\\u{22775}\\u8DC0\\u56A1\\u647C\\u3E43\"],\n      [\"8ac9\", \"\\u{2A601}\\u{20E09}\\u{22ACF}\\u{22CC9}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"8af6\", \"\\u{20EAB}\\u{20BA9}\\u{20D48}\\u{210C0}\\u{2113D}\\u3FF9\\u{22696}\\u6432\\u{20FAD}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8ca1\", \"\\u{233F9}\\u6919\\u6A43\\u{23C63}\\u6CFF\"],\n      [\"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\"],\n      [\"8cc9\", \"\\u9868\\u676B\\u4276\\u573D\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8d40\", \"\\u{20B9F}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"9ea1\", \"\\u9C5D\\u651F\\u{22DA0}\\u48F3\\u{247E0}\\u{29D7C}\\u{20FEC}\\u{20E0A}\\u6062\\u{275A3}\\u{20FED}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"9ef5\", \"\\u565D\\u{212A9}\\u57A7\\u{24963}\\u{29E06}\\u5234\\u{270AE}\\u35AD\\u6C4A\\u9D7C\"],\n      [\"9f40\", \"\\u7C56\\u9B39\\u57DE\\u{2176C}\\u5C53\\u64D3\\u{294D0}\\u{26335}\\u{27164}\\u86AD\\u{20D28}\\u{26D22}\\u{24AE2}\\u{20D71}\"],\n      [\"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\"],\n      [\"9fa1\", \"\\u692C\\u53DA\\u9C0A\\u9D02\\u4C3B\\u9641\\u6980\\u50A6\\u7546\\u{2176D}\\u99DA\\u5273\"],\n      [\"9fae\", \"\\u9159\\u9681\\u915C\"],\n      [\"9fb2\", \"\\u9151\\u{28E97}\\u637F\\u{26D23}\\u6ACA\\u5611\\u918E\\u757A\\u6285\\u{203FC}\\u734F\\u7C70\\u{25C21}\\u{23CFD}\"],\n      [\"9fc1\", \"\\u{24919}\\u76D6\\u9B9D\\u4E2A\\u{20CD4}\\u83BE\\u8842\"],\n      [\"9fc9\", \"\\u5C4A\\u69C0\\u50ED\\u577A\\u521F\\u5DF5\\u4ECE\\u6C31\\u{201F2}\\u4F39\\u549C\\u54DA\\u529A\\u8D82\\u35FE\\u5F0C\\u35F3\"],\n      [\"9fdb\", \"\\u6B52\\u917C\\u9FA5\\u9B97\\u982E\\u98B4\\u9ABA\\u9EA8\\u9E84\\u717A\\u7B14\"],\n      [\"9fe7\", \"\\u6BFA\\u8818\\u7F78\"],\n      [\"9feb\", \"\\u5620\\u{2A64A}\\u8E77\\u9F53\"],\n      [\"9ff0\", \"\\u8DD4\\u8E4F\\u9E1C\\u8E01\\u6282\\u{2837D}\\u8E28\\u8E75\\u7AD3\\u{24A77}\\u7A3E\\u78D8\\u6CEA\\u8A67\\u7607\"],\n      [\"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\"],\n      [\"a055\", \"\\u{2183B}\\u{26E05}\"],\n      [\"a058\", \"\\u8A7E\\u{2251B}\"],\n      [\"a05b\", \"\\u60FD\\u7667\\u9AD7\\u9D44\\u936E\\u9B8F\\u87F5\"],\n      [\"a063\", \"\\u880F\\u8CF7\\u732C\\u9721\\u9BB0\\u35D6\\u72B2\\u4C07\\u7C51\\u994A\\u{26159}\\u6159\\u4C04\\u9E96\\u617D\"],\n      [\"a073\", \"\\u575F\\u616F\\u62A6\\u6239\\u62CE\\u3A5C\\u61E2\\u53AA\\u{233F5}\\u6364\\u6802\\u35D2\"],\n      [\"a0a1\", \"\\u5D57\\u{28BC2}\\u8FDA\\u{28E39}\"],\n      [\"a0a6\", \"\\u50D9\\u{21D46}\\u7906\\u5332\\u9638\\u{20F3B}\\u4065\"],\n      [\"a0ae\", \"\\u77FE\"],\n      [\"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\"],\n      [\"a0d4\", \"\\u89A9\\u7468\\u6DB9\\u87C1\\u{24011}\\u74E7\\u3DDB\\u7176\\u60A4\\u619C\\u3CD1\\u7162\\u6077\"],\n      [\"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}\"],\n      [\"a3c0\", \"\\u2400\", 31, \"\\u2421\"],\n      [\"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],\n      [\"c740\", \"\\u3059\", 58, \"\\u30A1\\u30A2\\u30A3\\u30A4\"],\n      [\"c7a1\", \"\\u30A5\", 81, \"\\u0410\", 5, \"\\u0401\\u0416\", 4],\n      [\"c840\", \"\\u041B\", 26, \"\\u0451\\u0436\", 25, \"\\u21E7\\u21B8\\u21B9\\u31CF\\u{200CC}\\u4E5A\\u{2008A}\\u5202\\u4491\"],\n      [\"c8a1\", \"\\u9FB0\\u5188\\u9FB1\\u{27607}\"],\n      [\"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\"],\n      [\"c8f5\", \"\\u0283\\u0250\\u025B\\u0254\\u0275\\u0153\\xF8\\u014B\\u028A\\u026A\"],\n      [\"f9fe\", \"\\uFFED\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/dbcs-data.js\nvar require_dbcs_data = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/dbcs-data.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      // == Japanese/ShiftJIS ====================================================\n      // All japanese encodings are based on JIS X set of standards:\n      // JIS X 0201 - Single-byte encoding of ASCII + \u00A5 + Kana chars at 0xA1-0xDF.\n      // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. \n      //              Has several variations in 1978, 1983, 1990 and 1997.\n      // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.\n      // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.\n      //              2 planes, first is superset of 0208, second - revised 0212.\n      //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)\n      // Byte encodings are:\n      //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte\n      //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.\n      //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.\n      //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.\n      //               0x00-0x7F       - lower part of 0201\n      //               0x8E, 0xA1-0xDF - upper part of 0201\n      //               (0xA1-0xFE)x2   - 0208 plane (94x94).\n      //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).\n      //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.\n      //               Used as-is in ISO2022 family.\n      //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, \n      //                0201-1976 Roman, 0208-1978, 0208-1983.\n      //  * ISO2022-JP-1: Adds esc seq for 0212-1990.\n      //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.\n      //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.\n      //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.\n      //\n      // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.\n      //\n      // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html\n      \"shiftjis\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_shiftjis();\n        },\n        encodeAdd: { \"\\xA5\": 92, \"\\u203E\": 126 },\n        encodeSkipVals: [{ from: 60736, to: 63808 }]\n      },\n      \"csshiftjis\": \"shiftjis\",\n      \"mskanji\": \"shiftjis\",\n      \"sjis\": \"shiftjis\",\n      \"windows31j\": \"shiftjis\",\n      \"ms31j\": \"shiftjis\",\n      \"xsjis\": \"shiftjis\",\n      \"windows932\": \"shiftjis\",\n      \"ms932\": \"shiftjis\",\n      \"932\": \"shiftjis\",\n      \"cp932\": \"shiftjis\",\n      \"eucjp\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_eucjp();\n        },\n        encodeAdd: { \"\\xA5\": 92, \"\\u203E\": 126 }\n      },\n      // TODO: KDDI extension to Shift_JIS\n      // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.\n      // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.\n      // == Chinese/GBK ==========================================================\n      // http://en.wikipedia.org/wiki/GBK\n      // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder\n      // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936\n      \"gb2312\": \"cp936\",\n      \"gb231280\": \"cp936\",\n      \"gb23121980\": \"cp936\",\n      \"csgb2312\": \"cp936\",\n      \"csiso58gb231280\": \"cp936\",\n      \"euccn\": \"cp936\",\n      // Microsoft's CP936 is a subset and approximation of GBK.\n      \"windows936\": \"cp936\",\n      \"ms936\": \"cp936\",\n      \"936\": \"cp936\",\n      \"cp936\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp936();\n        }\n      },\n      // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.\n      \"gbk\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp936().concat(require_gbk_added());\n        }\n      },\n      \"xgbk\": \"gbk\",\n      \"isoir58\": \"gbk\",\n      // GB18030 is an algorithmic extension of GBK.\n      // Main source: https://www.w3.org/TR/encoding/#gbk-encoder\n      // http://icu-project.org/docs/papers/gb18030.html\n      // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml\n      // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0\n      \"gb18030\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp936().concat(require_gbk_added());\n        },\n        gb18030: function() {\n          return require_gb18030_ranges();\n        },\n        encodeSkipVals: [128],\n        encodeAdd: { \"\\u20AC\": 41699 }\n      },\n      \"chinese\": \"gb18030\",\n      // == Korean ===============================================================\n      // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.\n      \"windows949\": \"cp949\",\n      \"ms949\": \"cp949\",\n      \"949\": \"cp949\",\n      \"cp949\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp949();\n        }\n      },\n      \"cseuckr\": \"cp949\",\n      \"csksc56011987\": \"cp949\",\n      \"euckr\": \"cp949\",\n      \"isoir149\": \"cp949\",\n      \"korean\": \"cp949\",\n      \"ksc56011987\": \"cp949\",\n      \"ksc56011989\": \"cp949\",\n      \"ksc5601\": \"cp949\",\n      // == Big5/Taiwan/Hong Kong ================================================\n      // There are lots of tables for Big5 and cp950. Please see the following links for history:\n      // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html\n      // Variations, in roughly number of defined chars:\n      //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT\n      //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/\n      //  * Big5-2003 (Taiwan standard) almost superset of cp950.\n      //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.\n      //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. \n      //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.\n      //    Plus, it has 4 combining sequences.\n      //    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\n      //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.\n      //    Implementations are not consistent within browsers; sometimes labeled as just big5.\n      //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.\n      //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31\n      //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.\n      //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt\n      //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt\n      // \n      // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder\n      // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.\n      \"windows950\": \"cp950\",\n      \"ms950\": \"cp950\",\n      \"950\": \"cp950\",\n      \"cp950\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp950();\n        }\n      },\n      // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.\n      \"big5\": \"big5hkscs\",\n      \"big5hkscs\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp950().concat(require_big5_added());\n        },\n        encodeSkipVals: [\n          // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of\n          // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU.\n          // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter.\n          36457,\n          36463,\n          36478,\n          36523,\n          36532,\n          36557,\n          36560,\n          36695,\n          36713,\n          36718,\n          36811,\n          36862,\n          36973,\n          36986,\n          37060,\n          37084,\n          37105,\n          37311,\n          37551,\n          37552,\n          37553,\n          37554,\n          37585,\n          37959,\n          38090,\n          38361,\n          38652,\n          39285,\n          39798,\n          39800,\n          39803,\n          39878,\n          39902,\n          39916,\n          39926,\n          40002,\n          40019,\n          40034,\n          40040,\n          40043,\n          40055,\n          40124,\n          40125,\n          40144,\n          40279,\n          40282,\n          40388,\n          40431,\n          40443,\n          40617,\n          40687,\n          40701,\n          40800,\n          40907,\n          41079,\n          41180,\n          41183,\n          36812,\n          37576,\n          38468,\n          38637,\n          // 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\n          41636,\n          41637,\n          41639,\n          41638,\n          41676,\n          41678\n        ]\n      },\n      \"cnbig5\": \"big5hkscs\",\n      \"csbig5\": \"big5hkscs\",\n      \"xxbig5\": \"big5hkscs\"\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/encodings/index.js\nvar require_encodings = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/encodings/index.js\"(exports2, module2) {\n    \"use strict\";\n    var modules = [\n      require_internal(),\n      require_utf32(),\n      require_utf16(),\n      require_utf7(),\n      require_sbcs_codec(),\n      require_sbcs_data(),\n      require_sbcs_data_generated(),\n      require_dbcs_codec(),\n      require_dbcs_data()\n    ];\n    for (i = 0; i < modules.length; i++) {\n      module2 = modules[i];\n      for (enc in module2)\n        if (Object.prototype.hasOwnProperty.call(module2, enc))\n          exports2[enc] = module2[enc];\n    }\n    var module2;\n    var enc;\n    var i;\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/lib/streams.js\nvar require_streams = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/lib/streams.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    module2.exports = function(stream_module) {\n      var Transform = stream_module.Transform;\n      function IconvLiteEncoderStream(conv, options) {\n        this.conv = conv;\n        options = options || {};\n        options.decodeStrings = false;\n        Transform.call(this, options);\n      }\n      IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, {\n        constructor: { value: IconvLiteEncoderStream }\n      });\n      IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {\n        if (typeof chunk != \"string\")\n          return done(new Error(\"Iconv encoding stream needs strings as its input.\"));\n        try {\n          var res = this.conv.write(chunk);\n          if (res && res.length) this.push(res);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteEncoderStream.prototype._flush = function(done) {\n        try {\n          var res = this.conv.end();\n          if (res && res.length) this.push(res);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteEncoderStream.prototype.collect = function(cb) {\n        var chunks = [];\n        this.on(\"error\", cb);\n        this.on(\"data\", function(chunk) {\n          chunks.push(chunk);\n        });\n        this.on(\"end\", function() {\n          cb(null, Buffer2.concat(chunks));\n        });\n        return this;\n      };\n      function IconvLiteDecoderStream(conv, options) {\n        this.conv = conv;\n        options = options || {};\n        options.encoding = this.encoding = \"utf8\";\n        Transform.call(this, options);\n      }\n      IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {\n        constructor: { value: IconvLiteDecoderStream }\n      });\n      IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {\n        if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array))\n          return done(new Error(\"Iconv decoding stream needs buffers as its input.\"));\n        try {\n          var res = this.conv.write(chunk);\n          if (res && res.length) this.push(res, this.encoding);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteDecoderStream.prototype._flush = function(done) {\n        try {\n          var res = this.conv.end();\n          if (res && res.length) this.push(res, this.encoding);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteDecoderStream.prototype.collect = function(cb) {\n        var res = \"\";\n        this.on(\"error\", cb);\n        this.on(\"data\", function(chunk) {\n          res += chunk;\n        });\n        this.on(\"end\", function() {\n          cb(null, res);\n        });\n        return this;\n      };\n      return {\n        IconvLiteEncoderStream,\n        IconvLiteDecoderStream\n      };\n    };\n  }\n});\n\n// node_modules/raw-body/node_modules/iconv-lite/lib/index.js\nvar require_lib = __commonJS({\n  \"node_modules/raw-body/node_modules/iconv-lite/lib/index.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    var bomHandling = require_bom_handling();\n    var iconv = module2.exports;\n    iconv.encodings = null;\n    iconv.defaultCharUnicode = \"\\uFFFD\";\n    iconv.defaultCharSingleByte = \"?\";\n    iconv.encode = function encode(str, encoding, options) {\n      str = \"\" + (str || \"\");\n      var encoder = iconv.getEncoder(encoding, options);\n      var res = encoder.write(str);\n      var trail = encoder.end();\n      return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;\n    };\n    iconv.decode = function decode(buf, encoding, options) {\n      if (typeof buf === \"string\") {\n        if (!iconv.skipDecodeWarning) {\n          console.error(\"Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding\");\n          iconv.skipDecodeWarning = true;\n        }\n        buf = Buffer2.from(\"\" + (buf || \"\"), \"binary\");\n      }\n      var decoder = iconv.getDecoder(encoding, options);\n      var res = decoder.write(buf);\n      var trail = decoder.end();\n      return trail ? res + trail : res;\n    };\n    iconv.encodingExists = function encodingExists(enc) {\n      try {\n        iconv.getCodec(enc);\n        return true;\n      } catch (e) {\n        return false;\n      }\n    };\n    iconv.toEncoding = iconv.encode;\n    iconv.fromEncoding = iconv.decode;\n    iconv._codecDataCache = {};\n    iconv.getCodec = function getCodec(encoding) {\n      if (!iconv.encodings)\n        iconv.encodings = require_encodings();\n      var enc = iconv._canonicalizeEncoding(encoding);\n      var codecOptions = {};\n      while (true) {\n        var codec = iconv._codecDataCache[enc];\n        if (codec)\n          return codec;\n        var codecDef = iconv.encodings[enc];\n        switch (typeof codecDef) {\n          case \"string\":\n            enc = codecDef;\n            break;\n          case \"object\":\n            for (var key in codecDef)\n              codecOptions[key] = codecDef[key];\n            if (!codecOptions.encodingName)\n              codecOptions.encodingName = enc;\n            enc = codecDef.type;\n            break;\n          case \"function\":\n            if (!codecOptions.encodingName)\n              codecOptions.encodingName = enc;\n            codec = new codecDef(codecOptions, iconv);\n            iconv._codecDataCache[codecOptions.encodingName] = codec;\n            return codec;\n          default:\n            throw new Error(\"Encoding not recognized: '\" + encoding + \"' (searched as: '\" + enc + \"')\");\n        }\n      }\n    };\n    iconv._canonicalizeEncoding = function(encoding) {\n      return (\"\" + encoding).toLowerCase().replace(/:\\d{4}$|[^0-9a-z]/g, \"\");\n    };\n    iconv.getEncoder = function getEncoder(encoding, options) {\n      var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);\n      if (codec.bomAware && options && options.addBOM)\n        encoder = new bomHandling.PrependBOM(encoder, options);\n      return encoder;\n    };\n    iconv.getDecoder = function getDecoder(encoding, options) {\n      var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec);\n      if (codec.bomAware && !(options && options.stripBOM === false))\n        decoder = new bomHandling.StripBOM(decoder, options);\n      return decoder;\n    };\n    iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) {\n      if (iconv.supportsStreams)\n        return;\n      var streams = require_streams()(stream_module2);\n      iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;\n      iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;\n      iconv.encodeStream = function encodeStream(encoding, options) {\n        return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);\n      };\n      iconv.decodeStream = function decodeStream(encoding, options) {\n        return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);\n      };\n      iconv.supportsStreams = true;\n    };\n    var stream_module;\n    try {\n      stream_module = require(\"stream\");\n    } catch (e) {\n    }\n    if (stream_module && stream_module.Transform) {\n      iconv.enableStreamingAPI(stream_module);\n    } else {\n      iconv.encodeStream = iconv.decodeStream = function() {\n        throw new Error(\"iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.\");\n      };\n    }\n    if (false) {\n      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.\");\n    }\n  }\n});\n\n// node_modules/unpipe/index.js\nvar require_unpipe = __commonJS({\n  \"node_modules/unpipe/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = unpipe;\n    function hasPipeDataListeners(stream) {\n      var listeners = stream.listeners(\"data\");\n      for (var i = 0; i < listeners.length; i++) {\n        if (listeners[i].name === \"ondata\") {\n          return true;\n        }\n      }\n      return false;\n    }\n    function unpipe(stream) {\n      if (!stream) {\n        throw new TypeError(\"argument stream is required\");\n      }\n      if (typeof stream.unpipe === \"function\") {\n        stream.unpipe();\n        return;\n      }\n      if (!hasPipeDataListeners(stream)) {\n        return;\n      }\n      var listener;\n      var listeners = stream.listeners(\"close\");\n      for (var i = 0; i < listeners.length; i++) {\n        listener = listeners[i];\n        if (listener.name !== \"cleanup\" && listener.name !== \"onclose\") {\n          continue;\n        }\n        listener.call(stream);\n      }\n    }\n  }\n});\n\n// node_modules/raw-body/index.js\nvar require_raw_body = __commonJS({\n  \"node_modules/raw-body/index.js\"(exports2, module2) {\n    \"use strict\";\n    var asyncHooks = tryRequireAsyncHooks();\n    var bytes = require_bytes();\n    var createError = require_http_errors();\n    var iconv = require_lib();\n    var unpipe = require_unpipe();\n    module2.exports = getRawBody2;\n    var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;\n    function getDecoder(encoding) {\n      if (!encoding) return null;\n      try {\n        return iconv.getDecoder(encoding);\n      } catch (e) {\n        if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e;\n        throw createError(415, \"specified encoding unsupported\", {\n          encoding,\n          type: \"encoding.unsupported\"\n        });\n      }\n    }\n    function getRawBody2(stream, options, callback) {\n      var done = callback;\n      var opts = options || {};\n      if (stream === void 0) {\n        throw new TypeError(\"argument stream is required\");\n      } else if (typeof stream !== \"object\" || stream === null || typeof stream.on !== \"function\") {\n        throw new TypeError(\"argument stream must be a stream\");\n      }\n      if (options === true || typeof options === \"string\") {\n        opts = {\n          encoding: options\n        };\n      }\n      if (typeof options === \"function\") {\n        done = options;\n        opts = {};\n      }\n      if (done !== void 0 && typeof done !== \"function\") {\n        throw new TypeError(\"argument callback must be a function\");\n      }\n      if (!done && !global.Promise) {\n        throw new TypeError(\"argument callback is required\");\n      }\n      var encoding = opts.encoding !== true ? opts.encoding : \"utf-8\";\n      var limit = bytes.parse(opts.limit);\n      var length = opts.length != null && !isNaN(opts.length) ? parseInt(opts.length, 10) : null;\n      if (done) {\n        return readStream(stream, encoding, length, limit, wrap(done));\n      }\n      return new Promise(function executor(resolve, reject) {\n        readStream(stream, encoding, length, limit, function onRead(err2, buf) {\n          if (err2) return reject(err2);\n          resolve(buf);\n        });\n      });\n    }\n    function halt(stream) {\n      unpipe(stream);\n      if (typeof stream.pause === \"function\") {\n        stream.pause();\n      }\n    }\n    function readStream(stream, encoding, length, limit, callback) {\n      var complete = false;\n      var sync = true;\n      if (limit !== null && length !== null && length > limit) {\n        return done(createError(413, \"request entity too large\", {\n          expected: length,\n          length,\n          limit,\n          type: \"entity.too.large\"\n        }));\n      }\n      var state = stream._readableState;\n      if (stream._decoder || state && (state.encoding || state.decoder)) {\n        return done(createError(500, \"stream encoding should not be set\", {\n          type: \"stream.encoding.set\"\n        }));\n      }\n      if (typeof stream.readable !== \"undefined\" && !stream.readable) {\n        return done(createError(500, \"stream is not readable\", {\n          type: \"stream.not.readable\"\n        }));\n      }\n      var received = 0;\n      var decoder;\n      try {\n        decoder = getDecoder(encoding);\n      } catch (err2) {\n        return done(err2);\n      }\n      var buffer = decoder ? \"\" : [];\n      stream.on(\"aborted\", onAborted);\n      stream.on(\"close\", cleanup);\n      stream.on(\"data\", onData);\n      stream.on(\"end\", onEnd);\n      stream.on(\"error\", onEnd);\n      sync = false;\n      function done() {\n        var args = new Array(arguments.length);\n        for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i];\n        }\n        complete = true;\n        if (sync) {\n          process.nextTick(invokeCallback);\n        } else {\n          invokeCallback();\n        }\n        function invokeCallback() {\n          cleanup();\n          if (args[0]) {\n            halt(stream);\n          }\n          callback.apply(null, args);\n        }\n      }\n      function onAborted() {\n        if (complete) return;\n        done(createError(400, \"request aborted\", {\n          code: \"ECONNABORTED\",\n          expected: length,\n          length,\n          received,\n          type: \"request.aborted\"\n        }));\n      }\n      function onData(chunk) {\n        if (complete) return;\n        received += chunk.length;\n        if (limit !== null && received > limit) {\n          done(createError(413, \"request entity too large\", {\n            limit,\n            received,\n            type: \"entity.too.large\"\n          }));\n        } else if (decoder) {\n          buffer += decoder.write(chunk);\n        } else {\n          buffer.push(chunk);\n        }\n      }\n      function onEnd(err2) {\n        if (complete) return;\n        if (err2) return done(err2);\n        if (length !== null && received !== length) {\n          done(createError(400, \"request size did not match content length\", {\n            expected: length,\n            length,\n            received,\n            type: \"request.size.invalid\"\n          }));\n        } else {\n          var string = decoder ? buffer + (decoder.end() || \"\") : Buffer.concat(buffer);\n          done(null, string);\n        }\n      }\n      function cleanup() {\n        buffer = null;\n        stream.removeListener(\"aborted\", onAborted);\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"error\", onEnd);\n        stream.removeListener(\"close\", cleanup);\n      }\n    }\n    function tryRequireAsyncHooks() {\n      try {\n        return require(\"async_hooks\");\n      } catch (e) {\n        return {};\n      }\n    }\n    function wrap(fn) {\n      var res;\n      if (asyncHooks.AsyncResource) {\n        res = new asyncHooks.AsyncResource(fn.name || \"bound-anonymous-fn\");\n      }\n      if (!res || !res.runInAsyncScope) {\n        return fn;\n      }\n      return res.runInAsyncScope.bind(res, fn, null);\n    }\n  }\n});\n\n// node_modules/content-type/index.js\nvar require_content_type = __commonJS({\n  \"node_modules/content-type/index.js\"(exports2) {\n    \"use strict\";\n    var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *(\"(?:[\\u000b\\u0020\\u0021\\u0023-\\u005b\\u005d-\\u007e\\u0080-\\u00ff]|\\\\[\\u000b\\u0020-\\u00ff])*\"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;\n    var TEXT_REGEXP = /^[\\u000b\\u0020-\\u007e\\u0080-\\u00ff]+$/;\n    var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;\n    var QESC_REGEXP = /\\\\([\\u000b\\u0020-\\u00ff])/g;\n    var QUOTE_REGEXP = /([\\\\\"])/g;\n    var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;\n    exports2.format = format;\n    exports2.parse = parse;\n    function format(obj) {\n      if (!obj || typeof obj !== \"object\") {\n        throw new TypeError(\"argument obj is required\");\n      }\n      var parameters = obj.parameters;\n      var type = obj.type;\n      if (!type || !TYPE_REGEXP.test(type)) {\n        throw new TypeError(\"invalid type\");\n      }\n      var string = type;\n      if (parameters && typeof parameters === \"object\") {\n        var param;\n        var params = Object.keys(parameters).sort();\n        for (var i = 0; i < params.length; i++) {\n          param = params[i];\n          if (!TOKEN_REGEXP.test(param)) {\n            throw new TypeError(\"invalid parameter name\");\n          }\n          string += \"; \" + param + \"=\" + qstring(parameters[param]);\n        }\n      }\n      return string;\n    }\n    function parse(string) {\n      if (!string) {\n        throw new TypeError(\"argument string is required\");\n      }\n      var header = typeof string === \"object\" ? getcontenttype(string) : string;\n      if (typeof header !== \"string\") {\n        throw new TypeError(\"argument string is required to be a string\");\n      }\n      var index = header.indexOf(\";\");\n      var type = index !== -1 ? header.slice(0, index).trim() : header.trim();\n      if (!TYPE_REGEXP.test(type)) {\n        throw new TypeError(\"invalid media type\");\n      }\n      var obj = new ContentType(type.toLowerCase());\n      if (index !== -1) {\n        var key;\n        var match;\n        var value;\n        PARAM_REGEXP.lastIndex = index;\n        while (match = PARAM_REGEXP.exec(header)) {\n          if (match.index !== index) {\n            throw new TypeError(\"invalid parameter format\");\n          }\n          index += match[0].length;\n          key = match[1].toLowerCase();\n          value = match[2];\n          if (value.charCodeAt(0) === 34) {\n            value = value.slice(1, -1);\n            if (value.indexOf(\"\\\\\") !== -1) {\n              value = value.replace(QESC_REGEXP, \"$1\");\n            }\n          }\n          obj.parameters[key] = value;\n        }\n        if (index !== header.length) {\n          throw new TypeError(\"invalid parameter format\");\n        }\n      }\n      return obj;\n    }\n    function getcontenttype(obj) {\n      var header;\n      if (typeof obj.getHeader === \"function\") {\n        header = obj.getHeader(\"content-type\");\n      } else if (typeof obj.headers === \"object\") {\n        header = obj.headers && obj.headers[\"content-type\"];\n      }\n      if (typeof header !== \"string\") {\n        throw new TypeError(\"content-type header is missing from object\");\n      }\n      return header;\n    }\n    function qstring(val) {\n      var str = String(val);\n      if (TOKEN_REGEXP.test(str)) {\n        return str;\n      }\n      if (str.length > 0 && !TEXT_REGEXP.test(str)) {\n        throw new TypeError(\"invalid parameter value\");\n      }\n      return '\"' + str.replace(QUOTE_REGEXP, \"\\\\$1\") + '\"';\n    }\n    function ContentType(type) {\n      this.parameters = /* @__PURE__ */ Object.create(null);\n      this.type = type;\n    }\n  }\n});\n\n// node_modules/ms/index.js\nvar require_ms = __commonJS({\n  \"node_modules/ms/index.js\"(exports2, module2) {\n    var s = 1e3;\n    var m = s * 60;\n    var h = m * 60;\n    var d = h * 24;\n    var w = d * 7;\n    var y = d * 365.25;\n    module2.exports = function(val, options) {\n      options = options || {};\n      var type = typeof val;\n      if (type === \"string\" && val.length > 0) {\n        return parse(val);\n      } else if (type === \"number\" && isFinite(val)) {\n        return options.long ? fmtLong(val) : fmtShort(val);\n      }\n      throw new Error(\n        \"val is not a non-empty string or a valid number. val=\" + JSON.stringify(val)\n      );\n    };\n    function parse(str) {\n      str = String(str);\n      if (str.length > 100) {\n        return;\n      }\n      var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n        str\n      );\n      if (!match) {\n        return;\n      }\n      var n = parseFloat(match[1]);\n      var type = (match[2] || \"ms\").toLowerCase();\n      switch (type) {\n        case \"years\":\n        case \"year\":\n        case \"yrs\":\n        case \"yr\":\n        case \"y\":\n          return n * y;\n        case \"weeks\":\n        case \"week\":\n        case \"w\":\n          return n * w;\n        case \"days\":\n        case \"day\":\n        case \"d\":\n          return n * d;\n        case \"hours\":\n        case \"hour\":\n        case \"hrs\":\n        case \"hr\":\n        case \"h\":\n          return n * h;\n        case \"minutes\":\n        case \"minute\":\n        case \"mins\":\n        case \"min\":\n        case \"m\":\n          return n * m;\n        case \"seconds\":\n        case \"second\":\n        case \"secs\":\n        case \"sec\":\n        case \"s\":\n          return n * s;\n        case \"milliseconds\":\n        case \"millisecond\":\n        case \"msecs\":\n        case \"msec\":\n        case \"ms\":\n          return n;\n        default:\n          return void 0;\n      }\n    }\n    function fmtShort(ms) {\n      var msAbs = Math.abs(ms);\n      if (msAbs >= d) {\n        return Math.round(ms / d) + \"d\";\n      }\n      if (msAbs >= h) {\n        return Math.round(ms / h) + \"h\";\n      }\n      if (msAbs >= m) {\n        return Math.round(ms / m) + \"m\";\n      }\n      if (msAbs >= s) {\n        return Math.round(ms / s) + \"s\";\n      }\n      return ms + \"ms\";\n    }\n    function fmtLong(ms) {\n      var msAbs = Math.abs(ms);\n      if (msAbs >= d) {\n        return plural(ms, msAbs, d, \"day\");\n      }\n      if (msAbs >= h) {\n        return plural(ms, msAbs, h, \"hour\");\n      }\n      if (msAbs >= m) {\n        return plural(ms, msAbs, m, \"minute\");\n      }\n      if (msAbs >= s) {\n        return plural(ms, msAbs, s, \"second\");\n      }\n      return ms + \" ms\";\n    }\n    function plural(ms, msAbs, n, name) {\n      var isPlural = msAbs >= n * 1.5;\n      return Math.round(ms / n) + \" \" + name + (isPlural ? \"s\" : \"\");\n    }\n  }\n});\n\n// node_modules/debug/src/common.js\nvar require_common = __commonJS({\n  \"node_modules/debug/src/common.js\"(exports2, module2) {\n    function setup(env) {\n      createDebug.debug = createDebug;\n      createDebug.default = createDebug;\n      createDebug.coerce = coerce2;\n      createDebug.disable = disable;\n      createDebug.enable = enable;\n      createDebug.enabled = enabled;\n      createDebug.humanize = require_ms();\n      createDebug.destroy = destroy;\n      Object.keys(env).forEach((key) => {\n        createDebug[key] = env[key];\n      });\n      createDebug.names = [];\n      createDebug.skips = [];\n      createDebug.formatters = {};\n      function selectColor(namespace) {\n        let hash = 0;\n        for (let i = 0; i < namespace.length; i++) {\n          hash = (hash << 5) - hash + namespace.charCodeAt(i);\n          hash |= 0;\n        }\n        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n      }\n      createDebug.selectColor = selectColor;\n      function createDebug(namespace) {\n        let prevTime;\n        let enableOverride = null;\n        let namespacesCache;\n        let enabledCache;\n        function debug(...args) {\n          if (!debug.enabled) {\n            return;\n          }\n          const self2 = debug;\n          const curr = Number(/* @__PURE__ */ new Date());\n          const ms = curr - (prevTime || curr);\n          self2.diff = ms;\n          self2.prev = prevTime;\n          self2.curr = curr;\n          prevTime = curr;\n          args[0] = createDebug.coerce(args[0]);\n          if (typeof args[0] !== \"string\") {\n            args.unshift(\"%O\");\n          }\n          let index = 0;\n          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n            if (match === \"%%\") {\n              return \"%\";\n            }\n            index++;\n            const formatter = createDebug.formatters[format];\n            if (typeof formatter === \"function\") {\n              const val = args[index];\n              match = formatter.call(self2, val);\n              args.splice(index, 1);\n              index--;\n            }\n            return match;\n          });\n          createDebug.formatArgs.call(self2, args);\n          const logFn = self2.log || createDebug.log;\n          logFn.apply(self2, args);\n        }\n        debug.namespace = namespace;\n        debug.useColors = createDebug.useColors();\n        debug.color = createDebug.selectColor(namespace);\n        debug.extend = extend;\n        debug.destroy = createDebug.destroy;\n        Object.defineProperty(debug, \"enabled\", {\n          enumerable: true,\n          configurable: false,\n          get: () => {\n            if (enableOverride !== null) {\n              return enableOverride;\n            }\n            if (namespacesCache !== createDebug.namespaces) {\n              namespacesCache = createDebug.namespaces;\n              enabledCache = createDebug.enabled(namespace);\n            }\n            return enabledCache;\n          },\n          set: (v) => {\n            enableOverride = v;\n          }\n        });\n        if (typeof createDebug.init === \"function\") {\n          createDebug.init(debug);\n        }\n        return debug;\n      }\n      function extend(namespace, delimiter) {\n        const newDebug = createDebug(this.namespace + (typeof delimiter === \"undefined\" ? \":\" : delimiter) + namespace);\n        newDebug.log = this.log;\n        return newDebug;\n      }\n      function enable(namespaces) {\n        createDebug.save(namespaces);\n        createDebug.namespaces = namespaces;\n        createDebug.names = [];\n        createDebug.skips = [];\n        const split = (typeof namespaces === \"string\" ? namespaces : \"\").trim().replace(/\\s+/g, \",\").split(\",\").filter(Boolean);\n        for (const ns of split) {\n          if (ns[0] === \"-\") {\n            createDebug.skips.push(ns.slice(1));\n          } else {\n            createDebug.names.push(ns);\n          }\n        }\n      }\n      function matchesTemplate(search, template) {\n        let searchIndex = 0;\n        let templateIndex = 0;\n        let starIndex = -1;\n        let matchIndex = 0;\n        while (searchIndex < search.length) {\n          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === \"*\")) {\n            if (template[templateIndex] === \"*\") {\n              starIndex = templateIndex;\n              matchIndex = searchIndex;\n              templateIndex++;\n            } else {\n              searchIndex++;\n              templateIndex++;\n            }\n          } else if (starIndex !== -1) {\n            templateIndex = starIndex + 1;\n            matchIndex++;\n            searchIndex = matchIndex;\n          } else {\n            return false;\n          }\n        }\n        while (templateIndex < template.length && template[templateIndex] === \"*\") {\n          templateIndex++;\n        }\n        return templateIndex === template.length;\n      }\n      function disable() {\n        const namespaces = [\n          ...createDebug.names,\n          ...createDebug.skips.map((namespace) => \"-\" + namespace)\n        ].join(\",\");\n        createDebug.enable(\"\");\n        return namespaces;\n      }\n      function enabled(name) {\n        for (const skip of createDebug.skips) {\n          if (matchesTemplate(name, skip)) {\n            return false;\n          }\n        }\n        for (const ns of createDebug.names) {\n          if (matchesTemplate(name, ns)) {\n            return true;\n          }\n        }\n        return false;\n      }\n      function coerce2(val) {\n        if (val instanceof Error) {\n          return val.stack || val.message;\n        }\n        return val;\n      }\n      function destroy() {\n        console.warn(\"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.\");\n      }\n      createDebug.enable(createDebug.load());\n      return createDebug;\n    }\n    module2.exports = setup;\n  }\n});\n\n// node_modules/debug/src/browser.js\nvar require_browser = __commonJS({\n  \"node_modules/debug/src/browser.js\"(exports2, module2) {\n    exports2.formatArgs = formatArgs;\n    exports2.save = save;\n    exports2.load = load;\n    exports2.useColors = useColors;\n    exports2.storage = localstorage();\n    exports2.destroy = /* @__PURE__ */ (() => {\n      let warned = false;\n      return () => {\n        if (!warned) {\n          warned = true;\n          console.warn(\"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.\");\n        }\n      };\n    })();\n    exports2.colors = [\n      \"#0000CC\",\n      \"#0000FF\",\n      \"#0033CC\",\n      \"#0033FF\",\n      \"#0066CC\",\n      \"#0066FF\",\n      \"#0099CC\",\n      \"#0099FF\",\n      \"#00CC00\",\n      \"#00CC33\",\n      \"#00CC66\",\n      \"#00CC99\",\n      \"#00CCCC\",\n      \"#00CCFF\",\n      \"#3300CC\",\n      \"#3300FF\",\n      \"#3333CC\",\n      \"#3333FF\",\n      \"#3366CC\",\n      \"#3366FF\",\n      \"#3399CC\",\n      \"#3399FF\",\n      \"#33CC00\",\n      \"#33CC33\",\n      \"#33CC66\",\n      \"#33CC99\",\n      \"#33CCCC\",\n      \"#33CCFF\",\n      \"#6600CC\",\n      \"#6600FF\",\n      \"#6633CC\",\n      \"#6633FF\",\n      \"#66CC00\",\n      \"#66CC33\",\n      \"#9900CC\",\n      \"#9900FF\",\n      \"#9933CC\",\n      \"#9933FF\",\n      \"#99CC00\",\n      \"#99CC33\",\n      \"#CC0000\",\n      \"#CC0033\",\n      \"#CC0066\",\n      \"#CC0099\",\n      \"#CC00CC\",\n      \"#CC00FF\",\n      \"#CC3300\",\n      \"#CC3333\",\n      \"#CC3366\",\n      \"#CC3399\",\n      \"#CC33CC\",\n      \"#CC33FF\",\n      \"#CC6600\",\n      \"#CC6633\",\n      \"#CC9900\",\n      \"#CC9933\",\n      \"#CCCC00\",\n      \"#CCCC33\",\n      \"#FF0000\",\n      \"#FF0033\",\n      \"#FF0066\",\n      \"#FF0099\",\n      \"#FF00CC\",\n      \"#FF00FF\",\n      \"#FF3300\",\n      \"#FF3333\",\n      \"#FF3366\",\n      \"#FF3399\",\n      \"#FF33CC\",\n      \"#FF33FF\",\n      \"#FF6600\",\n      \"#FF6633\",\n      \"#FF9900\",\n      \"#FF9933\",\n      \"#FFCC00\",\n      \"#FFCC33\"\n    ];\n    function useColors() {\n      if (typeof window !== \"undefined\" && window.process && (window.process.type === \"renderer\" || window.process.__nwjs)) {\n        return true;\n      }\n      if (typeof navigator !== \"undefined\" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n        return false;\n      }\n      let m;\n      return typeof document !== \"undefined\" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773\n      typeof window !== \"undefined\" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?\n      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n      typeof navigator !== \"undefined\" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker\n      typeof navigator !== \"undefined\" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/);\n    }\n    function formatArgs(args) {\n      args[0] = (this.useColors ? \"%c\" : \"\") + this.namespace + (this.useColors ? \" %c\" : \" \") + args[0] + (this.useColors ? \"%c \" : \" \") + \"+\" + module2.exports.humanize(this.diff);\n      if (!this.useColors) {\n        return;\n      }\n      const c = \"color: \" + this.color;\n      args.splice(1, 0, c, \"color: inherit\");\n      let index = 0;\n      let lastC = 0;\n      args[0].replace(/%[a-zA-Z%]/g, (match) => {\n        if (match === \"%%\") {\n          return;\n        }\n        index++;\n        if (match === \"%c\") {\n          lastC = index;\n        }\n      });\n      args.splice(lastC, 0, c);\n    }\n    exports2.log = console.debug || console.log || (() => {\n    });\n    function save(namespaces) {\n      try {\n        if (namespaces) {\n          exports2.storage.setItem(\"debug\", namespaces);\n        } else {\n          exports2.storage.removeItem(\"debug\");\n        }\n      } catch (error) {\n      }\n    }\n    function load() {\n      let r;\n      try {\n        r = exports2.storage.getItem(\"debug\") || exports2.storage.getItem(\"DEBUG\");\n      } catch (error) {\n      }\n      if (!r && typeof process !== \"undefined\" && \"env\" in process) {\n        r = process.env.DEBUG;\n      }\n      return r;\n    }\n    function localstorage() {\n      try {\n        return localStorage;\n      } catch (error) {\n      }\n    }\n    module2.exports = require_common()(exports2);\n    var { formatters } = module2.exports;\n    formatters.j = function(v) {\n      try {\n        return JSON.stringify(v);\n      } catch (error) {\n        return \"[UnexpectedJSONParseError]: \" + error.message;\n      }\n    };\n  }\n});\n\n// node_modules/has-flag/index.js\nvar require_has_flag = __commonJS({\n  \"node_modules/has-flag/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = (flag, argv = process.argv) => {\n      const prefix = flag.startsWith(\"-\") ? \"\" : flag.length === 1 ? \"-\" : \"--\";\n      const position = argv.indexOf(prefix + flag);\n      const terminatorPosition = argv.indexOf(\"--\");\n      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);\n    };\n  }\n});\n\n// node_modules/supports-color/index.js\nvar require_supports_color = __commonJS({\n  \"node_modules/supports-color/index.js\"(exports2, module2) {\n    \"use strict\";\n    var os = require(\"os\");\n    var tty = require(\"tty\");\n    var hasFlag = require_has_flag();\n    var { env } = process;\n    var forceColor;\n    if (hasFlag(\"no-color\") || hasFlag(\"no-colors\") || hasFlag(\"color=false\") || hasFlag(\"color=never\")) {\n      forceColor = 0;\n    } else if (hasFlag(\"color\") || hasFlag(\"colors\") || hasFlag(\"color=true\") || hasFlag(\"color=always\")) {\n      forceColor = 1;\n    }\n    if (\"FORCE_COLOR\" in env) {\n      if (env.FORCE_COLOR === \"true\") {\n        forceColor = 1;\n      } else if (env.FORCE_COLOR === \"false\") {\n        forceColor = 0;\n      } else {\n        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);\n      }\n    }\n    function translateLevel(level) {\n      if (level === 0) {\n        return false;\n      }\n      return {\n        level,\n        hasBasic: true,\n        has256: level >= 2,\n        has16m: level >= 3\n      };\n    }\n    function supportsColor(haveStream, streamIsTTY) {\n      if (forceColor === 0) {\n        return 0;\n      }\n      if (hasFlag(\"color=16m\") || hasFlag(\"color=full\") || hasFlag(\"color=truecolor\")) {\n        return 3;\n      }\n      if (hasFlag(\"color=256\")) {\n        return 2;\n      }\n      if (haveStream && !streamIsTTY && forceColor === void 0) {\n        return 0;\n      }\n      const min = forceColor || 0;\n      if (env.TERM === \"dumb\") {\n        return min;\n      }\n      if (process.platform === \"win32\") {\n        const osRelease = os.release().split(\".\");\n        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {\n          return Number(osRelease[2]) >= 14931 ? 3 : 2;\n        }\n        return 1;\n      }\n      if (\"CI\" in env) {\n        if ([\"TRAVIS\", \"CIRCLECI\", \"APPVEYOR\", \"GITLAB_CI\", \"GITHUB_ACTIONS\", \"BUILDKITE\"].some((sign) => sign in env) || env.CI_NAME === \"codeship\") {\n          return 1;\n        }\n        return min;\n      }\n      if (\"TEAMCITY_VERSION\" in env) {\n        return /^(9\\.(0*[1-9]\\d*)\\.|\\d{2,}\\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;\n      }\n      if (env.COLORTERM === \"truecolor\") {\n        return 3;\n      }\n      if (\"TERM_PROGRAM\" in env) {\n        const version = parseInt((env.TERM_PROGRAM_VERSION || \"\").split(\".\")[0], 10);\n        switch (env.TERM_PROGRAM) {\n          case \"iTerm.app\":\n            return version >= 3 ? 3 : 2;\n          case \"Apple_Terminal\":\n            return 2;\n        }\n      }\n      if (/-256(color)?$/i.test(env.TERM)) {\n        return 2;\n      }\n      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {\n        return 1;\n      }\n      if (\"COLORTERM\" in env) {\n        return 1;\n      }\n      return min;\n    }\n    function getSupportLevel(stream) {\n      const level = supportsColor(stream, stream && stream.isTTY);\n      return translateLevel(level);\n    }\n    module2.exports = {\n      supportsColor: getSupportLevel,\n      stdout: translateLevel(supportsColor(true, tty.isatty(1))),\n      stderr: translateLevel(supportsColor(true, tty.isatty(2)))\n    };\n  }\n});\n\n// node_modules/debug/src/node.js\nvar require_node = __commonJS({\n  \"node_modules/debug/src/node.js\"(exports2, module2) {\n    var tty = require(\"tty\");\n    var util2 = require(\"util\");\n    exports2.init = init;\n    exports2.log = log;\n    exports2.formatArgs = formatArgs;\n    exports2.save = save;\n    exports2.load = load;\n    exports2.useColors = useColors;\n    exports2.destroy = util2.deprecate(\n      () => {\n      },\n      \"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.\"\n    );\n    exports2.colors = [6, 2, 3, 4, 5, 1];\n    try {\n      const supportsColor = require_supports_color();\n      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {\n        exports2.colors = [\n          20,\n          21,\n          26,\n          27,\n          32,\n          33,\n          38,\n          39,\n          40,\n          41,\n          42,\n          43,\n          44,\n          45,\n          56,\n          57,\n          62,\n          63,\n          68,\n          69,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          92,\n          93,\n          98,\n          99,\n          112,\n          113,\n          128,\n          129,\n          134,\n          135,\n          148,\n          149,\n          160,\n          161,\n          162,\n          163,\n          164,\n          165,\n          166,\n          167,\n          168,\n          169,\n          170,\n          171,\n          172,\n          173,\n          178,\n          179,\n          184,\n          185,\n          196,\n          197,\n          198,\n          199,\n          200,\n          201,\n          202,\n          203,\n          204,\n          205,\n          206,\n          207,\n          208,\n          209,\n          214,\n          215,\n          220,\n          221\n        ];\n      }\n    } catch (error) {\n    }\n    exports2.inspectOpts = Object.keys(process.env).filter((key) => {\n      return /^debug_/i.test(key);\n    }).reduce((obj, key) => {\n      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_2, k) => {\n        return k.toUpperCase();\n      });\n      let val = process.env[key];\n      if (/^(yes|on|true|enabled)$/i.test(val)) {\n        val = true;\n      } else if (/^(no|off|false|disabled)$/i.test(val)) {\n        val = false;\n      } else if (val === \"null\") {\n        val = null;\n      } else {\n        val = Number(val);\n      }\n      obj[prop] = val;\n      return obj;\n    }, {});\n    function useColors() {\n      return \"colors\" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);\n    }\n    function formatArgs(args) {\n      const { namespace: name, useColors: useColors2 } = this;\n      if (useColors2) {\n        const c = this.color;\n        const colorCode = \"\\x1B[3\" + (c < 8 ? c : \"8;5;\" + c);\n        const prefix = `  ${colorCode};1m${name} \\x1B[0m`;\n        args[0] = prefix + args[0].split(\"\\n\").join(\"\\n\" + prefix);\n        args.push(colorCode + \"m+\" + module2.exports.humanize(this.diff) + \"\\x1B[0m\");\n      } else {\n        args[0] = getDate() + name + \" \" + args[0];\n      }\n    }\n    function getDate() {\n      if (exports2.inspectOpts.hideDate) {\n        return \"\";\n      }\n      return (/* @__PURE__ */ new Date()).toISOString() + \" \";\n    }\n    function log(...args) {\n      return process.stderr.write(util2.formatWithOptions(exports2.inspectOpts, ...args) + \"\\n\");\n    }\n    function save(namespaces) {\n      if (namespaces) {\n        process.env.DEBUG = namespaces;\n      } else {\n        delete process.env.DEBUG;\n      }\n    }\n    function load() {\n      return process.env.DEBUG;\n    }\n    function init(debug) {\n      debug.inspectOpts = {};\n      const keys = Object.keys(exports2.inspectOpts);\n      for (let i = 0; i < keys.length; i++) {\n        debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];\n      }\n    }\n    module2.exports = require_common()(exports2);\n    var { formatters } = module2.exports;\n    formatters.o = function(v) {\n      this.inspectOpts.colors = this.useColors;\n      return util2.inspect(v, this.inspectOpts).split(\"\\n\").map((str) => str.trim()).join(\" \");\n    };\n    formatters.O = function(v) {\n      this.inspectOpts.colors = this.useColors;\n      return util2.inspect(v, this.inspectOpts);\n    };\n  }\n});\n\n// node_modules/debug/src/index.js\nvar require_src = __commonJS({\n  \"node_modules/debug/src/index.js\"(exports2, module2) {\n    if (typeof process === \"undefined\" || process.type === \"renderer\" || process.browser === true || process.__nwjs) {\n      module2.exports = require_browser();\n    } else {\n      module2.exports = require_node();\n    }\n  }\n});\n\n// node_modules/ee-first/index.js\nvar require_ee_first = __commonJS({\n  \"node_modules/ee-first/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = first;\n    function first(stuff, done) {\n      if (!Array.isArray(stuff))\n        throw new TypeError(\"arg must be an array of [ee, events...] arrays\");\n      var cleanups = [];\n      for (var i = 0; i < stuff.length; i++) {\n        var arr = stuff[i];\n        if (!Array.isArray(arr) || arr.length < 2)\n          throw new TypeError(\"each array member must be [ee, events...]\");\n        var ee = arr[0];\n        for (var j = 1; j < arr.length; j++) {\n          var event = arr[j];\n          var fn = listener(event, callback);\n          ee.on(event, fn);\n          cleanups.push({\n            ee,\n            event,\n            fn\n          });\n        }\n      }\n      function callback() {\n        cleanup();\n        done.apply(null, arguments);\n      }\n      function cleanup() {\n        var x;\n        for (var i2 = 0; i2 < cleanups.length; i2++) {\n          x = cleanups[i2];\n          x.ee.removeListener(x.event, x.fn);\n        }\n      }\n      function thunk(fn2) {\n        done = fn2;\n      }\n      thunk.cancel = cleanup;\n      return thunk;\n    }\n    function listener(event, done) {\n      return function onevent(arg1) {\n        var args = new Array(arguments.length);\n        var ee = this;\n        var err2 = event === \"error\" ? arg1 : null;\n        for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i];\n        }\n        done(err2, ee, event, args);\n      };\n    }\n  }\n});\n\n// node_modules/on-finished/index.js\nvar require_on_finished = __commonJS({\n  \"node_modules/on-finished/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = onFinished;\n    module2.exports.isFinished = isFinished;\n    var asyncHooks = tryRequireAsyncHooks();\n    var first = require_ee_first();\n    var defer = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n      process.nextTick(fn.bind.apply(fn, arguments));\n    };\n    function onFinished(msg, listener) {\n      if (isFinished(msg) !== false) {\n        defer(listener, null, msg);\n        return msg;\n      }\n      attachListener(msg, wrap(listener));\n      return msg;\n    }\n    function isFinished(msg) {\n      var socket = msg.socket;\n      if (typeof msg.finished === \"boolean\") {\n        return Boolean(msg.finished || socket && !socket.writable);\n      }\n      if (typeof msg.complete === \"boolean\") {\n        return Boolean(msg.upgrade || !socket || !socket.readable || msg.complete && !msg.readable);\n      }\n      return void 0;\n    }\n    function attachFinishedListener(msg, callback) {\n      var eeMsg;\n      var eeSocket;\n      var finished = false;\n      function onFinish(error) {\n        eeMsg.cancel();\n        eeSocket.cancel();\n        finished = true;\n        callback(error);\n      }\n      eeMsg = eeSocket = first([[msg, \"end\", \"finish\"]], onFinish);\n      function onSocket(socket) {\n        msg.removeListener(\"socket\", onSocket);\n        if (finished) return;\n        if (eeMsg !== eeSocket) return;\n        eeSocket = first([[socket, \"error\", \"close\"]], onFinish);\n      }\n      if (msg.socket) {\n        onSocket(msg.socket);\n        return;\n      }\n      msg.on(\"socket\", onSocket);\n      if (msg.socket === void 0) {\n        patchAssignSocket(msg, onSocket);\n      }\n    }\n    function attachListener(msg, listener) {\n      var attached = msg.__onFinished;\n      if (!attached || !attached.queue) {\n        attached = msg.__onFinished = createListener(msg);\n        attachFinishedListener(msg, attached);\n      }\n      attached.queue.push(listener);\n    }\n    function createListener(msg) {\n      function listener(err2) {\n        if (msg.__onFinished === listener) msg.__onFinished = null;\n        if (!listener.queue) return;\n        var queue = listener.queue;\n        listener.queue = null;\n        for (var i = 0; i < queue.length; i++) {\n          queue[i](err2, msg);\n        }\n      }\n      listener.queue = [];\n      return listener;\n    }\n    function patchAssignSocket(res, callback) {\n      var assignSocket = res.assignSocket;\n      if (typeof assignSocket !== \"function\") return;\n      res.assignSocket = function _assignSocket(socket) {\n        assignSocket.call(this, socket);\n        callback(socket);\n      };\n    }\n    function tryRequireAsyncHooks() {\n      try {\n        return require(\"async_hooks\");\n      } catch (e) {\n        return {};\n      }\n    }\n    function wrap(fn) {\n      var res;\n      if (asyncHooks.AsyncResource) {\n        res = new asyncHooks.AsyncResource(fn.name || \"bound-anonymous-fn\");\n      }\n      if (!res || !res.runInAsyncScope) {\n        return fn;\n      }\n      return res.runInAsyncScope.bind(res, fn, null);\n    }\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/lib/bom-handling.js\nvar require_bom_handling2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/lib/bom-handling.js\"(exports2) {\n    \"use strict\";\n    var BOMChar = \"\\uFEFF\";\n    exports2.PrependBOM = PrependBOMWrapper;\n    function PrependBOMWrapper(encoder, options) {\n      this.encoder = encoder;\n      this.addBOM = true;\n    }\n    PrependBOMWrapper.prototype.write = function(str) {\n      if (this.addBOM) {\n        str = BOMChar + str;\n        this.addBOM = false;\n      }\n      return this.encoder.write(str);\n    };\n    PrependBOMWrapper.prototype.end = function() {\n      return this.encoder.end();\n    };\n    exports2.StripBOM = StripBOMWrapper;\n    function StripBOMWrapper(decoder, options) {\n      this.decoder = decoder;\n      this.pass = false;\n      this.options = options || {};\n    }\n    StripBOMWrapper.prototype.write = function(buf) {\n      var res = this.decoder.write(buf);\n      if (this.pass || !res)\n        return res;\n      if (res[0] === BOMChar) {\n        res = res.slice(1);\n        if (typeof this.options.stripBOM === \"function\")\n          this.options.stripBOM();\n      }\n      this.pass = true;\n      return res;\n    };\n    StripBOMWrapper.prototype.end = function() {\n      return this.decoder.end();\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/internal.js\nvar require_internal2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/internal.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    module2.exports = {\n      // Encodings\n      utf8: { type: \"_internal\", bomAware: true },\n      cesu8: { type: \"_internal\", bomAware: true },\n      unicode11utf8: \"utf8\",\n      ucs2: { type: \"_internal\", bomAware: true },\n      utf16le: \"ucs2\",\n      binary: { type: \"_internal\" },\n      base64: { type: \"_internal\" },\n      hex: { type: \"_internal\" },\n      // Codec.\n      _internal: InternalCodec\n    };\n    function InternalCodec(codecOptions, iconv) {\n      this.enc = codecOptions.encodingName;\n      this.bomAware = codecOptions.bomAware;\n      if (this.enc === \"base64\")\n        this.encoder = InternalEncoderBase64;\n      else if (this.enc === \"cesu8\") {\n        this.enc = \"utf8\";\n        this.encoder = InternalEncoderCesu8;\n        if (Buffer2.from(\"eda0bdedb2a9\", \"hex\").toString() !== \"\\u{1F4A9}\") {\n          this.decoder = InternalDecoderCesu8;\n          this.defaultCharUnicode = iconv.defaultCharUnicode;\n        }\n      }\n    }\n    InternalCodec.prototype.encoder = InternalEncoder;\n    InternalCodec.prototype.decoder = InternalDecoder;\n    var StringDecoder = require(\"string_decoder\").StringDecoder;\n    if (!StringDecoder.prototype.end)\n      StringDecoder.prototype.end = function() {\n      };\n    function InternalDecoder(options, codec) {\n      this.decoder = new StringDecoder(codec.enc);\n    }\n    InternalDecoder.prototype.write = function(buf) {\n      if (!Buffer2.isBuffer(buf)) {\n        buf = Buffer2.from(buf);\n      }\n      return this.decoder.write(buf);\n    };\n    InternalDecoder.prototype.end = function() {\n      return this.decoder.end();\n    };\n    function InternalEncoder(options, codec) {\n      this.enc = codec.enc;\n    }\n    InternalEncoder.prototype.write = function(str) {\n      return Buffer2.from(str, this.enc);\n    };\n    InternalEncoder.prototype.end = function() {\n    };\n    function InternalEncoderBase64(options, codec) {\n      this.prevStr = \"\";\n    }\n    InternalEncoderBase64.prototype.write = function(str) {\n      str = this.prevStr + str;\n      var completeQuads = str.length - str.length % 4;\n      this.prevStr = str.slice(completeQuads);\n      str = str.slice(0, completeQuads);\n      return Buffer2.from(str, \"base64\");\n    };\n    InternalEncoderBase64.prototype.end = function() {\n      return Buffer2.from(this.prevStr, \"base64\");\n    };\n    function InternalEncoderCesu8(options, codec) {\n    }\n    InternalEncoderCesu8.prototype.write = function(str) {\n      var buf = Buffer2.alloc(str.length * 3), bufIdx = 0;\n      for (var i = 0; i < str.length; i++) {\n        var charCode = str.charCodeAt(i);\n        if (charCode < 128)\n          buf[bufIdx++] = charCode;\n        else if (charCode < 2048) {\n          buf[bufIdx++] = 192 + (charCode >>> 6);\n          buf[bufIdx++] = 128 + (charCode & 63);\n        } else {\n          buf[bufIdx++] = 224 + (charCode >>> 12);\n          buf[bufIdx++] = 128 + (charCode >>> 6 & 63);\n          buf[bufIdx++] = 128 + (charCode & 63);\n        }\n      }\n      return buf.slice(0, bufIdx);\n    };\n    InternalEncoderCesu8.prototype.end = function() {\n    };\n    function InternalDecoderCesu8(options, codec) {\n      this.acc = 0;\n      this.contBytes = 0;\n      this.accBytes = 0;\n      this.defaultCharUnicode = codec.defaultCharUnicode;\n    }\n    InternalDecoderCesu8.prototype.write = function(buf) {\n      var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = \"\";\n      for (var i = 0; i < buf.length; i++) {\n        var curByte = buf[i];\n        if ((curByte & 192) !== 128) {\n          if (contBytes > 0) {\n            res += this.defaultCharUnicode;\n            contBytes = 0;\n          }\n          if (curByte < 128) {\n            res += String.fromCharCode(curByte);\n          } else if (curByte < 224) {\n            acc = curByte & 31;\n            contBytes = 1;\n            accBytes = 1;\n          } else if (curByte < 240) {\n            acc = curByte & 15;\n            contBytes = 2;\n            accBytes = 1;\n          } else {\n            res += this.defaultCharUnicode;\n          }\n        } else {\n          if (contBytes > 0) {\n            acc = acc << 6 | curByte & 63;\n            contBytes--;\n            accBytes++;\n            if (contBytes === 0) {\n              if (accBytes === 2 && acc < 128 && acc > 0)\n                res += this.defaultCharUnicode;\n              else if (accBytes === 3 && acc < 2048)\n                res += this.defaultCharUnicode;\n              else\n                res += String.fromCharCode(acc);\n            }\n          } else {\n            res += this.defaultCharUnicode;\n          }\n        }\n      }\n      this.acc = acc;\n      this.contBytes = contBytes;\n      this.accBytes = accBytes;\n      return res;\n    };\n    InternalDecoderCesu8.prototype.end = function() {\n      var res = 0;\n      if (this.contBytes > 0)\n        res += this.defaultCharUnicode;\n      return res;\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/utf32.js\nvar require_utf322 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/utf32.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._utf32 = Utf32Codec;\n    function Utf32Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n      this.bomAware = true;\n      this.isLE = codecOptions.isLE;\n    }\n    exports2.utf32le = { type: \"_utf32\", isLE: true };\n    exports2.utf32be = { type: \"_utf32\", isLE: false };\n    exports2.ucs4le = \"utf32le\";\n    exports2.ucs4be = \"utf32be\";\n    Utf32Codec.prototype.encoder = Utf32Encoder;\n    Utf32Codec.prototype.decoder = Utf32Decoder;\n    function Utf32Encoder(options, codec) {\n      this.isLE = codec.isLE;\n      this.highSurrogate = 0;\n    }\n    Utf32Encoder.prototype.write = function(str) {\n      var src = Buffer2.from(str, \"ucs2\");\n      var dst = Buffer2.alloc(src.length * 2);\n      var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;\n      var offset = 0;\n      for (var i = 0; i < src.length; i += 2) {\n        var code = src.readUInt16LE(i);\n        var isHighSurrogate = 55296 <= code && code < 56320;\n        var isLowSurrogate = 56320 <= code && code < 57344;\n        if (this.highSurrogate) {\n          if (isHighSurrogate || !isLowSurrogate) {\n            write32.call(dst, this.highSurrogate, offset);\n            offset += 4;\n          } else {\n            var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536;\n            write32.call(dst, codepoint, offset);\n            offset += 4;\n            this.highSurrogate = 0;\n            continue;\n          }\n        }\n        if (isHighSurrogate)\n          this.highSurrogate = code;\n        else {\n          write32.call(dst, code, offset);\n          offset += 4;\n          this.highSurrogate = 0;\n        }\n      }\n      if (offset < dst.length)\n        dst = dst.slice(0, offset);\n      return dst;\n    };\n    Utf32Encoder.prototype.end = function() {\n      if (!this.highSurrogate)\n        return;\n      var buf = Buffer2.alloc(4);\n      if (this.isLE)\n        buf.writeUInt32LE(this.highSurrogate, 0);\n      else\n        buf.writeUInt32BE(this.highSurrogate, 0);\n      this.highSurrogate = 0;\n      return buf;\n    };\n    function Utf32Decoder(options, codec) {\n      this.isLE = codec.isLE;\n      this.badChar = codec.iconv.defaultCharUnicode.charCodeAt(0);\n      this.overflow = [];\n    }\n    Utf32Decoder.prototype.write = function(src) {\n      if (src.length === 0)\n        return \"\";\n      var i = 0;\n      var codepoint = 0;\n      var dst = Buffer2.alloc(src.length + 4);\n      var offset = 0;\n      var isLE = this.isLE;\n      var overflow = this.overflow;\n      var badChar = this.badChar;\n      if (overflow.length > 0) {\n        for (; i < src.length && overflow.length < 4; i++)\n          overflow.push(src[i]);\n        if (overflow.length === 4) {\n          if (isLE) {\n            codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;\n          } else {\n            codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 24;\n          }\n          overflow.length = 0;\n          offset = _writeCodepoint(dst, offset, codepoint, badChar);\n        }\n      }\n      for (; i < src.length - 3; i += 4) {\n        if (isLE) {\n          codepoint = src[i] | src[i + 1] << 8 | src[i + 2] << 16 | src[i + 3] << 24;\n        } else {\n          codepoint = src[i + 3] | src[i + 2] << 8 | src[i + 1] << 16 | src[i] << 24;\n        }\n        offset = _writeCodepoint(dst, offset, codepoint, badChar);\n      }\n      for (; i < src.length; i++) {\n        overflow.push(src[i]);\n      }\n      return dst.slice(0, offset).toString(\"ucs2\");\n    };\n    function _writeCodepoint(dst, offset, codepoint, badChar) {\n      if (codepoint < 0 || codepoint > 1114111) {\n        codepoint = badChar;\n      }\n      if (codepoint >= 65536) {\n        codepoint -= 65536;\n        var high = 55296 | codepoint >> 10;\n        dst[offset++] = high & 255;\n        dst[offset++] = high >> 8;\n        var codepoint = 56320 | codepoint & 1023;\n      }\n      dst[offset++] = codepoint & 255;\n      dst[offset++] = codepoint >> 8;\n      return offset;\n    }\n    Utf32Decoder.prototype.end = function() {\n      this.overflow.length = 0;\n    };\n    exports2.utf32 = Utf32AutoCodec;\n    exports2.ucs4 = \"utf32\";\n    function Utf32AutoCodec(options, iconv) {\n      this.iconv = iconv;\n    }\n    Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;\n    Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;\n    function Utf32AutoEncoder(options, codec) {\n      options = options || {};\n      if (options.addBOM === void 0)\n        options.addBOM = true;\n      this.encoder = codec.iconv.getEncoder(options.defaultEncoding || \"utf-32le\", options);\n    }\n    Utf32AutoEncoder.prototype.write = function(str) {\n      return this.encoder.write(str);\n    };\n    Utf32AutoEncoder.prototype.end = function() {\n      return this.encoder.end();\n    };\n    function Utf32AutoDecoder(options, codec) {\n      this.decoder = null;\n      this.initialBufs = [];\n      this.initialBufsLen = 0;\n      this.options = options || {};\n      this.iconv = codec.iconv;\n    }\n    Utf32AutoDecoder.prototype.write = function(buf) {\n      if (!this.decoder) {\n        this.initialBufs.push(buf);\n        this.initialBufsLen += buf.length;\n        if (this.initialBufsLen < 32)\n          return \"\";\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.write(buf);\n    };\n    Utf32AutoDecoder.prototype.end = function() {\n      if (!this.decoder) {\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        var trail = this.decoder.end();\n        if (trail)\n          resStr += trail;\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.end();\n    };\n    function detectEncoding(bufs, defaultEncoding) {\n      var b = [];\n      var charsProcessed = 0;\n      var invalidLE = 0, invalidBE = 0;\n      var bmpCharsLE = 0, bmpCharsBE = 0;\n      outer_loop:\n        for (var i = 0; i < bufs.length; i++) {\n          var buf = bufs[i];\n          for (var j = 0; j < buf.length; j++) {\n            b.push(buf[j]);\n            if (b.length === 4) {\n              if (charsProcessed === 0) {\n                if (b[0] === 255 && b[1] === 254 && b[2] === 0 && b[3] === 0) {\n                  return \"utf-32le\";\n                }\n                if (b[0] === 0 && b[1] === 0 && b[2] === 254 && b[3] === 255) {\n                  return \"utf-32be\";\n                }\n              }\n              if (b[0] !== 0 || b[1] > 16) invalidBE++;\n              if (b[3] !== 0 || b[2] > 16) invalidLE++;\n              if (b[0] === 0 && b[1] === 0 && (b[2] !== 0 || b[3] !== 0)) bmpCharsBE++;\n              if ((b[0] !== 0 || b[1] !== 0) && b[2] === 0 && b[3] === 0) bmpCharsLE++;\n              b.length = 0;\n              charsProcessed++;\n              if (charsProcessed >= 100) {\n                break outer_loop;\n              }\n            }\n          }\n        }\n      if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return \"utf-32be\";\n      if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return \"utf-32le\";\n      return defaultEncoding || \"utf-32le\";\n    }\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/utf16.js\nvar require_utf162 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/utf16.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2.utf16be = Utf16BECodec;\n    function Utf16BECodec() {\n    }\n    Utf16BECodec.prototype.encoder = Utf16BEEncoder;\n    Utf16BECodec.prototype.decoder = Utf16BEDecoder;\n    Utf16BECodec.prototype.bomAware = true;\n    function Utf16BEEncoder() {\n    }\n    Utf16BEEncoder.prototype.write = function(str) {\n      var buf = Buffer2.from(str, \"ucs2\");\n      for (var i = 0; i < buf.length; i += 2) {\n        var tmp = buf[i];\n        buf[i] = buf[i + 1];\n        buf[i + 1] = tmp;\n      }\n      return buf;\n    };\n    Utf16BEEncoder.prototype.end = function() {\n    };\n    function Utf16BEDecoder() {\n      this.overflowByte = -1;\n    }\n    Utf16BEDecoder.prototype.write = function(buf) {\n      if (buf.length == 0)\n        return \"\";\n      var buf2 = Buffer2.alloc(buf.length + 1), i = 0, j = 0;\n      if (this.overflowByte !== -1) {\n        buf2[0] = buf[0];\n        buf2[1] = this.overflowByte;\n        i = 1;\n        j = 2;\n      }\n      for (; i < buf.length - 1; i += 2, j += 2) {\n        buf2[j] = buf[i + 1];\n        buf2[j + 1] = buf[i];\n      }\n      this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1;\n      return buf2.slice(0, j).toString(\"ucs2\");\n    };\n    Utf16BEDecoder.prototype.end = function() {\n      this.overflowByte = -1;\n    };\n    exports2.utf16 = Utf16Codec;\n    function Utf16Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf16Codec.prototype.encoder = Utf16Encoder;\n    Utf16Codec.prototype.decoder = Utf16Decoder;\n    function Utf16Encoder(options, codec) {\n      options = options || {};\n      if (options.addBOM === void 0)\n        options.addBOM = true;\n      this.encoder = codec.iconv.getEncoder(\"utf-16le\", options);\n    }\n    Utf16Encoder.prototype.write = function(str) {\n      return this.encoder.write(str);\n    };\n    Utf16Encoder.prototype.end = function() {\n      return this.encoder.end();\n    };\n    function Utf16Decoder(options, codec) {\n      this.decoder = null;\n      this.initialBufs = [];\n      this.initialBufsLen = 0;\n      this.options = options || {};\n      this.iconv = codec.iconv;\n    }\n    Utf16Decoder.prototype.write = function(buf) {\n      if (!this.decoder) {\n        this.initialBufs.push(buf);\n        this.initialBufsLen += buf.length;\n        if (this.initialBufsLen < 16)\n          return \"\";\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.write(buf);\n    };\n    Utf16Decoder.prototype.end = function() {\n      if (!this.decoder) {\n        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);\n        this.decoder = this.iconv.getDecoder(encoding, this.options);\n        var resStr = \"\";\n        for (var i = 0; i < this.initialBufs.length; i++)\n          resStr += this.decoder.write(this.initialBufs[i]);\n        var trail = this.decoder.end();\n        if (trail)\n          resStr += trail;\n        this.initialBufs.length = this.initialBufsLen = 0;\n        return resStr;\n      }\n      return this.decoder.end();\n    };\n    function detectEncoding(bufs, defaultEncoding) {\n      var b = [];\n      var charsProcessed = 0;\n      var asciiCharsLE = 0, asciiCharsBE = 0;\n      outer_loop:\n        for (var i = 0; i < bufs.length; i++) {\n          var buf = bufs[i];\n          for (var j = 0; j < buf.length; j++) {\n            b.push(buf[j]);\n            if (b.length === 2) {\n              if (charsProcessed === 0) {\n                if (b[0] === 255 && b[1] === 254) return \"utf-16le\";\n                if (b[0] === 254 && b[1] === 255) return \"utf-16be\";\n              }\n              if (b[0] === 0 && b[1] !== 0) asciiCharsBE++;\n              if (b[0] !== 0 && b[1] === 0) asciiCharsLE++;\n              b.length = 0;\n              charsProcessed++;\n              if (charsProcessed >= 100) {\n                break outer_loop;\n              }\n            }\n          }\n        }\n      if (asciiCharsBE > asciiCharsLE) return \"utf-16be\";\n      if (asciiCharsBE < asciiCharsLE) return \"utf-16le\";\n      return defaultEncoding || \"utf-16le\";\n    }\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/utf7.js\nvar require_utf72 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/utf7.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2.utf7 = Utf7Codec;\n    exports2.unicode11utf7 = \"utf7\";\n    function Utf7Codec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf7Codec.prototype.encoder = Utf7Encoder;\n    Utf7Codec.prototype.decoder = Utf7Decoder;\n    Utf7Codec.prototype.bomAware = true;\n    var nonDirectChars = /[^A-Za-z0-9'\\(\\),-\\.\\/:\\? \\n\\r\\t]+/g;\n    function Utf7Encoder(options, codec) {\n      this.iconv = codec.iconv;\n    }\n    Utf7Encoder.prototype.write = function(str) {\n      return Buffer2.from(str.replace(nonDirectChars, function(chunk) {\n        return \"+\" + (chunk === \"+\" ? \"\" : this.iconv.encode(chunk, \"utf16-be\").toString(\"base64\").replace(/=+$/, \"\")) + \"-\";\n      }.bind(this)));\n    };\n    Utf7Encoder.prototype.end = function() {\n    };\n    function Utf7Decoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n    }\n    var base64Regex2 = /[A-Za-z0-9\\/+]/;\n    var base64Chars = [];\n    for (i = 0; i < 256; i++)\n      base64Chars[i] = base64Regex2.test(String.fromCharCode(i));\n    var i;\n    var plusChar = \"+\".charCodeAt(0);\n    var minusChar = \"-\".charCodeAt(0);\n    var andChar = \"&\".charCodeAt(0);\n    Utf7Decoder.prototype.write = function(buf) {\n      var res = \"\", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;\n      for (var i2 = 0; i2 < buf.length; i2++) {\n        if (!inBase64) {\n          if (buf[i2] == plusChar) {\n            res += this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n            lastI = i2 + 1;\n            inBase64 = true;\n          }\n        } else {\n          if (!base64Chars[buf[i2]]) {\n            if (i2 == lastI && buf[i2] == minusChar) {\n              res += \"+\";\n            } else {\n              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n              res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n            }\n            if (buf[i2] != minusChar)\n              i2--;\n            lastI = i2 + 1;\n            inBase64 = false;\n            base64Accum = \"\";\n          }\n        }\n      }\n      if (!inBase64) {\n        res += this.iconv.decode(buf.slice(lastI), \"ascii\");\n      } else {\n        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), \"ascii\");\n        var canBeDecoded = b64str.length - b64str.length % 8;\n        base64Accum = b64str.slice(canBeDecoded);\n        b64str = b64str.slice(0, canBeDecoded);\n        res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n      }\n      this.inBase64 = inBase64;\n      this.base64Accum = base64Accum;\n      return res;\n    };\n    Utf7Decoder.prototype.end = function() {\n      var res = \"\";\n      if (this.inBase64 && this.base64Accum.length > 0)\n        res = this.iconv.decode(Buffer2.from(this.base64Accum, \"base64\"), \"utf16-be\");\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n      return res;\n    };\n    exports2.utf7imap = Utf7IMAPCodec;\n    function Utf7IMAPCodec(codecOptions, iconv) {\n      this.iconv = iconv;\n    }\n    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;\n    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;\n    Utf7IMAPCodec.prototype.bomAware = true;\n    function Utf7IMAPEncoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = Buffer2.alloc(6);\n      this.base64AccumIdx = 0;\n    }\n    Utf7IMAPEncoder.prototype.write = function(str) {\n      var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer2.alloc(str.length * 5 + 10), bufIdx = 0;\n      for (var i2 = 0; i2 < str.length; i2++) {\n        var uChar = str.charCodeAt(i2);\n        if (32 <= uChar && uChar <= 126) {\n          if (inBase64) {\n            if (base64AccumIdx > 0) {\n              bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString(\"base64\").replace(/\\//g, \",\").replace(/=+$/, \"\"), bufIdx);\n              base64AccumIdx = 0;\n            }\n            buf[bufIdx++] = minusChar;\n            inBase64 = false;\n          }\n          if (!inBase64) {\n            buf[bufIdx++] = uChar;\n            if (uChar === andChar)\n              buf[bufIdx++] = minusChar;\n          }\n        } else {\n          if (!inBase64) {\n            buf[bufIdx++] = andChar;\n            inBase64 = true;\n          }\n          if (inBase64) {\n            base64Accum[base64AccumIdx++] = uChar >> 8;\n            base64Accum[base64AccumIdx++] = uChar & 255;\n            if (base64AccumIdx == base64Accum.length) {\n              bufIdx += buf.write(base64Accum.toString(\"base64\").replace(/\\//g, \",\"), bufIdx);\n              base64AccumIdx = 0;\n            }\n          }\n        }\n      }\n      this.inBase64 = inBase64;\n      this.base64AccumIdx = base64AccumIdx;\n      return buf.slice(0, bufIdx);\n    };\n    Utf7IMAPEncoder.prototype.end = function() {\n      var buf = Buffer2.alloc(10), bufIdx = 0;\n      if (this.inBase64) {\n        if (this.base64AccumIdx > 0) {\n          bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString(\"base64\").replace(/\\//g, \",\").replace(/=+$/, \"\"), bufIdx);\n          this.base64AccumIdx = 0;\n        }\n        buf[bufIdx++] = minusChar;\n        this.inBase64 = false;\n      }\n      return buf.slice(0, bufIdx);\n    };\n    function Utf7IMAPDecoder(options, codec) {\n      this.iconv = codec.iconv;\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n    }\n    var base64IMAPChars = base64Chars.slice();\n    base64IMAPChars[\",\".charCodeAt(0)] = true;\n    Utf7IMAPDecoder.prototype.write = function(buf) {\n      var res = \"\", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;\n      for (var i2 = 0; i2 < buf.length; i2++) {\n        if (!inBase64) {\n          if (buf[i2] == andChar) {\n            res += this.iconv.decode(buf.slice(lastI, i2), \"ascii\");\n            lastI = i2 + 1;\n            inBase64 = true;\n          }\n        } else {\n          if (!base64IMAPChars[buf[i2]]) {\n            if (i2 == lastI && buf[i2] == minusChar) {\n              res += \"&\";\n            } else {\n              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i2), \"ascii\").replace(/,/g, \"/\");\n              res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n            }\n            if (buf[i2] != minusChar)\n              i2--;\n            lastI = i2 + 1;\n            inBase64 = false;\n            base64Accum = \"\";\n          }\n        }\n      }\n      if (!inBase64) {\n        res += this.iconv.decode(buf.slice(lastI), \"ascii\");\n      } else {\n        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), \"ascii\").replace(/,/g, \"/\");\n        var canBeDecoded = b64str.length - b64str.length % 8;\n        base64Accum = b64str.slice(canBeDecoded);\n        b64str = b64str.slice(0, canBeDecoded);\n        res += this.iconv.decode(Buffer2.from(b64str, \"base64\"), \"utf16-be\");\n      }\n      this.inBase64 = inBase64;\n      this.base64Accum = base64Accum;\n      return res;\n    };\n    Utf7IMAPDecoder.prototype.end = function() {\n      var res = \"\";\n      if (this.inBase64 && this.base64Accum.length > 0)\n        res = this.iconv.decode(Buffer2.from(this.base64Accum, \"base64\"), \"utf16-be\");\n      this.inBase64 = false;\n      this.base64Accum = \"\";\n      return res;\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-codec.js\nvar require_sbcs_codec2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-codec.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._sbcs = SBCSCodec;\n    function SBCSCodec(codecOptions, iconv) {\n      if (!codecOptions)\n        throw new Error(\"SBCS codec is called without the data.\");\n      if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)\n        throw new Error(\"Encoding '\" + codecOptions.type + \"' has incorrect 'chars' (must be of len 128 or 256)\");\n      if (codecOptions.chars.length === 128) {\n        var asciiString = \"\";\n        for (var i = 0; i < 128; i++)\n          asciiString += String.fromCharCode(i);\n        codecOptions.chars = asciiString + codecOptions.chars;\n      }\n      this.decodeBuf = Buffer2.from(codecOptions.chars, \"ucs2\");\n      var encodeBuf = Buffer2.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));\n      for (var i = 0; i < codecOptions.chars.length; i++)\n        encodeBuf[codecOptions.chars.charCodeAt(i)] = i;\n      this.encodeBuf = encodeBuf;\n    }\n    SBCSCodec.prototype.encoder = SBCSEncoder;\n    SBCSCodec.prototype.decoder = SBCSDecoder;\n    function SBCSEncoder(options, codec) {\n      this.encodeBuf = codec.encodeBuf;\n    }\n    SBCSEncoder.prototype.write = function(str) {\n      var buf = Buffer2.alloc(str.length);\n      for (var i = 0; i < str.length; i++)\n        buf[i] = this.encodeBuf[str.charCodeAt(i)];\n      return buf;\n    };\n    SBCSEncoder.prototype.end = function() {\n    };\n    function SBCSDecoder(options, codec) {\n      this.decodeBuf = codec.decodeBuf;\n    }\n    SBCSDecoder.prototype.write = function(buf) {\n      var decodeBuf = this.decodeBuf;\n      var newBuf = Buffer2.alloc(buf.length * 2);\n      var idx1 = 0, idx2 = 0;\n      for (var i = 0; i < buf.length; i++) {\n        idx1 = buf[i] * 2;\n        idx2 = i * 2;\n        newBuf[idx2] = decodeBuf[idx1];\n        newBuf[idx2 + 1] = decodeBuf[idx1 + 1];\n      }\n      return newBuf.toString(\"ucs2\");\n    };\n    SBCSDecoder.prototype.end = function() {\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-data.js\nvar require_sbcs_data2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-data.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      // Not supported by iconv, not sure why.\n      \"10029\": \"maccenteuro\",\n      \"maccenteuro\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"808\": \"cp808\",\n      \"ibm808\": \"cp808\",\n      \"cp808\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"mik\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp720\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      // Aliases of generated encodings.\n      \"ascii8bit\": \"ascii\",\n      \"usascii\": \"ascii\",\n      \"ansix34\": \"ascii\",\n      \"ansix341968\": \"ascii\",\n      \"ansix341986\": \"ascii\",\n      \"csascii\": \"ascii\",\n      \"cp367\": \"ascii\",\n      \"ibm367\": \"ascii\",\n      \"isoir6\": \"ascii\",\n      \"iso646us\": \"ascii\",\n      \"iso646irv\": \"ascii\",\n      \"us\": \"ascii\",\n      \"latin1\": \"iso88591\",\n      \"latin2\": \"iso88592\",\n      \"latin3\": \"iso88593\",\n      \"latin4\": \"iso88594\",\n      \"latin5\": \"iso88599\",\n      \"latin6\": \"iso885910\",\n      \"latin7\": \"iso885913\",\n      \"latin8\": \"iso885914\",\n      \"latin9\": \"iso885915\",\n      \"latin10\": \"iso885916\",\n      \"csisolatin1\": \"iso88591\",\n      \"csisolatin2\": \"iso88592\",\n      \"csisolatin3\": \"iso88593\",\n      \"csisolatin4\": \"iso88594\",\n      \"csisolatincyrillic\": \"iso88595\",\n      \"csisolatinarabic\": \"iso88596\",\n      \"csisolatingreek\": \"iso88597\",\n      \"csisolatinhebrew\": \"iso88598\",\n      \"csisolatin5\": \"iso88599\",\n      \"csisolatin6\": \"iso885910\",\n      \"l1\": \"iso88591\",\n      \"l2\": \"iso88592\",\n      \"l3\": \"iso88593\",\n      \"l4\": \"iso88594\",\n      \"l5\": \"iso88599\",\n      \"l6\": \"iso885910\",\n      \"l7\": \"iso885913\",\n      \"l8\": \"iso885914\",\n      \"l9\": \"iso885915\",\n      \"l10\": \"iso885916\",\n      \"isoir14\": \"iso646jp\",\n      \"isoir57\": \"iso646cn\",\n      \"isoir100\": \"iso88591\",\n      \"isoir101\": \"iso88592\",\n      \"isoir109\": \"iso88593\",\n      \"isoir110\": \"iso88594\",\n      \"isoir144\": \"iso88595\",\n      \"isoir127\": \"iso88596\",\n      \"isoir126\": \"iso88597\",\n      \"isoir138\": \"iso88598\",\n      \"isoir148\": \"iso88599\",\n      \"isoir157\": \"iso885910\",\n      \"isoir166\": \"tis620\",\n      \"isoir179\": \"iso885913\",\n      \"isoir199\": \"iso885914\",\n      \"isoir203\": \"iso885915\",\n      \"isoir226\": \"iso885916\",\n      \"cp819\": \"iso88591\",\n      \"ibm819\": \"iso88591\",\n      \"cyrillic\": \"iso88595\",\n      \"arabic\": \"iso88596\",\n      \"arabic8\": \"iso88596\",\n      \"ecma114\": \"iso88596\",\n      \"asmo708\": \"iso88596\",\n      \"greek\": \"iso88597\",\n      \"greek8\": \"iso88597\",\n      \"ecma118\": \"iso88597\",\n      \"elot928\": \"iso88597\",\n      \"hebrew\": \"iso88598\",\n      \"hebrew8\": \"iso88598\",\n      \"turkish\": \"iso88599\",\n      \"turkish8\": \"iso88599\",\n      \"thai\": \"iso885911\",\n      \"thai8\": \"iso885911\",\n      \"celtic\": \"iso885914\",\n      \"celtic8\": \"iso885914\",\n      \"isoceltic\": \"iso885914\",\n      \"tis6200\": \"tis620\",\n      \"tis62025291\": \"tis620\",\n      \"tis62025330\": \"tis620\",\n      \"10000\": \"macroman\",\n      \"10006\": \"macgreek\",\n      \"10007\": \"maccyrillic\",\n      \"10079\": \"maciceland\",\n      \"10081\": \"macturkish\",\n      \"cspc8codepage437\": \"cp437\",\n      \"cspc775baltic\": \"cp775\",\n      \"cspc850multilingual\": \"cp850\",\n      \"cspcp852\": \"cp852\",\n      \"cspc862latinhebrew\": \"cp862\",\n      \"cpgr\": \"cp869\",\n      \"msee\": \"cp1250\",\n      \"mscyrl\": \"cp1251\",\n      \"msansi\": \"cp1252\",\n      \"msgreek\": \"cp1253\",\n      \"msturk\": \"cp1254\",\n      \"mshebr\": \"cp1255\",\n      \"msarab\": \"cp1256\",\n      \"winbaltrim\": \"cp1257\",\n      \"cp20866\": \"koi8r\",\n      \"20866\": \"koi8r\",\n      \"ibm878\": \"koi8r\",\n      \"cskoi8r\": \"koi8r\",\n      \"cp21866\": \"koi8u\",\n      \"21866\": \"koi8u\",\n      \"ibm1168\": \"koi8u\",\n      \"strk10482002\": \"rk1048\",\n      \"tcvn5712\": \"tcvn\",\n      \"tcvn57121\": \"tcvn\",\n      \"gb198880\": \"iso646cn\",\n      \"cn\": \"iso646cn\",\n      \"csiso14jisc6220ro\": \"iso646jp\",\n      \"jisc62201969ro\": \"iso646jp\",\n      \"jp\": \"iso646jp\",\n      \"cshproman8\": \"hproman8\",\n      \"r8\": \"hproman8\",\n      \"roman8\": \"hproman8\",\n      \"xroman8\": \"hproman8\",\n      \"ibm1051\": \"hproman8\",\n      \"mac\": \"macintosh\",\n      \"csmacintosh\": \"macintosh\"\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-data-generated.js\nvar require_sbcs_data_generated2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/sbcs-data-generated.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      \"437\": \"cp437\",\n      \"737\": \"cp737\",\n      \"775\": \"cp775\",\n      \"850\": \"cp850\",\n      \"852\": \"cp852\",\n      \"855\": \"cp855\",\n      \"856\": \"cp856\",\n      \"857\": \"cp857\",\n      \"858\": \"cp858\",\n      \"860\": \"cp860\",\n      \"861\": \"cp861\",\n      \"862\": \"cp862\",\n      \"863\": \"cp863\",\n      \"864\": \"cp864\",\n      \"865\": \"cp865\",\n      \"866\": \"cp866\",\n      \"869\": \"cp869\",\n      \"874\": \"windows874\",\n      \"922\": \"cp922\",\n      \"1046\": \"cp1046\",\n      \"1124\": \"cp1124\",\n      \"1125\": \"cp1125\",\n      \"1129\": \"cp1129\",\n      \"1133\": \"cp1133\",\n      \"1161\": \"cp1161\",\n      \"1162\": \"cp1162\",\n      \"1163\": \"cp1163\",\n      \"1250\": \"windows1250\",\n      \"1251\": \"windows1251\",\n      \"1252\": \"windows1252\",\n      \"1253\": \"windows1253\",\n      \"1254\": \"windows1254\",\n      \"1255\": \"windows1255\",\n      \"1256\": \"windows1256\",\n      \"1257\": \"windows1257\",\n      \"1258\": \"windows1258\",\n      \"28591\": \"iso88591\",\n      \"28592\": \"iso88592\",\n      \"28593\": \"iso88593\",\n      \"28594\": \"iso88594\",\n      \"28595\": \"iso88595\",\n      \"28596\": \"iso88596\",\n      \"28597\": \"iso88597\",\n      \"28598\": \"iso88598\",\n      \"28599\": \"iso88599\",\n      \"28600\": \"iso885910\",\n      \"28601\": \"iso885911\",\n      \"28603\": \"iso885913\",\n      \"28604\": \"iso885914\",\n      \"28605\": \"iso885915\",\n      \"28606\": \"iso885916\",\n      \"windows874\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win874\": \"windows874\",\n      \"cp874\": \"windows874\",\n      \"windows1250\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1250\": \"windows1250\",\n      \"cp1250\": \"windows1250\",\n      \"windows1251\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1251\": \"windows1251\",\n      \"cp1251\": \"windows1251\",\n      \"windows1252\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1252\": \"windows1252\",\n      \"cp1252\": \"windows1252\",\n      \"windows1253\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1253\": \"windows1253\",\n      \"cp1253\": \"windows1253\",\n      \"windows1254\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1254\": \"windows1254\",\n      \"cp1254\": \"windows1254\",\n      \"windows1255\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1255\": \"windows1255\",\n      \"cp1255\": \"windows1255\",\n      \"windows1256\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1256\": \"windows1256\",\n      \"cp1256\": \"windows1256\",\n      \"windows1257\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1257\": \"windows1257\",\n      \"cp1257\": \"windows1257\",\n      \"windows1258\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"win1258\": \"windows1258\",\n      \"cp1258\": \"windows1258\",\n      \"iso88591\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28591\": \"iso88591\",\n      \"iso88592\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28592\": \"iso88592\",\n      \"iso88593\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28593\": \"iso88593\",\n      \"iso88594\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28594\": \"iso88594\",\n      \"iso88595\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28595\": \"iso88595\",\n      \"iso88596\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28596\": \"iso88596\",\n      \"iso88597\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28597\": \"iso88597\",\n      \"iso88598\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28598\": \"iso88598\",\n      \"iso88599\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28599\": \"iso88599\",\n      \"iso885910\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28600\": \"iso885910\",\n      \"iso885911\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28601\": \"iso885911\",\n      \"iso885913\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28603\": \"iso885913\",\n      \"iso885914\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28604\": \"iso885914\",\n      \"iso885915\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28605\": \"iso885915\",\n      \"iso885916\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"cp28606\": \"iso885916\",\n      \"cp437\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm437\": \"cp437\",\n      \"csibm437\": \"cp437\",\n      \"cp737\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm737\": \"cp737\",\n      \"csibm737\": \"cp737\",\n      \"cp775\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm775\": \"cp775\",\n      \"csibm775\": \"cp775\",\n      \"cp850\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm850\": \"cp850\",\n      \"csibm850\": \"cp850\",\n      \"cp852\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm852\": \"cp852\",\n      \"csibm852\": \"cp852\",\n      \"cp855\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm855\": \"cp855\",\n      \"csibm855\": \"cp855\",\n      \"cp856\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm856\": \"cp856\",\n      \"csibm856\": \"cp856\",\n      \"cp857\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm857\": \"cp857\",\n      \"csibm857\": \"cp857\",\n      \"cp858\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm858\": \"cp858\",\n      \"csibm858\": \"cp858\",\n      \"cp860\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm860\": \"cp860\",\n      \"csibm860\": \"cp860\",\n      \"cp861\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm861\": \"cp861\",\n      \"csibm861\": \"cp861\",\n      \"cp862\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm862\": \"cp862\",\n      \"csibm862\": \"cp862\",\n      \"cp863\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm863\": \"cp863\",\n      \"csibm863\": \"cp863\",\n      \"cp864\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$\\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\"\n      },\n      \"ibm864\": \"cp864\",\n      \"csibm864\": \"cp864\",\n      \"cp865\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm865\": \"cp865\",\n      \"csibm865\": \"cp865\",\n      \"cp866\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm866\": \"cp866\",\n      \"csibm866\": \"cp866\",\n      \"cp869\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm869\": \"cp869\",\n      \"csibm869\": \"cp869\",\n      \"cp922\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm922\": \"cp922\",\n      \"csibm922\": \"cp922\",\n      \"cp1046\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1046\": \"cp1046\",\n      \"csibm1046\": \"cp1046\",\n      \"cp1124\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1124\": \"cp1124\",\n      \"csibm1124\": \"cp1124\",\n      \"cp1125\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1125\": \"cp1125\",\n      \"csibm1125\": \"cp1125\",\n      \"cp1129\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1129\": \"cp1129\",\n      \"csibm1129\": \"cp1129\",\n      \"cp1133\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1133\": \"cp1133\",\n      \"csibm1133\": \"cp1133\",\n      \"cp1161\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1161\": \"cp1161\",\n      \"csibm1161\": \"cp1161\",\n      \"cp1162\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1162\": \"cp1162\",\n      \"csibm1162\": \"cp1162\",\n      \"cp1163\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ibm1163\": \"cp1163\",\n      \"csibm1163\": \"cp1163\",\n      \"maccroatian\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"maccyrillic\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macgreek\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"maciceland\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macroman\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macromania\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macthai\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macturkish\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macukraine\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8r\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8u\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8ru\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"koi8t\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"armscii8\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"rk1048\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"tcvn\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\\xDA\\u1EE4\u0003\\u1EEA\\u1EEC\\u1EEE\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\\u1EE8\\u1EF0\\u1EF2\\u1EF6\\u1EF8\\xDD\\u1EF4\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"georgianacademy\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"georgianps\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"pt154\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"viscii\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\\u1EB2\u0003\u0004\\u1EB4\\u1EAA\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\\u1EF6\u0015\u0016\u0017\u0018\\u1EF8\u001A\\x1B\u001C\u001D\\u1EF4\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"iso646cn\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#\\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\"\n      },\n      \"iso646jp\": {\n        \"type\": \"_sbcs\",\n        \"chars\": \"\\0\u0001\u0002\u0003\u0004\u0005\u0006\\x07\\b\t\\n\\v\\f\\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\\x1B\u001C\u001D\u001E\u001F !\\\"#$%&'()*+,-./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\"\n      },\n      \"hproman8\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"macintosh\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"ascii\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      },\n      \"tis620\": {\n        \"type\": \"_sbcs\",\n        \"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\"\n      }\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/dbcs-codec.js\nvar require_dbcs_codec2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/dbcs-codec.js\"(exports2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    exports2._dbcs = DBCSCodec;\n    var UNASSIGNED = -1;\n    var GB18030_CODE = -2;\n    var SEQ_START = -10;\n    var NODE_START = -1e3;\n    var UNASSIGNED_NODE = new Array(256);\n    var DEF_CHAR = -1;\n    for (i = 0; i < 256; i++)\n      UNASSIGNED_NODE[i] = UNASSIGNED;\n    var i;\n    function DBCSCodec(codecOptions, iconv) {\n      this.encodingName = codecOptions.encodingName;\n      if (!codecOptions)\n        throw new Error(\"DBCS codec is called without the data.\");\n      if (!codecOptions.table)\n        throw new Error(\"Encoding '\" + this.encodingName + \"' has no data.\");\n      var mappingTable = codecOptions.table();\n      this.decodeTables = [];\n      this.decodeTables[0] = UNASSIGNED_NODE.slice(0);\n      this.decodeTableSeq = [];\n      for (var i2 = 0; i2 < mappingTable.length; i2++)\n        this._addDecodeChunk(mappingTable[i2]);\n      if (typeof codecOptions.gb18030 === \"function\") {\n        this.gb18030 = codecOptions.gb18030();\n        var commonThirdByteNodeIdx = this.decodeTables.length;\n        this.decodeTables.push(UNASSIGNED_NODE.slice(0));\n        var commonFourthByteNodeIdx = this.decodeTables.length;\n        this.decodeTables.push(UNASSIGNED_NODE.slice(0));\n        var firstByteNode = this.decodeTables[0];\n        for (var i2 = 129; i2 <= 254; i2++) {\n          var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i2]];\n          for (var j = 48; j <= 57; j++) {\n            if (secondByteNode[j] === UNASSIGNED) {\n              secondByteNode[j] = NODE_START - commonThirdByteNodeIdx;\n            } else if (secondByteNode[j] > NODE_START) {\n              throw new Error(\"gb18030 decode tables conflict at byte 2\");\n            }\n            var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j]];\n            for (var k = 129; k <= 254; k++) {\n              if (thirdByteNode[k] === UNASSIGNED) {\n                thirdByteNode[k] = NODE_START - commonFourthByteNodeIdx;\n              } else if (thirdByteNode[k] === NODE_START - commonFourthByteNodeIdx) {\n                continue;\n              } else if (thirdByteNode[k] > NODE_START) {\n                throw new Error(\"gb18030 decode tables conflict at byte 3\");\n              }\n              var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k]];\n              for (var l = 48; l <= 57; l++) {\n                if (fourthByteNode[l] === UNASSIGNED)\n                  fourthByteNode[l] = GB18030_CODE;\n              }\n            }\n          }\n        }\n      }\n      this.defaultCharUnicode = iconv.defaultCharUnicode;\n      this.encodeTable = [];\n      this.encodeTableSeq = [];\n      var skipEncodeChars = {};\n      if (codecOptions.encodeSkipVals)\n        for (var i2 = 0; i2 < codecOptions.encodeSkipVals.length; i2++) {\n          var val = codecOptions.encodeSkipVals[i2];\n          if (typeof val === \"number\")\n            skipEncodeChars[val] = true;\n          else\n            for (var j = val.from; j <= val.to; j++)\n              skipEncodeChars[j] = true;\n        }\n      this._fillEncodeTable(0, 0, skipEncodeChars);\n      if (codecOptions.encodeAdd) {\n        for (var uChar in codecOptions.encodeAdd)\n          if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar))\n            this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);\n      }\n      this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];\n      if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0][\"?\"];\n      if (this.defCharSB === UNASSIGNED) this.defCharSB = \"?\".charCodeAt(0);\n    }\n    DBCSCodec.prototype.encoder = DBCSEncoder;\n    DBCSCodec.prototype.decoder = DBCSDecoder;\n    DBCSCodec.prototype._getDecodeTrieNode = function(addr) {\n      var bytes = [];\n      for (; addr > 0; addr >>>= 8)\n        bytes.push(addr & 255);\n      if (bytes.length == 0)\n        bytes.push(0);\n      var node = this.decodeTables[0];\n      for (var i2 = bytes.length - 1; i2 > 0; i2--) {\n        var val = node[bytes[i2]];\n        if (val == UNASSIGNED) {\n          node[bytes[i2]] = NODE_START - this.decodeTables.length;\n          this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));\n        } else if (val <= NODE_START) {\n          node = this.decodeTables[NODE_START - val];\n        } else\n          throw new Error(\"Overwrite byte in \" + this.encodingName + \", addr: \" + addr.toString(16));\n      }\n      return node;\n    };\n    DBCSCodec.prototype._addDecodeChunk = function(chunk) {\n      var curAddr = parseInt(chunk[0], 16);\n      var writeTable = this._getDecodeTrieNode(curAddr);\n      curAddr = curAddr & 255;\n      for (var k = 1; k < chunk.length; k++) {\n        var part = chunk[k];\n        if (typeof part === \"string\") {\n          for (var l = 0; l < part.length; ) {\n            var code = part.charCodeAt(l++);\n            if (55296 <= code && code < 56320) {\n              var codeTrail = part.charCodeAt(l++);\n              if (56320 <= codeTrail && codeTrail < 57344)\n                writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);\n              else\n                throw new Error(\"Incorrect surrogate pair in \" + this.encodingName + \" at chunk \" + chunk[0]);\n            } else if (4080 < code && code <= 4095) {\n              var len = 4095 - code + 2;\n              var seq = [];\n              for (var m = 0; m < len; m++)\n                seq.push(part.charCodeAt(l++));\n              writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;\n              this.decodeTableSeq.push(seq);\n            } else\n              writeTable[curAddr++] = code;\n          }\n        } else if (typeof part === \"number\") {\n          var charCode = writeTable[curAddr - 1] + 1;\n          for (var l = 0; l < part; l++)\n            writeTable[curAddr++] = charCode++;\n        } else\n          throw new Error(\"Incorrect type '\" + typeof part + \"' given in \" + this.encodingName + \" at chunk \" + chunk[0]);\n      }\n      if (curAddr > 255)\n        throw new Error(\"Incorrect chunk in \" + this.encodingName + \" at addr \" + chunk[0] + \": too long\" + curAddr);\n    };\n    DBCSCodec.prototype._getEncodeBucket = function(uCode) {\n      var high = uCode >> 8;\n      if (this.encodeTable[high] === void 0)\n        this.encodeTable[high] = UNASSIGNED_NODE.slice(0);\n      return this.encodeTable[high];\n    };\n    DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {\n      var bucket = this._getEncodeBucket(uCode);\n      var low = uCode & 255;\n      if (bucket[low] <= SEQ_START)\n        this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;\n      else if (bucket[low] == UNASSIGNED)\n        bucket[low] = dbcsCode;\n    };\n    DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {\n      var uCode = seq[0];\n      var bucket = this._getEncodeBucket(uCode);\n      var low = uCode & 255;\n      var node;\n      if (bucket[low] <= SEQ_START) {\n        node = this.encodeTableSeq[SEQ_START - bucket[low]];\n      } else {\n        node = {};\n        if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];\n        bucket[low] = SEQ_START - this.encodeTableSeq.length;\n        this.encodeTableSeq.push(node);\n      }\n      for (var j = 1; j < seq.length - 1; j++) {\n        var oldVal = node[uCode];\n        if (typeof oldVal === \"object\")\n          node = oldVal;\n        else {\n          node = node[uCode] = {};\n          if (oldVal !== void 0)\n            node[DEF_CHAR] = oldVal;\n        }\n      }\n      uCode = seq[seq.length - 1];\n      node[uCode] = dbcsCode;\n    };\n    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {\n      var node = this.decodeTables[nodeIdx];\n      var hasValues = false;\n      var subNodeEmpty = {};\n      for (var i2 = 0; i2 < 256; i2++) {\n        var uCode = node[i2];\n        var mbCode = prefix + i2;\n        if (skipEncodeChars[mbCode])\n          continue;\n        if (uCode >= 0) {\n          this._setEncodeChar(uCode, mbCode);\n          hasValues = true;\n        } else if (uCode <= NODE_START) {\n          var subNodeIdx = NODE_START - uCode;\n          if (!subNodeEmpty[subNodeIdx]) {\n            var newPrefix = mbCode << 8 >>> 0;\n            if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars))\n              hasValues = true;\n            else\n              subNodeEmpty[subNodeIdx] = true;\n          }\n        } else if (uCode <= SEQ_START) {\n          this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);\n          hasValues = true;\n        }\n      }\n      return hasValues;\n    };\n    function DBCSEncoder(options, codec) {\n      this.leadSurrogate = -1;\n      this.seqObj = void 0;\n      this.encodeTable = codec.encodeTable;\n      this.encodeTableSeq = codec.encodeTableSeq;\n      this.defaultCharSingleByte = codec.defCharSB;\n      this.gb18030 = codec.gb18030;\n    }\n    DBCSEncoder.prototype.write = function(str) {\n      var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i2 = 0, j = 0;\n      while (true) {\n        if (nextChar === -1) {\n          if (i2 == str.length) break;\n          var uCode = str.charCodeAt(i2++);\n        } else {\n          var uCode = nextChar;\n          nextChar = -1;\n        }\n        if (55296 <= uCode && uCode < 57344) {\n          if (uCode < 56320) {\n            if (leadSurrogate === -1) {\n              leadSurrogate = uCode;\n              continue;\n            } else {\n              leadSurrogate = uCode;\n              uCode = UNASSIGNED;\n            }\n          } else {\n            if (leadSurrogate !== -1) {\n              uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);\n              leadSurrogate = -1;\n            } else {\n              uCode = UNASSIGNED;\n            }\n          }\n        } else if (leadSurrogate !== -1) {\n          nextChar = uCode;\n          uCode = UNASSIGNED;\n          leadSurrogate = -1;\n        }\n        var dbcsCode = UNASSIGNED;\n        if (seqObj !== void 0 && uCode != UNASSIGNED) {\n          var resCode = seqObj[uCode];\n          if (typeof resCode === \"object\") {\n            seqObj = resCode;\n            continue;\n          } else if (typeof resCode == \"number\") {\n            dbcsCode = resCode;\n          } else if (resCode == void 0) {\n            resCode = seqObj[DEF_CHAR];\n            if (resCode !== void 0) {\n              dbcsCode = resCode;\n              nextChar = uCode;\n            } else {\n            }\n          }\n          seqObj = void 0;\n        } else if (uCode >= 0) {\n          var subtable = this.encodeTable[uCode >> 8];\n          if (subtable !== void 0)\n            dbcsCode = subtable[uCode & 255];\n          if (dbcsCode <= SEQ_START) {\n            seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];\n            continue;\n          }\n          if (dbcsCode == UNASSIGNED && this.gb18030) {\n            var idx = findIdx(this.gb18030.uChars, uCode);\n            if (idx != -1) {\n              var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);\n              newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);\n              dbcsCode = dbcsCode % 12600;\n              newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);\n              dbcsCode = dbcsCode % 1260;\n              newBuf[j++] = 129 + Math.floor(dbcsCode / 10);\n              dbcsCode = dbcsCode % 10;\n              newBuf[j++] = 48 + dbcsCode;\n              continue;\n            }\n          }\n        }\n        if (dbcsCode === UNASSIGNED)\n          dbcsCode = this.defaultCharSingleByte;\n        if (dbcsCode < 256) {\n          newBuf[j++] = dbcsCode;\n        } else if (dbcsCode < 65536) {\n          newBuf[j++] = dbcsCode >> 8;\n          newBuf[j++] = dbcsCode & 255;\n        } else if (dbcsCode < 16777216) {\n          newBuf[j++] = dbcsCode >> 16;\n          newBuf[j++] = dbcsCode >> 8 & 255;\n          newBuf[j++] = dbcsCode & 255;\n        } else {\n          newBuf[j++] = dbcsCode >>> 24;\n          newBuf[j++] = dbcsCode >>> 16 & 255;\n          newBuf[j++] = dbcsCode >>> 8 & 255;\n          newBuf[j++] = dbcsCode & 255;\n        }\n      }\n      this.seqObj = seqObj;\n      this.leadSurrogate = leadSurrogate;\n      return newBuf.slice(0, j);\n    };\n    DBCSEncoder.prototype.end = function() {\n      if (this.leadSurrogate === -1 && this.seqObj === void 0)\n        return;\n      var newBuf = Buffer2.alloc(10), j = 0;\n      if (this.seqObj) {\n        var dbcsCode = this.seqObj[DEF_CHAR];\n        if (dbcsCode !== void 0) {\n          if (dbcsCode < 256) {\n            newBuf[j++] = dbcsCode;\n          } else {\n            newBuf[j++] = dbcsCode >> 8;\n            newBuf[j++] = dbcsCode & 255;\n          }\n        } else {\n        }\n        this.seqObj = void 0;\n      }\n      if (this.leadSurrogate !== -1) {\n        newBuf[j++] = this.defaultCharSingleByte;\n        this.leadSurrogate = -1;\n      }\n      return newBuf.slice(0, j);\n    };\n    DBCSEncoder.prototype.findIdx = findIdx;\n    function DBCSDecoder(options, codec) {\n      this.nodeIdx = 0;\n      this.prevBytes = [];\n      this.decodeTables = codec.decodeTables;\n      this.decodeTableSeq = codec.decodeTableSeq;\n      this.defaultCharUnicode = codec.defaultCharUnicode;\n      this.gb18030 = codec.gb18030;\n    }\n    DBCSDecoder.prototype.write = function(buf) {\n      var newBuf = Buffer2.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, uCode;\n      for (var i2 = 0, j = 0; i2 < buf.length; i2++) {\n        var curByte = i2 >= 0 ? buf[i2] : prevBytes[i2 + prevOffset];\n        var uCode = this.decodeTables[nodeIdx][curByte];\n        if (uCode >= 0) {\n        } else if (uCode === UNASSIGNED) {\n          uCode = this.defaultCharUnicode.charCodeAt(0);\n          i2 = seqStart;\n        } else if (uCode === GB18030_CODE) {\n          if (i2 >= 3) {\n            var ptr = (buf[i2 - 3] - 129) * 12600 + (buf[i2 - 2] - 48) * 1260 + (buf[i2 - 1] - 129) * 10 + (curByte - 48);\n          } else {\n            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);\n          }\n          var idx = findIdx(this.gb18030.gbChars, ptr);\n          uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];\n        } else if (uCode <= NODE_START) {\n          nodeIdx = NODE_START - uCode;\n          continue;\n        } else if (uCode <= SEQ_START) {\n          var seq = this.decodeTableSeq[SEQ_START - uCode];\n          for (var k = 0; k < seq.length - 1; k++) {\n            uCode = seq[k];\n            newBuf[j++] = uCode & 255;\n            newBuf[j++] = uCode >> 8;\n          }\n          uCode = seq[seq.length - 1];\n        } else\n          throw new Error(\"iconv-lite internal error: invalid decoding table value \" + uCode + \" at \" + nodeIdx + \"/\" + curByte);\n        if (uCode >= 65536) {\n          uCode -= 65536;\n          var uCodeLead = 55296 | uCode >> 10;\n          newBuf[j++] = uCodeLead & 255;\n          newBuf[j++] = uCodeLead >> 8;\n          uCode = 56320 | uCode & 1023;\n        }\n        newBuf[j++] = uCode & 255;\n        newBuf[j++] = uCode >> 8;\n        nodeIdx = 0;\n        seqStart = i2 + 1;\n      }\n      this.nodeIdx = nodeIdx;\n      this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf));\n      return newBuf.slice(0, j).toString(\"ucs2\");\n    };\n    DBCSDecoder.prototype.end = function() {\n      var ret = \"\";\n      while (this.prevBytes.length > 0) {\n        ret += this.defaultCharUnicode;\n        var bytesArr = this.prevBytes.slice(1);\n        this.prevBytes = [];\n        this.nodeIdx = 0;\n        if (bytesArr.length > 0)\n          ret += this.write(bytesArr);\n      }\n      this.prevBytes = [];\n      this.nodeIdx = 0;\n      return ret;\n    };\n    function findIdx(table, val) {\n      if (table[0] > val)\n        return -1;\n      var l = 0, r = table.length;\n      while (l < r - 1) {\n        var mid = l + (r - l + 1 >> 1);\n        if (table[mid] <= val)\n          l = mid;\n        else\n          r = mid;\n      }\n      return l;\n    }\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/shiftjis.json\nvar require_shiftjis2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/shiftjis.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 128],\n      [\"a1\", \"\\uFF61\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"81b8\", \"\\u2208\\u220B\\u2286\\u2287\\u2282\\u2283\\u222A\\u2229\"],\n      [\"81c8\", \"\\u2227\\u2228\\uFFE2\\u21D2\\u21D4\\u2200\\u2203\"],\n      [\"81da\", \"\\u2220\\u22A5\\u2312\\u2202\\u2207\\u2261\\u2252\\u226A\\u226B\\u221A\\u223D\\u221D\\u2235\\u222B\\u222C\"],\n      [\"81f0\", \"\\u212B\\u2030\\u266F\\u266D\\u266A\\u2020\\u2021\\xB6\"],\n      [\"81fc\", \"\\u25EF\"],\n      [\"824f\", \"\\uFF10\", 9],\n      [\"8260\", \"\\uFF21\", 25],\n      [\"8281\", \"\\uFF41\", 25],\n      [\"829f\", \"\\u3041\", 82],\n      [\"8340\", \"\\u30A1\", 62],\n      [\"8380\", \"\\u30E0\", 22],\n      [\"839f\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"83bf\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"8440\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"8470\", \"\\u0430\", 5, \"\\u0451\\u0436\", 7],\n      [\"8480\", \"\\u043E\", 17],\n      [\"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\"],\n      [\"8740\", \"\\u2460\", 19, \"\\u2160\", 9],\n      [\"875f\", \"\\u3349\\u3314\\u3322\\u334D\\u3318\\u3327\\u3303\\u3336\\u3351\\u3357\\u330D\\u3326\\u3323\\u332B\\u334A\\u333B\\u339C\\u339D\\u339E\\u338E\\u338F\\u33C4\\u33A1\"],\n      [\"877e\", \"\\u337B\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"eeef\", \"\\u2170\", 9, \"\\uFFE2\\uFFE4\\uFF07\\uFF02\"],\n      [\"f040\", \"\\uE000\", 62],\n      [\"f080\", \"\\uE03F\", 124],\n      [\"f140\", \"\\uE0BC\", 62],\n      [\"f180\", \"\\uE0FB\", 124],\n      [\"f240\", \"\\uE178\", 62],\n      [\"f280\", \"\\uE1B7\", 124],\n      [\"f340\", \"\\uE234\", 62],\n      [\"f380\", \"\\uE273\", 124],\n      [\"f440\", \"\\uE2F0\", 62],\n      [\"f480\", \"\\uE32F\", 124],\n      [\"f540\", \"\\uE3AC\", 62],\n      [\"f580\", \"\\uE3EB\", 124],\n      [\"f640\", \"\\uE468\", 62],\n      [\"f680\", \"\\uE4A7\", 124],\n      [\"f740\", \"\\uE524\", 62],\n      [\"f780\", \"\\uE563\", 124],\n      [\"f840\", \"\\uE5E0\", 62],\n      [\"f880\", \"\\uE61F\", 124],\n      [\"f940\", \"\\uE69C\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"fc40\", \"\\u9ADC\\u9B75\\u9B72\\u9B8F\\u9BB1\\u9BBB\\u9C00\\u9D70\\u9D6B\\uFA2D\\u9E19\\u9ED1\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/eucjp.json\nvar require_eucjp2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/eucjp.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"8ea1\", \"\\uFF61\", 62],\n      [\"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\"],\n      [\"a2a1\", \"\\u25C6\\u25A1\\u25A0\\u25B3\\u25B2\\u25BD\\u25BC\\u203B\\u3012\\u2192\\u2190\\u2191\\u2193\\u3013\"],\n      [\"a2ba\", \"\\u2208\\u220B\\u2286\\u2287\\u2282\\u2283\\u222A\\u2229\"],\n      [\"a2ca\", \"\\u2227\\u2228\\uFFE2\\u21D2\\u21D4\\u2200\\u2203\"],\n      [\"a2dc\", \"\\u2220\\u22A5\\u2312\\u2202\\u2207\\u2261\\u2252\\u226A\\u226B\\u221A\\u223D\\u221D\\u2235\\u222B\\u222C\"],\n      [\"a2f2\", \"\\u212B\\u2030\\u266F\\u266D\\u266A\\u2020\\u2021\\xB6\"],\n      [\"a2fe\", \"\\u25EF\"],\n      [\"a3b0\", \"\\uFF10\", 9],\n      [\"a3c1\", \"\\uFF21\", 25],\n      [\"a3e1\", \"\\uFF41\", 25],\n      [\"a4a1\", \"\\u3041\", 82],\n      [\"a5a1\", \"\\u30A1\", 85],\n      [\"a6a1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a6c1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a7a1\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"a7d1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"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\"],\n      [\"ada1\", \"\\u2460\", 19, \"\\u2160\", 9],\n      [\"adc0\", \"\\u3349\\u3314\\u3322\\u334D\\u3318\\u3327\\u3303\\u3336\\u3351\\u3357\\u330D\\u3326\\u3323\\u332B\\u334A\\u333B\\u339C\\u339D\\u339E\\u338E\\u338F\\u33C4\\u33A1\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"f4a1\", \"\\u582F\\u69C7\\u9059\\u7464\\u51DC\\u7199\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"fcf1\", \"\\u2170\", 9, \"\\uFFE2\\uFFE4\\uFF07\\uFF02\"],\n      [\"8fa2af\", \"\\u02D8\\u02C7\\xB8\\u02D9\\u02DD\\xAF\\u02DB\\u02DA\\uFF5E\\u0384\\u0385\"],\n      [\"8fa2c2\", \"\\xA1\\xA6\\xBF\"],\n      [\"8fa2eb\", \"\\xBA\\xAA\\xA9\\xAE\\u2122\\xA4\\u2116\"],\n      [\"8fa6e1\", \"\\u0386\\u0388\\u0389\\u038A\\u03AA\"],\n      [\"8fa6e7\", \"\\u038C\"],\n      [\"8fa6e9\", \"\\u038E\\u03AB\"],\n      [\"8fa6ec\", \"\\u038F\"],\n      [\"8fa6f1\", \"\\u03AC\\u03AD\\u03AE\\u03AF\\u03CA\\u0390\\u03CC\\u03C2\\u03CD\\u03CB\\u03B0\\u03CE\"],\n      [\"8fa7c2\", \"\\u0402\", 10, \"\\u040E\\u040F\"],\n      [\"8fa7f2\", \"\\u0452\", 10, \"\\u045E\\u045F\"],\n      [\"8fa9a1\", \"\\xC6\\u0110\"],\n      [\"8fa9a4\", \"\\u0126\"],\n      [\"8fa9a6\", \"\\u0132\"],\n      [\"8fa9a8\", \"\\u0141\\u013F\"],\n      [\"8fa9ab\", \"\\u014A\\xD8\\u0152\"],\n      [\"8fa9af\", \"\\u0166\\xDE\"],\n      [\"8fa9c1\", \"\\xE6\\u0111\\xF0\\u0127\\u0131\\u0133\\u0138\\u0142\\u0140\\u0149\\u014B\\xF8\\u0153\\xDF\\u0167\\xFE\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8fabbd\", \"\\u0121\\u0125\\xED\\xEC\\xEF\\xEE\\u01D0\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp936.json\nvar require_cp9362 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp936.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127, \"\\u20AC\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"8340\", \"\\u50BD\", 17, \"\\u50D0\", 5, \"\\u50D7\\u50D8\\u50D9\\u50DB\", 10, \"\\u50E8\\u50E9\\u50EA\\u50EB\\u50EF\\u50F0\\u50F1\\u50F2\\u50F4\\u50F6\", 4, \"\\u50FC\", 9, \"\\u5108\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"8b40\", \"\\u5A61\\u5A63\\u5A64\\u5A65\\u5A66\\u5A68\\u5A69\\u5A6B\", 8, \"\\u5A78\\u5A79\\u5A7B\\u5A7C\\u5A7D\\u5A7E\\u5A80\", 17, \"\\u5A93\", 6, \"\\u5A9C\", 13, \"\\u5AAB\\u5AAC\"],\n      [\"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],\n      [\"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\"],\n      [\"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],\n      [\"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],\n      [\"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\"],\n      [\"8e40\", \"\\u5DA1\", 21, \"\\u5DB8\", 12, \"\\u5DC6\", 6, \"\\u5DCE\", 12, \"\\u5DDC\\u5DDF\\u5DE0\\u5DE3\\u5DE4\\u5DEA\\u5DEC\\u5DED\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"9440\", \"\\u64DB\\u64DC\\u64DD\\u64DF\\u64E0\\u64E1\\u64E3\\u64E5\\u64E7\", 24, \"\\u6501\", 7, \"\\u650A\", 7, \"\\u6513\", 4, \"\\u6519\", 8],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"9980\", \"\\u6AA7\\u6AA8\\u6AAA\\u6AAD\", 114, \"\\u6B25\\u6B26\\u6B28\", 6],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"9e40\", \"\\u6FE6\", 7, \"\\u6FF0\", 32, \"\\u7012\", 7, \"\\u701C\", 6, \"\\u7024\", 6],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"a040\", \"\\u71D6\", 9, \"\\u71E1\\u71E2\\u71E3\\u71E4\\u71E6\\u71E8\", 5, \"\\u71EF\", 9, \"\\u71FA\", 11, \"\\u7207\", 19],\n      [\"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\"],\n      [\"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\"],\n      [\"a2a1\", \"\\u2170\", 9],\n      [\"a2b1\", \"\\u2488\", 19, \"\\u2474\", 19, \"\\u2460\", 9],\n      [\"a2e5\", \"\\u3220\", 9],\n      [\"a2f1\", \"\\u2160\", 11],\n      [\"a3a1\", \"\\uFF01\\uFF02\\uFF03\\uFFE5\\uFF05\", 88, \"\\uFFE3\"],\n      [\"a4a1\", \"\\u3041\", 82],\n      [\"a5a1\", \"\\u30A1\", 85],\n      [\"a6a1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a6c1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a6e0\", \"\\uFE35\\uFE36\\uFE39\\uFE3A\\uFE3F\\uFE40\\uFE3D\\uFE3E\\uFE41\\uFE42\\uFE43\\uFE44\"],\n      [\"a6ee\", \"\\uFE3B\\uFE3C\\uFE37\\uFE38\\uFE31\"],\n      [\"a6f4\", \"\\uFE33\\uFE34\"],\n      [\"a7a1\", \"\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"a7d1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"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],\n      [\"a880\", \"\\u2588\", 7, \"\\u2593\\u2594\\u2595\\u25BC\\u25BD\\u25E2\\u25E3\\u25E4\\u25E5\\u2609\\u2295\\u3012\\u301D\\u301E\"],\n      [\"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\"],\n      [\"a8bd\", \"\\u0144\\u0148\"],\n      [\"a8c0\", \"\\u0261\"],\n      [\"a8c5\", \"\\u3105\", 36],\n      [\"a940\", \"\\u3021\", 8, \"\\u32A3\\u338E\\u338F\\u339C\\u339D\\u339E\\u33A1\\u33C4\\u33CE\\u33D1\\u33D2\\u33D5\\uFE30\\uFFE2\\uFFE4\"],\n      [\"a959\", \"\\u2121\\u3231\"],\n      [\"a95c\", \"\\u2010\"],\n      [\"a960\", \"\\u30FC\\u309B\\u309C\\u30FD\\u30FE\\u3006\\u309D\\u309E\\uFE49\", 9, \"\\uFE54\\uFE55\\uFE56\\uFE57\\uFE59\", 8],\n      [\"a980\", \"\\uFE62\", 4, \"\\uFE68\\uFE69\\uFE6A\\uFE6B\"],\n      [\"a996\", \"\\u3007\"],\n      [\"a9a4\", \"\\u2500\", 75],\n      [\"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],\n      [\"aa80\", \"\\u7349\\u734A\\u734B\\u734C\\u734E\\u734F\\u7351\\u7353\\u7354\\u7355\\u7356\\u7358\", 7, \"\\u7361\", 10, \"\\u736E\\u7370\\u7371\"],\n      [\"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],\n      [\"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],\n      [\"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],\n      [\"ac80\", \"\\u744E\", 6, \"\\u7456\\u7458\\u745D\\u7460\", 12, \"\\u746E\\u746F\\u7471\", 4, \"\\u7478\\u7479\\u747A\"],\n      [\"ad40\", \"\\u747B\\u747C\\u747D\\u747F\\u7482\\u7484\\u7485\\u7486\\u7488\\u7489\\u748A\\u748C\\u748D\\u748F\\u7491\", 10, \"\\u749D\\u749F\", 7, \"\\u74AA\", 15, \"\\u74BB\", 12],\n      [\"ad80\", \"\\u74C8\", 9, \"\\u74D3\", 8, \"\\u74DD\\u74DF\\u74E1\\u74E5\\u74E7\", 6, \"\\u74F0\\u74F1\\u74F2\"],\n      [\"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\"],\n      [\"ae80\", \"\\u755D\", 7, \"\\u7567\\u7568\\u7569\\u756B\", 6, \"\\u7573\\u7575\\u7576\\u7577\\u757A\", 4, \"\\u7580\\u7581\\u7582\\u7584\\u7585\\u7587\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"b740\", \"\\u7A1D\\u7A1F\\u7A21\\u7A22\\u7A24\", 14, \"\\u7A34\\u7A35\\u7A36\\u7A38\\u7A3A\\u7A3E\\u7A40\", 5, \"\\u7A47\", 9, \"\\u7A52\", 4, \"\\u7A58\", 16],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"bb40\", \"\\u7C43\", 9, \"\\u7C4E\", 36, \"\\u7C75\", 5, \"\\u7C7E\", 9],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"bd40\", \"\\u7D37\", 54, \"\\u7D6F\", 7],\n      [\"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\"],\n      [\"be40\", \"\\u7D99\", 12, \"\\u7DA7\", 6, \"\\u7DAF\", 42],\n      [\"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\"],\n      [\"bf40\", \"\\u7DFB\", 62],\n      [\"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\"],\n      [\"c040\", \"\\u7E5E\", 35, \"\\u7E83\", 23, \"\\u7E9C\\u7E9D\\u7E9E\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"d240\", \"\\u8938\", 8, \"\\u8942\\u8943\\u8945\", 24, \"\\u8960\", 5, \"\\u8967\", 19, \"\\u897C\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"d440\", \"\\u8A1E\", 31, \"\\u8A3F\", 8, \"\\u8A49\", 21],\n      [\"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\"],\n      [\"d540\", \"\\u8A81\", 7, \"\\u8A8B\", 7, \"\\u8A94\", 46],\n      [\"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\"],\n      [\"d640\", \"\\u8AE4\", 34, \"\\u8B08\", 27],\n      [\"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\"],\n      [\"d740\", \"\\u8B46\", 31, \"\\u8B67\", 4, \"\\u8B6D\", 25],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"d940\", \"\\u8CAE\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"dd40\", \"\\u8EE5\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"e240\", \"\\u91E6\", 62],\n      [\"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\"],\n      [\"e340\", \"\\u9246\", 45, \"\\u9275\", 16],\n      [\"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\"],\n      [\"e440\", \"\\u92A8\", 5, \"\\u92AF\", 24, \"\\u92C9\", 31],\n      [\"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\"],\n      [\"e540\", \"\\u930A\", 51, \"\\u933F\", 10],\n      [\"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\"],\n      [\"e640\", \"\\u936C\", 34, \"\\u9390\", 27],\n      [\"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\"],\n      [\"e740\", \"\\u93CE\", 7, \"\\u93D7\", 54],\n      [\"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\"],\n      [\"e840\", \"\\u942F\", 14, \"\\u943F\", 43, \"\\u946C\\u946D\\u946E\\u946F\"],\n      [\"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\"],\n      [\"e940\", \"\\u9527\\u9533\\u953D\\u9543\\u9548\\u954B\\u9555\\u955A\\u9560\\u956E\\u9574\\u9575\\u9577\", 7, \"\\u9580\", 42],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"ed40\", \"\\u979E\\u979F\\u97A1\\u97A2\\u97A4\", 6, \"\\u97AC\\u97AE\\u97B0\\u97B1\\u97B3\\u97B5\", 46],\n      [\"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\"],\n      [\"ee40\", \"\\u980F\", 62],\n      [\"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\"],\n      [\"ef40\", \"\\u986F\", 5, \"\\u988B\\u988E\\u9892\\u9895\\u9899\\u98A3\\u98A8\", 37, \"\\u98CF\\u98D0\\u98D4\\u98D6\\u98D7\\u98DB\\u98DC\\u98DD\\u98E0\", 4],\n      [\"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\"],\n      [\"f040\", \"\\u9908\", 4, \"\\u990E\\u990F\\u9911\", 28, \"\\u992F\", 26],\n      [\"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\"],\n      [\"f140\", \"\\u998C\\u998E\\u999A\", 10, \"\\u99A6\\u99A7\\u99A9\", 47],\n      [\"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\"],\n      [\"f240\", \"\\u99FA\", 62],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"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\"],\n      [\"f540\", \"\\u9B7C\", 62],\n      [\"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\"],\n      [\"f640\", \"\\u9BDC\", 62],\n      [\"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\"],\n      [\"f740\", \"\\u9C3C\", 62],\n      [\"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\"],\n      [\"f840\", \"\\u9CE3\", 62],\n      [\"f880\", \"\\u9D22\", 32],\n      [\"f940\", \"\\u9D43\", 62],\n      [\"f980\", \"\\u9D82\", 32],\n      [\"fa40\", \"\\u9DA3\", 62],\n      [\"fa80\", \"\\u9DE2\", 32],\n      [\"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\"],\n      [\"fb80\", \"\\u9E81\\u9E83\\u9E84\\u9E85\\u9E86\\u9E89\\u9E8A\\u9E8C\", 5, \"\\u9E94\", 8, \"\\u9E9E\\u9EA0\", 5, \"\\u9EA7\\u9EA8\\u9EA9\\u9EAA\"],\n      [\"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],\n      [\"fc80\", \"\\u9F06\", 4, \"\\u9F0C\\u9F0F\\u9F11\\u9F12\\u9F14\\u9F15\\u9F16\\u9F18\\u9F1A\", 5, \"\\u9F21\\u9F23\", 8, \"\\u9F2D\\u9F2E\\u9F30\\u9F31\"],\n      [\"fd40\", \"\\u9F32\", 4, \"\\u9F38\\u9F3A\\u9F3C\\u9F3F\", 4, \"\\u9F45\", 10, \"\\u9F52\", 38],\n      [\"fd80\", \"\\u9F79\", 5, \"\\u9F81\\u9F82\\u9F8D\", 11, \"\\u9F9C\\u9F9D\\u9F9E\\u9FA1\", 4, \"\\uF92C\\uF979\\uF995\\uF9E7\\uF9F1\"],\n      [\"fe40\", \"\\uFA0C\\uFA0D\\uFA0E\\uFA0F\\uFA11\\uFA13\\uFA14\\uFA18\\uFA1F\\uFA20\\uFA21\\uFA23\\uFA24\\uFA27\\uFA28\\uFA29\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/gbk-added.json\nvar require_gbk_added2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/gbk-added.json\"(exports2, module2) {\n    module2.exports = [\n      [\"a140\", \"\\uE4C6\", 62],\n      [\"a180\", \"\\uE505\", 32],\n      [\"a240\", \"\\uE526\", 62],\n      [\"a280\", \"\\uE565\", 32],\n      [\"a2ab\", \"\\uE766\", 5],\n      [\"a2e3\", \"\\u20AC\\uE76D\"],\n      [\"a2ef\", \"\\uE76E\\uE76F\"],\n      [\"a2fd\", \"\\uE770\\uE771\"],\n      [\"a340\", \"\\uE586\", 62],\n      [\"a380\", \"\\uE5C5\", 31, \"\\u3000\"],\n      [\"a440\", \"\\uE5E6\", 62],\n      [\"a480\", \"\\uE625\", 32],\n      [\"a4f4\", \"\\uE772\", 10],\n      [\"a540\", \"\\uE646\", 62],\n      [\"a580\", \"\\uE685\", 32],\n      [\"a5f7\", \"\\uE77D\", 7],\n      [\"a640\", \"\\uE6A6\", 62],\n      [\"a680\", \"\\uE6E5\", 32],\n      [\"a6b9\", \"\\uE785\", 7],\n      [\"a6d9\", \"\\uE78D\", 6],\n      [\"a6ec\", \"\\uE794\\uE795\"],\n      [\"a6f3\", \"\\uE796\"],\n      [\"a6f6\", \"\\uE797\", 8],\n      [\"a740\", \"\\uE706\", 62],\n      [\"a780\", \"\\uE745\", 32],\n      [\"a7c2\", \"\\uE7A0\", 14],\n      [\"a7f2\", \"\\uE7AF\", 12],\n      [\"a896\", \"\\uE7BC\", 10],\n      [\"a8bc\", \"\\u1E3F\"],\n      [\"a8bf\", \"\\u01F9\"],\n      [\"a8c1\", \"\\uE7C9\\uE7CA\\uE7CB\\uE7CC\"],\n      [\"a8ea\", \"\\uE7CD\", 20],\n      [\"a958\", \"\\uE7E2\"],\n      [\"a95b\", \"\\uE7E3\"],\n      [\"a95d\", \"\\uE7E4\\uE7E5\\uE7E6\"],\n      [\"a989\", \"\\u303E\\u2FF0\", 11],\n      [\"a997\", \"\\uE7F4\", 12],\n      [\"a9f0\", \"\\uE801\", 14],\n      [\"aaa1\", \"\\uE000\", 93],\n      [\"aba1\", \"\\uE05E\", 93],\n      [\"aca1\", \"\\uE0BC\", 93],\n      [\"ada1\", \"\\uE11A\", 93],\n      [\"aea1\", \"\\uE178\", 93],\n      [\"afa1\", \"\\uE1D6\", 93],\n      [\"d7fa\", \"\\uE810\", 4],\n      [\"f8a1\", \"\\uE234\", 93],\n      [\"f9a1\", \"\\uE292\", 93],\n      [\"faa1\", \"\\uE2F0\", 93],\n      [\"fba1\", \"\\uE34E\", 93],\n      [\"fca1\", \"\\uE3AC\", 93],\n      [\"fda1\", \"\\uE40A\", 93],\n      [\"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\"],\n      [\"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],\n      [\"8135f437\", \"\\uE7C7\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json\nvar require_gb18030_ranges2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json\"(exports2, module2) {\n    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] };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp949.json\nvar require_cp9492 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp949.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"8141\", \"\\uAC02\\uAC03\\uAC05\\uAC06\\uAC0B\", 4, \"\\uAC18\\uAC1E\\uAC1F\\uAC21\\uAC22\\uAC23\\uAC25\", 6, \"\\uAC2E\\uAC32\\uAC33\\uAC34\"],\n      [\"8161\", \"\\uAC35\\uAC36\\uAC37\\uAC3A\\uAC3B\\uAC3D\\uAC3E\\uAC3F\\uAC41\", 9, \"\\uAC4C\\uAC4E\", 5, \"\\uAC55\"],\n      [\"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\"],\n      [\"8241\", \"\\uAD14\\uAD15\\uAD16\\uAD17\\uAD19\\uAD1A\\uAD1B\\uAD1D\\uAD1E\\uAD1F\\uAD21\", 7, \"\\uAD2A\\uAD2B\\uAD2E\", 5],\n      [\"8261\", \"\\uAD36\\uAD37\\uAD39\\uAD3A\\uAD3B\\uAD3D\", 6, \"\\uAD46\\uAD48\\uAD4A\", 5, \"\\uAD51\\uAD52\\uAD53\\uAD55\\uAD56\\uAD57\"],\n      [\"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],\n      [\"8341\", \"\\uADFA\\uADFB\\uADFD\\uADFE\\uAE02\", 5, \"\\uAE0A\\uAE0C\\uAE0E\", 5, \"\\uAE15\", 7],\n      [\"8361\", \"\\uAE1D\", 18, \"\\uAE32\\uAE33\\uAE35\\uAE36\\uAE39\\uAE3B\\uAE3C\"],\n      [\"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],\n      [\"8441\", \"\\uAEE6\\uAEE7\\uAEE9\\uAEEA\\uAEEC\\uAEEE\", 5, \"\\uAEF5\\uAEF6\\uAEF7\\uAEF9\\uAEFA\\uAEFB\\uAEFD\", 8],\n      [\"8461\", \"\\uAF06\\uAF09\\uAF0A\\uAF0B\\uAF0C\\uAF0E\\uAF0F\\uAF11\", 18],\n      [\"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\"],\n      [\"8541\", \"\\uAFBF\\uAFC1\", 5, \"\\uAFCA\\uAFCC\\uAFCF\", 4, \"\\uAFD5\", 6, \"\\uAFDD\", 4],\n      [\"8561\", \"\\uAFE2\", 5, \"\\uAFEA\", 5, \"\\uAFF2\\uAFF3\\uAFF5\\uAFF6\\uAFF7\\uAFF9\", 6, \"\\uB002\\uB003\"],\n      [\"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\"],\n      [\"8641\", \"\\uB0A5\\uB0A6\\uB0A7\\uB0AA\\uB0B0\\uB0B2\\uB0B6\\uB0B7\\uB0B9\\uB0BA\\uB0BB\\uB0BD\", 6, \"\\uB0C6\\uB0CA\", 5, \"\\uB0D2\"],\n      [\"8661\", \"\\uB0D3\\uB0D5\\uB0D6\\uB0D7\\uB0D9\", 6, \"\\uB0E1\\uB0E2\\uB0E3\\uB0E4\\uB0E6\", 10],\n      [\"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\"],\n      [\"8741\", \"\\uB19E\", 9, \"\\uB1A9\", 15],\n      [\"8761\", \"\\uB1B9\", 18, \"\\uB1CD\\uB1CE\\uB1CF\\uB1D1\\uB1D2\\uB1D3\\uB1D5\"],\n      [\"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],\n      [\"8841\", \"\\uB26F\", 4, \"\\uB276\", 5, \"\\uB27D\", 6, \"\\uB286\\uB287\\uB288\\uB28A\", 4],\n      [\"8861\", \"\\uB28F\\uB292\\uB293\\uB295\\uB296\\uB297\\uB29B\", 4, \"\\uB2A2\\uB2A4\\uB2A7\\uB2A8\\uB2A9\\uB2AB\\uB2AD\\uB2AE\\uB2AF\\uB2B1\\uB2B2\\uB2B3\\uB2B5\\uB2B6\\uB2B7\"],\n      [\"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\"],\n      [\"8941\", \"\\uB366\\uB368\\uB36A\\uB36C\\uB36D\\uB36F\\uB372\\uB373\\uB375\\uB376\\uB377\\uB379\", 6, \"\\uB382\\uB386\", 5, \"\\uB38D\"],\n      [\"8961\", \"\\uB38E\\uB38F\\uB391\\uB392\\uB393\\uB395\", 10, \"\\uB3A2\", 5, \"\\uB3A9\\uB3AA\\uB3AB\\uB3AD\"],\n      [\"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],\n      [\"8a41\", \"\\uB445\", 10, \"\\uB452\\uB453\\uB455\\uB456\\uB457\\uB459\", 6, \"\\uB462\\uB464\\uB466\"],\n      [\"8a61\", \"\\uB467\", 4, \"\\uB46D\", 18, \"\\uB481\\uB482\"],\n      [\"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\"],\n      [\"8b41\", \"\\uB51E\", 5, \"\\uB526\\uB52B\", 4, \"\\uB532\\uB533\\uB535\\uB536\\uB537\\uB539\", 6, \"\\uB542\\uB546\"],\n      [\"8b61\", \"\\uB547\\uB548\\uB549\\uB54A\\uB54E\\uB54F\\uB551\\uB552\\uB553\\uB555\", 6, \"\\uB55E\\uB562\", 8],\n      [\"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],\n      [\"8c41\", \"\\uB600\", 15, \"\\uB612\\uB613\\uB615\\uB616\\uB617\\uB619\", 4],\n      [\"8c61\", \"\\uB61E\", 6, \"\\uB626\", 5, \"\\uB62D\", 6, \"\\uB635\", 5],\n      [\"8c81\", \"\\uB63B\", 12, \"\\uB649\", 26, \"\\uB665\\uB666\\uB667\\uB669\", 50, \"\\uB69E\\uB69F\\uB6A1\\uB6A2\\uB6A3\\uB6A5\", 5, \"\\uB6AD\\uB6AE\\uB6AF\\uB6B0\\uB6B2\", 16],\n      [\"8d41\", \"\\uB6C3\", 16, \"\\uB6D5\", 8],\n      [\"8d61\", \"\\uB6DE\", 17, \"\\uB6F1\\uB6F2\\uB6F3\\uB6F5\\uB6F6\\uB6F7\\uB6F9\\uB6FA\"],\n      [\"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\"],\n      [\"8e41\", \"\\uB79F\\uB7A1\", 6, \"\\uB7AA\\uB7AE\", 5, \"\\uB7B6\\uB7B7\\uB7B9\", 8],\n      [\"8e61\", \"\\uB7C2\", 4, \"\\uB7C8\\uB7CA\", 19],\n      [\"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],\n      [\"8f41\", \"\\uB885\", 7, \"\\uB88E\", 17],\n      [\"8f61\", \"\\uB8A0\", 7, \"\\uB8A9\", 6, \"\\uB8B1\\uB8B2\\uB8B3\\uB8B5\\uB8B6\\uB8B7\\uB8B9\", 4],\n      [\"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],\n      [\"9041\", \"\\uB95A\\uB95B\\uB95D\\uB95E\\uB95F\\uB961\", 6, \"\\uB96A\\uB96C\\uB96E\", 5, \"\\uB976\\uB977\\uB979\\uB97A\\uB97B\\uB97D\"],\n      [\"9061\", \"\\uB97E\", 5, \"\\uB986\\uB988\\uB98B\\uB98C\\uB98F\", 15],\n      [\"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\"],\n      [\"9141\", \"\\uBA47\\uBA4A\\uBA4C\\uBA4F\\uBA50\\uBA51\\uBA52\\uBA56\\uBA57\\uBA59\\uBA5A\\uBA5B\\uBA5D\", 6, \"\\uBA66\\uBA6A\", 5],\n      [\"9161\", \"\\uBA72\\uBA73\\uBA75\\uBA76\\uBA77\\uBA79\", 9, \"\\uBA86\\uBA88\\uBA89\\uBA8A\\uBA8B\\uBA8D\", 5],\n      [\"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],\n      [\"9241\", \"\\uBB28\\uBB2A\\uBB2C\", 7, \"\\uBB37\\uBB39\\uBB3A\\uBB3F\", 4, \"\\uBB46\\uBB48\\uBB4A\\uBB4B\\uBB4C\\uBB4E\\uBB51\\uBB52\"],\n      [\"9261\", \"\\uBB53\\uBB55\\uBB56\\uBB57\\uBB59\", 7, \"\\uBB62\\uBB64\", 7, \"\\uBB6D\", 4],\n      [\"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\"],\n      [\"9341\", \"\\uBC03\", 4, \"\\uBC0A\\uBC0E\\uBC10\\uBC12\\uBC13\\uBC19\\uBC1A\\uBC20\\uBC21\\uBC22\\uBC23\\uBC26\\uBC28\\uBC2A\\uBC2B\\uBC2C\\uBC2E\\uBC2F\\uBC32\\uBC33\\uBC35\"],\n      [\"9361\", \"\\uBC36\\uBC37\\uBC39\", 6, \"\\uBC42\\uBC46\\uBC47\\uBC48\\uBC4A\\uBC4B\\uBC4E\\uBC4F\\uBC51\", 8],\n      [\"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\"],\n      [\"9441\", \"\\uBCFE\", 5, \"\\uBD06\\uBD08\\uBD0A\", 5, \"\\uBD11\\uBD12\\uBD13\\uBD15\", 8],\n      [\"9461\", \"\\uBD1E\", 5, \"\\uBD25\", 6, \"\\uBD2D\", 12],\n      [\"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],\n      [\"9541\", \"\\uBDD2\\uBDD3\\uBDD6\\uBDD7\\uBDD9\\uBDDA\\uBDDB\\uBDDD\", 11, \"\\uBDEA\", 5, \"\\uBDF1\"],\n      [\"9561\", \"\\uBDF2\\uBDF3\\uBDF5\\uBDF6\\uBDF7\\uBDF9\", 6, \"\\uBE01\\uBE02\\uBE04\\uBE06\", 5, \"\\uBE0E\\uBE0F\\uBE11\\uBE12\\uBE13\"],\n      [\"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],\n      [\"9641\", \"\\uBEB8\", 23, \"\\uBED2\\uBED3\"],\n      [\"9661\", \"\\uBED5\\uBED6\\uBED9\", 6, \"\\uBEE1\\uBEE2\\uBEE6\", 5, \"\\uBEED\", 8],\n      [\"9681\", \"\\uBEF6\", 10, \"\\uBF02\", 5, \"\\uBF0A\", 13, \"\\uBF1A\\uBF1E\", 33, \"\\uBF42\\uBF43\\uBF45\\uBF46\\uBF47\\uBF49\", 6, \"\\uBF52\\uBF53\\uBF54\\uBF56\", 44],\n      [\"9741\", \"\\uBF83\", 16, \"\\uBF95\", 8],\n      [\"9761\", \"\\uBF9E\", 17, \"\\uBFB1\", 7],\n      [\"9781\", \"\\uBFB9\", 11, \"\\uBFC6\", 5, \"\\uBFCE\\uBFCF\\uBFD1\\uBFD2\\uBFD3\\uBFD5\", 6, \"\\uBFDD\\uBFDE\\uBFE0\\uBFE2\", 89, \"\\uC03D\\uC03E\\uC03F\"],\n      [\"9841\", \"\\uC040\", 16, \"\\uC052\", 5, \"\\uC059\\uC05A\\uC05B\"],\n      [\"9861\", \"\\uC05D\\uC05E\\uC05F\\uC061\", 6, \"\\uC06A\", 15],\n      [\"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\"],\n      [\"9941\", \"\\uC132\\uC133\\uC134\\uC135\\uC137\\uC13A\\uC13B\\uC13D\\uC13E\\uC13F\\uC141\", 6, \"\\uC14A\\uC14E\", 5, \"\\uC156\\uC157\"],\n      [\"9961\", \"\\uC159\\uC15A\\uC15B\\uC15D\", 6, \"\\uC166\\uC16A\", 5, \"\\uC171\\uC172\\uC173\\uC175\\uC176\\uC177\\uC179\\uC17A\\uC17B\"],\n      [\"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\"],\n      [\"9a41\", \"\\uC224\\uC225\\uC226\\uC227\\uC22A\\uC22C\\uC22E\\uC230\\uC233\\uC235\", 16],\n      [\"9a61\", \"\\uC246\\uC247\\uC249\", 6, \"\\uC252\\uC253\\uC255\\uC256\\uC257\\uC259\", 6, \"\\uC261\\uC262\\uC263\\uC264\\uC266\"],\n      [\"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\"],\n      [\"9b41\", \"\\uC310\\uC311\\uC312\\uC316\\uC317\\uC319\\uC31A\\uC31B\\uC31D\", 6, \"\\uC326\\uC327\\uC32A\", 8],\n      [\"9b61\", \"\\uC333\", 17, \"\\uC346\", 7],\n      [\"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\"],\n      [\"9c41\", \"\\uC3DB\\uC3DD\\uC3DE\\uC3E1\\uC3E3\", 4, \"\\uC3EA\\uC3EB\\uC3EC\\uC3EE\", 5, \"\\uC3F6\\uC3F7\\uC3F9\", 5],\n      [\"9c61\", \"\\uC3FF\", 8, \"\\uC409\", 6, \"\\uC411\", 9],\n      [\"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],\n      [\"9d41\", \"\\uC4AA\", 13, \"\\uC4B9\\uC4BA\\uC4BB\\uC4BD\", 8],\n      [\"9d61\", \"\\uC4C6\", 25],\n      [\"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\"],\n      [\"9e41\", \"\\uC596\\uC599\\uC59A\\uC59B\\uC59D\\uC59E\\uC59F\\uC5A1\", 7, \"\\uC5AA\", 9, \"\\uC5B6\"],\n      [\"9e61\", \"\\uC5B7\\uC5BA\\uC5BF\", 4, \"\\uC5CB\\uC5CD\\uC5CF\\uC5D2\\uC5D3\\uC5D5\\uC5D6\\uC5D7\\uC5D9\", 6, \"\\uC5E2\\uC5E4\\uC5E6\\uC5E7\"],\n      [\"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\"],\n      [\"9f41\", \"\\uC6A8\\uC6AA\", 5, \"\\uC6B2\\uC6B3\\uC6B5\\uC6B6\\uC6B7\\uC6BB\", 4, \"\\uC6C2\\uC6C4\\uC6C6\", 5, \"\\uC6CE\"],\n      [\"9f61\", \"\\uC6CF\\uC6D1\\uC6D2\\uC6D3\\uC6D5\", 6, \"\\uC6DE\\uC6DF\\uC6E2\", 5, \"\\uC6EA\\uC6EB\\uC6ED\\uC6EE\\uC6EF\\uC6F1\\uC6F2\"],\n      [\"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\"],\n      [\"a041\", \"\\uC7B8\\uC7B9\\uC7BA\\uC7BB\\uC7BE\\uC7C2\", 5, \"\\uC7CA\\uC7CB\\uC7CD\\uC7CF\\uC7D1\", 6, \"\\uC7D9\\uC7DA\\uC7DB\\uC7DC\"],\n      [\"a061\", \"\\uC7DE\", 5, \"\\uC7E5\\uC7E6\\uC7E7\\uC7E9\\uC7EA\\uC7EB\\uC7ED\", 13],\n      [\"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\"],\n      [\"a141\", \"\\uC8A5\\uC8A6\\uC8A7\\uC8A9\", 18, \"\\uC8BE\\uC8BF\\uC8C0\\uC8C1\"],\n      [\"a161\", \"\\uC8C2\\uC8C3\\uC8C5\\uC8C6\\uC8C7\\uC8C9\\uC8CA\\uC8CB\\uC8CD\", 6, \"\\uC8D6\\uC8D8\\uC8DA\", 5, \"\\uC8E2\\uC8E3\\uC8E5\"],\n      [\"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\"],\n      [\"a241\", \"\\uC910\\uC912\", 5, \"\\uC919\", 18],\n      [\"a261\", \"\\uC92D\", 6, \"\\uC935\", 18],\n      [\"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\"],\n      [\"a341\", \"\\uC971\\uC972\\uC973\\uC975\", 6, \"\\uC97D\", 10, \"\\uC98A\\uC98B\\uC98D\\uC98E\\uC98F\"],\n      [\"a361\", \"\\uC991\", 6, \"\\uC99A\\uC99C\\uC99E\", 16],\n      [\"a381\", \"\\uC9AF\", 16, \"\\uC9C2\\uC9C3\\uC9C5\\uC9C6\\uC9C9\\uC9CB\", 4, \"\\uC9D2\\uC9D4\\uC9D7\\uC9D8\\uC9DB\\uFF01\", 58, \"\\uFFE6\\uFF3D\", 32, \"\\uFFE3\"],\n      [\"a441\", \"\\uC9DE\\uC9DF\\uC9E1\\uC9E3\\uC9E5\\uC9E6\\uC9E8\\uC9E9\\uC9EA\\uC9EB\\uC9EE\\uC9F2\", 5, \"\\uC9FA\\uC9FB\\uC9FD\\uC9FE\\uC9FF\\uCA01\\uCA02\\uCA03\\uCA04\"],\n      [\"a461\", \"\\uCA05\\uCA06\\uCA07\\uCA0A\\uCA0E\", 5, \"\\uCA15\\uCA16\\uCA17\\uCA19\", 12],\n      [\"a481\", \"\\uCA26\\uCA27\\uCA28\\uCA2A\", 28, \"\\u3131\", 93],\n      [\"a541\", \"\\uCA47\", 4, \"\\uCA4E\\uCA4F\\uCA51\\uCA52\\uCA53\\uCA55\", 6, \"\\uCA5E\\uCA62\", 5, \"\\uCA69\\uCA6A\"],\n      [\"a561\", \"\\uCA6B\", 17, \"\\uCA7E\", 5, \"\\uCA85\\uCA86\"],\n      [\"a581\", \"\\uCA87\", 16, \"\\uCA99\", 14, \"\\u2170\", 9],\n      [\"a5b0\", \"\\u2160\", 9],\n      [\"a5c1\", \"\\u0391\", 16, \"\\u03A3\", 6],\n      [\"a5e1\", \"\\u03B1\", 16, \"\\u03C3\", 6],\n      [\"a641\", \"\\uCAA8\", 19, \"\\uCABE\\uCABF\\uCAC1\\uCAC2\\uCAC3\\uCAC5\"],\n      [\"a661\", \"\\uCAC6\", 5, \"\\uCACE\\uCAD0\\uCAD2\\uCAD4\\uCAD5\\uCAD6\\uCAD7\\uCADA\", 5, \"\\uCAE1\", 6],\n      [\"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],\n      [\"a741\", \"\\uCB0B\", 4, \"\\uCB11\\uCB12\\uCB13\\uCB15\\uCB16\\uCB17\\uCB19\", 6, \"\\uCB22\", 7],\n      [\"a761\", \"\\uCB2A\", 22, \"\\uCB42\\uCB43\\uCB44\"],\n      [\"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\"],\n      [\"a841\", \"\\uCB6D\", 10, \"\\uCB7A\", 14],\n      [\"a861\", \"\\uCB89\", 18, \"\\uCB9D\", 6],\n      [\"a881\", \"\\uCBA4\", 19, \"\\uCBB9\", 11, \"\\xC6\\xD0\\xAA\\u0126\"],\n      [\"a8a6\", \"\\u0132\"],\n      [\"a8a8\", \"\\u013F\\u0141\\xD8\\u0152\\xBA\\xDE\\u0166\\u014A\"],\n      [\"a8b1\", \"\\u3260\", 27, \"\\u24D0\", 25, \"\\u2460\", 14, \"\\xBD\\u2153\\u2154\\xBC\\xBE\\u215B\\u215C\\u215D\\u215E\"],\n      [\"a941\", \"\\uCBC5\", 14, \"\\uCBD5\", 10],\n      [\"a961\", \"\\uCBE0\\uCBE1\\uCBE2\\uCBE3\\uCBE5\\uCBE6\\uCBE8\\uCBEA\", 18],\n      [\"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\"],\n      [\"aa41\", \"\\uCC25\\uCC26\\uCC2A\\uCC2B\\uCC2D\\uCC2F\\uCC31\", 6, \"\\uCC3A\\uCC3F\", 4, \"\\uCC46\\uCC47\\uCC49\\uCC4A\\uCC4B\\uCC4D\\uCC4E\"],\n      [\"aa61\", \"\\uCC4F\", 4, \"\\uCC56\\uCC5A\", 5, \"\\uCC61\\uCC62\\uCC63\\uCC65\\uCC67\\uCC69\", 6, \"\\uCC71\\uCC72\"],\n      [\"aa81\", \"\\uCC73\\uCC74\\uCC76\", 29, \"\\u3041\", 82],\n      [\"ab41\", \"\\uCC94\\uCC95\\uCC96\\uCC97\\uCC9A\\uCC9B\\uCC9D\\uCC9E\\uCC9F\\uCCA1\", 6, \"\\uCCAA\\uCCAE\", 5, \"\\uCCB6\\uCCB7\\uCCB9\"],\n      [\"ab61\", \"\\uCCBA\\uCCBB\\uCCBD\", 6, \"\\uCCC6\\uCCC8\\uCCCA\", 5, \"\\uCCD1\\uCCD2\\uCCD3\\uCCD5\", 5],\n      [\"ab81\", \"\\uCCDB\", 8, \"\\uCCE5\", 6, \"\\uCCED\\uCCEE\\uCCEF\\uCCF1\", 12, \"\\u30A1\", 85],\n      [\"ac41\", \"\\uCCFE\\uCCFF\\uCD00\\uCD02\", 5, \"\\uCD0A\\uCD0B\\uCD0D\\uCD0E\\uCD0F\\uCD11\", 6, \"\\uCD1A\\uCD1C\\uCD1E\\uCD1F\\uCD20\"],\n      [\"ac61\", \"\\uCD21\\uCD22\\uCD23\\uCD25\\uCD26\\uCD27\\uCD29\\uCD2A\\uCD2B\\uCD2D\", 11, \"\\uCD3A\", 4],\n      [\"ac81\", \"\\uCD3F\", 28, \"\\uCD5D\\uCD5E\\uCD5F\\u0410\", 5, \"\\u0401\\u0416\", 25],\n      [\"acd1\", \"\\u0430\", 5, \"\\u0451\\u0436\", 25],\n      [\"ad41\", \"\\uCD61\\uCD62\\uCD63\\uCD65\", 6, \"\\uCD6E\\uCD70\\uCD72\", 5, \"\\uCD79\", 7],\n      [\"ad61\", \"\\uCD81\", 6, \"\\uCD89\", 10, \"\\uCD96\\uCD97\\uCD99\\uCD9A\\uCD9B\\uCD9D\\uCD9E\\uCD9F\"],\n      [\"ad81\", \"\\uCDA0\\uCDA1\\uCDA2\\uCDA3\\uCDA6\\uCDA8\\uCDAA\", 5, \"\\uCDB1\", 18, \"\\uCDC5\"],\n      [\"ae41\", \"\\uCDC6\", 5, \"\\uCDCD\\uCDCE\\uCDCF\\uCDD1\", 16],\n      [\"ae61\", \"\\uCDE2\", 5, \"\\uCDE9\\uCDEA\\uCDEB\\uCDED\\uCDEE\\uCDEF\\uCDF1\", 6, \"\\uCDFA\\uCDFC\\uCDFE\", 4],\n      [\"ae81\", \"\\uCE03\\uCE05\\uCE06\\uCE07\\uCE09\\uCE0A\\uCE0B\\uCE0D\", 6, \"\\uCE15\\uCE16\\uCE17\\uCE18\\uCE1A\", 5, \"\\uCE22\\uCE23\\uCE25\\uCE26\\uCE27\\uCE29\\uCE2A\\uCE2B\"],\n      [\"af41\", \"\\uCE2C\\uCE2D\\uCE2E\\uCE2F\\uCE32\\uCE34\\uCE36\", 19],\n      [\"af61\", \"\\uCE4A\", 13, \"\\uCE5A\\uCE5B\\uCE5D\\uCE5E\\uCE62\", 5, \"\\uCE6A\\uCE6C\"],\n      [\"af81\", \"\\uCE6E\", 5, \"\\uCE76\\uCE77\\uCE79\\uCE7A\\uCE7B\\uCE7D\", 6, \"\\uCE86\\uCE88\\uCE8A\", 5, \"\\uCE92\\uCE93\\uCE95\\uCE96\\uCE97\\uCE99\"],\n      [\"b041\", \"\\uCE9A\", 5, \"\\uCEA2\\uCEA6\", 5, \"\\uCEAE\", 12],\n      [\"b061\", \"\\uCEBB\", 5, \"\\uCEC2\", 19],\n      [\"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\"],\n      [\"b141\", \"\\uCF02\\uCF03\\uCF05\\uCF06\\uCF07\\uCF09\", 6, \"\\uCF12\\uCF14\\uCF16\", 5, \"\\uCF1D\\uCF1E\\uCF1F\\uCF21\\uCF22\\uCF23\"],\n      [\"b161\", \"\\uCF25\", 6, \"\\uCF2E\\uCF32\", 5, \"\\uCF39\", 11],\n      [\"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\"],\n      [\"b241\", \"\\uCF6D\\uCF6E\\uCF6F\\uCF72\\uCF73\\uCF75\\uCF76\\uCF77\\uCF79\", 6, \"\\uCF81\\uCF82\\uCF83\\uCF84\\uCF86\", 5, \"\\uCF8D\"],\n      [\"b261\", \"\\uCF8E\", 18, \"\\uCFA2\", 5, \"\\uCFA9\"],\n      [\"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\"],\n      [\"b341\", \"\\uCFCC\", 19, \"\\uCFE2\\uCFE3\\uCFE5\\uCFE6\\uCFE7\\uCFE9\"],\n      [\"b361\", \"\\uCFEA\", 5, \"\\uCFF2\\uCFF4\\uCFF6\", 5, \"\\uCFFD\\uCFFE\\uCFFF\\uD001\\uD002\\uD003\\uD005\", 5],\n      [\"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\"],\n      [\"b441\", \"\\uD02E\", 5, \"\\uD036\\uD037\\uD039\\uD03A\\uD03B\\uD03D\", 6, \"\\uD046\\uD048\\uD04A\", 5],\n      [\"b461\", \"\\uD051\\uD052\\uD053\\uD055\\uD056\\uD057\\uD059\", 6, \"\\uD061\", 10, \"\\uD06E\\uD06F\"],\n      [\"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\"],\n      [\"b541\", \"\\uD095\", 14, \"\\uD0A6\\uD0A7\\uD0A9\\uD0AA\\uD0AB\\uD0AD\", 5],\n      [\"b561\", \"\\uD0B3\\uD0B6\\uD0B8\\uD0BA\", 5, \"\\uD0C2\\uD0C3\\uD0C5\\uD0C6\\uD0C7\\uD0CA\", 5, \"\\uD0D2\\uD0D6\", 4],\n      [\"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\"],\n      [\"b641\", \"\\uD105\", 7, \"\\uD10E\", 17],\n      [\"b661\", \"\\uD120\", 15, \"\\uD132\\uD133\\uD135\\uD136\\uD137\\uD139\\uD13B\\uD13C\\uD13D\\uD13E\"],\n      [\"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\"],\n      [\"b741\", \"\\uD16E\", 13, \"\\uD17D\", 6, \"\\uD185\\uD186\\uD187\\uD189\\uD18A\"],\n      [\"b761\", \"\\uD18B\", 20, \"\\uD1A2\\uD1A3\\uD1A5\\uD1A6\\uD1A7\"],\n      [\"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\"],\n      [\"b841\", \"\\uD1D0\", 7, \"\\uD1D9\", 17],\n      [\"b861\", \"\\uD1EB\", 8, \"\\uD1F5\\uD1F6\\uD1F7\\uD1F9\", 13],\n      [\"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\"],\n      [\"b941\", \"\\uD22A\\uD22B\\uD22E\\uD22F\\uD231\\uD232\\uD233\\uD235\", 6, \"\\uD23E\\uD240\\uD242\", 5, \"\\uD249\\uD24A\\uD24B\\uD24C\"],\n      [\"b961\", \"\\uD24D\", 14, \"\\uD25D\", 6, \"\\uD265\\uD266\\uD267\\uD268\"],\n      [\"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\"],\n      [\"ba41\", \"\\uD28D\\uD28E\\uD28F\\uD292\\uD293\\uD294\\uD296\", 5, \"\\uD29D\\uD29E\\uD29F\\uD2A1\\uD2A2\\uD2A3\\uD2A5\", 6, \"\\uD2AD\"],\n      [\"ba61\", \"\\uD2AE\\uD2AF\\uD2B0\\uD2B2\", 5, \"\\uD2BA\\uD2BB\\uD2BD\\uD2BE\\uD2C1\\uD2C3\", 4, \"\\uD2CA\\uD2CC\", 5],\n      [\"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\"],\n      [\"bb41\", \"\\uD2FB\", 4, \"\\uD302\\uD304\\uD306\", 5, \"\\uD30F\\uD311\\uD312\\uD313\\uD315\\uD317\", 4, \"\\uD31E\\uD322\\uD323\"],\n      [\"bb61\", \"\\uD324\\uD326\\uD327\\uD32A\\uD32B\\uD32D\\uD32E\\uD32F\\uD331\", 6, \"\\uD33A\\uD33E\", 5, \"\\uD346\\uD347\\uD348\\uD349\"],\n      [\"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\"],\n      [\"bc41\", \"\\uD36A\", 17, \"\\uD37E\\uD37F\\uD381\\uD382\\uD383\\uD385\\uD386\\uD387\"],\n      [\"bc61\", \"\\uD388\\uD389\\uD38A\\uD38B\\uD38E\\uD392\", 5, \"\\uD39A\\uD39B\\uD39D\\uD39E\\uD39F\\uD3A1\", 6, \"\\uD3AA\\uD3AC\\uD3AE\"],\n      [\"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\"],\n      [\"bd41\", \"\\uD3D7\\uD3D9\", 7, \"\\uD3E2\\uD3E4\", 7, \"\\uD3EE\\uD3EF\\uD3F1\\uD3F2\\uD3F3\\uD3F5\\uD3F6\\uD3F7\"],\n      [\"bd61\", \"\\uD3F8\\uD3F9\\uD3FA\\uD3FB\\uD3FE\\uD400\\uD402\", 5, \"\\uD409\", 13],\n      [\"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\"],\n      [\"be41\", \"\\uD438\", 7, \"\\uD441\\uD442\\uD443\\uD445\", 14],\n      [\"be61\", \"\\uD454\", 7, \"\\uD45D\\uD45E\\uD45F\\uD461\\uD462\\uD463\\uD465\", 7, \"\\uD46E\\uD470\\uD471\\uD472\"],\n      [\"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\"],\n      [\"bf41\", \"\\uD49E\", 10, \"\\uD4AA\", 14],\n      [\"bf61\", \"\\uD4B9\", 18, \"\\uD4CD\\uD4CE\\uD4CF\\uD4D1\\uD4D2\\uD4D3\\uD4D5\"],\n      [\"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\"],\n      [\"c041\", \"\\uD4FE\", 5, \"\\uD505\\uD506\\uD507\\uD509\\uD50A\\uD50B\\uD50D\", 6, \"\\uD516\\uD518\", 5],\n      [\"c061\", \"\\uD51E\", 25],\n      [\"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\"],\n      [\"c141\", \"\\uD564\\uD566\\uD567\\uD56A\\uD56C\\uD56E\", 5, \"\\uD576\\uD577\\uD579\\uD57A\\uD57B\\uD57D\", 6, \"\\uD586\\uD58A\\uD58B\"],\n      [\"c161\", \"\\uD58C\\uD58D\\uD58E\\uD58F\\uD591\", 19, \"\\uD5A6\\uD5A7\"],\n      [\"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\"],\n      [\"c241\", \"\\uD5CA\\uD5CB\\uD5CD\\uD5CE\\uD5CF\\uD5D1\\uD5D3\", 4, \"\\uD5DA\\uD5DC\\uD5DE\", 5, \"\\uD5E6\\uD5E7\\uD5E9\\uD5EA\\uD5EB\\uD5ED\\uD5EE\"],\n      [\"c261\", \"\\uD5EF\", 4, \"\\uD5F6\\uD5F8\\uD5FA\", 5, \"\\uD602\\uD603\\uD605\\uD606\\uD607\\uD609\", 6, \"\\uD612\"],\n      [\"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\"],\n      [\"c341\", \"\\uD63D\\uD63E\\uD63F\\uD641\\uD642\\uD643\\uD644\\uD646\\uD647\\uD64A\\uD64C\\uD64E\\uD64F\\uD650\\uD652\\uD653\\uD656\\uD657\\uD659\\uD65A\\uD65B\\uD65D\", 4],\n      [\"c361\", \"\\uD662\", 4, \"\\uD668\\uD66A\", 5, \"\\uD672\\uD673\\uD675\", 11],\n      [\"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\"],\n      [\"c441\", \"\\uD6AB\\uD6AD\\uD6AE\\uD6AF\\uD6B1\", 7, \"\\uD6BA\\uD6BC\", 7, \"\\uD6C6\\uD6C7\\uD6C9\\uD6CA\\uD6CB\"],\n      [\"c461\", \"\\uD6CD\\uD6CE\\uD6CF\\uD6D0\\uD6D2\\uD6D3\\uD6D5\\uD6D6\\uD6D8\\uD6DA\", 5, \"\\uD6E1\\uD6E2\\uD6E3\\uD6E5\\uD6E6\\uD6E7\\uD6E9\", 4],\n      [\"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\"],\n      [\"c541\", \"\\uD715\\uD716\\uD717\\uD71A\\uD71B\\uD71D\\uD71E\\uD71F\\uD721\", 6, \"\\uD72A\\uD72C\\uD72E\", 5, \"\\uD736\\uD737\\uD739\"],\n      [\"c561\", \"\\uD73A\\uD73B\\uD73D\", 6, \"\\uD745\\uD746\\uD748\\uD74A\", 5, \"\\uD752\\uD753\\uD755\\uD75A\", 4],\n      [\"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\"],\n      [\"c641\", \"\\uD78D\\uD78E\\uD78F\\uD791\", 6, \"\\uD79A\\uD79C\\uD79E\", 5],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp950.json\nvar require_cp9502 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/cp950.json\"(exports2, module2) {\n    module2.exports = [\n      [\"0\", \"\\0\", 127],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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],\n      [\"a340\", \"\\uFF57\\uFF58\\uFF59\\uFF5A\\u0391\", 16, \"\\u03A3\", 6, \"\\u03B1\", 16, \"\\u03C3\", 6, \"\\u3105\", 10],\n      [\"a3a1\", \"\\u3110\", 25, \"\\u02D9\\u02C9\\u02CA\\u02C7\\u02CB\"],\n      [\"a3e1\", \"\\u20AC\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/tables/big5-added.json\nvar require_big5_added2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/tables/big5-added.json\"(exports2, module2) {\n    module2.exports = [\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"88a1\", \"\\u01DC\\xFC\\u0FFF\\xEA\\u0304\\u1EBF\\u0FFF\\xEA\\u030C\\u1EC1\\xEA\\u0261\\u23DA\\u23DB\"],\n      [\"8940\", \"\\u{2A3A9}\\u{21145}\"],\n      [\"8943\", \"\\u650A\"],\n      [\"8946\", \"\\u4E3D\\u6EDD\\u9D4E\\u91DF\"],\n      [\"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\"],\n      [\"89a1\", \"\\u7411\\u7CFC\\u7DCD\\u6946\\u7AC9\\u5227\"],\n      [\"89ab\", \"\\u918C\\u78B8\\u915E\\u80BC\"],\n      [\"89b0\", \"\\u8D0B\\u80F6\\u{209E7}\"],\n      [\"89b5\", \"\\u809F\\u9EC7\\u4CCD\\u9DC9\\u9E0C\\u4C3E\\u{29DF6}\\u{2700E}\\u9E0A\\u{2A133}\\u35C1\"],\n      [\"89c1\", \"\\u6E9A\\u823E\\u7519\"],\n      [\"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\"],\n      [\"8a40\", \"\\u{27D84}\\u5525\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"8a76\", \"\\u43D9\\u{260A5}\\u64B4\\u54E3\\u{22D4C}\\u{22BCA}\\u{21077}\\u39FB\\u{2106F}\"],\n      [\"8aa1\", \"\\u{266DA}\\u{26716}\\u{279A0}\\u64EA\\u{25052}\\u{20C43}\\u8E68\\u{221A1}\\u{28B4C}\\u{20731}\"],\n      [\"8aac\", \"\\u480B\\u{201A9}\\u3FFA\\u5873\\u{22D8D}\"],\n      [\"8ab2\", \"\\u{245C8}\\u{204FC}\\u{26097}\\u{20F4C}\\u{20D96}\\u5579\\u40BB\\u43BA\"],\n      [\"8abb\", \"\\u4AB4\\u{22A66}\\u{2109D}\\u81AA\\u98F5\\u{20D9C}\\u6379\\u39FE\\u{22775}\\u8DC0\\u56A1\\u647C\\u3E43\"],\n      [\"8ac9\", \"\\u{2A601}\\u{20E09}\\u{22ACF}\\u{22CC9}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"8af6\", \"\\u{20EAB}\\u{20BA9}\\u{20D48}\\u{210C0}\\u{2113D}\\u3FF9\\u{22696}\\u6432\\u{20FAD}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8ca1\", \"\\u{233F9}\\u6919\\u6A43\\u{23C63}\\u6CFF\"],\n      [\"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\"],\n      [\"8cc9\", \"\\u9868\\u676B\\u4276\\u573D\"],\n      [\"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\"],\n      [\"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\"],\n      [\"8d40\", \"\\u{20B9F}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"9ea1\", \"\\u9C5D\\u651F\\u{22DA0}\\u48F3\\u{247E0}\\u{29D7C}\\u{20FEC}\\u{20E0A}\\u6062\\u{275A3}\\u{20FED}\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"9ef5\", \"\\u565D\\u{212A9}\\u57A7\\u{24963}\\u{29E06}\\u5234\\u{270AE}\\u35AD\\u6C4A\\u9D7C\"],\n      [\"9f40\", \"\\u7C56\\u9B39\\u57DE\\u{2176C}\\u5C53\\u64D3\\u{294D0}\\u{26335}\\u{27164}\\u86AD\\u{20D28}\\u{26D22}\\u{24AE2}\\u{20D71}\"],\n      [\"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\"],\n      [\"9fa1\", \"\\u692C\\u53DA\\u9C0A\\u9D02\\u4C3B\\u9641\\u6980\\u50A6\\u7546\\u{2176D}\\u99DA\\u5273\"],\n      [\"9fae\", \"\\u9159\\u9681\\u915C\"],\n      [\"9fb2\", \"\\u9151\\u{28E97}\\u637F\\u{26D23}\\u6ACA\\u5611\\u918E\\u757A\\u6285\\u{203FC}\\u734F\\u7C70\\u{25C21}\\u{23CFD}\"],\n      [\"9fc1\", \"\\u{24919}\\u76D6\\u9B9D\\u4E2A\\u{20CD4}\\u83BE\\u8842\"],\n      [\"9fc9\", \"\\u5C4A\\u69C0\\u50ED\\u577A\\u521F\\u5DF5\\u4ECE\\u6C31\\u{201F2}\\u4F39\\u549C\\u54DA\\u529A\\u8D82\\u35FE\\u5F0C\\u35F3\"],\n      [\"9fdb\", \"\\u6B52\\u917C\\u9FA5\\u9B97\\u982E\\u98B4\\u9ABA\\u9EA8\\u9E84\\u717A\\u7B14\"],\n      [\"9fe7\", \"\\u6BFA\\u8818\\u7F78\"],\n      [\"9feb\", \"\\u5620\\u{2A64A}\\u8E77\\u9F53\"],\n      [\"9ff0\", \"\\u8DD4\\u8E4F\\u9E1C\\u8E01\\u6282\\u{2837D}\\u8E28\\u8E75\\u7AD3\\u{24A77}\\u7A3E\\u78D8\\u6CEA\\u8A67\\u7607\"],\n      [\"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\"],\n      [\"a055\", \"\\u{2183B}\\u{26E05}\"],\n      [\"a058\", \"\\u8A7E\\u{2251B}\"],\n      [\"a05b\", \"\\u60FD\\u7667\\u9AD7\\u9D44\\u936E\\u9B8F\\u87F5\"],\n      [\"a063\", \"\\u880F\\u8CF7\\u732C\\u9721\\u9BB0\\u35D6\\u72B2\\u4C07\\u7C51\\u994A\\u{26159}\\u6159\\u4C04\\u9E96\\u617D\"],\n      [\"a073\", \"\\u575F\\u616F\\u62A6\\u6239\\u62CE\\u3A5C\\u61E2\\u53AA\\u{233F5}\\u6364\\u6802\\u35D2\"],\n      [\"a0a1\", \"\\u5D57\\u{28BC2}\\u8FDA\\u{28E39}\"],\n      [\"a0a6\", \"\\u50D9\\u{21D46}\\u7906\\u5332\\u9638\\u{20F3B}\\u4065\"],\n      [\"a0ae\", \"\\u77FE\"],\n      [\"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\"],\n      [\"a0d4\", \"\\u89A9\\u7468\\u6DB9\\u87C1\\u{24011}\\u74E7\\u3DDB\\u7176\\u60A4\\u619C\\u3CD1\\u7162\\u6077\"],\n      [\"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}\"],\n      [\"a3c0\", \"\\u2400\", 31, \"\\u2421\"],\n      [\"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],\n      [\"c740\", \"\\u3059\", 58, \"\\u30A1\\u30A2\\u30A3\\u30A4\"],\n      [\"c7a1\", \"\\u30A5\", 81, \"\\u0410\", 5, \"\\u0401\\u0416\", 4],\n      [\"c840\", \"\\u041B\", 26, \"\\u0451\\u0436\", 25, \"\\u21E7\\u21B8\\u21B9\\u31CF\\u{200CC}\\u4E5A\\u{2008A}\\u5202\\u4491\"],\n      [\"c8a1\", \"\\u9FB0\\u5188\\u9FB1\\u{27607}\"],\n      [\"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\"],\n      [\"c8f5\", \"\\u0283\\u0250\\u025B\\u0254\\u0275\\u0153\\xF8\\u014B\\u028A\\u026A\"],\n      [\"f9fe\", \"\\uFFED\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"],\n      [\"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}\"],\n      [\"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\"]\n    ];\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/dbcs-data.js\nvar require_dbcs_data2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/dbcs-data.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      // == Japanese/ShiftJIS ====================================================\n      // All japanese encodings are based on JIS X set of standards:\n      // JIS X 0201 - Single-byte encoding of ASCII + \u00A5 + Kana chars at 0xA1-0xDF.\n      // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. \n      //              Has several variations in 1978, 1983, 1990 and 1997.\n      // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.\n      // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.\n      //              2 planes, first is superset of 0208, second - revised 0212.\n      //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)\n      // Byte encodings are:\n      //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte\n      //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.\n      //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.\n      //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.\n      //               0x00-0x7F       - lower part of 0201\n      //               0x8E, 0xA1-0xDF - upper part of 0201\n      //               (0xA1-0xFE)x2   - 0208 plane (94x94).\n      //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).\n      //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.\n      //               Used as-is in ISO2022 family.\n      //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, \n      //                0201-1976 Roman, 0208-1978, 0208-1983.\n      //  * ISO2022-JP-1: Adds esc seq for 0212-1990.\n      //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.\n      //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.\n      //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.\n      //\n      // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.\n      //\n      // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html\n      \"shiftjis\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_shiftjis2();\n        },\n        encodeAdd: { \"\\xA5\": 92, \"\\u203E\": 126 },\n        encodeSkipVals: [{ from: 60736, to: 63808 }]\n      },\n      \"csshiftjis\": \"shiftjis\",\n      \"mskanji\": \"shiftjis\",\n      \"sjis\": \"shiftjis\",\n      \"windows31j\": \"shiftjis\",\n      \"ms31j\": \"shiftjis\",\n      \"xsjis\": \"shiftjis\",\n      \"windows932\": \"shiftjis\",\n      \"ms932\": \"shiftjis\",\n      \"932\": \"shiftjis\",\n      \"cp932\": \"shiftjis\",\n      \"eucjp\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_eucjp2();\n        },\n        encodeAdd: { \"\\xA5\": 92, \"\\u203E\": 126 }\n      },\n      // TODO: KDDI extension to Shift_JIS\n      // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.\n      // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.\n      // == Chinese/GBK ==========================================================\n      // http://en.wikipedia.org/wiki/GBK\n      // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder\n      // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936\n      \"gb2312\": \"cp936\",\n      \"gb231280\": \"cp936\",\n      \"gb23121980\": \"cp936\",\n      \"csgb2312\": \"cp936\",\n      \"csiso58gb231280\": \"cp936\",\n      \"euccn\": \"cp936\",\n      // Microsoft's CP936 is a subset and approximation of GBK.\n      \"windows936\": \"cp936\",\n      \"ms936\": \"cp936\",\n      \"936\": \"cp936\",\n      \"cp936\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9362();\n        }\n      },\n      // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.\n      \"gbk\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9362().concat(require_gbk_added2());\n        }\n      },\n      \"xgbk\": \"gbk\",\n      \"isoir58\": \"gbk\",\n      // GB18030 is an algorithmic extension of GBK.\n      // Main source: https://www.w3.org/TR/encoding/#gbk-encoder\n      // http://icu-project.org/docs/papers/gb18030.html\n      // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml\n      // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0\n      \"gb18030\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9362().concat(require_gbk_added2());\n        },\n        gb18030: function() {\n          return require_gb18030_ranges2();\n        },\n        encodeSkipVals: [128],\n        encodeAdd: { \"\\u20AC\": 41699 }\n      },\n      \"chinese\": \"gb18030\",\n      // == Korean ===============================================================\n      // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.\n      \"windows949\": \"cp949\",\n      \"ms949\": \"cp949\",\n      \"949\": \"cp949\",\n      \"cp949\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9492();\n        }\n      },\n      \"cseuckr\": \"cp949\",\n      \"csksc56011987\": \"cp949\",\n      \"euckr\": \"cp949\",\n      \"isoir149\": \"cp949\",\n      \"korean\": \"cp949\",\n      \"ksc56011987\": \"cp949\",\n      \"ksc56011989\": \"cp949\",\n      \"ksc5601\": \"cp949\",\n      // == Big5/Taiwan/Hong Kong ================================================\n      // There are lots of tables for Big5 and cp950. Please see the following links for history:\n      // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html\n      // Variations, in roughly number of defined chars:\n      //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT\n      //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/\n      //  * Big5-2003 (Taiwan standard) almost superset of cp950.\n      //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.\n      //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. \n      //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.\n      //    Plus, it has 4 combining sequences.\n      //    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\n      //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.\n      //    Implementations are not consistent within browsers; sometimes labeled as just big5.\n      //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.\n      //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31\n      //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.\n      //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt\n      //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt\n      // \n      // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder\n      // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.\n      \"windows950\": \"cp950\",\n      \"ms950\": \"cp950\",\n      \"950\": \"cp950\",\n      \"cp950\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9502();\n        }\n      },\n      // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.\n      \"big5\": \"big5hkscs\",\n      \"big5hkscs\": {\n        type: \"_dbcs\",\n        table: function() {\n          return require_cp9502().concat(require_big5_added2());\n        },\n        encodeSkipVals: [\n          // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of\n          // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU.\n          // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter.\n          36457,\n          36463,\n          36478,\n          36523,\n          36532,\n          36557,\n          36560,\n          36695,\n          36713,\n          36718,\n          36811,\n          36862,\n          36973,\n          36986,\n          37060,\n          37084,\n          37105,\n          37311,\n          37551,\n          37552,\n          37553,\n          37554,\n          37585,\n          37959,\n          38090,\n          38361,\n          38652,\n          39285,\n          39798,\n          39800,\n          39803,\n          39878,\n          39902,\n          39916,\n          39926,\n          40002,\n          40019,\n          40034,\n          40040,\n          40043,\n          40055,\n          40124,\n          40125,\n          40144,\n          40279,\n          40282,\n          40388,\n          40431,\n          40443,\n          40617,\n          40687,\n          40701,\n          40800,\n          40907,\n          41079,\n          41180,\n          41183,\n          36812,\n          37576,\n          38468,\n          38637,\n          // 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\n          41636,\n          41637,\n          41639,\n          41638,\n          41676,\n          41678\n        ]\n      },\n      \"cnbig5\": \"big5hkscs\",\n      \"csbig5\": \"big5hkscs\",\n      \"xxbig5\": \"big5hkscs\"\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/encodings/index.js\nvar require_encodings2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/encodings/index.js\"(exports2, module2) {\n    \"use strict\";\n    var modules = [\n      require_internal2(),\n      require_utf322(),\n      require_utf162(),\n      require_utf72(),\n      require_sbcs_codec2(),\n      require_sbcs_data2(),\n      require_sbcs_data_generated2(),\n      require_dbcs_codec2(),\n      require_dbcs_data2()\n    ];\n    for (i = 0; i < modules.length; i++) {\n      module2 = modules[i];\n      for (enc in module2)\n        if (Object.prototype.hasOwnProperty.call(module2, enc))\n          exports2[enc] = module2[enc];\n    }\n    var module2;\n    var enc;\n    var i;\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/lib/streams.js\nvar require_streams2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/lib/streams.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    module2.exports = function(stream_module) {\n      var Transform = stream_module.Transform;\n      function IconvLiteEncoderStream(conv, options) {\n        this.conv = conv;\n        options = options || {};\n        options.decodeStrings = false;\n        Transform.call(this, options);\n      }\n      IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, {\n        constructor: { value: IconvLiteEncoderStream }\n      });\n      IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {\n        if (typeof chunk != \"string\")\n          return done(new Error(\"Iconv encoding stream needs strings as its input.\"));\n        try {\n          var res = this.conv.write(chunk);\n          if (res && res.length) this.push(res);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteEncoderStream.prototype._flush = function(done) {\n        try {\n          var res = this.conv.end();\n          if (res && res.length) this.push(res);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteEncoderStream.prototype.collect = function(cb) {\n        var chunks = [];\n        this.on(\"error\", cb);\n        this.on(\"data\", function(chunk) {\n          chunks.push(chunk);\n        });\n        this.on(\"end\", function() {\n          cb(null, Buffer2.concat(chunks));\n        });\n        return this;\n      };\n      function IconvLiteDecoderStream(conv, options) {\n        this.conv = conv;\n        options = options || {};\n        options.encoding = this.encoding = \"utf8\";\n        Transform.call(this, options);\n      }\n      IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {\n        constructor: { value: IconvLiteDecoderStream }\n      });\n      IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {\n        if (!Buffer2.isBuffer(chunk) && !(chunk instanceof Uint8Array))\n          return done(new Error(\"Iconv decoding stream needs buffers as its input.\"));\n        try {\n          var res = this.conv.write(chunk);\n          if (res && res.length) this.push(res, this.encoding);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteDecoderStream.prototype._flush = function(done) {\n        try {\n          var res = this.conv.end();\n          if (res && res.length) this.push(res, this.encoding);\n          done();\n        } catch (e) {\n          done(e);\n        }\n      };\n      IconvLiteDecoderStream.prototype.collect = function(cb) {\n        var res = \"\";\n        this.on(\"error\", cb);\n        this.on(\"data\", function(chunk) {\n          res += chunk;\n        });\n        this.on(\"end\", function() {\n          cb(null, res);\n        });\n        return this;\n      };\n      return {\n        IconvLiteEncoderStream,\n        IconvLiteDecoderStream\n      };\n    };\n  }\n});\n\n// node_modules/body-parser/node_modules/iconv-lite/lib/index.js\nvar require_lib2 = __commonJS({\n  \"node_modules/body-parser/node_modules/iconv-lite/lib/index.js\"(exports2, module2) {\n    \"use strict\";\n    var Buffer2 = require_safer().Buffer;\n    var bomHandling = require_bom_handling2();\n    var iconv = module2.exports;\n    iconv.encodings = null;\n    iconv.defaultCharUnicode = \"\\uFFFD\";\n    iconv.defaultCharSingleByte = \"?\";\n    iconv.encode = function encode(str, encoding, options) {\n      str = \"\" + (str || \"\");\n      var encoder = iconv.getEncoder(encoding, options);\n      var res = encoder.write(str);\n      var trail = encoder.end();\n      return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;\n    };\n    iconv.decode = function decode(buf, encoding, options) {\n      if (typeof buf === \"string\") {\n        if (!iconv.skipDecodeWarning) {\n          console.error(\"Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding\");\n          iconv.skipDecodeWarning = true;\n        }\n        buf = Buffer2.from(\"\" + (buf || \"\"), \"binary\");\n      }\n      var decoder = iconv.getDecoder(encoding, options);\n      var res = decoder.write(buf);\n      var trail = decoder.end();\n      return trail ? res + trail : res;\n    };\n    iconv.encodingExists = function encodingExists(enc) {\n      try {\n        iconv.getCodec(enc);\n        return true;\n      } catch (e) {\n        return false;\n      }\n    };\n    iconv.toEncoding = iconv.encode;\n    iconv.fromEncoding = iconv.decode;\n    iconv._codecDataCache = {};\n    iconv.getCodec = function getCodec(encoding) {\n      if (!iconv.encodings)\n        iconv.encodings = require_encodings2();\n      var enc = iconv._canonicalizeEncoding(encoding);\n      var codecOptions = {};\n      while (true) {\n        var codec = iconv._codecDataCache[enc];\n        if (codec)\n          return codec;\n        var codecDef = iconv.encodings[enc];\n        switch (typeof codecDef) {\n          case \"string\":\n            enc = codecDef;\n            break;\n          case \"object\":\n            for (var key in codecDef)\n              codecOptions[key] = codecDef[key];\n            if (!codecOptions.encodingName)\n              codecOptions.encodingName = enc;\n            enc = codecDef.type;\n            break;\n          case \"function\":\n            if (!codecOptions.encodingName)\n              codecOptions.encodingName = enc;\n            codec = new codecDef(codecOptions, iconv);\n            iconv._codecDataCache[codecOptions.encodingName] = codec;\n            return codec;\n          default:\n            throw new Error(\"Encoding not recognized: '\" + encoding + \"' (searched as: '\" + enc + \"')\");\n        }\n      }\n    };\n    iconv._canonicalizeEncoding = function(encoding) {\n      return (\"\" + encoding).toLowerCase().replace(/:\\d{4}$|[^0-9a-z]/g, \"\");\n    };\n    iconv.getEncoder = function getEncoder(encoding, options) {\n      var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);\n      if (codec.bomAware && options && options.addBOM)\n        encoder = new bomHandling.PrependBOM(encoder, options);\n      return encoder;\n    };\n    iconv.getDecoder = function getDecoder(encoding, options) {\n      var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options, codec);\n      if (codec.bomAware && !(options && options.stripBOM === false))\n        decoder = new bomHandling.StripBOM(decoder, options);\n      return decoder;\n    };\n    iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) {\n      if (iconv.supportsStreams)\n        return;\n      var streams = require_streams2()(stream_module2);\n      iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;\n      iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;\n      iconv.encodeStream = function encodeStream(encoding, options) {\n        return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);\n      };\n      iconv.decodeStream = function decodeStream(encoding, options) {\n        return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);\n      };\n      iconv.supportsStreams = true;\n    };\n    var stream_module;\n    try {\n      stream_module = require(\"stream\");\n    } catch (e) {\n    }\n    if (stream_module && stream_module.Transform) {\n      iconv.enableStreamingAPI(stream_module);\n    } else {\n      iconv.encodeStream = iconv.decodeStream = function() {\n        throw new Error(\"iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.\");\n      };\n    }\n    if (false) {\n      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.\");\n    }\n  }\n});\n\n// node_modules/body-parser/lib/read.js\nvar require_read = __commonJS({\n  \"node_modules/body-parser/lib/read.js\"(exports2, module2) {\n    \"use strict\";\n    var createError = require_http_errors();\n    var getBody = require_raw_body();\n    var iconv = require_lib2();\n    var onFinished = require_on_finished();\n    var zlib = require(\"node:zlib\");\n    module2.exports = read;\n    function read(req, res, next, parse, debug, options) {\n      var length;\n      var opts = options;\n      var stream;\n      var encoding = opts.encoding !== null ? opts.encoding : null;\n      var verify = opts.verify;\n      try {\n        stream = contentstream(req, debug, opts.inflate);\n        length = stream.length;\n        stream.length = void 0;\n      } catch (err2) {\n        return next(err2);\n      }\n      opts.length = length;\n      opts.encoding = verify ? null : encoding;\n      if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) {\n        return next(createError(415, 'unsupported charset \"' + encoding.toUpperCase() + '\"', {\n          charset: encoding.toLowerCase(),\n          type: \"charset.unsupported\"\n        }));\n      }\n      debug(\"read body\");\n      getBody(stream, opts, function(error, body) {\n        if (error) {\n          var _error;\n          if (error.type === \"encoding.unsupported\") {\n            _error = createError(415, 'unsupported charset \"' + encoding.toUpperCase() + '\"', {\n              charset: encoding.toLowerCase(),\n              type: \"charset.unsupported\"\n            });\n          } else {\n            _error = createError(400, error);\n          }\n          if (stream !== req) {\n            req.unpipe();\n            stream.destroy();\n          }\n          dump(req, function onfinished() {\n            next(createError(400, _error));\n          });\n          return;\n        }\n        if (verify) {\n          try {\n            debug(\"verify body\");\n            verify(req, res, body, encoding);\n          } catch (err2) {\n            next(createError(403, err2, {\n              body,\n              type: err2.type || \"entity.verify.failed\"\n            }));\n            return;\n          }\n        }\n        var str = body;\n        try {\n          debug(\"parse body\");\n          str = typeof body !== \"string\" && encoding !== null ? iconv.decode(body, encoding) : body;\n          req.body = parse(str, encoding);\n        } catch (err2) {\n          next(createError(400, err2, {\n            body: str,\n            type: err2.type || \"entity.parse.failed\"\n          }));\n          return;\n        }\n        next();\n      });\n    }\n    function contentstream(req, debug, inflate) {\n      var encoding = (req.headers[\"content-encoding\"] || \"identity\").toLowerCase();\n      var length = req.headers[\"content-length\"];\n      debug('content-encoding \"%s\"', encoding);\n      if (inflate === false && encoding !== \"identity\") {\n        throw createError(415, \"content encoding unsupported\", {\n          encoding,\n          type: \"encoding.unsupported\"\n        });\n      }\n      if (encoding === \"identity\") {\n        req.length = length;\n        return req;\n      }\n      var stream = createDecompressionStream(encoding, debug);\n      req.pipe(stream);\n      return stream;\n    }\n    function createDecompressionStream(encoding, debug) {\n      switch (encoding) {\n        case \"deflate\":\n          debug(\"inflate body\");\n          return zlib.createInflate();\n        case \"gzip\":\n          debug(\"gunzip body\");\n          return zlib.createGunzip();\n        case \"br\":\n          debug(\"brotli decompress body\");\n          return zlib.createBrotliDecompress();\n        default:\n          throw createError(415, 'unsupported content encoding \"' + encoding + '\"', {\n            encoding,\n            type: \"encoding.unsupported\"\n          });\n      }\n    }\n    function dump(req, callback) {\n      if (onFinished.isFinished(req)) {\n        callback(null);\n      } else {\n        onFinished(req, callback);\n        req.resume();\n      }\n    }\n  }\n});\n\n// node_modules/type-is/node_modules/mime-db/db.json\nvar require_db = __commonJS({\n  \"node_modules/type-is/node_modules/mime-db/db.json\"(exports2, module2) {\n    module2.exports = {\n      \"application/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"application/3gpdash-qoe-report+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/3gpp-ims+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphalforms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/a2l\": {\n        source: \"iana\"\n      },\n      \"application/ace+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ace-groupcomm+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace-trl+cbor\": {\n        source: \"iana\"\n      },\n      \"application/activemessage\": {\n        source: \"iana\"\n      },\n      \"application/activity+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aif+cbor\": {\n        source: \"iana\"\n      },\n      \"application/aif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdni+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdnifilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-directory+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcost+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcostparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointprop+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointpropparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-error+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmapparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tips+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tipsparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamcontrol+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aml\": {\n        source: \"iana\"\n      },\n      \"application/andrew-inset\": {\n        source: \"iana\",\n        extensions: [\"ez\"]\n      },\n      \"application/appinstaller\": {\n        compressible: false,\n        extensions: [\"appinstaller\"]\n      },\n      \"application/applefile\": {\n        source: \"iana\"\n      },\n      \"application/applixware\": {\n        source: \"apache\",\n        extensions: [\"aw\"]\n      },\n      \"application/appx\": {\n        compressible: false,\n        extensions: [\"appx\"]\n      },\n      \"application/appxbundle\": {\n        compressible: false,\n        extensions: [\"appxbundle\"]\n      },\n      \"application/at+jwt\": {\n        source: \"iana\"\n      },\n      \"application/atf\": {\n        source: \"iana\"\n      },\n      \"application/atfx\": {\n        source: \"iana\"\n      },\n      \"application/atom+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atom\"]\n      },\n      \"application/atomcat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomcat\"]\n      },\n      \"application/atomdeleted+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomdeleted\"]\n      },\n      \"application/atomicmail\": {\n        source: \"iana\"\n      },\n      \"application/atomsvc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomsvc\"]\n      },\n      \"application/atsc-dwd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dwd\"]\n      },\n      \"application/atsc-dynamic-event-message\": {\n        source: \"iana\"\n      },\n      \"application/atsc-held+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"held\"]\n      },\n      \"application/atsc-rdt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/atsc-rsat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsat\"]\n      },\n      \"application/atxml\": {\n        source: \"iana\"\n      },\n      \"application/auth-policy+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/automationml-aml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"aml\"]\n      },\n      \"application/automationml-amlx+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"amlx\"]\n      },\n      \"application/bacnet-xdd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/batch-smtp\": {\n        source: \"iana\"\n      },\n      \"application/bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/beep+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/bufr\": {\n        source: \"iana\"\n      },\n      \"application/c2pa\": {\n        source: \"iana\"\n      },\n      \"application/calendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/calendar+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xcs\"]\n      },\n      \"application/call-completion\": {\n        source: \"iana\"\n      },\n      \"application/cals-1840\": {\n        source: \"iana\"\n      },\n      \"application/captive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cbor\": {\n        source: \"iana\"\n      },\n      \"application/cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/cccex\": {\n        source: \"iana\"\n      },\n      \"application/ccmp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ccxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ccxml\"]\n      },\n      \"application/cda+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/cdfx+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdfx\"]\n      },\n      \"application/cdmi-capability\": {\n        source: \"iana\",\n        extensions: [\"cdmia\"]\n      },\n      \"application/cdmi-container\": {\n        source: \"iana\",\n        extensions: [\"cdmic\"]\n      },\n      \"application/cdmi-domain\": {\n        source: \"iana\",\n        extensions: [\"cdmid\"]\n      },\n      \"application/cdmi-object\": {\n        source: \"iana\",\n        extensions: [\"cdmio\"]\n      },\n      \"application/cdmi-queue\": {\n        source: \"iana\",\n        extensions: [\"cdmiq\"]\n      },\n      \"application/cdni\": {\n        source: \"iana\"\n      },\n      \"application/ce+cbor\": {\n        source: \"iana\"\n      },\n      \"application/cea\": {\n        source: \"iana\"\n      },\n      \"application/cea-2018+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cellml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cfw\": {\n        source: \"iana\"\n      },\n      \"application/cid-edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/city+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/city+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/clr\": {\n        source: \"iana\"\n      },\n      \"application/clue+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/clue_info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cms\": {\n        source: \"iana\"\n      },\n      \"application/cnrp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-eap\": {\n        source: \"iana\"\n      },\n      \"application/coap-group+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-payload\": {\n        source: \"iana\"\n      },\n      \"application/commonground\": {\n        source: \"iana\"\n      },\n      \"application/concise-problem-details+cbor\": {\n        source: \"iana\"\n      },\n      \"application/conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cose\": {\n        source: \"iana\"\n      },\n      \"application/cose-key\": {\n        source: \"iana\"\n      },\n      \"application/cose-key-set\": {\n        source: \"iana\"\n      },\n      \"application/cose-x509\": {\n        source: \"iana\"\n      },\n      \"application/cpl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cpl\"]\n      },\n      \"application/csrattrs\": {\n        source: \"iana\"\n      },\n      \"application/csta+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cstadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/csvm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cu-seeme\": {\n        source: \"apache\",\n        extensions: [\"cu\"]\n      },\n      \"application/cwl\": {\n        source: \"iana\",\n        extensions: [\"cwl\"]\n      },\n      \"application/cwl+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cwl+yaml\": {\n        source: \"iana\"\n      },\n      \"application/cwt\": {\n        source: \"iana\"\n      },\n      \"application/cybercash\": {\n        source: \"iana\"\n      },\n      \"application/dart\": {\n        compressible: true\n      },\n      \"application/dash+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpd\"]\n      },\n      \"application/dash-patch+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpp\"]\n      },\n      \"application/dashdelta\": {\n        source: \"iana\"\n      },\n      \"application/davmount+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"davmount\"]\n      },\n      \"application/dca-rft\": {\n        source: \"iana\"\n      },\n      \"application/dcd\": {\n        source: \"iana\"\n      },\n      \"application/dec-dx\": {\n        source: \"iana\"\n      },\n      \"application/dialog-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom\": {\n        source: \"iana\",\n        extensions: [\"dcm\"]\n      },\n      \"application/dicom+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dii\": {\n        source: \"iana\"\n      },\n      \"application/dit\": {\n        source: \"iana\"\n      },\n      \"application/dns\": {\n        source: \"iana\"\n      },\n      \"application/dns+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dns-message\": {\n        source: \"iana\"\n      },\n      \"application/docbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dbk\"]\n      },\n      \"application/dots+cbor\": {\n        source: \"iana\"\n      },\n      \"application/dpop+jwt\": {\n        source: \"iana\"\n      },\n      \"application/dskpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dssc+der\": {\n        source: \"iana\",\n        extensions: [\"dssc\"]\n      },\n      \"application/dssc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdssc\"]\n      },\n      \"application/dvcs\": {\n        source: \"iana\"\n      },\n      \"application/eat+cwt\": {\n        source: \"iana\"\n      },\n      \"application/eat+jwt\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/eat-ucs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-ucs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ecmascript\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ecma\"]\n      },\n      \"application/edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/edi-consent\": {\n        source: \"iana\"\n      },\n      \"application/edi-x12\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/edifact\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/efi\": {\n        source: \"iana\"\n      },\n      \"application/elm+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/elm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.cap+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/emergencycalldata.comment+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.deviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.ecall.msd\": {\n        source: \"iana\"\n      },\n      \"application/emergencycalldata.legacyesn+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.providerinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.serviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.subscriberinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.veds+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emma+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emma\"]\n      },\n      \"application/emotionml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emotionml\"]\n      },\n      \"application/encaprtp\": {\n        source: \"iana\"\n      },\n      \"application/entity-statement+jwt\": {\n        source: \"iana\"\n      },\n      \"application/epp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/epub+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"epub\"]\n      },\n      \"application/eshop\": {\n        source: \"iana\"\n      },\n      \"application/exi\": {\n        source: \"iana\",\n        extensions: [\"exi\"]\n      },\n      \"application/expect-ct-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/express\": {\n        source: \"iana\",\n        extensions: [\"exp\"]\n      },\n      \"application/fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/fastsoap\": {\n        source: \"iana\"\n      },\n      \"application/fdf\": {\n        source: \"iana\",\n        extensions: [\"fdf\"]\n      },\n      \"application/fdt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fdt\"]\n      },\n      \"application/fhir+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fhir+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fido.trusted-apps+json\": {\n        compressible: true\n      },\n      \"application/fits\": {\n        source: \"iana\"\n      },\n      \"application/flexfec\": {\n        source: \"iana\"\n      },\n      \"application/font-sfnt\": {\n        source: \"iana\"\n      },\n      \"application/font-tdpfr\": {\n        source: \"iana\",\n        extensions: [\"pfr\"]\n      },\n      \"application/font-woff\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/framework-attributes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geo+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"geojson\"]\n      },\n      \"application/geo+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/geopackage+sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/geopose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/gltf-buffer\": {\n        source: \"iana\"\n      },\n      \"application/gml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gml\"]\n      },\n      \"application/gnap-binding-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gpx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"gpx\"]\n      },\n      \"application/grib\": {\n        source: \"iana\"\n      },\n      \"application/gxf\": {\n        source: \"apache\",\n        extensions: [\"gxf\"]\n      },\n      \"application/gzip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gz\"]\n      },\n      \"application/h224\": {\n        source: \"iana\"\n      },\n      \"application/held+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/hjson\": {\n        extensions: [\"hjson\"]\n      },\n      \"application/hl7v2+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/http\": {\n        source: \"iana\"\n      },\n      \"application/hyperstudio\": {\n        source: \"iana\",\n        extensions: [\"stk\"]\n      },\n      \"application/ibe-key-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pkg-reply+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pp-data\": {\n        source: \"iana\"\n      },\n      \"application/iges\": {\n        source: \"iana\"\n      },\n      \"application/im-iscomposing+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/index\": {\n        source: \"iana\"\n      },\n      \"application/index.cmd\": {\n        source: \"iana\"\n      },\n      \"application/index.obj\": {\n        source: \"iana\"\n      },\n      \"application/index.response\": {\n        source: \"iana\"\n      },\n      \"application/index.vnd\": {\n        source: \"iana\"\n      },\n      \"application/inkml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ink\", \"inkml\"]\n      },\n      \"application/iotp\": {\n        source: \"iana\"\n      },\n      \"application/ipfix\": {\n        source: \"iana\",\n        extensions: [\"ipfix\"]\n      },\n      \"application/ipp\": {\n        source: \"iana\"\n      },\n      \"application/isup\": {\n        source: \"iana\"\n      },\n      \"application/its+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"its\"]\n      },\n      \"application/java-archive\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jar\", \"war\", \"ear\"]\n      },\n      \"application/java-serialized-object\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"ser\"]\n      },\n      \"application/java-vm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"class\"]\n      },\n      \"application/javascript\": {\n        source: \"apache\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\"]\n      },\n      \"application/jf2feed+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jose\": {\n        source: \"iana\"\n      },\n      \"application/jose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jrd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscalendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscontact+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"json\", \"map\"]\n      },\n      \"application/json-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json-seq\": {\n        source: \"iana\"\n      },\n      \"application/json5\": {\n        extensions: [\"json5\"]\n      },\n      \"application/jsonml+json\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"jsonml\"]\n      },\n      \"application/jsonpath\": {\n        source: \"iana\"\n      },\n      \"application/jwk+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+jwt\": {\n        source: \"iana\"\n      },\n      \"application/jwt\": {\n        source: \"iana\"\n      },\n      \"application/kpml-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/kpml-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ld+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"jsonld\"]\n      },\n      \"application/lgr+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lgr\"]\n      },\n      \"application/link-format\": {\n        source: \"iana\"\n      },\n      \"application/linkset\": {\n        source: \"iana\"\n      },\n      \"application/linkset+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/load-control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/logout+jwt\": {\n        source: \"iana\"\n      },\n      \"application/lost+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lostxml\"]\n      },\n      \"application/lostsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/lpf+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/lxf\": {\n        source: \"iana\"\n      },\n      \"application/mac-binhex40\": {\n        source: \"iana\",\n        extensions: [\"hqx\"]\n      },\n      \"application/mac-compactpro\": {\n        source: \"apache\",\n        extensions: [\"cpt\"]\n      },\n      \"application/macwriteii\": {\n        source: \"iana\"\n      },\n      \"application/mads+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mads\"]\n      },\n      \"application/manifest+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"webmanifest\"]\n      },\n      \"application/marc\": {\n        source: \"iana\",\n        extensions: [\"mrc\"]\n      },\n      \"application/marcxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mrcx\"]\n      },\n      \"application/mathematica\": {\n        source: \"iana\",\n        extensions: [\"ma\", \"nb\", \"mb\"]\n      },\n      \"application/mathml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mathml\"]\n      },\n      \"application/mathml-content+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mathml-presentation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-associated-procedure-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-deregister+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-envelope+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-protection-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-reception-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-user-service-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbox\": {\n        source: \"iana\",\n        extensions: [\"mbox\"]\n      },\n      \"application/media-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpf\"]\n      },\n      \"application/media_control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mediaservercontrol+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mscml\"]\n      },\n      \"application/merge-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/metalink+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"metalink\"]\n      },\n      \"application/metalink4+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"meta4\"]\n      },\n      \"application/mets+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mets\"]\n      },\n      \"application/mf4\": {\n        source: \"iana\"\n      },\n      \"application/mikey\": {\n        source: \"iana\"\n      },\n      \"application/mipc\": {\n        source: \"iana\"\n      },\n      \"application/missing-blocks+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/mmt-aei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"maei\"]\n      },\n      \"application/mmt-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musd\"]\n      },\n      \"application/mods+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mods\"]\n      },\n      \"application/moss-keys\": {\n        source: \"iana\"\n      },\n      \"application/moss-signature\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-data\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-request\": {\n        source: \"iana\"\n      },\n      \"application/mp21\": {\n        source: \"iana\",\n        extensions: [\"m21\", \"mp21\"]\n      },\n      \"application/mp4\": {\n        source: \"iana\",\n        extensions: [\"mp4\", \"mpg4\", \"mp4s\", \"m4p\"]\n      },\n      \"application/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod-xmt\": {\n        source: \"iana\"\n      },\n      \"application/mrb-consumer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mrb-publish+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/msc-ivr+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msc-mixer+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msix\": {\n        compressible: false,\n        extensions: [\"msix\"]\n      },\n      \"application/msixbundle\": {\n        compressible: false,\n        extensions: [\"msixbundle\"]\n      },\n      \"application/msword\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"doc\", \"dot\"]\n      },\n      \"application/mud+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/multipart-core\": {\n        source: \"iana\"\n      },\n      \"application/mxf\": {\n        source: \"iana\",\n        extensions: [\"mxf\"]\n      },\n      \"application/n-quads\": {\n        source: \"iana\",\n        extensions: [\"nq\"]\n      },\n      \"application/n-triples\": {\n        source: \"iana\",\n        extensions: [\"nt\"]\n      },\n      \"application/nasdata\": {\n        source: \"iana\"\n      },\n      \"application/news-checkgroups\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-groupinfo\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-transmission\": {\n        source: \"iana\"\n      },\n      \"application/nlsml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/node\": {\n        source: \"iana\",\n        extensions: [\"cjs\"]\n      },\n      \"application/nss\": {\n        source: \"iana\"\n      },\n      \"application/oauth-authz-req+jwt\": {\n        source: \"iana\"\n      },\n      \"application/oblivious-dns-message\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-request\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-response\": {\n        source: \"iana\"\n      },\n      \"application/octet-stream\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bin\", \"dms\", \"lrf\", \"mar\", \"so\", \"dist\", \"distz\", \"pkg\", \"bpk\", \"dump\", \"elc\", \"deploy\", \"exe\", \"dll\", \"deb\", \"dmg\", \"iso\", \"img\", \"msi\", \"msp\", \"msm\", \"buffer\"]\n      },\n      \"application/oda\": {\n        source: \"iana\",\n        extensions: [\"oda\"]\n      },\n      \"application/odm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/odx\": {\n        source: \"iana\"\n      },\n      \"application/oebps-package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"opf\"]\n      },\n      \"application/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogx\"]\n      },\n      \"application/ohttp-keys\": {\n        source: \"iana\"\n      },\n      \"application/omdoc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"omdoc\"]\n      },\n      \"application/onenote\": {\n        source: \"apache\",\n        extensions: [\"onetoc\", \"onetoc2\", \"onetmp\", \"onepkg\", \"one\", \"onea\"]\n      },\n      \"application/opc-nodeset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/oscore\": {\n        source: \"iana\"\n      },\n      \"application/oxps\": {\n        source: \"iana\",\n        extensions: [\"oxps\"]\n      },\n      \"application/p21\": {\n        source: \"iana\"\n      },\n      \"application/p21+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/p2p-overlay+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"relo\"]\n      },\n      \"application/parityfec\": {\n        source: \"iana\"\n      },\n      \"application/passport\": {\n        source: \"iana\"\n      },\n      \"application/patch-ops-error+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xer\"]\n      },\n      \"application/pdf\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pdf\"]\n      },\n      \"application/pdx\": {\n        source: \"iana\"\n      },\n      \"application/pem-certificate-chain\": {\n        source: \"iana\"\n      },\n      \"application/pgp-encrypted\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pgp\"]\n      },\n      \"application/pgp-keys\": {\n        source: \"iana\",\n        extensions: [\"asc\"]\n      },\n      \"application/pgp-signature\": {\n        source: \"iana\",\n        extensions: [\"sig\", \"asc\"]\n      },\n      \"application/pics-rules\": {\n        source: \"apache\",\n        extensions: [\"prf\"]\n      },\n      \"application/pidf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pidf-diff+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pkcs10\": {\n        source: \"iana\",\n        extensions: [\"p10\"]\n      },\n      \"application/pkcs12\": {\n        source: \"iana\"\n      },\n      \"application/pkcs7-mime\": {\n        source: \"iana\",\n        extensions: [\"p7m\", \"p7c\"]\n      },\n      \"application/pkcs7-signature\": {\n        source: \"iana\",\n        extensions: [\"p7s\"]\n      },\n      \"application/pkcs8\": {\n        source: \"iana\",\n        extensions: [\"p8\"]\n      },\n      \"application/pkcs8-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/pkix-attr-cert\": {\n        source: \"iana\",\n        extensions: [\"ac\"]\n      },\n      \"application/pkix-cert\": {\n        source: \"iana\",\n        extensions: [\"cer\"]\n      },\n      \"application/pkix-crl\": {\n        source: \"iana\",\n        extensions: [\"crl\"]\n      },\n      \"application/pkix-pkipath\": {\n        source: \"iana\",\n        extensions: [\"pkipath\"]\n      },\n      \"application/pkixcmp\": {\n        source: \"iana\",\n        extensions: [\"pki\"]\n      },\n      \"application/pls+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pls\"]\n      },\n      \"application/poc-settings+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/postscript\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ai\", \"eps\", \"ps\"]\n      },\n      \"application/ppsp-tracker+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/private-token-issuer-directory\": {\n        source: \"iana\"\n      },\n      \"application/private-token-request\": {\n        source: \"iana\"\n      },\n      \"application/private-token-response\": {\n        source: \"iana\"\n      },\n      \"application/problem+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/problem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/provenance+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"provx\"]\n      },\n      \"application/provided-claims+jwt\": {\n        source: \"iana\"\n      },\n      \"application/prs.alvestrand.titrax-sheet\": {\n        source: \"iana\"\n      },\n      \"application/prs.cww\": {\n        source: \"iana\",\n        extensions: [\"cww\"]\n      },\n      \"application/prs.cyn\": {\n        source: \"iana\",\n        charset: \"7-BIT\"\n      },\n      \"application/prs.hpub+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/prs.implied-document+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-executable\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-object+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+yaml\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-structure\": {\n        source: \"iana\"\n      },\n      \"application/prs.mayfile\": {\n        source: \"iana\"\n      },\n      \"application/prs.nprend\": {\n        source: \"iana\"\n      },\n      \"application/prs.plucker\": {\n        source: \"iana\"\n      },\n      \"application/prs.rdf-xml-crypt\": {\n        source: \"iana\"\n      },\n      \"application/prs.vcfbzip2\": {\n        source: \"iana\"\n      },\n      \"application/prs.xsf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsf\"]\n      },\n      \"application/pskc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pskcxml\"]\n      },\n      \"application/pvd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/qsig\": {\n        source: \"iana\"\n      },\n      \"application/raml+yaml\": {\n        compressible: true,\n        extensions: [\"raml\"]\n      },\n      \"application/raptorfec\": {\n        source: \"iana\"\n      },\n      \"application/rdap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rdf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rdf\", \"owl\"]\n      },\n      \"application/reginfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rif\"]\n      },\n      \"application/relax-ng-compact-syntax\": {\n        source: \"iana\",\n        extensions: [\"rnc\"]\n      },\n      \"application/remote-printing\": {\n        source: \"apache\"\n      },\n      \"application/reputon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/resolve-response+jwt\": {\n        source: \"iana\"\n      },\n      \"application/resource-lists+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rl\"]\n      },\n      \"application/resource-lists-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rld\"]\n      },\n      \"application/rfc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/riscos\": {\n        source: \"iana\"\n      },\n      \"application/rlmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rls-services+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rs\"]\n      },\n      \"application/route-apd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rapd\"]\n      },\n      \"application/route-s-tsid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sls\"]\n      },\n      \"application/route-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rusd\"]\n      },\n      \"application/rpki-checklist\": {\n        source: \"iana\"\n      },\n      \"application/rpki-ghostbusters\": {\n        source: \"iana\",\n        extensions: [\"gbr\"]\n      },\n      \"application/rpki-manifest\": {\n        source: \"iana\",\n        extensions: [\"mft\"]\n      },\n      \"application/rpki-publication\": {\n        source: \"iana\"\n      },\n      \"application/rpki-roa\": {\n        source: \"iana\",\n        extensions: [\"roa\"]\n      },\n      \"application/rpki-signed-tal\": {\n        source: \"iana\"\n      },\n      \"application/rpki-updown\": {\n        source: \"iana\"\n      },\n      \"application/rsd+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rsd\"]\n      },\n      \"application/rss+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rss\"]\n      },\n      \"application/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"application/rtploopback\": {\n        source: \"iana\"\n      },\n      \"application/rtx\": {\n        source: \"iana\"\n      },\n      \"application/samlassertion+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/samlmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif-external-properties+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sbe\": {\n        source: \"iana\"\n      },\n      \"application/sbml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sbml\"]\n      },\n      \"application/scaip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scim+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scvp-cv-request\": {\n        source: \"iana\",\n        extensions: [\"scq\"]\n      },\n      \"application/scvp-cv-response\": {\n        source: \"iana\",\n        extensions: [\"scs\"]\n      },\n      \"application/scvp-vp-request\": {\n        source: \"iana\",\n        extensions: [\"spq\"]\n      },\n      \"application/scvp-vp-response\": {\n        source: \"iana\",\n        extensions: [\"spp\"]\n      },\n      \"application/sdp\": {\n        source: \"iana\",\n        extensions: [\"sdp\"]\n      },\n      \"application/secevent+jwt\": {\n        source: \"iana\"\n      },\n      \"application/senml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"senmlx\"]\n      },\n      \"application/senml-etch+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml-etch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sensml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/sensml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sensml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sensmlx\"]\n      },\n      \"application/sensml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sep+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sep-exi\": {\n        source: \"iana\"\n      },\n      \"application/session-info\": {\n        source: \"iana\"\n      },\n      \"application/set-payment\": {\n        source: \"iana\"\n      },\n      \"application/set-payment-initiation\": {\n        source: \"iana\",\n        extensions: [\"setpay\"]\n      },\n      \"application/set-registration\": {\n        source: \"iana\"\n      },\n      \"application/set-registration-initiation\": {\n        source: \"iana\",\n        extensions: [\"setreg\"]\n      },\n      \"application/sgml\": {\n        source: \"iana\"\n      },\n      \"application/sgml-open-catalog\": {\n        source: \"iana\"\n      },\n      \"application/shf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"shf\"]\n      },\n      \"application/sieve\": {\n        source: \"iana\",\n        extensions: [\"siv\", \"sieve\"]\n      },\n      \"application/simple-filter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/simple-message-summary\": {\n        source: \"iana\"\n      },\n      \"application/simplesymbolcontainer\": {\n        source: \"iana\"\n      },\n      \"application/sipc\": {\n        source: \"iana\"\n      },\n      \"application/slate\": {\n        source: \"iana\"\n      },\n      \"application/smil\": {\n        source: \"apache\"\n      },\n      \"application/smil+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"smi\", \"smil\"]\n      },\n      \"application/smpte336m\": {\n        source: \"iana\"\n      },\n      \"application/soap+fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/soap+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sparql-query\": {\n        source: \"iana\",\n        extensions: [\"rq\"]\n      },\n      \"application/sparql-results+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"srx\"]\n      },\n      \"application/spdx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/spirits-event+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sql\": {\n        source: \"iana\",\n        extensions: [\"sql\"]\n      },\n      \"application/srgs\": {\n        source: \"iana\",\n        extensions: [\"gram\"]\n      },\n      \"application/srgs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"grxml\"]\n      },\n      \"application/sru+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sru\"]\n      },\n      \"application/ssdl+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ssdl\"]\n      },\n      \"application/sslkeylogfile\": {\n        source: \"iana\"\n      },\n      \"application/ssml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ssml\"]\n      },\n      \"application/st2110-41\": {\n        source: \"iana\"\n      },\n      \"application/stix+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/stratum\": {\n        source: \"iana\"\n      },\n      \"application/swid+cbor\": {\n        source: \"iana\"\n      },\n      \"application/swid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"swidtag\"]\n      },\n      \"application/tamp-apex-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-apex-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-error\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-query\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-response\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tar\": {\n        compressible: true\n      },\n      \"application/taxii+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/td+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tei\", \"teicorpus\"]\n      },\n      \"application/tetra_isi\": {\n        source: \"iana\"\n      },\n      \"application/thraud+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tfi\"]\n      },\n      \"application/timestamp-query\": {\n        source: \"iana\"\n      },\n      \"application/timestamp-reply\": {\n        source: \"iana\"\n      },\n      \"application/timestamped-data\": {\n        source: \"iana\",\n        extensions: [\"tsd\"]\n      },\n      \"application/tlsrpt+gzip\": {\n        source: \"iana\"\n      },\n      \"application/tlsrpt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tnauthlist\": {\n        source: \"iana\"\n      },\n      \"application/toc+cbor\": {\n        source: \"iana\"\n      },\n      \"application/token-introspection+jwt\": {\n        source: \"iana\"\n      },\n      \"application/toml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"toml\"]\n      },\n      \"application/trickle-ice-sdpfrag\": {\n        source: \"iana\"\n      },\n      \"application/trig\": {\n        source: \"iana\",\n        extensions: [\"trig\"]\n      },\n      \"application/trust-chain+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/trust-mark+jwt\": {\n        source: \"iana\"\n      },\n      \"application/trust-mark-delegation+jwt\": {\n        source: \"iana\"\n      },\n      \"application/ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttml\"]\n      },\n      \"application/tve-trigger\": {\n        source: \"iana\"\n      },\n      \"application/tzif\": {\n        source: \"iana\"\n      },\n      \"application/tzif-leap\": {\n        source: \"iana\"\n      },\n      \"application/ubjson\": {\n        compressible: false,\n        extensions: [\"ubj\"]\n      },\n      \"application/uccs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ujcs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ulpfec\": {\n        source: \"iana\"\n      },\n      \"application/urc-grpsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/urc-ressheet+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsheet\"]\n      },\n      \"application/urc-targetdesc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"td\"]\n      },\n      \"application/urc-uisocketdesc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vc\": {\n        source: \"iana\"\n      },\n      \"application/vc+cose\": {\n        source: \"iana\"\n      },\n      \"application/vc+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vcard+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vcard+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vemmi\": {\n        source: \"iana\"\n      },\n      \"application/vividence.scriptfile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.1000minds.decision-model+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"1km\"]\n      },\n      \"application/vnd.1ob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp-prose+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3a+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ach+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc8+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-v2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gnas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.access-transfer-events+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.bsf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.crs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.current-location-discovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gmop+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gtpc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.interworking-data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.lpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mc-signalling-ear\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-payload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-signalling\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-floor-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-signed+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-init-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-transmission-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mid-call+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ngap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pfcp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pic-bw-large\": {\n        source: \"iana\",\n        extensions: [\"plb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-small\": {\n        source: \"iana\",\n        extensions: [\"psb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-var\": {\n        source: \"iana\",\n        extensions: [\"pvb\"]\n      },\n      \"application/vnd.3gpp.pinapp-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.s1ap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.seal-group-doc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-network-qos-management-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-ue-config-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-unicast-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-user-profile-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.sms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-ext+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.state-and-event-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ussd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.v2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.vae-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.bcmcsinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp2.tcap\": {\n        source: \"iana\",\n        extensions: [\"tcap\"]\n      },\n      \"application/vnd.3lightssoftware.imagescal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3m.post-it-notes\": {\n        source: \"iana\",\n        extensions: [\"pwn\"]\n      },\n      \"application/vnd.accpac.simply.aso\": {\n        source: \"iana\",\n        extensions: [\"aso\"]\n      },\n      \"application/vnd.accpac.simply.imp\": {\n        source: \"iana\",\n        extensions: [\"imp\"]\n      },\n      \"application/vnd.acm.addressxfer+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acm.chatbot+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acucobol\": {\n        source: \"iana\",\n        extensions: [\"acu\"]\n      },\n      \"application/vnd.acucorp\": {\n        source: \"iana\",\n        extensions: [\"atc\", \"acutc\"]\n      },\n      \"application/vnd.adobe.air-application-installer-package+zip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"air\"]\n      },\n      \"application/vnd.adobe.flash.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.formscentral.fcdt\": {\n        source: \"iana\",\n        extensions: [\"fcdt\"]\n      },\n      \"application/vnd.adobe.fxp\": {\n        source: \"iana\",\n        extensions: [\"fxp\", \"fxpl\"]\n      },\n      \"application/vnd.adobe.partial-upload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.xdp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdp\"]\n      },\n      \"application/vnd.adobe.xfdf\": {\n        source: \"apache\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/vnd.aether.imp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata-pagedef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.cmoca-cmresource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-charset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codedfont\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codepage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-cmtable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-formdef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-mediummap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-objectcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-overlay\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-pagesegment\": {\n        source: \"iana\"\n      },\n      \"application/vnd.age\": {\n        source: \"iana\",\n        extensions: [\"age\"]\n      },\n      \"application/vnd.ah-barcode\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ahead.space\": {\n        source: \"iana\",\n        extensions: [\"ahead\"]\n      },\n      \"application/vnd.airzip.filesecure.azf\": {\n        source: \"iana\",\n        extensions: [\"azf\"]\n      },\n      \"application/vnd.airzip.filesecure.azs\": {\n        source: \"iana\",\n        extensions: [\"azs\"]\n      },\n      \"application/vnd.amadeus+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.amazon.ebook\": {\n        source: \"apache\",\n        extensions: [\"azw\"]\n      },\n      \"application/vnd.amazon.mobi8-ebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.americandynamics.acc\": {\n        source: \"iana\",\n        extensions: [\"acc\"]\n      },\n      \"application/vnd.amiga.ami\": {\n        source: \"iana\",\n        extensions: [\"ami\"]\n      },\n      \"application/vnd.amundsen.maze+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.android.ota\": {\n        source: \"iana\"\n      },\n      \"application/vnd.android.package-archive\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"apk\"]\n      },\n      \"application/vnd.anki\": {\n        source: \"iana\"\n      },\n      \"application/vnd.anser-web-certificate-issue-initiation\": {\n        source: \"iana\",\n        extensions: [\"cii\"]\n      },\n      \"application/vnd.anser-web-funds-transfer-initiation\": {\n        source: \"apache\",\n        extensions: [\"fti\"]\n      },\n      \"application/vnd.antix.game-component\": {\n        source: \"iana\",\n        extensions: [\"atx\"]\n      },\n      \"application/vnd.apache.arrow.file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.arrow.stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.parquet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.compact\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apexlang\": {\n        source: \"iana\"\n      },\n      \"application/vnd.api+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.aplextor.warrp+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apothekende.reservation+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apple.installer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpkg\"]\n      },\n      \"application/vnd.apple.keynote\": {\n        source: \"iana\",\n        extensions: [\"key\"]\n      },\n      \"application/vnd.apple.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"m3u8\"]\n      },\n      \"application/vnd.apple.numbers\": {\n        source: \"iana\",\n        extensions: [\"numbers\"]\n      },\n      \"application/vnd.apple.pages\": {\n        source: \"iana\",\n        extensions: [\"pages\"]\n      },\n      \"application/vnd.apple.pkpass\": {\n        compressible: false,\n        extensions: [\"pkpass\"]\n      },\n      \"application/vnd.arastra.swi\": {\n        source: \"apache\"\n      },\n      \"application/vnd.aristanetworks.swi\": {\n        source: \"iana\",\n        extensions: [\"swi\"]\n      },\n      \"application/vnd.artisan+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.artsquare\": {\n        source: \"iana\"\n      },\n      \"application/vnd.astraea-software.iota\": {\n        source: \"iana\",\n        extensions: [\"iota\"]\n      },\n      \"application/vnd.audiograph\": {\n        source: \"iana\",\n        extensions: [\"aep\"]\n      },\n      \"application/vnd.autodesk.fbx\": {\n        extensions: [\"fbx\"]\n      },\n      \"application/vnd.autopackage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.avalon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.avistar+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.balsamiq.bmml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmml\"]\n      },\n      \"application/vnd.balsamiq.bmpr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.banana-accounting\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.error\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bekitzur-stech+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.belightsoft.lhzd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.belightsoft.lhzl+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.bint.med-content\": {\n        source: \"iana\"\n      },\n      \"application/vnd.biopax.rdf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.blink-idb-value-wrapper\": {\n        source: \"iana\"\n      },\n      \"application/vnd.blueice.multipass\": {\n        source: \"iana\",\n        extensions: [\"mpm\"]\n      },\n      \"application/vnd.bluetooth.ep.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bluetooth.le.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bmi\": {\n        source: \"iana\",\n        extensions: [\"bmi\"]\n      },\n      \"application/vnd.bpf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bpf3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.businessobjects\": {\n        source: \"iana\",\n        extensions: [\"rep\"]\n      },\n      \"application/vnd.byu.uapi+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bzip3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.c3voc.schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cab-jscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-cpdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-lips\": {\n        source: \"iana\"\n      },\n      \"application/vnd.capasystems-pg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cendio.thinlinc.clientconf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.century-systems.tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chemdraw+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdxml\"]\n      },\n      \"application/vnd.chess-pgn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chipnuts.karaoke-mmd\": {\n        source: \"iana\",\n        extensions: [\"mmd\"]\n      },\n      \"application/vnd.ciedi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cinderella\": {\n        source: \"iana\",\n        extensions: [\"cdy\"]\n      },\n      \"application/vnd.cirpack.isdn-ext\": {\n        source: \"iana\"\n      },\n      \"application/vnd.citationstyles.style+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csl\"]\n      },\n      \"application/vnd.claymore\": {\n        source: \"iana\",\n        extensions: [\"cla\"]\n      },\n      \"application/vnd.cloanto.rp9\": {\n        source: \"iana\",\n        extensions: [\"rp9\"]\n      },\n      \"application/vnd.clonk.c4group\": {\n        source: \"iana\",\n        extensions: [\"c4g\", \"c4d\", \"c4f\", \"c4p\", \"c4u\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config\": {\n        source: \"iana\",\n        extensions: [\"c11amc\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config-pkg\": {\n        source: \"iana\",\n        extensions: [\"c11amz\"]\n      },\n      \"application/vnd.cncf.helm.chart.content.v1.tar+gzip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.chart.provenance.v1.prov\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.config.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.coffeescript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collection+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.doc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.next+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.comicbook+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.comicbook-rar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commerce-battelle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commonspace\": {\n        source: \"iana\",\n        extensions: [\"csp\"]\n      },\n      \"application/vnd.contact.cmsg\": {\n        source: \"iana\",\n        extensions: [\"cdbcmsg\"]\n      },\n      \"application/vnd.coreos.ignition+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cosmocaller\": {\n        source: \"iana\",\n        extensions: [\"cmc\"]\n      },\n      \"application/vnd.crick.clicker\": {\n        source: \"iana\",\n        extensions: [\"clkx\"]\n      },\n      \"application/vnd.crick.clicker.keyboard\": {\n        source: \"iana\",\n        extensions: [\"clkk\"]\n      },\n      \"application/vnd.crick.clicker.palette\": {\n        source: \"iana\",\n        extensions: [\"clkp\"]\n      },\n      \"application/vnd.crick.clicker.template\": {\n        source: \"iana\",\n        extensions: [\"clkt\"]\n      },\n      \"application/vnd.crick.clicker.wordbank\": {\n        source: \"iana\",\n        extensions: [\"clkw\"]\n      },\n      \"application/vnd.criticaltools.wbs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wbs\"]\n      },\n      \"application/vnd.cryptii.pipe+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.crypto-shade-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.vault\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ctc-posml\": {\n        source: \"iana\",\n        extensions: [\"pml\"]\n      },\n      \"application/vnd.ctct.ws+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cups-pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-postscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-ppd\": {\n        source: \"iana\",\n        extensions: [\"ppd\"]\n      },\n      \"application/vnd.cups-raster\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl.car\": {\n        source: \"apache\",\n        extensions: [\"car\"]\n      },\n      \"application/vnd.curl.pcurl\": {\n        source: \"apache\",\n        extensions: [\"pcurl\"]\n      },\n      \"application/vnd.cyan.dean.root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cybank\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cyclonedx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cyclonedx+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.d2l.coursepackage1p0+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.d3m-dataset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.d3m-problem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dart\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dart\"]\n      },\n      \"application/vnd.data-vision.rdz\": {\n        source: \"iana\",\n        extensions: [\"rdz\"]\n      },\n      \"application/vnd.datalog\": {\n        source: \"iana\"\n      },\n      \"application/vnd.datapackage+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dataresource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dbf\": {\n        source: \"iana\",\n        extensions: [\"dbf\"]\n      },\n      \"application/vnd.dcmp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dcmp\"]\n      },\n      \"application/vnd.debian.binary-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dece.data\": {\n        source: \"iana\",\n        extensions: [\"uvf\", \"uvvf\", \"uvd\", \"uvvd\"]\n      },\n      \"application/vnd.dece.ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uvt\", \"uvvt\"]\n      },\n      \"application/vnd.dece.unspecified\": {\n        source: \"iana\",\n        extensions: [\"uvx\", \"uvvx\"]\n      },\n      \"application/vnd.dece.zip\": {\n        source: \"iana\",\n        extensions: [\"uvz\", \"uvvz\"]\n      },\n      \"application/vnd.denovo.fcselayout-link\": {\n        source: \"iana\",\n        extensions: [\"fe_launch\"]\n      },\n      \"application/vnd.desmume.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dir-bi.plate-dl-nosuffix\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dm.delegation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dna\": {\n        source: \"iana\",\n        extensions: [\"dna\"]\n      },\n      \"application/vnd.document+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dolby.mlp\": {\n        source: \"apache\",\n        extensions: [\"mlp\"]\n      },\n      \"application/vnd.dolby.mobile.1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dolby.mobile.2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.doremir.scorecloud-binary-document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dpgraph\": {\n        source: \"iana\",\n        extensions: [\"dpg\"]\n      },\n      \"application/vnd.dreamfactory\": {\n        source: \"iana\",\n        extensions: [\"dfac\"]\n      },\n      \"application/vnd.drive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ds-keypoint\": {\n        source: \"apache\",\n        extensions: [\"kpxx\"]\n      },\n      \"application/vnd.dtg.local\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.flash\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ait\": {\n        source: \"iana\",\n        extensions: [\"ait\"]\n      },\n      \"application/vnd.dvb.dvbisl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.dvbj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.esgcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcdftnotifaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgpdd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcroaming\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-enhancement\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.notif-aggregate-root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-container+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-generic+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-msglist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-init+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.pfr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.service\": {\n        source: \"iana\",\n        extensions: [\"svc\"]\n      },\n      \"application/vnd.dxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dynageo\": {\n        source: \"iana\",\n        extensions: [\"geo\"]\n      },\n      \"application/vnd.dzr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.easykaraoke.cdgdownload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecdis-update\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecip.rlp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eclipse.ditto+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ecowin.chart\": {\n        source: \"iana\",\n        extensions: [\"mag\"]\n      },\n      \"application/vnd.ecowin.filerequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.fileupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.series\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesrequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.img\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.iso\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eln+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.emclient.accessrequest+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.enliven\": {\n        source: \"iana\",\n        extensions: [\"nml\"]\n      },\n      \"application/vnd.enphase.envoy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eprints.data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.epson.esf\": {\n        source: \"iana\",\n        extensions: [\"esf\"]\n      },\n      \"application/vnd.epson.msf\": {\n        source: \"iana\",\n        extensions: [\"msf\"]\n      },\n      \"application/vnd.epson.quickanime\": {\n        source: \"iana\",\n        extensions: [\"qam\"]\n      },\n      \"application/vnd.epson.salt\": {\n        source: \"iana\",\n        extensions: [\"slt\"]\n      },\n      \"application/vnd.epson.ssf\": {\n        source: \"iana\",\n        extensions: [\"ssf\"]\n      },\n      \"application/vnd.ericsson.quickcall\": {\n        source: \"iana\"\n      },\n      \"application/vnd.erofs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.espass-espass+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.eszigno3+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"es3\", \"et3\"]\n      },\n      \"application/vnd.etsi.aoc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.asic-e+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.asic-s+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.cug+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvcommand+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-bc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-cod+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-npvr+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvservice+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mcid+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mheg5\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.overload-control-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.pstn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.sci+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.simservs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.timestamp-token\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.tsl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.tsl.der\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eu.kasparian.car+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.eudora.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.profile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.settings\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.theme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.exstream-empower+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.exstream-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ezpix-album\": {\n        source: \"iana\",\n        extensions: [\"ez2\"]\n      },\n      \"application/vnd.ezpix-package\": {\n        source: \"iana\",\n        extensions: [\"ez3\"]\n      },\n      \"application/vnd.f-secure.mobile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.familysearch.gedcom+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.fastcopy-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fdf\": {\n        source: \"apache\",\n        extensions: [\"fdf\"]\n      },\n      \"application/vnd.fdsn.mseed\": {\n        source: \"iana\",\n        extensions: [\"mseed\"]\n      },\n      \"application/vnd.fdsn.seed\": {\n        source: \"iana\",\n        extensions: [\"seed\", \"dataless\"]\n      },\n      \"application/vnd.fdsn.stationxml+xml\": {\n        source: \"iana\",\n        charset: \"XML-BASED\",\n        compressible: true\n      },\n      \"application/vnd.ffsns\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ficlab.flb+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.filmit.zfc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fints\": {\n        source: \"iana\"\n      },\n      \"application/vnd.firemonkeys.cloudcell\": {\n        source: \"iana\"\n      },\n      \"application/vnd.flographit\": {\n        source: \"iana\",\n        extensions: [\"gph\"]\n      },\n      \"application/vnd.fluxtime.clip\": {\n        source: \"iana\",\n        extensions: [\"ftc\"]\n      },\n      \"application/vnd.font-fontforge-sfd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.framemaker\": {\n        source: \"iana\",\n        extensions: [\"fm\", \"frame\", \"maker\", \"book\"]\n      },\n      \"application/vnd.freelog.comic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.frogans.fnc\": {\n        source: \"apache\",\n        extensions: [\"fnc\"]\n      },\n      \"application/vnd.frogans.ltf\": {\n        source: \"apache\",\n        extensions: [\"ltf\"]\n      },\n      \"application/vnd.fsc.weblaunch\": {\n        source: \"iana\",\n        extensions: [\"fsc\"]\n      },\n      \"application/vnd.fujifilm.fb.docuworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.binder\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.jfi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fujitsu.oasys\": {\n        source: \"iana\",\n        extensions: [\"oas\"]\n      },\n      \"application/vnd.fujitsu.oasys2\": {\n        source: \"iana\",\n        extensions: [\"oa2\"]\n      },\n      \"application/vnd.fujitsu.oasys3\": {\n        source: \"iana\",\n        extensions: [\"oa3\"]\n      },\n      \"application/vnd.fujitsu.oasysgp\": {\n        source: \"iana\",\n        extensions: [\"fg5\"]\n      },\n      \"application/vnd.fujitsu.oasysprs\": {\n        source: \"iana\",\n        extensions: [\"bh2\"]\n      },\n      \"application/vnd.fujixerox.art-ex\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.art4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.ddd\": {\n        source: \"iana\",\n        extensions: [\"ddd\"]\n      },\n      \"application/vnd.fujixerox.docuworks\": {\n        source: \"iana\",\n        extensions: [\"xdw\"]\n      },\n      \"application/vnd.fujixerox.docuworks.binder\": {\n        source: \"iana\",\n        extensions: [\"xbd\"]\n      },\n      \"application/vnd.fujixerox.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.hbpl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fut-misnet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fuzzysheet\": {\n        source: \"iana\",\n        extensions: [\"fzs\"]\n      },\n      \"application/vnd.ga4gh.passport+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.genomatix.tuxedo\": {\n        source: \"iana\",\n        extensions: [\"txd\"]\n      },\n      \"application/vnd.genozip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentics.grd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.catmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.ebuild\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.eclass\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.gpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.manifest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.pkgmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.xpak\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geo+json\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geocube+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geogebra.file\": {\n        source: \"iana\",\n        extensions: [\"ggb\"]\n      },\n      \"application/vnd.geogebra.pinboard\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geogebra.slides\": {\n        source: \"iana\",\n        extensions: [\"ggs\"]\n      },\n      \"application/vnd.geogebra.tool\": {\n        source: \"iana\",\n        extensions: [\"ggt\"]\n      },\n      \"application/vnd.geometry-explorer\": {\n        source: \"iana\",\n        extensions: [\"gex\", \"gre\"]\n      },\n      \"application/vnd.geonext\": {\n        source: \"iana\",\n        extensions: [\"gxt\"]\n      },\n      \"application/vnd.geoplan\": {\n        source: \"iana\",\n        extensions: [\"g2w\"]\n      },\n      \"application/vnd.geospace\": {\n        source: \"iana\",\n        extensions: [\"g3w\"]\n      },\n      \"application/vnd.gerber\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gmx\": {\n        source: \"iana\",\n        extensions: [\"gmx\"]\n      },\n      \"application/vnd.gnu.taler.exchange+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gnu.taler.merchant+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.google-apps.audio\": {},\n      \"application/vnd.google-apps.document\": {\n        compressible: false,\n        extensions: [\"gdoc\"]\n      },\n      \"application/vnd.google-apps.drawing\": {\n        compressible: false,\n        extensions: [\"gdraw\"]\n      },\n      \"application/vnd.google-apps.drive-sdk\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.file\": {},\n      \"application/vnd.google-apps.folder\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.form\": {\n        compressible: false,\n        extensions: [\"gform\"]\n      },\n      \"application/vnd.google-apps.fusiontable\": {},\n      \"application/vnd.google-apps.jam\": {\n        compressible: false,\n        extensions: [\"gjam\"]\n      },\n      \"application/vnd.google-apps.mail-layout\": {},\n      \"application/vnd.google-apps.map\": {\n        compressible: false,\n        extensions: [\"gmap\"]\n      },\n      \"application/vnd.google-apps.photo\": {},\n      \"application/vnd.google-apps.presentation\": {\n        compressible: false,\n        extensions: [\"gslides\"]\n      },\n      \"application/vnd.google-apps.script\": {\n        compressible: false,\n        extensions: [\"gscript\"]\n      },\n      \"application/vnd.google-apps.shortcut\": {},\n      \"application/vnd.google-apps.site\": {\n        compressible: false,\n        extensions: [\"gsite\"]\n      },\n      \"application/vnd.google-apps.spreadsheet\": {\n        compressible: false,\n        extensions: [\"gsheet\"]\n      },\n      \"application/vnd.google-apps.unknown\": {},\n      \"application/vnd.google-apps.video\": {},\n      \"application/vnd.google-earth.kml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"kml\"]\n      },\n      \"application/vnd.google-earth.kmz\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"kmz\"]\n      },\n      \"application/vnd.gov.sk.e-form+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.gov.sk.e-form+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.gov.sk.xmldatacontainer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdcf\"]\n      },\n      \"application/vnd.gpxsee.map+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.grafeq\": {\n        source: \"iana\",\n        extensions: [\"gqf\", \"gqs\"]\n      },\n      \"application/vnd.gridmp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.groove-account\": {\n        source: \"iana\",\n        extensions: [\"gac\"]\n      },\n      \"application/vnd.groove-help\": {\n        source: \"iana\",\n        extensions: [\"ghf\"]\n      },\n      \"application/vnd.groove-identity-message\": {\n        source: \"iana\",\n        extensions: [\"gim\"]\n      },\n      \"application/vnd.groove-injector\": {\n        source: \"iana\",\n        extensions: [\"grv\"]\n      },\n      \"application/vnd.groove-tool-message\": {\n        source: \"iana\",\n        extensions: [\"gtm\"]\n      },\n      \"application/vnd.groove-tool-template\": {\n        source: \"iana\",\n        extensions: [\"tpl\"]\n      },\n      \"application/vnd.groove-vcard\": {\n        source: \"iana\",\n        extensions: [\"vcg\"]\n      },\n      \"application/vnd.hal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hal+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"hal\"]\n      },\n      \"application/vnd.handheld-entertainment+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zmm\"]\n      },\n      \"application/vnd.hbci\": {\n        source: \"iana\",\n        extensions: [\"hbci\"]\n      },\n      \"application/vnd.hc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hcl-bireports\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hdt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.heroku+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hhe.lesson-player\": {\n        source: \"iana\",\n        extensions: [\"les\"]\n      },\n      \"application/vnd.hp-hpgl\": {\n        source: \"iana\",\n        extensions: [\"hpgl\"]\n      },\n      \"application/vnd.hp-hpid\": {\n        source: \"iana\",\n        extensions: [\"hpid\"]\n      },\n      \"application/vnd.hp-hps\": {\n        source: \"iana\",\n        extensions: [\"hps\"]\n      },\n      \"application/vnd.hp-jlyt\": {\n        source: \"iana\",\n        extensions: [\"jlt\"]\n      },\n      \"application/vnd.hp-pcl\": {\n        source: \"iana\",\n        extensions: [\"pcl\"]\n      },\n      \"application/vnd.hp-pclxl\": {\n        source: \"iana\",\n        extensions: [\"pclxl\"]\n      },\n      \"application/vnd.hsl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.httphone\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hydrostatix.sof-data\": {\n        source: \"iana\",\n        extensions: [\"sfd-hdstx\"]\n      },\n      \"application/vnd.hyper+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyper-item+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyperdrive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hzn-3d-crossword\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.afplinedata\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ibm.electronic-media\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.minipay\": {\n        source: \"iana\",\n        extensions: [\"mpy\"]\n      },\n      \"application/vnd.ibm.modcap\": {\n        source: \"apache\",\n        extensions: [\"afp\", \"listafp\", \"list3820\"]\n      },\n      \"application/vnd.ibm.rights-management\": {\n        source: \"iana\",\n        extensions: [\"irm\"]\n      },\n      \"application/vnd.ibm.secure-container\": {\n        source: \"iana\",\n        extensions: [\"sc\"]\n      },\n      \"application/vnd.iccprofile\": {\n        source: \"iana\",\n        extensions: [\"icc\", \"icm\"]\n      },\n      \"application/vnd.ieee.1905\": {\n        source: \"iana\"\n      },\n      \"application/vnd.igloader\": {\n        source: \"iana\",\n        extensions: [\"igl\"]\n      },\n      \"application/vnd.imagemeter.folder+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.imagemeter.image+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.immervision-ivp\": {\n        source: \"iana\",\n        extensions: [\"ivp\"]\n      },\n      \"application/vnd.immervision-ivu\": {\n        source: \"iana\",\n        extensions: [\"ivu\"]\n      },\n      \"application/vnd.ims.imsccv1p1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.lis.v2.result+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolconsumerprofile+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy.id+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings.simple+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informedcontrol.rms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informix-visionary\": {\n        source: \"apache\"\n      },\n      \"application/vnd.infotech.project\": {\n        source: \"iana\"\n      },\n      \"application/vnd.infotech.project+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.innopath.wamp.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.insors.igm\": {\n        source: \"iana\",\n        extensions: [\"igm\"]\n      },\n      \"application/vnd.intercon.formnet\": {\n        source: \"iana\",\n        extensions: [\"xpw\", \"xpx\"]\n      },\n      \"application/vnd.intergeo\": {\n        source: \"iana\",\n        extensions: [\"i2g\"]\n      },\n      \"application/vnd.intertrust.digibox\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intertrust.nncp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intu.qbo\": {\n        source: \"iana\",\n        extensions: [\"qbo\"]\n      },\n      \"application/vnd.intu.qfx\": {\n        source: \"iana\",\n        extensions: [\"qfx\"]\n      },\n      \"application/vnd.ipfs.ipns-record\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.car\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.iptc.g2.catalogitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.conceptitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.knowledgeitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.packageitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.planningitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ipunplugged.rcprofile\": {\n        source: \"iana\",\n        extensions: [\"rcprofile\"]\n      },\n      \"application/vnd.irepository.package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"irp\"]\n      },\n      \"application/vnd.is-xpr\": {\n        source: \"iana\",\n        extensions: [\"xpr\"]\n      },\n      \"application/vnd.isac.fcs\": {\n        source: \"iana\",\n        extensions: [\"fcs\"]\n      },\n      \"application/vnd.iso11783-10+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.jam\": {\n        source: \"iana\",\n        extensions: [\"jam\"]\n      },\n      \"application/vnd.japannet-directory-service\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-jpnstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-payment-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-setstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.jcp.javame.midlet-rms\": {\n        source: \"iana\",\n        extensions: [\"rms\"]\n      },\n      \"application/vnd.jisp\": {\n        source: \"iana\",\n        extensions: [\"jisp\"]\n      },\n      \"application/vnd.joost.joda-archive\": {\n        source: \"iana\",\n        extensions: [\"joda\"]\n      },\n      \"application/vnd.jsk.isdn-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kahootz\": {\n        source: \"iana\",\n        extensions: [\"ktz\", \"ktr\"]\n      },\n      \"application/vnd.kde.karbon\": {\n        source: \"iana\",\n        extensions: [\"karbon\"]\n      },\n      \"application/vnd.kde.kchart\": {\n        source: \"iana\",\n        extensions: [\"chrt\"]\n      },\n      \"application/vnd.kde.kformula\": {\n        source: \"iana\",\n        extensions: [\"kfo\"]\n      },\n      \"application/vnd.kde.kivio\": {\n        source: \"iana\",\n        extensions: [\"flw\"]\n      },\n      \"application/vnd.kde.kontour\": {\n        source: \"iana\",\n        extensions: [\"kon\"]\n      },\n      \"application/vnd.kde.kpresenter\": {\n        source: \"iana\",\n        extensions: [\"kpr\", \"kpt\"]\n      },\n      \"application/vnd.kde.kspread\": {\n        source: \"iana\",\n        extensions: [\"ksp\"]\n      },\n      \"application/vnd.kde.kword\": {\n        source: \"iana\",\n        extensions: [\"kwd\", \"kwt\"]\n      },\n      \"application/vnd.kdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kenameaapp\": {\n        source: \"iana\",\n        extensions: [\"htke\"]\n      },\n      \"application/vnd.keyman.kmp+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.keyman.kmx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kidspiration\": {\n        source: \"iana\",\n        extensions: [\"kia\"]\n      },\n      \"application/vnd.kinar\": {\n        source: \"iana\",\n        extensions: [\"kne\", \"knp\"]\n      },\n      \"application/vnd.koan\": {\n        source: \"iana\",\n        extensions: [\"skp\", \"skd\", \"skt\", \"skm\"]\n      },\n      \"application/vnd.kodak-descriptor\": {\n        source: \"iana\",\n        extensions: [\"sse\"]\n      },\n      \"application/vnd.las\": {\n        source: \"iana\"\n      },\n      \"application/vnd.las.las+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.las.las+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lasxml\"]\n      },\n      \"application/vnd.laszip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ldev.productlicensing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.leap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.liberty-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.llamagraphics.life-balance.desktop\": {\n        source: \"iana\",\n        extensions: [\"lbd\"]\n      },\n      \"application/vnd.llamagraphics.life-balance.exchange+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lbe\"]\n      },\n      \"application/vnd.logipipe.circuit+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.loom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.lotus-1-2-3\": {\n        source: \"iana\",\n        extensions: [\"123\"]\n      },\n      \"application/vnd.lotus-approach\": {\n        source: \"iana\",\n        extensions: [\"apr\"]\n      },\n      \"application/vnd.lotus-freelance\": {\n        source: \"iana\",\n        extensions: [\"pre\"]\n      },\n      \"application/vnd.lotus-notes\": {\n        source: \"iana\",\n        extensions: [\"nsf\"]\n      },\n      \"application/vnd.lotus-organizer\": {\n        source: \"iana\",\n        extensions: [\"org\"]\n      },\n      \"application/vnd.lotus-screencam\": {\n        source: \"iana\",\n        extensions: [\"scm\"]\n      },\n      \"application/vnd.lotus-wordpro\": {\n        source: \"iana\",\n        extensions: [\"lwp\"]\n      },\n      \"application/vnd.macports.portpkg\": {\n        source: \"iana\",\n        extensions: [\"portpkg\"]\n      },\n      \"application/vnd.mapbox-vector-tile\": {\n        source: \"iana\",\n        extensions: [\"mvt\"]\n      },\n      \"application/vnd.marlin.drm.actiontoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.conftoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.license+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.mdcf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mason+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.maxar.archive.3tz+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.maxmind.maxmind-db\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mcd\": {\n        source: \"iana\",\n        extensions: [\"mcd\"]\n      },\n      \"application/vnd.mdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mdl-mbsdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.medcalcdata\": {\n        source: \"iana\",\n        extensions: [\"mc1\"]\n      },\n      \"application/vnd.mediastation.cdkey\": {\n        source: \"iana\",\n        extensions: [\"cdkey\"]\n      },\n      \"application/vnd.medicalholodeck.recordxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.meridian-slingshot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mermaid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mfer\": {\n        source: \"iana\",\n        extensions: [\"mwf\"]\n      },\n      \"application/vnd.mfmp\": {\n        source: \"iana\",\n        extensions: [\"mfm\"]\n      },\n      \"application/vnd.micro+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.micrografx.flo\": {\n        source: \"iana\",\n        extensions: [\"flo\"]\n      },\n      \"application/vnd.micrografx.igx\": {\n        source: \"iana\",\n        extensions: [\"igx\"]\n      },\n      \"application/vnd.microsoft.portable-executable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.microsoft.windows.thumbnail-cache\": {\n        source: \"iana\"\n      },\n      \"application/vnd.miele+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.mif\": {\n        source: \"iana\",\n        extensions: [\"mif\"]\n      },\n      \"application/vnd.minisoft-hp3000-save\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mitsubishi.misty-guard.trustweb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mobius.daf\": {\n        source: \"iana\",\n        extensions: [\"daf\"]\n      },\n      \"application/vnd.mobius.dis\": {\n        source: \"iana\",\n        extensions: [\"dis\"]\n      },\n      \"application/vnd.mobius.mbk\": {\n        source: \"iana\",\n        extensions: [\"mbk\"]\n      },\n      \"application/vnd.mobius.mqy\": {\n        source: \"iana\",\n        extensions: [\"mqy\"]\n      },\n      \"application/vnd.mobius.msl\": {\n        source: \"iana\",\n        extensions: [\"msl\"]\n      },\n      \"application/vnd.mobius.plc\": {\n        source: \"iana\",\n        extensions: [\"plc\"]\n      },\n      \"application/vnd.mobius.txf\": {\n        source: \"iana\",\n        extensions: [\"txf\"]\n      },\n      \"application/vnd.modl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mophun.application\": {\n        source: \"iana\",\n        extensions: [\"mpn\"]\n      },\n      \"application/vnd.mophun.certificate\": {\n        source: \"iana\",\n        extensions: [\"mpc\"]\n      },\n      \"application/vnd.motorola.flexsuite\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.adsi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.fis\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.gotap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.kmr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.ttc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.wem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.iprm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mozilla.xul+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xul\"]\n      },\n      \"application/vnd.ms-3mfdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-artgalry\": {\n        source: \"iana\",\n        extensions: [\"cil\"]\n      },\n      \"application/vnd.ms-asf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-cab-compressed\": {\n        source: \"iana\",\n        extensions: [\"cab\"]\n      },\n      \"application/vnd.ms-color.iccprofile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-excel\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xls\", \"xlm\", \"xla\", \"xlc\", \"xlt\", \"xlw\"]\n      },\n      \"application/vnd.ms-excel.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlam\"]\n      },\n      \"application/vnd.ms-excel.sheet.binary.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsb\"]\n      },\n      \"application/vnd.ms-excel.sheet.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsm\"]\n      },\n      \"application/vnd.ms-excel.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xltm\"]\n      },\n      \"application/vnd.ms-fontobject\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eot\"]\n      },\n      \"application/vnd.ms-htmlhelp\": {\n        source: \"iana\",\n        extensions: [\"chm\"]\n      },\n      \"application/vnd.ms-ims\": {\n        source: \"iana\",\n        extensions: [\"ims\"]\n      },\n      \"application/vnd.ms-lrm\": {\n        source: \"iana\",\n        extensions: [\"lrm\"]\n      },\n      \"application/vnd.ms-office.activex+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-officetheme\": {\n        source: \"iana\",\n        extensions: [\"thmx\"]\n      },\n      \"application/vnd.ms-opentype\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-outlook\": {\n        compressible: false,\n        extensions: [\"msg\"]\n      },\n      \"application/vnd.ms-package.obfuscated-opentype\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-pki.seccat\": {\n        source: \"apache\",\n        extensions: [\"cat\"]\n      },\n      \"application/vnd.ms-pki.stl\": {\n        source: \"apache\",\n        extensions: [\"stl\"]\n      },\n      \"application/vnd.ms-playready.initiator+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-powerpoint\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ppt\", \"pps\", \"pot\"]\n      },\n      \"application/vnd.ms-powerpoint.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppam\"]\n      },\n      \"application/vnd.ms-powerpoint.presentation.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"pptm\"]\n      },\n      \"application/vnd.ms-powerpoint.slide.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"sldm\"]\n      },\n      \"application/vnd.ms-powerpoint.slideshow.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppsm\"]\n      },\n      \"application/vnd.ms-powerpoint.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"potm\"]\n      },\n      \"application/vnd.ms-printdevicecapabilities+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-printing.printticket+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-printschematicket+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-project\": {\n        source: \"iana\",\n        extensions: [\"mpp\", \"mpt\"]\n      },\n      \"application/vnd.ms-tnef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-visio.viewer\": {\n        extensions: [\"vdx\"]\n      },\n      \"application/vnd.ms-windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.nwprinting.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.printerpairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.wsd.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-word.document.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"docm\"]\n      },\n      \"application/vnd.ms-word.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"dotm\"]\n      },\n      \"application/vnd.ms-works\": {\n        source: \"iana\",\n        extensions: [\"wps\", \"wks\", \"wcm\", \"wdb\"]\n      },\n      \"application/vnd.ms-wpl\": {\n        source: \"iana\",\n        extensions: [\"wpl\"]\n      },\n      \"application/vnd.ms-xpsdocument\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xps\"]\n      },\n      \"application/vnd.msa-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mseq\": {\n        source: \"iana\",\n        extensions: [\"mseq\"]\n      },\n      \"application/vnd.msgpack\": {\n        source: \"iana\"\n      },\n      \"application/vnd.msign\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator.cif\": {\n        source: \"iana\"\n      },\n      \"application/vnd.music-niff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.musician\": {\n        source: \"iana\",\n        extensions: [\"mus\"]\n      },\n      \"application/vnd.muvee.style\": {\n        source: \"iana\",\n        extensions: [\"msty\"]\n      },\n      \"application/vnd.mynfc\": {\n        source: \"iana\",\n        extensions: [\"taglet\"]\n      },\n      \"application/vnd.nacamar.ybrid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nato.bindingdataobject+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bdo\"]\n      },\n      \"application/vnd.nato.openxmlformats-package.iepd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.ncd.control\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ncd.reference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nearst.inv+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nebumind.line\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nervana\": {\n        source: \"iana\"\n      },\n      \"application/vnd.netfpx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.neurolanguage.nlu\": {\n        source: \"iana\",\n        extensions: [\"nlu\"]\n      },\n      \"application/vnd.nimn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.nitro.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.snes.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nitf\": {\n        source: \"iana\",\n        extensions: [\"ntf\", \"nitf\"]\n      },\n      \"application/vnd.noblenet-directory\": {\n        source: \"iana\",\n        extensions: [\"nnd\"]\n      },\n      \"application/vnd.noblenet-sealer\": {\n        source: \"iana\",\n        extensions: [\"nns\"]\n      },\n      \"application/vnd.noblenet-web\": {\n        source: \"iana\",\n        extensions: [\"nnw\"]\n      },\n      \"application/vnd.nokia.catalogs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.iptv.config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.isds-radio-presets\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.landmarkcollection+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.n-gage.ac+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ac\"]\n      },\n      \"application/vnd.nokia.n-gage.data\": {\n        source: \"iana\",\n        extensions: [\"ngdat\"]\n      },\n      \"application/vnd.nokia.n-gage.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"n-gage\"]\n      },\n      \"application/vnd.nokia.ncd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.radio-preset\": {\n        source: \"iana\",\n        extensions: [\"rpst\"]\n      },\n      \"application/vnd.nokia.radio-presets\": {\n        source: \"iana\",\n        extensions: [\"rpss\"]\n      },\n      \"application/vnd.novadigm.edm\": {\n        source: \"iana\",\n        extensions: [\"edm\"]\n      },\n      \"application/vnd.novadigm.edx\": {\n        source: \"iana\",\n        extensions: [\"edx\"]\n      },\n      \"application/vnd.novadigm.ext\": {\n        source: \"iana\",\n        extensions: [\"ext\"]\n      },\n      \"application/vnd.ntt-local.content-share\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.file-transfer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.ogw_remote-access\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_remote\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oai.workflows+yaml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.chart\": {\n        source: \"iana\",\n        extensions: [\"odc\"]\n      },\n      \"application/vnd.oasis.opendocument.chart-template\": {\n        source: \"iana\",\n        extensions: [\"otc\"]\n      },\n      \"application/vnd.oasis.opendocument.database\": {\n        source: \"apache\",\n        extensions: [\"odb\"]\n      },\n      \"application/vnd.oasis.opendocument.formula\": {\n        source: \"iana\",\n        extensions: [\"odf\"]\n      },\n      \"application/vnd.oasis.opendocument.formula-template\": {\n        source: \"iana\",\n        extensions: [\"odft\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odg\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics-template\": {\n        source: \"iana\",\n        extensions: [\"otg\"]\n      },\n      \"application/vnd.oasis.opendocument.image\": {\n        source: \"iana\",\n        extensions: [\"odi\"]\n      },\n      \"application/vnd.oasis.opendocument.image-template\": {\n        source: \"iana\",\n        extensions: [\"oti\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odp\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation-template\": {\n        source: \"iana\",\n        extensions: [\"otp\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ods\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet-template\": {\n        source: \"iana\",\n        extensions: [\"ots\"]\n      },\n      \"application/vnd.oasis.opendocument.text\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odt\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master\": {\n        source: \"iana\",\n        extensions: [\"odm\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.text-template\": {\n        source: \"iana\",\n        extensions: [\"ott\"]\n      },\n      \"application/vnd.oasis.opendocument.text-web\": {\n        source: \"iana\",\n        extensions: [\"oth\"]\n      },\n      \"application/vnd.obn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ocf+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oci.image.manifest.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oftn.l10n+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessdownload+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessstreaming+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.cspg-hexbinary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.dae.svg+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.dae.xhtml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.mippvcontrolmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.pae.gem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.spdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.spdlist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.ueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.userprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.olpc-sugar\": {\n        source: \"iana\",\n        extensions: [\"xo\"]\n      },\n      \"application/vnd.oma-scws-config\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-request\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.associated-procedure-parameter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.drm-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.imd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.ltkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.notification+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.provisioningtrigger\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgboot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgdd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sgdu\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.simple-symbol-container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.smartcard-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sprov+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.stkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.cab-address-book+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-feature-handler+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-pcc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-subs-invite+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-user-prefs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.dcd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dcdc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dd2+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dd2\"]\n      },\n      \"application/vnd.oma.drm.risd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.group-usage-list+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.lwm2m+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+tlv\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.pal+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.detailed-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.final-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.groups+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.invocation-descriptor+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.optimized-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.push\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.scidm.messages+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.xcap-directory+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.omads-email+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-file+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-folder+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omaloc-supl-init\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepager\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertat\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onvif.metadata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openblox.game+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"obgx\"]\n      },\n      \"application/vnd.openblox.game-binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openeye.oeb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openofficeorg.extension\": {\n        source: \"apache\",\n        extensions: [\"oxt\"]\n      },\n      \"application/vnd.openstreetmap.data+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osm\"]\n      },\n      \"application/vnd.opentimestamps.ots\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openvpi.dspx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.custom-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.customxmlproperties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawing+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chart+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.extended-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pptx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide\": {\n        source: \"iana\",\n        extensions: [\"sldx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow\": {\n        source: \"iana\",\n        extensions: [\"ppsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tags+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template\": {\n        source: \"iana\",\n        extensions: [\"potx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xlsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template\": {\n        source: \"iana\",\n        extensions: [\"xltx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.theme+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.themeoverride+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.vmldrawing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"docx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template\": {\n        source: \"iana\",\n        extensions: [\"dotx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.core-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.relationships+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oracle.resource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.orange.indata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osa.netdeploy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgeo.mapguide.package\": {\n        source: \"iana\",\n        extensions: [\"mgp\"]\n      },\n      \"application/vnd.osgi.bundle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgi.dp\": {\n        source: \"iana\",\n        extensions: [\"dp\"]\n      },\n      \"application/vnd.osgi.subsystem\": {\n        source: \"iana\",\n        extensions: [\"esa\"]\n      },\n      \"application/vnd.otps.ct-kip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oxli.countgraph\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pagerduty+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.palm\": {\n        source: \"iana\",\n        extensions: [\"pdb\", \"pqa\", \"oprc\"]\n      },\n      \"application/vnd.panoply\": {\n        source: \"iana\"\n      },\n      \"application/vnd.paos.xml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patentdive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patientecommsdoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pawaafile\": {\n        source: \"iana\",\n        extensions: [\"paw\"]\n      },\n      \"application/vnd.pcos\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pg.format\": {\n        source: \"iana\",\n        extensions: [\"str\"]\n      },\n      \"application/vnd.pg.osasli\": {\n        source: \"iana\",\n        extensions: [\"ei6\"]\n      },\n      \"application/vnd.piaccess.application-licence\": {\n        source: \"iana\"\n      },\n      \"application/vnd.picsel\": {\n        source: \"iana\",\n        extensions: [\"efif\"]\n      },\n      \"application/vnd.pmi.widget\": {\n        source: \"iana\",\n        extensions: [\"wg\"]\n      },\n      \"application/vnd.poc.group-advertisement+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.pocketlearn\": {\n        source: \"iana\",\n        extensions: [\"plf\"]\n      },\n      \"application/vnd.powerbuilder6\": {\n        source: \"iana\",\n        extensions: [\"pbd\"]\n      },\n      \"application/vnd.powerbuilder6-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.preminet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.previewsystems.box\": {\n        source: \"iana\",\n        extensions: [\"box\"]\n      },\n      \"application/vnd.procrate.brushset\": {\n        extensions: [\"brushset\"]\n      },\n      \"application/vnd.procreate.brush\": {\n        extensions: [\"brush\"]\n      },\n      \"application/vnd.procreate.dream\": {\n        extensions: [\"drm\"]\n      },\n      \"application/vnd.proteus.magazine\": {\n        source: \"iana\",\n        extensions: [\"mgz\"]\n      },\n      \"application/vnd.psfs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pt.mundusmundi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.publishare-delta-tree\": {\n        source: \"iana\",\n        extensions: [\"qps\"]\n      },\n      \"application/vnd.pvi.ptid1\": {\n        source: \"iana\",\n        extensions: [\"ptid\"]\n      },\n      \"application/vnd.pwg-multiplexed\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pwg-xhtml-print+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtm\"]\n      },\n      \"application/vnd.qualcomm.brew-app-res\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quarantainenet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quark.quarkxpress\": {\n        source: \"iana\",\n        extensions: [\"qxd\", \"qxt\", \"qwd\", \"qwt\", \"qxl\", \"qxb\"]\n      },\n      \"application/vnd.quobject-quoxdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.radisys.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-stream+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-base+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-detect+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-sendrecv+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-group+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-speech+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-transform+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rainstor.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rapid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rar\": {\n        source: \"iana\",\n        extensions: [\"rar\"]\n      },\n      \"application/vnd.realvnc.bed\": {\n        source: \"iana\",\n        extensions: [\"bed\"]\n      },\n      \"application/vnd.recordare.musicxml\": {\n        source: \"iana\",\n        extensions: [\"mxl\"]\n      },\n      \"application/vnd.recordare.musicxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musicxml\"]\n      },\n      \"application/vnd.relpipe\": {\n        source: \"iana\"\n      },\n      \"application/vnd.renlearn.rlprint\": {\n        source: \"iana\"\n      },\n      \"application/vnd.resilient.logic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.restful+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rig.cryptonote\": {\n        source: \"iana\",\n        extensions: [\"cryptonote\"]\n      },\n      \"application/vnd.rim.cod\": {\n        source: \"apache\",\n        extensions: [\"cod\"]\n      },\n      \"application/vnd.rn-realmedia\": {\n        source: \"apache\",\n        extensions: [\"rm\"]\n      },\n      \"application/vnd.rn-realmedia-vbr\": {\n        source: \"apache\",\n        extensions: [\"rmvb\"]\n      },\n      \"application/vnd.route66.link66+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"link66\"]\n      },\n      \"application/vnd.rs-274x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ruckus.download\": {\n        source: \"iana\"\n      },\n      \"application/vnd.s3sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sailingtracker.track\": {\n        source: \"iana\",\n        extensions: [\"st\"]\n      },\n      \"application/vnd.sar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.cid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.mid2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.scribus\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.3df\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.csf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.doc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.eml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.mht\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.net\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.ppt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.tiff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.xls\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.seemail\": {\n        source: \"iana\",\n        extensions: [\"see\"]\n      },\n      \"application/vnd.seis+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sema\": {\n        source: \"iana\",\n        extensions: [\"sema\"]\n      },\n      \"application/vnd.semd\": {\n        source: \"iana\",\n        extensions: [\"semd\"]\n      },\n      \"application/vnd.semf\": {\n        source: \"iana\",\n        extensions: [\"semf\"]\n      },\n      \"application/vnd.shade-save-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shana.informed.formdata\": {\n        source: \"iana\",\n        extensions: [\"ifm\"]\n      },\n      \"application/vnd.shana.informed.formtemplate\": {\n        source: \"iana\",\n        extensions: [\"itp\"]\n      },\n      \"application/vnd.shana.informed.interchange\": {\n        source: \"iana\",\n        extensions: [\"iif\"]\n      },\n      \"application/vnd.shana.informed.package\": {\n        source: \"iana\",\n        extensions: [\"ipk\"]\n      },\n      \"application/vnd.shootproof+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shopkick+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sigrok.session\": {\n        source: \"iana\"\n      },\n      \"application/vnd.simtech-mindmapper\": {\n        source: \"iana\",\n        extensions: [\"twd\", \"twds\"]\n      },\n      \"application/vnd.siren+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sketchometry\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smaf\": {\n        source: \"iana\",\n        extensions: [\"mmf\"]\n      },\n      \"application/vnd.smart.notebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smart.teacher\": {\n        source: \"iana\",\n        extensions: [\"teacher\"]\n      },\n      \"application/vnd.smintio.portals.archive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.snesdev-page-table\": {\n        source: \"iana\"\n      },\n      \"application/vnd.software602.filler.form+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fo\"]\n      },\n      \"application/vnd.software602.filler.form-xml-zip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.solent.sdkm+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sdkm\", \"sdkd\"]\n      },\n      \"application/vnd.spotfire.dxp\": {\n        source: \"iana\",\n        extensions: [\"dxp\"]\n      },\n      \"application/vnd.spotfire.sfs\": {\n        source: \"iana\",\n        extensions: [\"sfs\"]\n      },\n      \"application/vnd.sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-cod\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-dtf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-ntf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.stardivision.calc\": {\n        source: \"apache\",\n        extensions: [\"sdc\"]\n      },\n      \"application/vnd.stardivision.draw\": {\n        source: \"apache\",\n        extensions: [\"sda\"]\n      },\n      \"application/vnd.stardivision.impress\": {\n        source: \"apache\",\n        extensions: [\"sdd\"]\n      },\n      \"application/vnd.stardivision.math\": {\n        source: \"apache\",\n        extensions: [\"smf\"]\n      },\n      \"application/vnd.stardivision.writer\": {\n        source: \"apache\",\n        extensions: [\"sdw\", \"vor\"]\n      },\n      \"application/vnd.stardivision.writer-global\": {\n        source: \"apache\",\n        extensions: [\"sgl\"]\n      },\n      \"application/vnd.stepmania.package\": {\n        source: \"iana\",\n        extensions: [\"smzip\"]\n      },\n      \"application/vnd.stepmania.stepchart\": {\n        source: \"iana\",\n        extensions: [\"sm\"]\n      },\n      \"application/vnd.street-stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sun.wadl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wadl\"]\n      },\n      \"application/vnd.sun.xml.calc\": {\n        source: \"apache\",\n        extensions: [\"sxc\"]\n      },\n      \"application/vnd.sun.xml.calc.template\": {\n        source: \"apache\",\n        extensions: [\"stc\"]\n      },\n      \"application/vnd.sun.xml.draw\": {\n        source: \"apache\",\n        extensions: [\"sxd\"]\n      },\n      \"application/vnd.sun.xml.draw.template\": {\n        source: \"apache\",\n        extensions: [\"std\"]\n      },\n      \"application/vnd.sun.xml.impress\": {\n        source: \"apache\",\n        extensions: [\"sxi\"]\n      },\n      \"application/vnd.sun.xml.impress.template\": {\n        source: \"apache\",\n        extensions: [\"sti\"]\n      },\n      \"application/vnd.sun.xml.math\": {\n        source: \"apache\",\n        extensions: [\"sxm\"]\n      },\n      \"application/vnd.sun.xml.writer\": {\n        source: \"apache\",\n        extensions: [\"sxw\"]\n      },\n      \"application/vnd.sun.xml.writer.global\": {\n        source: \"apache\",\n        extensions: [\"sxg\"]\n      },\n      \"application/vnd.sun.xml.writer.template\": {\n        source: \"apache\",\n        extensions: [\"stw\"]\n      },\n      \"application/vnd.sus-calendar\": {\n        source: \"iana\",\n        extensions: [\"sus\", \"susp\"]\n      },\n      \"application/vnd.svd\": {\n        source: \"iana\",\n        extensions: [\"svd\"]\n      },\n      \"application/vnd.swiftview-ics\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sybyl.mol2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sycle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.syft+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"sis\", \"sisx\"]\n      },\n      \"application/vnd.syncml+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xsm\"]\n      },\n      \"application/vnd.syncml.dm+wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"bdm\"]\n      },\n      \"application/vnd.syncml.dm+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xdm\"]\n      },\n      \"application/vnd.syncml.dm.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"ddf\"]\n      },\n      \"application/vnd.syncml.dmtnds+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmtnds+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.syncml.ds.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tableschema+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tao.intent-module-archive\": {\n        source: \"iana\",\n        extensions: [\"tao\"]\n      },\n      \"application/vnd.tcpdump.pcap\": {\n        source: \"iana\",\n        extensions: [\"pcap\", \"cap\", \"dmp\"]\n      },\n      \"application/vnd.think-cell.ppttc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tmd.mediaflex.api+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tmobile-livetv\": {\n        source: \"iana\",\n        extensions: [\"tmo\"]\n      },\n      \"application/vnd.tri.onesource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.trid.tpt\": {\n        source: \"iana\",\n        extensions: [\"tpt\"]\n      },\n      \"application/vnd.triscape.mxs\": {\n        source: \"iana\",\n        extensions: [\"mxs\"]\n      },\n      \"application/vnd.trueapp\": {\n        source: \"iana\",\n        extensions: [\"tra\"]\n      },\n      \"application/vnd.truedoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ubisoft.webplayer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ufdl\": {\n        source: \"iana\",\n        extensions: [\"ufd\", \"ufdl\"]\n      },\n      \"application/vnd.uic.osdm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.uiq.theme\": {\n        source: \"iana\",\n        extensions: [\"utz\"]\n      },\n      \"application/vnd.umajin\": {\n        source: \"iana\",\n        extensions: [\"umj\"]\n      },\n      \"application/vnd.unity\": {\n        source: \"iana\",\n        extensions: [\"unityweb\"]\n      },\n      \"application/vnd.uoml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uoml\", \"uo\"]\n      },\n      \"application/vnd.uplanet.alert\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.alert-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.signal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uri-map\": {\n        source: \"iana\"\n      },\n      \"application/vnd.valve.source.material\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vcx\": {\n        source: \"iana\",\n        extensions: [\"vcx\"]\n      },\n      \"application/vnd.vd-study\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vectorworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vel+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veraison.tsm-report+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veraison.tsm-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.verimatrix.vcas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veritone.aion+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veryant.thin\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ves.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vidsoft.vidconference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.visio\": {\n        source: \"iana\",\n        extensions: [\"vsd\", \"vst\", \"vss\", \"vsw\", \"vsdx\", \"vtx\"]\n      },\n      \"application/vnd.visionary\": {\n        source: \"iana\",\n        extensions: [\"vis\"]\n      },\n      \"application/vnd.vividence.scriptfile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vocalshaper.vsp4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vsf\": {\n        source: \"iana\",\n        extensions: [\"vsf\"]\n      },\n      \"application/vnd.wap.sic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.slc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"wbxml\"]\n      },\n      \"application/vnd.wap.wmlc\": {\n        source: \"iana\",\n        extensions: [\"wmlc\"]\n      },\n      \"application/vnd.wap.wmlscriptc\": {\n        source: \"iana\",\n        extensions: [\"wmlsc\"]\n      },\n      \"application/vnd.wasmflow.wafl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.webturbo\": {\n        source: \"iana\",\n        extensions: [\"wtb\"]\n      },\n      \"application/vnd.wfa.dpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.p2p\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.wsc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmf.bootstrap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica.package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.player\": {\n        source: \"iana\",\n        extensions: [\"nbp\"]\n      },\n      \"application/vnd.wordlift\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wordperfect\": {\n        source: \"iana\",\n        extensions: [\"wpd\"]\n      },\n      \"application/vnd.wqd\": {\n        source: \"iana\",\n        extensions: [\"wqd\"]\n      },\n      \"application/vnd.wrq-hp3000-labelled\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wt.stf\": {\n        source: \"iana\",\n        extensions: [\"stf\"]\n      },\n      \"application/vnd.wv.csp+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wv.csp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.wv.ssp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xara\": {\n        source: \"iana\",\n        extensions: [\"xar\"]\n      },\n      \"application/vnd.xarin.cpj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xecrets-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xfdl\": {\n        source: \"iana\",\n        extensions: [\"xfdl\"]\n      },\n      \"application/vnd.xfdl.webform\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xmpie.cpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.dpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.plan\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.ppkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.xlim\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.hv-dic\": {\n        source: \"iana\",\n        extensions: [\"hvd\"]\n      },\n      \"application/vnd.yamaha.hv-script\": {\n        source: \"iana\",\n        extensions: [\"hvs\"]\n      },\n      \"application/vnd.yamaha.hv-voice\": {\n        source: \"iana\",\n        extensions: [\"hvp\"]\n      },\n      \"application/vnd.yamaha.openscoreformat\": {\n        source: \"iana\",\n        extensions: [\"osf\"]\n      },\n      \"application/vnd.yamaha.openscoreformat.osfpvg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osfpvg\"]\n      },\n      \"application/vnd.yamaha.remote-setup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.smaf-audio\": {\n        source: \"iana\",\n        extensions: [\"saf\"]\n      },\n      \"application/vnd.yamaha.smaf-phrase\": {\n        source: \"iana\",\n        extensions: [\"spf\"]\n      },\n      \"application/vnd.yamaha.through-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.tunnel-udpencap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yaoweme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yellowriver-custom-menu\": {\n        source: \"iana\",\n        extensions: [\"cmp\"]\n      },\n      \"application/vnd.zul\": {\n        source: \"iana\",\n        extensions: [\"zir\", \"zirz\"]\n      },\n      \"application/vnd.zzazz.deck+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zaz\"]\n      },\n      \"application/voicexml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vxml\"]\n      },\n      \"application/voucher-cms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/voucher-jws+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vp\": {\n        source: \"iana\"\n      },\n      \"application/vp+cose\": {\n        source: \"iana\"\n      },\n      \"application/vp+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vq-rtcpxr\": {\n        source: \"iana\"\n      },\n      \"application/wasm\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wasm\"]\n      },\n      \"application/watcherinfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wif\"]\n      },\n      \"application/webpush-options+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/whoispp-query\": {\n        source: \"iana\"\n      },\n      \"application/whoispp-response\": {\n        source: \"iana\"\n      },\n      \"application/widget\": {\n        source: \"iana\",\n        extensions: [\"wgt\"]\n      },\n      \"application/winhlp\": {\n        source: \"apache\",\n        extensions: [\"hlp\"]\n      },\n      \"application/wita\": {\n        source: \"iana\"\n      },\n      \"application/wordperfect5.1\": {\n        source: \"iana\"\n      },\n      \"application/wsdl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wsdl\"]\n      },\n      \"application/wspolicy+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wspolicy\"]\n      },\n      \"application/x-7z-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"7z\"]\n      },\n      \"application/x-abiword\": {\n        source: \"apache\",\n        extensions: [\"abw\"]\n      },\n      \"application/x-ace-compressed\": {\n        source: \"apache\",\n        extensions: [\"ace\"]\n      },\n      \"application/x-amf\": {\n        source: \"apache\"\n      },\n      \"application/x-apple-diskimage\": {\n        source: \"apache\",\n        extensions: [\"dmg\"]\n      },\n      \"application/x-arj\": {\n        compressible: false,\n        extensions: [\"arj\"]\n      },\n      \"application/x-authorware-bin\": {\n        source: \"apache\",\n        extensions: [\"aab\", \"x32\", \"u32\", \"vox\"]\n      },\n      \"application/x-authorware-map\": {\n        source: \"apache\",\n        extensions: [\"aam\"]\n      },\n      \"application/x-authorware-seg\": {\n        source: \"apache\",\n        extensions: [\"aas\"]\n      },\n      \"application/x-bcpio\": {\n        source: \"apache\",\n        extensions: [\"bcpio\"]\n      },\n      \"application/x-bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/x-bittorrent\": {\n        source: \"apache\",\n        extensions: [\"torrent\"]\n      },\n      \"application/x-blender\": {\n        extensions: [\"blend\"]\n      },\n      \"application/x-blorb\": {\n        source: \"apache\",\n        extensions: [\"blb\", \"blorb\"]\n      },\n      \"application/x-bzip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz\"]\n      },\n      \"application/x-bzip2\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz2\", \"boz\"]\n      },\n      \"application/x-cbr\": {\n        source: \"apache\",\n        extensions: [\"cbr\", \"cba\", \"cbt\", \"cbz\", \"cb7\"]\n      },\n      \"application/x-cdlink\": {\n        source: \"apache\",\n        extensions: [\"vcd\"]\n      },\n      \"application/x-cfs-compressed\": {\n        source: \"apache\",\n        extensions: [\"cfs\"]\n      },\n      \"application/x-chat\": {\n        source: \"apache\",\n        extensions: [\"chat\"]\n      },\n      \"application/x-chess-pgn\": {\n        source: \"apache\",\n        extensions: [\"pgn\"]\n      },\n      \"application/x-chrome-extension\": {\n        extensions: [\"crx\"]\n      },\n      \"application/x-cocoa\": {\n        source: \"nginx\",\n        extensions: [\"cco\"]\n      },\n      \"application/x-compress\": {\n        source: \"apache\"\n      },\n      \"application/x-compressed\": {\n        extensions: [\"rar\"]\n      },\n      \"application/x-conference\": {\n        source: \"apache\",\n        extensions: [\"nsc\"]\n      },\n      \"application/x-cpio\": {\n        source: \"apache\",\n        extensions: [\"cpio\"]\n      },\n      \"application/x-csh\": {\n        source: \"apache\",\n        extensions: [\"csh\"]\n      },\n      \"application/x-deb\": {\n        compressible: false\n      },\n      \"application/x-debian-package\": {\n        source: \"apache\",\n        extensions: [\"deb\", \"udeb\"]\n      },\n      \"application/x-dgc-compressed\": {\n        source: \"apache\",\n        extensions: [\"dgc\"]\n      },\n      \"application/x-director\": {\n        source: \"apache\",\n        extensions: [\"dir\", \"dcr\", \"dxr\", \"cst\", \"cct\", \"cxt\", \"w3d\", \"fgd\", \"swa\"]\n      },\n      \"application/x-doom\": {\n        source: \"apache\",\n        extensions: [\"wad\"]\n      },\n      \"application/x-dtbncx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ncx\"]\n      },\n      \"application/x-dtbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dtb\"]\n      },\n      \"application/x-dtbresource+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"res\"]\n      },\n      \"application/x-dvi\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"dvi\"]\n      },\n      \"application/x-envoy\": {\n        source: \"apache\",\n        extensions: [\"evy\"]\n      },\n      \"application/x-eva\": {\n        source: \"apache\",\n        extensions: [\"eva\"]\n      },\n      \"application/x-font-bdf\": {\n        source: \"apache\",\n        extensions: [\"bdf\"]\n      },\n      \"application/x-font-dos\": {\n        source: \"apache\"\n      },\n      \"application/x-font-framemaker\": {\n        source: \"apache\"\n      },\n      \"application/x-font-ghostscript\": {\n        source: \"apache\",\n        extensions: [\"gsf\"]\n      },\n      \"application/x-font-libgrx\": {\n        source: \"apache\"\n      },\n      \"application/x-font-linux-psf\": {\n        source: \"apache\",\n        extensions: [\"psf\"]\n      },\n      \"application/x-font-pcf\": {\n        source: \"apache\",\n        extensions: [\"pcf\"]\n      },\n      \"application/x-font-snf\": {\n        source: \"apache\",\n        extensions: [\"snf\"]\n      },\n      \"application/x-font-speedo\": {\n        source: \"apache\"\n      },\n      \"application/x-font-sunos-news\": {\n        source: \"apache\"\n      },\n      \"application/x-font-type1\": {\n        source: \"apache\",\n        extensions: [\"pfa\", \"pfb\", \"pfm\", \"afm\"]\n      },\n      \"application/x-font-vfont\": {\n        source: \"apache\"\n      },\n      \"application/x-freearc\": {\n        source: \"apache\",\n        extensions: [\"arc\"]\n      },\n      \"application/x-futuresplash\": {\n        source: \"apache\",\n        extensions: [\"spl\"]\n      },\n      \"application/x-gca-compressed\": {\n        source: \"apache\",\n        extensions: [\"gca\"]\n      },\n      \"application/x-glulx\": {\n        source: \"apache\",\n        extensions: [\"ulx\"]\n      },\n      \"application/x-gnumeric\": {\n        source: \"apache\",\n        extensions: [\"gnumeric\"]\n      },\n      \"application/x-gramps-xml\": {\n        source: \"apache\",\n        extensions: [\"gramps\"]\n      },\n      \"application/x-gtar\": {\n        source: \"apache\",\n        extensions: [\"gtar\"]\n      },\n      \"application/x-gzip\": {\n        source: \"apache\"\n      },\n      \"application/x-hdf\": {\n        source: \"apache\",\n        extensions: [\"hdf\"]\n      },\n      \"application/x-httpd-php\": {\n        compressible: true,\n        extensions: [\"php\"]\n      },\n      \"application/x-install-instructions\": {\n        source: \"apache\",\n        extensions: [\"install\"]\n      },\n      \"application/x-ipynb+json\": {\n        compressible: true,\n        extensions: [\"ipynb\"]\n      },\n      \"application/x-iso9660-image\": {\n        source: \"apache\",\n        extensions: [\"iso\"]\n      },\n      \"application/x-iwork-keynote-sffkey\": {\n        extensions: [\"key\"]\n      },\n      \"application/x-iwork-numbers-sffnumbers\": {\n        extensions: [\"numbers\"]\n      },\n      \"application/x-iwork-pages-sffpages\": {\n        extensions: [\"pages\"]\n      },\n      \"application/x-java-archive-diff\": {\n        source: \"nginx\",\n        extensions: [\"jardiff\"]\n      },\n      \"application/x-java-jnlp-file\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"jnlp\"]\n      },\n      \"application/x-javascript\": {\n        compressible: true\n      },\n      \"application/x-keepass2\": {\n        extensions: [\"kdbx\"]\n      },\n      \"application/x-latex\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"latex\"]\n      },\n      \"application/x-lua-bytecode\": {\n        extensions: [\"luac\"]\n      },\n      \"application/x-lzh-compressed\": {\n        source: \"apache\",\n        extensions: [\"lzh\", \"lha\"]\n      },\n      \"application/x-makeself\": {\n        source: \"nginx\",\n        extensions: [\"run\"]\n      },\n      \"application/x-mie\": {\n        source: \"apache\",\n        extensions: [\"mie\"]\n      },\n      \"application/x-mobipocket-ebook\": {\n        source: \"apache\",\n        extensions: [\"prc\", \"mobi\"]\n      },\n      \"application/x-mpegurl\": {\n        compressible: false\n      },\n      \"application/x-ms-application\": {\n        source: \"apache\",\n        extensions: [\"application\"]\n      },\n      \"application/x-ms-shortcut\": {\n        source: \"apache\",\n        extensions: [\"lnk\"]\n      },\n      \"application/x-ms-wmd\": {\n        source: \"apache\",\n        extensions: [\"wmd\"]\n      },\n      \"application/x-ms-wmz\": {\n        source: \"apache\",\n        extensions: [\"wmz\"]\n      },\n      \"application/x-ms-xbap\": {\n        source: \"apache\",\n        extensions: [\"xbap\"]\n      },\n      \"application/x-msaccess\": {\n        source: \"apache\",\n        extensions: [\"mdb\"]\n      },\n      \"application/x-msbinder\": {\n        source: \"apache\",\n        extensions: [\"obd\"]\n      },\n      \"application/x-mscardfile\": {\n        source: \"apache\",\n        extensions: [\"crd\"]\n      },\n      \"application/x-msclip\": {\n        source: \"apache\",\n        extensions: [\"clp\"]\n      },\n      \"application/x-msdos-program\": {\n        extensions: [\"exe\"]\n      },\n      \"application/x-msdownload\": {\n        source: \"apache\",\n        extensions: [\"exe\", \"dll\", \"com\", \"bat\", \"msi\"]\n      },\n      \"application/x-msmediaview\": {\n        source: \"apache\",\n        extensions: [\"mvb\", \"m13\", \"m14\"]\n      },\n      \"application/x-msmetafile\": {\n        source: \"apache\",\n        extensions: [\"wmf\", \"wmz\", \"emf\", \"emz\"]\n      },\n      \"application/x-msmoney\": {\n        source: \"apache\",\n        extensions: [\"mny\"]\n      },\n      \"application/x-mspublisher\": {\n        source: \"apache\",\n        extensions: [\"pub\"]\n      },\n      \"application/x-msschedule\": {\n        source: \"apache\",\n        extensions: [\"scd\"]\n      },\n      \"application/x-msterminal\": {\n        source: \"apache\",\n        extensions: [\"trm\"]\n      },\n      \"application/x-mswrite\": {\n        source: \"apache\",\n        extensions: [\"wri\"]\n      },\n      \"application/x-netcdf\": {\n        source: \"apache\",\n        extensions: [\"nc\", \"cdf\"]\n      },\n      \"application/x-ns-proxy-autoconfig\": {\n        compressible: true,\n        extensions: [\"pac\"]\n      },\n      \"application/x-nzb\": {\n        source: \"apache\",\n        extensions: [\"nzb\"]\n      },\n      \"application/x-perl\": {\n        source: \"nginx\",\n        extensions: [\"pl\", \"pm\"]\n      },\n      \"application/x-pilot\": {\n        source: \"nginx\",\n        extensions: [\"prc\", \"pdb\"]\n      },\n      \"application/x-pkcs12\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"p12\", \"pfx\"]\n      },\n      \"application/x-pkcs7-certificates\": {\n        source: \"apache\",\n        extensions: [\"p7b\", \"spc\"]\n      },\n      \"application/x-pkcs7-certreqresp\": {\n        source: \"apache\",\n        extensions: [\"p7r\"]\n      },\n      \"application/x-pki-message\": {\n        source: \"iana\"\n      },\n      \"application/x-rar-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"rar\"]\n      },\n      \"application/x-redhat-package-manager\": {\n        source: \"nginx\",\n        extensions: [\"rpm\"]\n      },\n      \"application/x-research-info-systems\": {\n        source: \"apache\",\n        extensions: [\"ris\"]\n      },\n      \"application/x-sea\": {\n        source: \"nginx\",\n        extensions: [\"sea\"]\n      },\n      \"application/x-sh\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"sh\"]\n      },\n      \"application/x-shar\": {\n        source: \"apache\",\n        extensions: [\"shar\"]\n      },\n      \"application/x-shockwave-flash\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"swf\"]\n      },\n      \"application/x-silverlight-app\": {\n        source: \"apache\",\n        extensions: [\"xap\"]\n      },\n      \"application/x-sql\": {\n        source: \"apache\",\n        extensions: [\"sql\"]\n      },\n      \"application/x-stuffit\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"sit\"]\n      },\n      \"application/x-stuffitx\": {\n        source: \"apache\",\n        extensions: [\"sitx\"]\n      },\n      \"application/x-subrip\": {\n        source: \"apache\",\n        extensions: [\"srt\"]\n      },\n      \"application/x-sv4cpio\": {\n        source: \"apache\",\n        extensions: [\"sv4cpio\"]\n      },\n      \"application/x-sv4crc\": {\n        source: \"apache\",\n        extensions: [\"sv4crc\"]\n      },\n      \"application/x-t3vm-image\": {\n        source: \"apache\",\n        extensions: [\"t3\"]\n      },\n      \"application/x-tads\": {\n        source: \"apache\",\n        extensions: [\"gam\"]\n      },\n      \"application/x-tar\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"tar\"]\n      },\n      \"application/x-tcl\": {\n        source: \"apache\",\n        extensions: [\"tcl\", \"tk\"]\n      },\n      \"application/x-tex\": {\n        source: \"apache\",\n        extensions: [\"tex\"]\n      },\n      \"application/x-tex-tfm\": {\n        source: \"apache\",\n        extensions: [\"tfm\"]\n      },\n      \"application/x-texinfo\": {\n        source: \"apache\",\n        extensions: [\"texinfo\", \"texi\"]\n      },\n      \"application/x-tgif\": {\n        source: \"apache\",\n        extensions: [\"obj\"]\n      },\n      \"application/x-ustar\": {\n        source: \"apache\",\n        extensions: [\"ustar\"]\n      },\n      \"application/x-virtualbox-hdd\": {\n        compressible: true,\n        extensions: [\"hdd\"]\n      },\n      \"application/x-virtualbox-ova\": {\n        compressible: true,\n        extensions: [\"ova\"]\n      },\n      \"application/x-virtualbox-ovf\": {\n        compressible: true,\n        extensions: [\"ovf\"]\n      },\n      \"application/x-virtualbox-vbox\": {\n        compressible: true,\n        extensions: [\"vbox\"]\n      },\n      \"application/x-virtualbox-vbox-extpack\": {\n        compressible: false,\n        extensions: [\"vbox-extpack\"]\n      },\n      \"application/x-virtualbox-vdi\": {\n        compressible: true,\n        extensions: [\"vdi\"]\n      },\n      \"application/x-virtualbox-vhd\": {\n        compressible: true,\n        extensions: [\"vhd\"]\n      },\n      \"application/x-virtualbox-vmdk\": {\n        compressible: true,\n        extensions: [\"vmdk\"]\n      },\n      \"application/x-wais-source\": {\n        source: \"apache\",\n        extensions: [\"src\"]\n      },\n      \"application/x-web-app-manifest+json\": {\n        compressible: true,\n        extensions: [\"webapp\"]\n      },\n      \"application/x-www-form-urlencoded\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/x-x509-ca-cert\": {\n        source: \"iana\",\n        extensions: [\"der\", \"crt\", \"pem\"]\n      },\n      \"application/x-x509-ca-ra-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-x509-next-ca-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-xfig\": {\n        source: \"apache\",\n        extensions: [\"fig\"]\n      },\n      \"application/x-xliff+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/x-xpinstall\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"xpi\"]\n      },\n      \"application/x-xz\": {\n        source: \"apache\",\n        extensions: [\"xz\"]\n      },\n      \"application/x-zip-compressed\": {\n        extensions: [\"zip\"]\n      },\n      \"application/x-zmachine\": {\n        source: \"apache\",\n        extensions: [\"z1\", \"z2\", \"z3\", \"z4\", \"z5\", \"z6\", \"z7\", \"z8\"]\n      },\n      \"application/x400-bp\": {\n        source: \"iana\"\n      },\n      \"application/xacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xaml+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xaml\"]\n      },\n      \"application/xcap-att+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xav\"]\n      },\n      \"application/xcap-caps+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xca\"]\n      },\n      \"application/xcap-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdf\"]\n      },\n      \"application/xcap-el+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xel\"]\n      },\n      \"application/xcap-error+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcap-ns+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xns\"]\n      },\n      \"application/xcon-conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcon-conference-info-diff+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xenc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xenc\"]\n      },\n      \"application/xfdf\": {\n        source: \"iana\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/xhtml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtml\", \"xht\"]\n      },\n      \"application/xhtml-voice+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/xliff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\", \"xsl\", \"xsd\", \"rng\"]\n      },\n      \"application/xml-dtd\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dtd\"]\n      },\n      \"application/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"application/xml-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xmpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xop+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xop\"]\n      },\n      \"application/xproc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xpl\"]\n      },\n      \"application/xslt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsl\", \"xslt\"]\n      },\n      \"application/xspf+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xspf\"]\n      },\n      \"application/xv+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mxml\", \"xhvml\", \"xvml\", \"xvm\"]\n      },\n      \"application/yaml\": {\n        source: \"iana\"\n      },\n      \"application/yang\": {\n        source: \"iana\",\n        extensions: [\"yang\"]\n      },\n      \"application/yang-data+cbor\": {\n        source: \"iana\"\n      },\n      \"application/yang-data+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-sid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yin+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"yin\"]\n      },\n      \"application/zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"zip\"]\n      },\n      \"application/zip+dotlottie\": {\n        extensions: [\"lottie\"]\n      },\n      \"application/zlib\": {\n        source: \"iana\"\n      },\n      \"application/zstd\": {\n        source: \"iana\"\n      },\n      \"audio/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/3gpp\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"3gpp\"]\n      },\n      \"audio/3gpp2\": {\n        source: \"iana\"\n      },\n      \"audio/aac\": {\n        source: \"iana\",\n        extensions: [\"adts\", \"aac\"]\n      },\n      \"audio/ac3\": {\n        source: \"iana\"\n      },\n      \"audio/adpcm\": {\n        source: \"apache\",\n        extensions: [\"adp\"]\n      },\n      \"audio/amr\": {\n        source: \"iana\",\n        extensions: [\"amr\"]\n      },\n      \"audio/amr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/amr-wb+\": {\n        source: \"iana\"\n      },\n      \"audio/aptx\": {\n        source: \"iana\"\n      },\n      \"audio/asc\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-advanced-lossless\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-x\": {\n        source: \"iana\"\n      },\n      \"audio/atrac3\": {\n        source: \"iana\"\n      },\n      \"audio/basic\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"au\", \"snd\"]\n      },\n      \"audio/bv16\": {\n        source: \"iana\"\n      },\n      \"audio/bv32\": {\n        source: \"iana\"\n      },\n      \"audio/clearmode\": {\n        source: \"iana\"\n      },\n      \"audio/cn\": {\n        source: \"iana\"\n      },\n      \"audio/dat12\": {\n        source: \"iana\"\n      },\n      \"audio/dls\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es201108\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202050\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202211\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202212\": {\n        source: \"iana\"\n      },\n      \"audio/dv\": {\n        source: \"iana\"\n      },\n      \"audio/dvi4\": {\n        source: \"iana\"\n      },\n      \"audio/eac3\": {\n        source: \"iana\"\n      },\n      \"audio/encaprtp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc\": {\n        source: \"iana\"\n      },\n      \"audio/evrc-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc0\": {\n        source: \"iana\"\n      },\n      \"audio/evrc1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb1\": {\n        source: \"iana\"\n      },\n      \"audio/evs\": {\n        source: \"iana\"\n      },\n      \"audio/flac\": {\n        source: \"iana\"\n      },\n      \"audio/flexfec\": {\n        source: \"iana\"\n      },\n      \"audio/fwdred\": {\n        source: \"iana\"\n      },\n      \"audio/g711-0\": {\n        source: \"iana\"\n      },\n      \"audio/g719\": {\n        source: \"iana\"\n      },\n      \"audio/g722\": {\n        source: \"iana\"\n      },\n      \"audio/g7221\": {\n        source: \"iana\"\n      },\n      \"audio/g723\": {\n        source: \"iana\"\n      },\n      \"audio/g726-16\": {\n        source: \"iana\"\n      },\n      \"audio/g726-24\": {\n        source: \"iana\"\n      },\n      \"audio/g726-32\": {\n        source: \"iana\"\n      },\n      \"audio/g726-40\": {\n        source: \"iana\"\n      },\n      \"audio/g728\": {\n        source: \"iana\"\n      },\n      \"audio/g729\": {\n        source: \"iana\"\n      },\n      \"audio/g7291\": {\n        source: \"iana\"\n      },\n      \"audio/g729d\": {\n        source: \"iana\"\n      },\n      \"audio/g729e\": {\n        source: \"iana\"\n      },\n      \"audio/gsm\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-efr\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-hr-08\": {\n        source: \"iana\"\n      },\n      \"audio/ilbc\": {\n        source: \"iana\"\n      },\n      \"audio/ip-mr_v2.5\": {\n        source: \"iana\"\n      },\n      \"audio/isac\": {\n        source: \"apache\"\n      },\n      \"audio/l16\": {\n        source: \"iana\"\n      },\n      \"audio/l20\": {\n        source: \"iana\"\n      },\n      \"audio/l24\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/l8\": {\n        source: \"iana\"\n      },\n      \"audio/lpc\": {\n        source: \"iana\"\n      },\n      \"audio/matroska\": {\n        source: \"iana\"\n      },\n      \"audio/melp\": {\n        source: \"iana\"\n      },\n      \"audio/melp1200\": {\n        source: \"iana\"\n      },\n      \"audio/melp2400\": {\n        source: \"iana\"\n      },\n      \"audio/melp600\": {\n        source: \"iana\"\n      },\n      \"audio/mhas\": {\n        source: \"iana\"\n      },\n      \"audio/midi\": {\n        source: \"apache\",\n        extensions: [\"mid\", \"midi\", \"kar\", \"rmi\"]\n      },\n      \"audio/midi-clip\": {\n        source: \"iana\"\n      },\n      \"audio/mobile-xmf\": {\n        source: \"iana\",\n        extensions: [\"mxmf\"]\n      },\n      \"audio/mp3\": {\n        compressible: false,\n        extensions: [\"mp3\"]\n      },\n      \"audio/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"m4a\", \"mp4a\", \"m4b\"]\n      },\n      \"audio/mp4a-latm\": {\n        source: \"iana\"\n      },\n      \"audio/mpa\": {\n        source: \"iana\"\n      },\n      \"audio/mpa-robust\": {\n        source: \"iana\"\n      },\n      \"audio/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpga\", \"mp2\", \"mp2a\", \"mp3\", \"m2a\", \"m3a\"]\n      },\n      \"audio/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"audio/musepack\": {\n        source: \"apache\"\n      },\n      \"audio/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"oga\", \"ogg\", \"spx\", \"opus\"]\n      },\n      \"audio/opus\": {\n        source: \"iana\"\n      },\n      \"audio/parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/pcma\": {\n        source: \"iana\"\n      },\n      \"audio/pcma-wb\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu-wb\": {\n        source: \"iana\"\n      },\n      \"audio/prs.sid\": {\n        source: \"iana\"\n      },\n      \"audio/qcelp\": {\n        source: \"iana\"\n      },\n      \"audio/raptorfec\": {\n        source: \"iana\"\n      },\n      \"audio/red\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/rtploopback\": {\n        source: \"iana\"\n      },\n      \"audio/rtx\": {\n        source: \"iana\"\n      },\n      \"audio/s3m\": {\n        source: \"apache\",\n        extensions: [\"s3m\"]\n      },\n      \"audio/scip\": {\n        source: \"iana\"\n      },\n      \"audio/silk\": {\n        source: \"apache\",\n        extensions: [\"sil\"]\n      },\n      \"audio/smv\": {\n        source: \"iana\"\n      },\n      \"audio/smv-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/smv0\": {\n        source: \"iana\"\n      },\n      \"audio/sofa\": {\n        source: \"iana\"\n      },\n      \"audio/sp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/speex\": {\n        source: \"iana\"\n      },\n      \"audio/t140c\": {\n        source: \"iana\"\n      },\n      \"audio/t38\": {\n        source: \"iana\"\n      },\n      \"audio/telephone-event\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp_bb\": {\n        source: \"iana\"\n      },\n      \"audio/tone\": {\n        source: \"iana\"\n      },\n      \"audio/tsvcis\": {\n        source: \"iana\"\n      },\n      \"audio/uemclip\": {\n        source: \"iana\"\n      },\n      \"audio/ulpfec\": {\n        source: \"iana\"\n      },\n      \"audio/usac\": {\n        source: \"iana\"\n      },\n      \"audio/vdvi\": {\n        source: \"iana\"\n      },\n      \"audio/vmr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.3gpp.iufp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.4sb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.audiokoz\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.celp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cisco.nse\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cmles.radio-events\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.anp1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.inf1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dece.audio\": {\n        source: \"iana\",\n        extensions: [\"uva\", \"uvva\"]\n      },\n      \"audio/vnd.digital-winds\": {\n        source: \"iana\",\n        extensions: [\"eol\"]\n      },\n      \"audio/vnd.dlna.adts\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mlp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mps\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2x\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2z\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pulse.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dra\": {\n        source: \"iana\",\n        extensions: [\"dra\"]\n      },\n      \"audio/vnd.dts\": {\n        source: \"iana\",\n        extensions: [\"dts\"]\n      },\n      \"audio/vnd.dts.hd\": {\n        source: \"iana\",\n        extensions: [\"dtshd\"]\n      },\n      \"audio/vnd.dts.uhd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dvb.file\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.everad.plj\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.hns.audio\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.lucent.voice\": {\n        source: \"iana\",\n        extensions: [\"lvp\"]\n      },\n      \"audio/vnd.ms-playready.media.pya\": {\n        source: \"iana\",\n        extensions: [\"pya\"]\n      },\n      \"audio/vnd.nokia.mobile-xmf\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nortel.vbk\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nuera.ecelp4800\": {\n        source: \"iana\",\n        extensions: [\"ecelp4800\"]\n      },\n      \"audio/vnd.nuera.ecelp7470\": {\n        source: \"iana\",\n        extensions: [\"ecelp7470\"]\n      },\n      \"audio/vnd.nuera.ecelp9600\": {\n        source: \"iana\",\n        extensions: [\"ecelp9600\"]\n      },\n      \"audio/vnd.octel.sbc\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.presonus.multitrack\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.qcelp\": {\n        source: \"apache\"\n      },\n      \"audio/vnd.rhetorex.32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.rip\": {\n        source: \"iana\",\n        extensions: [\"rip\"]\n      },\n      \"audio/vnd.rn-realaudio\": {\n        compressible: false\n      },\n      \"audio/vnd.sealedmedia.softseal.mpeg\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.vmx.cvsd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.wave\": {\n        compressible: false\n      },\n      \"audio/vorbis\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/vorbis-config\": {\n        source: \"iana\"\n      },\n      \"audio/wav\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/wave\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"weba\"]\n      },\n      \"audio/x-aac\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"aac\"]\n      },\n      \"audio/x-aiff\": {\n        source: \"apache\",\n        extensions: [\"aif\", \"aiff\", \"aifc\"]\n      },\n      \"audio/x-caf\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"caf\"]\n      },\n      \"audio/x-flac\": {\n        source: \"apache\",\n        extensions: [\"flac\"]\n      },\n      \"audio/x-m4a\": {\n        source: \"nginx\",\n        extensions: [\"m4a\"]\n      },\n      \"audio/x-matroska\": {\n        source: \"apache\",\n        extensions: [\"mka\"]\n      },\n      \"audio/x-mpegurl\": {\n        source: \"apache\",\n        extensions: [\"m3u\"]\n      },\n      \"audio/x-ms-wax\": {\n        source: \"apache\",\n        extensions: [\"wax\"]\n      },\n      \"audio/x-ms-wma\": {\n        source: \"apache\",\n        extensions: [\"wma\"]\n      },\n      \"audio/x-pn-realaudio\": {\n        source: \"apache\",\n        extensions: [\"ram\", \"ra\"]\n      },\n      \"audio/x-pn-realaudio-plugin\": {\n        source: \"apache\",\n        extensions: [\"rmp\"]\n      },\n      \"audio/x-realaudio\": {\n        source: \"nginx\",\n        extensions: [\"ra\"]\n      },\n      \"audio/x-tta\": {\n        source: \"apache\"\n      },\n      \"audio/x-wav\": {\n        source: \"apache\",\n        extensions: [\"wav\"]\n      },\n      \"audio/xm\": {\n        source: \"apache\",\n        extensions: [\"xm\"]\n      },\n      \"chemical/x-cdx\": {\n        source: \"apache\",\n        extensions: [\"cdx\"]\n      },\n      \"chemical/x-cif\": {\n        source: \"apache\",\n        extensions: [\"cif\"]\n      },\n      \"chemical/x-cmdf\": {\n        source: \"apache\",\n        extensions: [\"cmdf\"]\n      },\n      \"chemical/x-cml\": {\n        source: \"apache\",\n        extensions: [\"cml\"]\n      },\n      \"chemical/x-csml\": {\n        source: \"apache\",\n        extensions: [\"csml\"]\n      },\n      \"chemical/x-pdb\": {\n        source: \"apache\"\n      },\n      \"chemical/x-xyz\": {\n        source: \"apache\",\n        extensions: [\"xyz\"]\n      },\n      \"font/collection\": {\n        source: \"iana\",\n        extensions: [\"ttc\"]\n      },\n      \"font/otf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"otf\"]\n      },\n      \"font/sfnt\": {\n        source: \"iana\"\n      },\n      \"font/ttf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttf\"]\n      },\n      \"font/woff\": {\n        source: \"iana\",\n        extensions: [\"woff\"]\n      },\n      \"font/woff2\": {\n        source: \"iana\",\n        extensions: [\"woff2\"]\n      },\n      \"image/aces\": {\n        source: \"iana\",\n        extensions: [\"exr\"]\n      },\n      \"image/apng\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"apng\"]\n      },\n      \"image/avci\": {\n        source: \"iana\",\n        extensions: [\"avci\"]\n      },\n      \"image/avcs\": {\n        source: \"iana\",\n        extensions: [\"avcs\"]\n      },\n      \"image/avif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"avif\"]\n      },\n      \"image/bmp\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmp\", \"dib\"]\n      },\n      \"image/cgm\": {\n        source: \"iana\",\n        extensions: [\"cgm\"]\n      },\n      \"image/dicom-rle\": {\n        source: \"iana\",\n        extensions: [\"drle\"]\n      },\n      \"image/dpx\": {\n        source: \"iana\",\n        extensions: [\"dpx\"]\n      },\n      \"image/emf\": {\n        source: \"iana\",\n        extensions: [\"emf\"]\n      },\n      \"image/fits\": {\n        source: \"iana\",\n        extensions: [\"fits\"]\n      },\n      \"image/g3fax\": {\n        source: \"iana\",\n        extensions: [\"g3\"]\n      },\n      \"image/gif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gif\"]\n      },\n      \"image/heic\": {\n        source: \"iana\",\n        extensions: [\"heic\"]\n      },\n      \"image/heic-sequence\": {\n        source: \"iana\",\n        extensions: [\"heics\"]\n      },\n      \"image/heif\": {\n        source: \"iana\",\n        extensions: [\"heif\"]\n      },\n      \"image/heif-sequence\": {\n        source: \"iana\",\n        extensions: [\"heifs\"]\n      },\n      \"image/hej2k\": {\n        source: \"iana\",\n        extensions: [\"hej2\"]\n      },\n      \"image/ief\": {\n        source: \"iana\",\n        extensions: [\"ief\"]\n      },\n      \"image/j2c\": {\n        source: \"iana\"\n      },\n      \"image/jaii\": {\n        source: \"iana\",\n        extensions: [\"jaii\"]\n      },\n      \"image/jais\": {\n        source: \"iana\",\n        extensions: [\"jais\"]\n      },\n      \"image/jls\": {\n        source: \"iana\",\n        extensions: [\"jls\"]\n      },\n      \"image/jp2\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jp2\", \"jpg2\"]\n      },\n      \"image/jpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpg\", \"jpeg\", \"jpe\"]\n      },\n      \"image/jph\": {\n        source: \"iana\",\n        extensions: [\"jph\"]\n      },\n      \"image/jphc\": {\n        source: \"iana\",\n        extensions: [\"jhc\"]\n      },\n      \"image/jpm\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"image/jpx\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpx\", \"jpf\"]\n      },\n      \"image/jxl\": {\n        source: \"iana\",\n        extensions: [\"jxl\"]\n      },\n      \"image/jxr\": {\n        source: \"iana\",\n        extensions: [\"jxr\"]\n      },\n      \"image/jxra\": {\n        source: \"iana\",\n        extensions: [\"jxra\"]\n      },\n      \"image/jxrs\": {\n        source: \"iana\",\n        extensions: [\"jxrs\"]\n      },\n      \"image/jxs\": {\n        source: \"iana\",\n        extensions: [\"jxs\"]\n      },\n      \"image/jxsc\": {\n        source: \"iana\",\n        extensions: [\"jxsc\"]\n      },\n      \"image/jxsi\": {\n        source: \"iana\",\n        extensions: [\"jxsi\"]\n      },\n      \"image/jxss\": {\n        source: \"iana\",\n        extensions: [\"jxss\"]\n      },\n      \"image/ktx\": {\n        source: \"iana\",\n        extensions: [\"ktx\"]\n      },\n      \"image/ktx2\": {\n        source: \"iana\",\n        extensions: [\"ktx2\"]\n      },\n      \"image/naplps\": {\n        source: \"iana\"\n      },\n      \"image/pjpeg\": {\n        compressible: false,\n        extensions: [\"jfif\"]\n      },\n      \"image/png\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"png\"]\n      },\n      \"image/prs.btif\": {\n        source: \"iana\",\n        extensions: [\"btif\", \"btf\"]\n      },\n      \"image/prs.pti\": {\n        source: \"iana\",\n        extensions: [\"pti\"]\n      },\n      \"image/pwg-raster\": {\n        source: \"iana\"\n      },\n      \"image/sgi\": {\n        source: \"apache\",\n        extensions: [\"sgi\"]\n      },\n      \"image/svg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"svg\", \"svgz\"]\n      },\n      \"image/t38\": {\n        source: \"iana\",\n        extensions: [\"t38\"]\n      },\n      \"image/tiff\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"tif\", \"tiff\"]\n      },\n      \"image/tiff-fx\": {\n        source: \"iana\",\n        extensions: [\"tfx\"]\n      },\n      \"image/vnd.adobe.photoshop\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"psd\"]\n      },\n      \"image/vnd.airzip.accelerator.azv\": {\n        source: \"iana\",\n        extensions: [\"azv\"]\n      },\n      \"image/vnd.clip\": {\n        source: \"iana\"\n      },\n      \"image/vnd.cns.inf2\": {\n        source: \"iana\"\n      },\n      \"image/vnd.dece.graphic\": {\n        source: \"iana\",\n        extensions: [\"uvi\", \"uvvi\", \"uvg\", \"uvvg\"]\n      },\n      \"image/vnd.djvu\": {\n        source: \"iana\",\n        extensions: [\"djvu\", \"djv\"]\n      },\n      \"image/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"image/vnd.dwg\": {\n        source: \"iana\",\n        extensions: [\"dwg\"]\n      },\n      \"image/vnd.dxf\": {\n        source: \"iana\",\n        extensions: [\"dxf\"]\n      },\n      \"image/vnd.fastbidsheet\": {\n        source: \"iana\",\n        extensions: [\"fbs\"]\n      },\n      \"image/vnd.fpx\": {\n        source: \"iana\",\n        extensions: [\"fpx\"]\n      },\n      \"image/vnd.fst\": {\n        source: \"iana\",\n        extensions: [\"fst\"]\n      },\n      \"image/vnd.fujixerox.edmics-mmr\": {\n        source: \"iana\",\n        extensions: [\"mmr\"]\n      },\n      \"image/vnd.fujixerox.edmics-rlc\": {\n        source: \"iana\",\n        extensions: [\"rlc\"]\n      },\n      \"image/vnd.globalgraphics.pgb\": {\n        source: \"iana\"\n      },\n      \"image/vnd.microsoft.icon\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/vnd.mix\": {\n        source: \"iana\"\n      },\n      \"image/vnd.mozilla.apng\": {\n        source: \"iana\"\n      },\n      \"image/vnd.ms-dds\": {\n        compressible: true,\n        extensions: [\"dds\"]\n      },\n      \"image/vnd.ms-modi\": {\n        source: \"iana\",\n        extensions: [\"mdi\"]\n      },\n      \"image/vnd.ms-photo\": {\n        source: \"apache\",\n        extensions: [\"wdp\"]\n      },\n      \"image/vnd.net-fpx\": {\n        source: \"iana\",\n        extensions: [\"npx\"]\n      },\n      \"image/vnd.pco.b16\": {\n        source: \"iana\",\n        extensions: [\"b16\"]\n      },\n      \"image/vnd.radiance\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealed.png\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.gif\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.jpg\": {\n        source: \"iana\"\n      },\n      \"image/vnd.svf\": {\n        source: \"iana\"\n      },\n      \"image/vnd.tencent.tap\": {\n        source: \"iana\",\n        extensions: [\"tap\"]\n      },\n      \"image/vnd.valve.source.texture\": {\n        source: \"iana\",\n        extensions: [\"vtf\"]\n      },\n      \"image/vnd.wap.wbmp\": {\n        source: \"iana\",\n        extensions: [\"wbmp\"]\n      },\n      \"image/vnd.xiff\": {\n        source: \"iana\",\n        extensions: [\"xif\"]\n      },\n      \"image/vnd.zbrush.pcx\": {\n        source: \"iana\",\n        extensions: [\"pcx\"]\n      },\n      \"image/webp\": {\n        source: \"iana\",\n        extensions: [\"webp\"]\n      },\n      \"image/wmf\": {\n        source: \"iana\",\n        extensions: [\"wmf\"]\n      },\n      \"image/x-3ds\": {\n        source: \"apache\",\n        extensions: [\"3ds\"]\n      },\n      \"image/x-adobe-dng\": {\n        extensions: [\"dng\"]\n      },\n      \"image/x-cmu-raster\": {\n        source: \"apache\",\n        extensions: [\"ras\"]\n      },\n      \"image/x-cmx\": {\n        source: \"apache\",\n        extensions: [\"cmx\"]\n      },\n      \"image/x-emf\": {\n        source: \"iana\"\n      },\n      \"image/x-freehand\": {\n        source: \"apache\",\n        extensions: [\"fh\", \"fhc\", \"fh4\", \"fh5\", \"fh7\"]\n      },\n      \"image/x-icon\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/x-jng\": {\n        source: \"nginx\",\n        extensions: [\"jng\"]\n      },\n      \"image/x-mrsid-image\": {\n        source: \"apache\",\n        extensions: [\"sid\"]\n      },\n      \"image/x-ms-bmp\": {\n        source: \"nginx\",\n        compressible: true,\n        extensions: [\"bmp\"]\n      },\n      \"image/x-pcx\": {\n        source: \"apache\",\n        extensions: [\"pcx\"]\n      },\n      \"image/x-pict\": {\n        source: \"apache\",\n        extensions: [\"pic\", \"pct\"]\n      },\n      \"image/x-portable-anymap\": {\n        source: \"apache\",\n        extensions: [\"pnm\"]\n      },\n      \"image/x-portable-bitmap\": {\n        source: \"apache\",\n        extensions: [\"pbm\"]\n      },\n      \"image/x-portable-graymap\": {\n        source: \"apache\",\n        extensions: [\"pgm\"]\n      },\n      \"image/x-portable-pixmap\": {\n        source: \"apache\",\n        extensions: [\"ppm\"]\n      },\n      \"image/x-rgb\": {\n        source: \"apache\",\n        extensions: [\"rgb\"]\n      },\n      \"image/x-tga\": {\n        source: \"apache\",\n        extensions: [\"tga\"]\n      },\n      \"image/x-wmf\": {\n        source: \"iana\"\n      },\n      \"image/x-xbitmap\": {\n        source: \"apache\",\n        extensions: [\"xbm\"]\n      },\n      \"image/x-xcf\": {\n        compressible: false\n      },\n      \"image/x-xpixmap\": {\n        source: \"apache\",\n        extensions: [\"xpm\"]\n      },\n      \"image/x-xwindowdump\": {\n        source: \"apache\",\n        extensions: [\"xwd\"]\n      },\n      \"message/bhttp\": {\n        source: \"iana\"\n      },\n      \"message/cpim\": {\n        source: \"iana\"\n      },\n      \"message/delivery-status\": {\n        source: \"iana\"\n      },\n      \"message/disposition-notification\": {\n        source: \"iana\",\n        extensions: [\n          \"disposition-notification\"\n        ]\n      },\n      \"message/external-body\": {\n        source: \"iana\"\n      },\n      \"message/feedback-report\": {\n        source: \"iana\"\n      },\n      \"message/global\": {\n        source: \"iana\",\n        extensions: [\"u8msg\"]\n      },\n      \"message/global-delivery-status\": {\n        source: \"iana\",\n        extensions: [\"u8dsn\"]\n      },\n      \"message/global-disposition-notification\": {\n        source: \"iana\",\n        extensions: [\"u8mdn\"]\n      },\n      \"message/global-headers\": {\n        source: \"iana\",\n        extensions: [\"u8hdr\"]\n      },\n      \"message/http\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/imdn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"message/mls\": {\n        source: \"iana\"\n      },\n      \"message/news\": {\n        source: \"apache\"\n      },\n      \"message/ohttp-req\": {\n        source: \"iana\"\n      },\n      \"message/ohttp-res\": {\n        source: \"iana\"\n      },\n      \"message/partial\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/rfc822\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eml\", \"mime\", \"mht\", \"mhtml\"]\n      },\n      \"message/s-http\": {\n        source: \"apache\"\n      },\n      \"message/sip\": {\n        source: \"iana\"\n      },\n      \"message/sipfrag\": {\n        source: \"iana\"\n      },\n      \"message/tracking-status\": {\n        source: \"iana\"\n      },\n      \"message/vnd.si.simp\": {\n        source: \"apache\"\n      },\n      \"message/vnd.wfa.wsc\": {\n        source: \"iana\",\n        extensions: [\"wsc\"]\n      },\n      \"model/3mf\": {\n        source: \"iana\",\n        extensions: [\"3mf\"]\n      },\n      \"model/e57\": {\n        source: \"iana\"\n      },\n      \"model/gltf+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gltf\"]\n      },\n      \"model/gltf-binary\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"glb\"]\n      },\n      \"model/iges\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"igs\", \"iges\"]\n      },\n      \"model/jt\": {\n        source: \"iana\",\n        extensions: [\"jt\"]\n      },\n      \"model/mesh\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"msh\", \"mesh\", \"silo\"]\n      },\n      \"model/mtl\": {\n        source: \"iana\",\n        extensions: [\"mtl\"]\n      },\n      \"model/obj\": {\n        source: \"iana\",\n        extensions: [\"obj\"]\n      },\n      \"model/prc\": {\n        source: \"iana\",\n        extensions: [\"prc\"]\n      },\n      \"model/step\": {\n        source: \"iana\",\n        extensions: [\"step\", \"stp\", \"stpnc\", \"p21\", \"210\"]\n      },\n      \"model/step+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"stpx\"]\n      },\n      \"model/step+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpz\"]\n      },\n      \"model/step-xml+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpxz\"]\n      },\n      \"model/stl\": {\n        source: \"iana\",\n        extensions: [\"stl\"]\n      },\n      \"model/u3d\": {\n        source: \"iana\",\n        extensions: [\"u3d\"]\n      },\n      \"model/vnd.bary\": {\n        source: \"iana\",\n        extensions: [\"bary\"]\n      },\n      \"model/vnd.cld\": {\n        source: \"iana\",\n        extensions: [\"cld\"]\n      },\n      \"model/vnd.collada+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dae\"]\n      },\n      \"model/vnd.dwf\": {\n        source: \"iana\",\n        extensions: [\"dwf\"]\n      },\n      \"model/vnd.flatland.3dml\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gdl\": {\n        source: \"iana\",\n        extensions: [\"gdl\"]\n      },\n      \"model/vnd.gs-gdl\": {\n        source: \"apache\"\n      },\n      \"model/vnd.gs.gdl\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gtw\": {\n        source: \"iana\",\n        extensions: [\"gtw\"]\n      },\n      \"model/vnd.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"model/vnd.mts\": {\n        source: \"iana\",\n        extensions: [\"mts\"]\n      },\n      \"model/vnd.opengex\": {\n        source: \"iana\",\n        extensions: [\"ogex\"]\n      },\n      \"model/vnd.parasolid.transmit.binary\": {\n        source: \"iana\",\n        extensions: [\"x_b\"]\n      },\n      \"model/vnd.parasolid.transmit.text\": {\n        source: \"iana\",\n        extensions: [\"x_t\"]\n      },\n      \"model/vnd.pytha.pyox\": {\n        source: \"iana\",\n        extensions: [\"pyo\", \"pyox\"]\n      },\n      \"model/vnd.rosette.annotated-data-model\": {\n        source: \"iana\"\n      },\n      \"model/vnd.sap.vds\": {\n        source: \"iana\",\n        extensions: [\"vds\"]\n      },\n      \"model/vnd.usda\": {\n        source: \"iana\",\n        extensions: [\"usda\"]\n      },\n      \"model/vnd.usdz+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"usdz\"]\n      },\n      \"model/vnd.valve.source.compiled-map\": {\n        source: \"iana\",\n        extensions: [\"bsp\"]\n      },\n      \"model/vnd.vtu\": {\n        source: \"iana\",\n        extensions: [\"vtu\"]\n      },\n      \"model/vrml\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"wrl\", \"vrml\"]\n      },\n      \"model/x3d+binary\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3db\", \"x3dbz\"]\n      },\n      \"model/x3d+fastinfoset\": {\n        source: \"iana\",\n        extensions: [\"x3db\"]\n      },\n      \"model/x3d+vrml\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3dv\", \"x3dvz\"]\n      },\n      \"model/x3d+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"x3d\", \"x3dz\"]\n      },\n      \"model/x3d-vrml\": {\n        source: \"iana\",\n        extensions: [\"x3dv\"]\n      },\n      \"multipart/alternative\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/appledouble\": {\n        source: \"iana\"\n      },\n      \"multipart/byteranges\": {\n        source: \"iana\"\n      },\n      \"multipart/digest\": {\n        source: \"iana\"\n      },\n      \"multipart/encrypted\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/form-data\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/header-set\": {\n        source: \"iana\"\n      },\n      \"multipart/mixed\": {\n        source: \"iana\"\n      },\n      \"multipart/multilingual\": {\n        source: \"iana\"\n      },\n      \"multipart/parallel\": {\n        source: \"iana\"\n      },\n      \"multipart/related\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/report\": {\n        source: \"iana\"\n      },\n      \"multipart/signed\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/vnd.bint.med-plus\": {\n        source: \"iana\"\n      },\n      \"multipart/voice-message\": {\n        source: \"iana\"\n      },\n      \"multipart/x-mixed-replace\": {\n        source: \"iana\"\n      },\n      \"text/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"text/cache-manifest\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"appcache\", \"manifest\"]\n      },\n      \"text/calendar\": {\n        source: \"iana\",\n        extensions: [\"ics\", \"ifb\"]\n      },\n      \"text/calender\": {\n        compressible: true\n      },\n      \"text/cmd\": {\n        compressible: true\n      },\n      \"text/coffeescript\": {\n        extensions: [\"coffee\", \"litcoffee\"]\n      },\n      \"text/cql\": {\n        source: \"iana\"\n      },\n      \"text/cql-expression\": {\n        source: \"iana\"\n      },\n      \"text/cql-identifier\": {\n        source: \"iana\"\n      },\n      \"text/css\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"css\"]\n      },\n      \"text/csv\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csv\"]\n      },\n      \"text/csv-schema\": {\n        source: \"iana\"\n      },\n      \"text/directory\": {\n        source: \"iana\"\n      },\n      \"text/dns\": {\n        source: \"iana\"\n      },\n      \"text/ecmascript\": {\n        source: \"apache\"\n      },\n      \"text/encaprtp\": {\n        source: \"iana\"\n      },\n      \"text/enriched\": {\n        source: \"iana\"\n      },\n      \"text/fhirpath\": {\n        source: \"iana\"\n      },\n      \"text/flexfec\": {\n        source: \"iana\"\n      },\n      \"text/fwdred\": {\n        source: \"iana\"\n      },\n      \"text/gff3\": {\n        source: \"iana\"\n      },\n      \"text/grammar-ref-list\": {\n        source: \"iana\"\n      },\n      \"text/hl7v2\": {\n        source: \"iana\"\n      },\n      \"text/html\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"html\", \"htm\", \"shtml\"]\n      },\n      \"text/jade\": {\n        extensions: [\"jade\"]\n      },\n      \"text/javascript\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\", \"mjs\"]\n      },\n      \"text/jcr-cnd\": {\n        source: \"iana\"\n      },\n      \"text/jsx\": {\n        compressible: true,\n        extensions: [\"jsx\"]\n      },\n      \"text/less\": {\n        compressible: true,\n        extensions: [\"less\"]\n      },\n      \"text/markdown\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"md\", \"markdown\"]\n      },\n      \"text/mathml\": {\n        source: \"nginx\",\n        extensions: [\"mml\"]\n      },\n      \"text/mdx\": {\n        compressible: true,\n        extensions: [\"mdx\"]\n      },\n      \"text/mizar\": {\n        source: \"iana\"\n      },\n      \"text/n3\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"n3\"]\n      },\n      \"text/parameters\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/parityfec\": {\n        source: \"iana\"\n      },\n      \"text/plain\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"txt\", \"text\", \"conf\", \"def\", \"list\", \"log\", \"in\", \"ini\"]\n      },\n      \"text/provenance-notation\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/prs.fallenstein.rst\": {\n        source: \"iana\"\n      },\n      \"text/prs.lines.tag\": {\n        source: \"iana\",\n        extensions: [\"dsc\"]\n      },\n      \"text/prs.prop.logic\": {\n        source: \"iana\"\n      },\n      \"text/prs.texi\": {\n        source: \"iana\"\n      },\n      \"text/raptorfec\": {\n        source: \"iana\"\n      },\n      \"text/red\": {\n        source: \"iana\"\n      },\n      \"text/rfc822-headers\": {\n        source: \"iana\"\n      },\n      \"text/richtext\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtx\"]\n      },\n      \"text/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"text/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"text/rtploopback\": {\n        source: \"iana\"\n      },\n      \"text/rtx\": {\n        source: \"iana\"\n      },\n      \"text/sgml\": {\n        source: \"iana\",\n        extensions: [\"sgml\", \"sgm\"]\n      },\n      \"text/shaclc\": {\n        source: \"iana\"\n      },\n      \"text/shex\": {\n        source: \"iana\",\n        extensions: [\"shex\"]\n      },\n      \"text/slim\": {\n        extensions: [\"slim\", \"slm\"]\n      },\n      \"text/spdx\": {\n        source: \"iana\",\n        extensions: [\"spdx\"]\n      },\n      \"text/strings\": {\n        source: \"iana\"\n      },\n      \"text/stylus\": {\n        extensions: [\"stylus\", \"styl\"]\n      },\n      \"text/t140\": {\n        source: \"iana\"\n      },\n      \"text/tab-separated-values\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tsv\"]\n      },\n      \"text/troff\": {\n        source: \"iana\",\n        extensions: [\"t\", \"tr\", \"roff\", \"man\", \"me\", \"ms\"]\n      },\n      \"text/turtle\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"ttl\"]\n      },\n      \"text/ulpfec\": {\n        source: \"iana\"\n      },\n      \"text/uri-list\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uri\", \"uris\", \"urls\"]\n      },\n      \"text/vcard\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vcard\"]\n      },\n      \"text/vnd.a\": {\n        source: \"iana\"\n      },\n      \"text/vnd.abc\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ascii-art\": {\n        source: \"iana\"\n      },\n      \"text/vnd.curl\": {\n        source: \"iana\",\n        extensions: [\"curl\"]\n      },\n      \"text/vnd.curl.dcurl\": {\n        source: \"apache\",\n        extensions: [\"dcurl\"]\n      },\n      \"text/vnd.curl.mcurl\": {\n        source: \"apache\",\n        extensions: [\"mcurl\"]\n      },\n      \"text/vnd.curl.scurl\": {\n        source: \"apache\",\n        extensions: [\"scurl\"]\n      },\n      \"text/vnd.debian.copyright\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.dmclientscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"text/vnd.esmertec.theme-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.exchangeable\": {\n        source: \"iana\"\n      },\n      \"text/vnd.familysearch.gedcom\": {\n        source: \"iana\",\n        extensions: [\"ged\"]\n      },\n      \"text/vnd.ficlab.flt\": {\n        source: \"iana\"\n      },\n      \"text/vnd.fly\": {\n        source: \"iana\",\n        extensions: [\"fly\"]\n      },\n      \"text/vnd.fmi.flexstor\": {\n        source: \"iana\",\n        extensions: [\"flx\"]\n      },\n      \"text/vnd.gml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.graphviz\": {\n        source: \"iana\",\n        extensions: [\"gv\"]\n      },\n      \"text/vnd.hans\": {\n        source: \"iana\"\n      },\n      \"text/vnd.hgl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.in3d.3dml\": {\n        source: \"iana\",\n        extensions: [\"3dml\"]\n      },\n      \"text/vnd.in3d.spot\": {\n        source: \"iana\",\n        extensions: [\"spot\"]\n      },\n      \"text/vnd.iptc.newsml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.iptc.nitf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.latex-z\": {\n        source: \"iana\"\n      },\n      \"text/vnd.motorola.reflex\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ms-mediapackage\": {\n        source: \"iana\"\n      },\n      \"text/vnd.net2phone.commcenter.command\": {\n        source: \"iana\"\n      },\n      \"text/vnd.radisys.msml-basic-layout\": {\n        source: \"iana\"\n      },\n      \"text/vnd.senx.warpscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.si.uricatalogue\": {\n        source: \"apache\"\n      },\n      \"text/vnd.sosi\": {\n        source: \"iana\"\n      },\n      \"text/vnd.sun.j2me.app-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"jad\"]\n      },\n      \"text/vnd.trolltech.linguist\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.vcf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.si\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.sl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.wml\": {\n        source: \"iana\",\n        extensions: [\"wml\"]\n      },\n      \"text/vnd.wap.wmlscript\": {\n        source: \"iana\",\n        extensions: [\"wmls\"]\n      },\n      \"text/vnd.zoo.kcl\": {\n        source: \"iana\"\n      },\n      \"text/vtt\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"vtt\"]\n      },\n      \"text/wgsl\": {\n        source: \"iana\",\n        extensions: [\"wgsl\"]\n      },\n      \"text/x-asm\": {\n        source: \"apache\",\n        extensions: [\"s\", \"asm\"]\n      },\n      \"text/x-c\": {\n        source: \"apache\",\n        extensions: [\"c\", \"cc\", \"cxx\", \"cpp\", \"h\", \"hh\", \"dic\"]\n      },\n      \"text/x-component\": {\n        source: \"nginx\",\n        extensions: [\"htc\"]\n      },\n      \"text/x-fortran\": {\n        source: \"apache\",\n        extensions: [\"f\", \"for\", \"f77\", \"f90\"]\n      },\n      \"text/x-gwt-rpc\": {\n        compressible: true\n      },\n      \"text/x-handlebars-template\": {\n        extensions: [\"hbs\"]\n      },\n      \"text/x-java-source\": {\n        source: \"apache\",\n        extensions: [\"java\"]\n      },\n      \"text/x-jquery-tmpl\": {\n        compressible: true\n      },\n      \"text/x-lua\": {\n        extensions: [\"lua\"]\n      },\n      \"text/x-markdown\": {\n        compressible: true,\n        extensions: [\"mkd\"]\n      },\n      \"text/x-nfo\": {\n        source: \"apache\",\n        extensions: [\"nfo\"]\n      },\n      \"text/x-opml\": {\n        source: \"apache\",\n        extensions: [\"opml\"]\n      },\n      \"text/x-org\": {\n        compressible: true,\n        extensions: [\"org\"]\n      },\n      \"text/x-pascal\": {\n        source: \"apache\",\n        extensions: [\"p\", \"pas\"]\n      },\n      \"text/x-processing\": {\n        compressible: true,\n        extensions: [\"pde\"]\n      },\n      \"text/x-sass\": {\n        extensions: [\"sass\"]\n      },\n      \"text/x-scss\": {\n        extensions: [\"scss\"]\n      },\n      \"text/x-setext\": {\n        source: \"apache\",\n        extensions: [\"etx\"]\n      },\n      \"text/x-sfv\": {\n        source: \"apache\",\n        extensions: [\"sfv\"]\n      },\n      \"text/x-suse-ymp\": {\n        compressible: true,\n        extensions: [\"ymp\"]\n      },\n      \"text/x-uuencode\": {\n        source: \"apache\",\n        extensions: [\"uu\"]\n      },\n      \"text/x-vcalendar\": {\n        source: \"apache\",\n        extensions: [\"vcs\"]\n      },\n      \"text/x-vcard\": {\n        source: \"apache\",\n        extensions: [\"vcf\"]\n      },\n      \"text/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\"]\n      },\n      \"text/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"text/yaml\": {\n        compressible: true,\n        extensions: [\"yaml\", \"yml\"]\n      },\n      \"video/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"video/3gpp\": {\n        source: \"iana\",\n        extensions: [\"3gp\", \"3gpp\"]\n      },\n      \"video/3gpp-tt\": {\n        source: \"iana\"\n      },\n      \"video/3gpp2\": {\n        source: \"iana\",\n        extensions: [\"3g2\"]\n      },\n      \"video/av1\": {\n        source: \"iana\"\n      },\n      \"video/bmpeg\": {\n        source: \"iana\"\n      },\n      \"video/bt656\": {\n        source: \"iana\"\n      },\n      \"video/celb\": {\n        source: \"iana\"\n      },\n      \"video/dv\": {\n        source: \"iana\"\n      },\n      \"video/encaprtp\": {\n        source: \"iana\"\n      },\n      \"video/evc\": {\n        source: \"iana\"\n      },\n      \"video/ffv1\": {\n        source: \"iana\"\n      },\n      \"video/flexfec\": {\n        source: \"iana\"\n      },\n      \"video/h261\": {\n        source: \"iana\",\n        extensions: [\"h261\"]\n      },\n      \"video/h263\": {\n        source: \"iana\",\n        extensions: [\"h263\"]\n      },\n      \"video/h263-1998\": {\n        source: \"iana\"\n      },\n      \"video/h263-2000\": {\n        source: \"iana\"\n      },\n      \"video/h264\": {\n        source: \"iana\",\n        extensions: [\"h264\"]\n      },\n      \"video/h264-rcdo\": {\n        source: \"iana\"\n      },\n      \"video/h264-svc\": {\n        source: \"iana\"\n      },\n      \"video/h265\": {\n        source: \"iana\"\n      },\n      \"video/h266\": {\n        source: \"iana\"\n      },\n      \"video/iso.segment\": {\n        source: \"iana\",\n        extensions: [\"m4s\"]\n      },\n      \"video/jpeg\": {\n        source: \"iana\",\n        extensions: [\"jpgv\"]\n      },\n      \"video/jpeg2000\": {\n        source: \"iana\"\n      },\n      \"video/jpm\": {\n        source: \"apache\",\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"video/jxsv\": {\n        source: \"iana\"\n      },\n      \"video/lottie+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"video/matroska\": {\n        source: \"iana\"\n      },\n      \"video/matroska-3d\": {\n        source: \"iana\"\n      },\n      \"video/mj2\": {\n        source: \"iana\",\n        extensions: [\"mj2\", \"mjp2\"]\n      },\n      \"video/mp1s\": {\n        source: \"iana\"\n      },\n      \"video/mp2p\": {\n        source: \"iana\"\n      },\n      \"video/mp2t\": {\n        source: \"iana\",\n        extensions: [\"ts\", \"m2t\", \"m2ts\", \"mts\"]\n      },\n      \"video/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mp4\", \"mp4v\", \"mpg4\"]\n      },\n      \"video/mp4v-es\": {\n        source: \"iana\"\n      },\n      \"video/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpeg\", \"mpg\", \"mpe\", \"m1v\", \"m2v\"]\n      },\n      \"video/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"video/mpv\": {\n        source: \"iana\"\n      },\n      \"video/nv\": {\n        source: \"iana\"\n      },\n      \"video/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogv\"]\n      },\n      \"video/parityfec\": {\n        source: \"iana\"\n      },\n      \"video/pointer\": {\n        source: \"iana\"\n      },\n      \"video/quicktime\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"qt\", \"mov\"]\n      },\n      \"video/raptorfec\": {\n        source: \"iana\"\n      },\n      \"video/raw\": {\n        source: \"iana\"\n      },\n      \"video/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"video/rtploopback\": {\n        source: \"iana\"\n      },\n      \"video/rtx\": {\n        source: \"iana\"\n      },\n      \"video/scip\": {\n        source: \"iana\"\n      },\n      \"video/smpte291\": {\n        source: \"iana\"\n      },\n      \"video/smpte292m\": {\n        source: \"iana\"\n      },\n      \"video/ulpfec\": {\n        source: \"iana\"\n      },\n      \"video/vc1\": {\n        source: \"iana\"\n      },\n      \"video/vc2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.cctv\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.hd\": {\n        source: \"iana\",\n        extensions: [\"uvh\", \"uvvh\"]\n      },\n      \"video/vnd.dece.mobile\": {\n        source: \"iana\",\n        extensions: [\"uvm\", \"uvvm\"]\n      },\n      \"video/vnd.dece.mp4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.pd\": {\n        source: \"iana\",\n        extensions: [\"uvp\", \"uvvp\"]\n      },\n      \"video/vnd.dece.sd\": {\n        source: \"iana\",\n        extensions: [\"uvs\", \"uvvs\"]\n      },\n      \"video/vnd.dece.video\": {\n        source: \"iana\",\n        extensions: [\"uvv\", \"uvvv\"]\n      },\n      \"video/vnd.directv.mpeg\": {\n        source: \"iana\"\n      },\n      \"video/vnd.directv.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dlna.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dvb.file\": {\n        source: \"iana\",\n        extensions: [\"dvb\"]\n      },\n      \"video/vnd.fvt\": {\n        source: \"iana\",\n        extensions: [\"fvt\"]\n      },\n      \"video/vnd.hns.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsavc\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsmpeg2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.videop\": {\n        source: \"iana\"\n      },\n      \"video/vnd.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"mxu\", \"m4u\"]\n      },\n      \"video/vnd.ms-playready.media.pyv\": {\n        source: \"iana\",\n        extensions: [\"pyv\"]\n      },\n      \"video/vnd.nokia.interleaved-multimedia\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.mp4vr\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.videovoip\": {\n        source: \"iana\"\n      },\n      \"video/vnd.objectvideo\": {\n        source: \"iana\"\n      },\n      \"video/vnd.planar\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.bink\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.smacker\": {\n        source: \"apache\"\n      },\n      \"video/vnd.sealed.mpeg1\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.mpeg4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.swf\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealedmedia.softseal.mov\": {\n        source: \"iana\"\n      },\n      \"video/vnd.uvvu.mp4\": {\n        source: \"iana\",\n        extensions: [\"uvu\", \"uvvu\"]\n      },\n      \"video/vnd.vivo\": {\n        source: \"iana\",\n        extensions: [\"viv\"]\n      },\n      \"video/vnd.youtube.yt\": {\n        source: \"iana\"\n      },\n      \"video/vp8\": {\n        source: \"iana\"\n      },\n      \"video/vp9\": {\n        source: \"iana\"\n      },\n      \"video/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"webm\"]\n      },\n      \"video/x-f4v\": {\n        source: \"apache\",\n        extensions: [\"f4v\"]\n      },\n      \"video/x-fli\": {\n        source: \"apache\",\n        extensions: [\"fli\"]\n      },\n      \"video/x-flv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"flv\"]\n      },\n      \"video/x-m4v\": {\n        source: \"apache\",\n        extensions: [\"m4v\"]\n      },\n      \"video/x-matroska\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"mkv\", \"mk3d\", \"mks\"]\n      },\n      \"video/x-mng\": {\n        source: \"apache\",\n        extensions: [\"mng\"]\n      },\n      \"video/x-ms-asf\": {\n        source: \"apache\",\n        extensions: [\"asf\", \"asx\"]\n      },\n      \"video/x-ms-vob\": {\n        source: \"apache\",\n        extensions: [\"vob\"]\n      },\n      \"video/x-ms-wm\": {\n        source: \"apache\",\n        extensions: [\"wm\"]\n      },\n      \"video/x-ms-wmv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"wmv\"]\n      },\n      \"video/x-ms-wmx\": {\n        source: \"apache\",\n        extensions: [\"wmx\"]\n      },\n      \"video/x-ms-wvx\": {\n        source: \"apache\",\n        extensions: [\"wvx\"]\n      },\n      \"video/x-msvideo\": {\n        source: \"apache\",\n        extensions: [\"avi\"]\n      },\n      \"video/x-sgi-movie\": {\n        source: \"apache\",\n        extensions: [\"movie\"]\n      },\n      \"video/x-smv\": {\n        source: \"apache\",\n        extensions: [\"smv\"]\n      },\n      \"x-conference/x-cooltalk\": {\n        source: \"apache\",\n        extensions: [\"ice\"]\n      },\n      \"x-shader/x-fragment\": {\n        compressible: true\n      },\n      \"x-shader/x-vertex\": {\n        compressible: true\n      }\n    };\n  }\n});\n\n// node_modules/type-is/node_modules/mime-db/index.js\nvar require_mime_db = __commonJS({\n  \"node_modules/type-is/node_modules/mime-db/index.js\"(exports2, module2) {\n    module2.exports = require_db();\n  }\n});\n\n// node_modules/type-is/node_modules/mime-types/mimeScore.js\nvar require_mimeScore = __commonJS({\n  \"node_modules/type-is/node_modules/mime-types/mimeScore.js\"(exports2, module2) {\n    var FACET_SCORES = {\n      \"prs.\": 100,\n      \"x-\": 200,\n      \"x.\": 300,\n      \"vnd.\": 400,\n      default: 900\n    };\n    var SOURCE_SCORES = {\n      nginx: 10,\n      apache: 20,\n      iana: 40,\n      default: 30\n      // definitions added by `jshttp/mime-db` project?\n    };\n    var TYPE_SCORES = {\n      // prefer application/xml over text/xml\n      // prefer application/rtf over text/rtf\n      application: 1,\n      // prefer font/woff over application/font-woff\n      font: 2,\n      default: 0\n    };\n    module2.exports = function mimeScore(mimeType, source = \"default\") {\n      if (mimeType === \"application/octet-stream\") {\n        return 0;\n      }\n      const [type, subtype] = mimeType.split(\"/\");\n      const facet = subtype.replace(/(\\.|x-).*/, \"$1\");\n      const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;\n      const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;\n      const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;\n      const lengthScore = 1 - mimeType.length / 100;\n      return facetScore + sourceScore + typeScore + lengthScore;\n    };\n  }\n});\n\n// node_modules/type-is/node_modules/mime-types/index.js\nvar require_mime_types = __commonJS({\n  \"node_modules/type-is/node_modules/mime-types/index.js\"(exports2) {\n    \"use strict\";\n    var db = require_mime_db();\n    var extname = require(\"path\").extname;\n    var mimeScore = require_mimeScore();\n    var EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/;\n    var TEXT_TYPE_REGEXP = /^text\\//i;\n    exports2.charset = charset;\n    exports2.charsets = { lookup: charset };\n    exports2.contentType = contentType2;\n    exports2.extension = extension;\n    exports2.extensions = /* @__PURE__ */ Object.create(null);\n    exports2.lookup = lookup;\n    exports2.types = /* @__PURE__ */ Object.create(null);\n    exports2._extensionConflicts = [];\n    populateMaps(exports2.extensions, exports2.types);\n    function charset(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var mime = match && db[match[1].toLowerCase()];\n      if (mime && mime.charset) {\n        return mime.charset;\n      }\n      if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n        return \"UTF-8\";\n      }\n      return false;\n    }\n    function contentType2(str) {\n      if (!str || typeof str !== \"string\") {\n        return false;\n      }\n      var mime = str.indexOf(\"/\") === -1 ? exports2.lookup(str) : str;\n      if (!mime) {\n        return false;\n      }\n      if (mime.indexOf(\"charset\") === -1) {\n        var charset2 = exports2.charset(mime);\n        if (charset2) mime += \"; charset=\" + charset2.toLowerCase();\n      }\n      return mime;\n    }\n    function extension(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var exts = match && exports2.extensions[match[1].toLowerCase()];\n      if (!exts || !exts.length) {\n        return false;\n      }\n      return exts[0];\n    }\n    function lookup(path) {\n      if (!path || typeof path !== \"string\") {\n        return false;\n      }\n      var extension2 = extname(\"x.\" + path).toLowerCase().slice(1);\n      if (!extension2) {\n        return false;\n      }\n      return exports2.types[extension2] || false;\n    }\n    function populateMaps(extensions, types) {\n      Object.keys(db).forEach(function forEachMimeType(type) {\n        var mime = db[type];\n        var exts = mime.extensions;\n        if (!exts || !exts.length) {\n          return;\n        }\n        extensions[type] = exts;\n        for (var i = 0; i < exts.length; i++) {\n          var extension2 = exts[i];\n          types[extension2] = _preferredType(extension2, types[extension2], type);\n          const legacyType = _preferredTypeLegacy(\n            extension2,\n            types[extension2],\n            type\n          );\n          if (legacyType !== types[extension2]) {\n            exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]);\n          }\n        }\n      });\n    }\n    function _preferredType(ext, type0, type1) {\n      var score0 = type0 ? mimeScore(type0, db[type0].source) : 0;\n      var score1 = type1 ? mimeScore(type1, db[type1].source) : 0;\n      return score0 > score1 ? type0 : type1;\n    }\n    function _preferredTypeLegacy(ext, type0, type1) {\n      var SOURCE_RANK = [\"nginx\", \"apache\", void 0, \"iana\"];\n      var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0;\n      var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0;\n      if (exports2.types[extension] !== \"application/octet-stream\" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === \"application/\")) {\n        return type0;\n      }\n      return score0 > score1 ? type0 : type1;\n    }\n  }\n});\n\n// node_modules/media-typer/index.js\nvar require_media_typer = __commonJS({\n  \"node_modules/media-typer/index.js\"(exports2) {\n    \"use strict\";\n    var SUBTYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;\n    var TYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;\n    var TYPE_REGEXP = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;\n    exports2.format = format;\n    exports2.parse = parse;\n    exports2.test = test;\n    function format(obj) {\n      if (!obj || typeof obj !== \"object\") {\n        throw new TypeError(\"argument obj is required\");\n      }\n      var subtype = obj.subtype;\n      var suffix = obj.suffix;\n      var type = obj.type;\n      if (!type || !TYPE_NAME_REGEXP.test(type)) {\n        throw new TypeError(\"invalid type\");\n      }\n      if (!subtype || !SUBTYPE_NAME_REGEXP.test(subtype)) {\n        throw new TypeError(\"invalid subtype\");\n      }\n      var string = type + \"/\" + subtype;\n      if (suffix) {\n        if (!TYPE_NAME_REGEXP.test(suffix)) {\n          throw new TypeError(\"invalid suffix\");\n        }\n        string += \"+\" + suffix;\n      }\n      return string;\n    }\n    function test(string) {\n      if (!string) {\n        throw new TypeError(\"argument string is required\");\n      }\n      if (typeof string !== \"string\") {\n        throw new TypeError(\"argument string is required to be a string\");\n      }\n      return TYPE_REGEXP.test(string.toLowerCase());\n    }\n    function parse(string) {\n      if (!string) {\n        throw new TypeError(\"argument string is required\");\n      }\n      if (typeof string !== \"string\") {\n        throw new TypeError(\"argument string is required to be a string\");\n      }\n      var match = TYPE_REGEXP.exec(string.toLowerCase());\n      if (!match) {\n        throw new TypeError(\"invalid media type\");\n      }\n      var type = match[1];\n      var subtype = match[2];\n      var suffix;\n      var index = subtype.lastIndexOf(\"+\");\n      if (index !== -1) {\n        suffix = subtype.substr(index + 1);\n        subtype = subtype.substr(0, index);\n      }\n      return new MediaType(type, subtype, suffix);\n    }\n    function MediaType(type, subtype, suffix) {\n      this.type = type;\n      this.subtype = subtype;\n      this.suffix = suffix;\n    }\n  }\n});\n\n// node_modules/type-is/index.js\nvar require_type_is = __commonJS({\n  \"node_modules/type-is/index.js\"(exports2, module2) {\n    \"use strict\";\n    var contentType2 = require_content_type();\n    var mime = require_mime_types();\n    var typer = require_media_typer();\n    module2.exports = typeofrequest;\n    module2.exports.is = typeis;\n    module2.exports.hasBody = hasbody;\n    module2.exports.normalize = normalize;\n    module2.exports.match = mimeMatch;\n    function typeis(value, types_) {\n      var i;\n      var types = types_;\n      var val = tryNormalizeType(value);\n      if (!val) {\n        return false;\n      }\n      if (types && !Array.isArray(types)) {\n        types = new Array(arguments.length - 1);\n        for (i = 0; i < types.length; i++) {\n          types[i] = arguments[i + 1];\n        }\n      }\n      if (!types || !types.length) {\n        return val;\n      }\n      var type;\n      for (i = 0; i < types.length; i++) {\n        if (mimeMatch(normalize(type = types[i]), val)) {\n          return type[0] === \"+\" || type.indexOf(\"*\") !== -1 ? val : type;\n        }\n      }\n      return false;\n    }\n    function hasbody(req) {\n      return req.headers[\"transfer-encoding\"] !== void 0 || !isNaN(req.headers[\"content-length\"]);\n    }\n    function typeofrequest(req, types_) {\n      if (!hasbody(req)) return null;\n      var types = arguments.length > 2 ? Array.prototype.slice.call(arguments, 1) : types_;\n      var value = req.headers[\"content-type\"];\n      return typeis(value, types);\n    }\n    function normalize(type) {\n      if (typeof type !== \"string\") {\n        return false;\n      }\n      switch (type) {\n        case \"urlencoded\":\n          return \"application/x-www-form-urlencoded\";\n        case \"multipart\":\n          return \"multipart/*\";\n      }\n      if (type[0] === \"+\") {\n        return \"*/*\" + type;\n      }\n      return type.indexOf(\"/\") === -1 ? mime.lookup(type) : type;\n    }\n    function mimeMatch(expected, actual) {\n      if (expected === false) {\n        return false;\n      }\n      var actualParts = actual.split(\"/\");\n      var expectedParts = expected.split(\"/\");\n      if (actualParts.length !== 2 || expectedParts.length !== 2) {\n        return false;\n      }\n      if (expectedParts[0] !== \"*\" && expectedParts[0] !== actualParts[0]) {\n        return false;\n      }\n      if (expectedParts[1].slice(0, 2) === \"*+\") {\n        return expectedParts[1].length <= actualParts[1].length + 1 && expectedParts[1].slice(1) === actualParts[1].slice(1 - expectedParts[1].length);\n      }\n      if (expectedParts[1] !== \"*\" && expectedParts[1] !== actualParts[1]) {\n        return false;\n      }\n      return true;\n    }\n    function normalizeType(value) {\n      var type = contentType2.parse(value).type;\n      return typer.test(type) ? type : null;\n    }\n    function tryNormalizeType(value) {\n      try {\n        return value ? normalizeType(value) : null;\n      } catch (err2) {\n        return null;\n      }\n    }\n  }\n});\n\n// node_modules/body-parser/lib/utils.js\nvar require_utils = __commonJS({\n  \"node_modules/body-parser/lib/utils.js\"(exports2, module2) {\n    \"use strict\";\n    var bytes = require_bytes();\n    var contentType2 = require_content_type();\n    var typeis = require_type_is();\n    module2.exports = {\n      getCharset,\n      normalizeOptions\n    };\n    function getCharset(req) {\n      try {\n        return (contentType2.parse(req).parameters.charset || \"\").toLowerCase();\n      } catch {\n        return void 0;\n      }\n    }\n    function typeChecker(type) {\n      return function checkType(req) {\n        return Boolean(typeis(req, type));\n      };\n    }\n    function normalizeOptions(options, defaultType) {\n      if (!defaultType) {\n        throw new TypeError(\"defaultType must be provided\");\n      }\n      var inflate = options?.inflate !== false;\n      var limit = typeof options?.limit !== \"number\" ? bytes.parse(options?.limit || \"100kb\") : options?.limit;\n      var type = options?.type || defaultType;\n      var verify = options?.verify || false;\n      if (verify !== false && typeof verify !== \"function\") {\n        throw new TypeError(\"option verify must be function\");\n      }\n      var shouldParse = typeof type !== \"function\" ? typeChecker(type) : type;\n      return {\n        inflate,\n        limit,\n        verify,\n        shouldParse\n      };\n    }\n  }\n});\n\n// node_modules/body-parser/lib/types/json.js\nvar require_json = __commonJS({\n  \"node_modules/body-parser/lib/types/json.js\"(exports2, module2) {\n    \"use strict\";\n    var createError = require_http_errors();\n    var debug = require_src()(\"body-parser:json\");\n    var isFinished = require_on_finished().isFinished;\n    var read = require_read();\n    var typeis = require_type_is();\n    var { getCharset, normalizeOptions } = require_utils();\n    module2.exports = json;\n    var FIRST_CHAR_REGEXP = /^[\\x20\\x09\\x0a\\x0d]*([^\\x20\\x09\\x0a\\x0d])/;\n    var JSON_SYNTAX_CHAR = \"#\";\n    var JSON_SYNTAX_REGEXP = /#+/g;\n    function json(options) {\n      var { inflate, limit, verify, shouldParse } = normalizeOptions(options, \"application/json\");\n      var reviver = options?.reviver;\n      var strict = options?.strict !== false;\n      function parse(body) {\n        if (body.length === 0) {\n          return {};\n        }\n        if (strict) {\n          var first = firstchar(body);\n          if (first !== \"{\" && first !== \"[\") {\n            debug(\"strict violation\");\n            throw createStrictSyntaxError(body, first);\n          }\n        }\n        try {\n          debug(\"parse json\");\n          return JSON.parse(body, reviver);\n        } catch (e) {\n          throw normalizeJsonSyntaxError(e, {\n            message: e.message,\n            stack: e.stack\n          });\n        }\n      }\n      return function jsonParser(req, res, next) {\n        if (isFinished(req)) {\n          debug(\"body already parsed\");\n          next();\n          return;\n        }\n        if (!(\"body\" in req)) {\n          req.body = void 0;\n        }\n        if (!typeis.hasBody(req)) {\n          debug(\"skip empty body\");\n          next();\n          return;\n        }\n        debug(\"content-type %j\", req.headers[\"content-type\"]);\n        if (!shouldParse(req)) {\n          debug(\"skip parsing\");\n          next();\n          return;\n        }\n        var charset = getCharset(req) || \"utf-8\";\n        if (charset.slice(0, 4) !== \"utf-\") {\n          debug(\"invalid charset\");\n          next(createError(415, 'unsupported charset \"' + charset.toUpperCase() + '\"', {\n            charset,\n            type: \"charset.unsupported\"\n          }));\n          return;\n        }\n        read(req, res, next, parse, debug, {\n          encoding: charset,\n          inflate,\n          limit,\n          verify\n        });\n      };\n    }\n    function createStrictSyntaxError(str, char) {\n      var index = str.indexOf(char);\n      var partial = \"\";\n      if (index !== -1) {\n        partial = str.substring(0, index) + JSON_SYNTAX_CHAR;\n        for (var i = index + 1; i < str.length; i++) {\n          partial += JSON_SYNTAX_CHAR;\n        }\n      }\n      try {\n        JSON.parse(partial);\n        throw new SyntaxError(\"strict violation\");\n      } catch (e) {\n        return normalizeJsonSyntaxError(e, {\n          message: e.message.replace(JSON_SYNTAX_REGEXP, function(placeholder) {\n            return str.substring(index, index + placeholder.length);\n          }),\n          stack: e.stack\n        });\n      }\n    }\n    function firstchar(str) {\n      var match = FIRST_CHAR_REGEXP.exec(str);\n      return match ? match[1] : void 0;\n    }\n    function normalizeJsonSyntaxError(error, obj) {\n      var keys = Object.getOwnPropertyNames(error);\n      for (var i = 0; i < keys.length; i++) {\n        var key = keys[i];\n        if (key !== \"stack\" && key !== \"message\") {\n          delete error[key];\n        }\n      }\n      error.stack = obj.stack.replace(error.message, obj.message);\n      error.message = obj.message;\n      return error;\n    }\n  }\n});\n\n// node_modules/body-parser/lib/types/raw.js\nvar require_raw = __commonJS({\n  \"node_modules/body-parser/lib/types/raw.js\"(exports2, module2) {\n    \"use strict\";\n    var debug = require_src()(\"body-parser:raw\");\n    var isFinished = require_on_finished().isFinished;\n    var read = require_read();\n    var typeis = require_type_is();\n    var { normalizeOptions } = require_utils();\n    module2.exports = raw;\n    function raw(options) {\n      var { inflate, limit, verify, shouldParse } = normalizeOptions(options, \"application/octet-stream\");\n      function parse(buf) {\n        return buf;\n      }\n      return function rawParser(req, res, next) {\n        if (isFinished(req)) {\n          debug(\"body already parsed\");\n          next();\n          return;\n        }\n        if (!(\"body\" in req)) {\n          req.body = void 0;\n        }\n        if (!typeis.hasBody(req)) {\n          debug(\"skip empty body\");\n          next();\n          return;\n        }\n        debug(\"content-type %j\", req.headers[\"content-type\"]);\n        if (!shouldParse(req)) {\n          debug(\"skip parsing\");\n          next();\n          return;\n        }\n        read(req, res, next, parse, debug, {\n          encoding: null,\n          inflate,\n          limit,\n          verify\n        });\n      };\n    }\n  }\n});\n\n// node_modules/body-parser/lib/types/text.js\nvar require_text = __commonJS({\n  \"node_modules/body-parser/lib/types/text.js\"(exports2, module2) {\n    \"use strict\";\n    var debug = require_src()(\"body-parser:text\");\n    var isFinished = require_on_finished().isFinished;\n    var read = require_read();\n    var typeis = require_type_is();\n    var { getCharset, normalizeOptions } = require_utils();\n    module2.exports = text;\n    function text(options) {\n      var { inflate, limit, verify, shouldParse } = normalizeOptions(options, \"text/plain\");\n      var defaultCharset = options?.defaultCharset || \"utf-8\";\n      function parse(buf) {\n        return buf;\n      }\n      return function textParser(req, res, next) {\n        if (isFinished(req)) {\n          debug(\"body already parsed\");\n          next();\n          return;\n        }\n        if (!(\"body\" in req)) {\n          req.body = void 0;\n        }\n        if (!typeis.hasBody(req)) {\n          debug(\"skip empty body\");\n          next();\n          return;\n        }\n        debug(\"content-type %j\", req.headers[\"content-type\"]);\n        if (!shouldParse(req)) {\n          debug(\"skip parsing\");\n          next();\n          return;\n        }\n        var charset = getCharset(req) || defaultCharset;\n        read(req, res, next, parse, debug, {\n          encoding: charset,\n          inflate,\n          limit,\n          verify\n        });\n      };\n    }\n  }\n});\n\n// node_modules/es-errors/type.js\nvar require_type = __commonJS({\n  \"node_modules/es-errors/type.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = TypeError;\n  }\n});\n\n// node_modules/object-inspect/util.inspect.js\nvar require_util_inspect = __commonJS({\n  \"node_modules/object-inspect/util.inspect.js\"(exports2, module2) {\n    module2.exports = require(\"util\").inspect;\n  }\n});\n\n// node_modules/object-inspect/index.js\nvar require_object_inspect = __commonJS({\n  \"node_modules/object-inspect/index.js\"(exports2, module2) {\n    var hasMap = typeof Map === \"function\" && Map.prototype;\n    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, \"size\") : null;\n    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === \"function\" ? mapSizeDescriptor.get : null;\n    var mapForEach = hasMap && Map.prototype.forEach;\n    var hasSet = typeof Set === \"function\" && Set.prototype;\n    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, \"size\") : null;\n    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === \"function\" ? setSizeDescriptor.get : null;\n    var setForEach = hasSet && Set.prototype.forEach;\n    var hasWeakMap = typeof WeakMap === \"function\" && WeakMap.prototype;\n    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\n    var hasWeakSet = typeof WeakSet === \"function\" && WeakSet.prototype;\n    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\n    var hasWeakRef = typeof WeakRef === \"function\" && WeakRef.prototype;\n    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\n    var booleanValueOf = Boolean.prototype.valueOf;\n    var objectToString = Object.prototype.toString;\n    var functionToString = Function.prototype.toString;\n    var $match = String.prototype.match;\n    var $slice = String.prototype.slice;\n    var $replace = String.prototype.replace;\n    var $toUpperCase = String.prototype.toUpperCase;\n    var $toLowerCase = String.prototype.toLowerCase;\n    var $test = RegExp.prototype.test;\n    var $concat = Array.prototype.concat;\n    var $join = Array.prototype.join;\n    var $arrSlice = Array.prototype.slice;\n    var $floor = Math.floor;\n    var bigIntValueOf = typeof BigInt === \"function\" ? BigInt.prototype.valueOf : null;\n    var gOPS = Object.getOwnPropertySymbols;\n    var symToString = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? Symbol.prototype.toString : null;\n    var hasShammedSymbols = typeof Symbol === \"function\" && typeof Symbol.iterator === \"object\";\n    var toStringTag = typeof Symbol === \"function\" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? \"object\" : \"symbol\") ? Symbol.toStringTag : null;\n    var isEnumerable = Object.prototype.propertyIsEnumerable;\n    var gPO = (typeof Reflect === \"function\" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {\n      return O.__proto__;\n    } : null);\n    function addNumericSeparator(num, str) {\n      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {\n        return str;\n      }\n      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n      if (typeof num === \"number\") {\n        var int = num < 0 ? -$floor(-num) : $floor(num);\n        if (int !== num) {\n          var intStr = String(int);\n          var dec = $slice.call(str, intStr.length + 1);\n          return $replace.call(intStr, sepRegex, \"$&_\") + \".\" + $replace.call($replace.call(dec, /([0-9]{3})/g, \"$&_\"), /_$/, \"\");\n        }\n      }\n      return $replace.call(str, sepRegex, \"$&_\");\n    }\n    var utilInspect = require_util_inspect();\n    var inspectCustom = utilInspect.custom;\n    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n    var quotes = {\n      __proto__: null,\n      \"double\": '\"',\n      single: \"'\"\n    };\n    var quoteREs = {\n      __proto__: null,\n      \"double\": /([\"\\\\])/g,\n      single: /(['\\\\])/g\n    };\n    module2.exports = function inspect_(obj, options, depth, seen) {\n      var opts = options || {};\n      if (has(opts, \"quoteStyle\") && !has(quotes, opts.quoteStyle)) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n      }\n      if (has(opts, \"maxStringLength\") && (typeof opts.maxStringLength === \"number\" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n      }\n      var customInspect = has(opts, \"customInspect\") ? opts.customInspect : true;\n      if (typeof customInspect !== \"boolean\" && customInspect !== \"symbol\") {\n        throw new TypeError(\"option \\\"customInspect\\\", if provided, must be `true`, `false`, or `'symbol'`\");\n      }\n      if (has(opts, \"indent\") && opts.indent !== null && opts.indent !== \"\t\" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n      }\n      if (has(opts, \"numericSeparator\") && typeof opts.numericSeparator !== \"boolean\") {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n      }\n      var numericSeparator = opts.numericSeparator;\n      if (typeof obj === \"undefined\") {\n        return \"undefined\";\n      }\n      if (obj === null) {\n        return \"null\";\n      }\n      if (typeof obj === \"boolean\") {\n        return obj ? \"true\" : \"false\";\n      }\n      if (typeof obj === \"string\") {\n        return inspectString(obj, opts);\n      }\n      if (typeof obj === \"number\") {\n        if (obj === 0) {\n          return Infinity / obj > 0 ? \"0\" : \"-0\";\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n      }\n      if (typeof obj === \"bigint\") {\n        var bigIntStr = String(obj) + \"n\";\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n      }\n      var maxDepth = typeof opts.depth === \"undefined\" ? 5 : opts.depth;\n      if (typeof depth === \"undefined\") {\n        depth = 0;\n      }\n      if (depth >= maxDepth && maxDepth > 0 && typeof obj === \"object\") {\n        return isArray(obj) ? \"[Array]\" : \"[Object]\";\n      }\n      var indent = getIndent(opts, depth);\n      if (typeof seen === \"undefined\") {\n        seen = [];\n      } else if (indexOf(seen, obj) >= 0) {\n        return \"[Circular]\";\n      }\n      function inspect(value, from, noIndent) {\n        if (from) {\n          seen = $arrSlice.call(seen);\n          seen.push(from);\n        }\n        if (noIndent) {\n          var newOpts = {\n            depth: opts.depth\n          };\n          if (has(opts, \"quoteStyle\")) {\n            newOpts.quoteStyle = opts.quoteStyle;\n          }\n          return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n      }\n      if (typeof obj === \"function\" && !isRegExp(obj)) {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return \"[Function\" + (name ? \": \" + name : \" (anonymous)\") + \"]\" + (keys.length > 0 ? \" { \" + $join.call(keys, \", \") + \" }\" : \"\");\n      }\n      if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, \"$1\") : symToString.call(obj);\n        return typeof obj === \"object\" && !hasShammedSymbols ? markBoxed(symString) : symString;\n      }\n      if (isElement(obj)) {\n        var s = \"<\" + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n          s += \" \" + attrs[i].name + \"=\" + wrapQuotes(quote(attrs[i].value), \"double\", opts);\n        }\n        s += \">\";\n        if (obj.childNodes && obj.childNodes.length) {\n          s += \"...\";\n        }\n        s += \"</\" + $toLowerCase.call(String(obj.nodeName)) + \">\";\n        return s;\n      }\n      if (isArray(obj)) {\n        if (obj.length === 0) {\n          return \"[]\";\n        }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n          return \"[\" + indentedJoin(xs, indent) + \"]\";\n        }\n        return \"[ \" + $join.call(xs, \", \") + \" ]\";\n      }\n      if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if (!(\"cause\" in Error.prototype) && \"cause\" in obj && !isEnumerable.call(obj, \"cause\")) {\n          return \"{ [\" + String(obj) + \"] \" + $join.call($concat.call(\"[cause]: \" + inspect(obj.cause), parts), \", \") + \" }\";\n        }\n        if (parts.length === 0) {\n          return \"[\" + String(obj) + \"]\";\n        }\n        return \"{ [\" + String(obj) + \"] \" + $join.call(parts, \", \") + \" }\";\n      }\n      if (typeof obj === \"object\" && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === \"function\" && utilInspect) {\n          return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== \"symbol\" && typeof obj.inspect === \"function\") {\n          return obj.inspect();\n        }\n      }\n      if (isMap(obj)) {\n        var mapParts = [];\n        if (mapForEach) {\n          mapForEach.call(obj, function(value, key) {\n            mapParts.push(inspect(key, obj, true) + \" => \" + inspect(value, obj));\n          });\n        }\n        return collectionOf(\"Map\", mapSize.call(obj), mapParts, indent);\n      }\n      if (isSet(obj)) {\n        var setParts = [];\n        if (setForEach) {\n          setForEach.call(obj, function(value) {\n            setParts.push(inspect(value, obj));\n          });\n        }\n        return collectionOf(\"Set\", setSize.call(obj), setParts, indent);\n      }\n      if (isWeakMap(obj)) {\n        return weakCollectionOf(\"WeakMap\");\n      }\n      if (isWeakSet(obj)) {\n        return weakCollectionOf(\"WeakSet\");\n      }\n      if (isWeakRef(obj)) {\n        return weakCollectionOf(\"WeakRef\");\n      }\n      if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n      }\n      if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n      }\n      if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n      }\n      if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n      }\n      if (typeof window !== \"undefined\" && obj === window) {\n        return \"{ [object Window] }\";\n      }\n      if (typeof globalThis !== \"undefined\" && obj === globalThis || typeof global !== \"undefined\" && obj === global) {\n        return \"{ [object globalThis] }\";\n      }\n      if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? \"\" : \"null prototype\";\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? \"Object\" : \"\";\n        var constructorTag = isPlainObject || typeof obj.constructor !== \"function\" ? \"\" : obj.constructor.name ? obj.constructor.name + \" \" : \"\";\n        var tag = constructorTag + (stringTag || protoTag ? \"[\" + $join.call($concat.call([], stringTag || [], protoTag || []), \": \") + \"] \" : \"\");\n        if (ys.length === 0) {\n          return tag + \"{}\";\n        }\n        if (indent) {\n          return tag + \"{\" + indentedJoin(ys, indent) + \"}\";\n        }\n        return tag + \"{ \" + $join.call(ys, \", \") + \" }\";\n      }\n      return String(obj);\n    };\n    function wrapQuotes(s, defaultStyle, opts) {\n      var style = opts.quoteStyle || defaultStyle;\n      var quoteChar = quotes[style];\n      return quoteChar + s + quoteChar;\n    }\n    function quote(s) {\n      return $replace.call(String(s), /\"/g, \"&quot;\");\n    }\n    function canTrustToString(obj) {\n      return !toStringTag || !(typeof obj === \"object\" && (toStringTag in obj || typeof obj[toStringTag] !== \"undefined\"));\n    }\n    function isArray(obj) {\n      return toStr(obj) === \"[object Array]\" && canTrustToString(obj);\n    }\n    function isDate(obj) {\n      return toStr(obj) === \"[object Date]\" && canTrustToString(obj);\n    }\n    function isRegExp(obj) {\n      return toStr(obj) === \"[object RegExp]\" && canTrustToString(obj);\n    }\n    function isError(obj) {\n      return toStr(obj) === \"[object Error]\" && canTrustToString(obj);\n    }\n    function isString(obj) {\n      return toStr(obj) === \"[object String]\" && canTrustToString(obj);\n    }\n    function isNumber(obj) {\n      return toStr(obj) === \"[object Number]\" && canTrustToString(obj);\n    }\n    function isBoolean(obj) {\n      return toStr(obj) === \"[object Boolean]\" && canTrustToString(obj);\n    }\n    function isSymbol(obj) {\n      if (hasShammedSymbols) {\n        return obj && typeof obj === \"object\" && obj instanceof Symbol;\n      }\n      if (typeof obj === \"symbol\") {\n        return true;\n      }\n      if (!obj || typeof obj !== \"object\" || !symToString) {\n        return false;\n      }\n      try {\n        symToString.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isBigInt(obj) {\n      if (!obj || typeof obj !== \"object\" || !bigIntValueOf) {\n        return false;\n      }\n      try {\n        bigIntValueOf.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    var hasOwn = Object.prototype.hasOwnProperty || function(key) {\n      return key in this;\n    };\n    function has(obj, key) {\n      return hasOwn.call(obj, key);\n    }\n    function toStr(obj) {\n      return objectToString.call(obj);\n    }\n    function nameOf(f) {\n      if (f.name) {\n        return f.name;\n      }\n      var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n      if (m) {\n        return m[1];\n      }\n      return null;\n    }\n    function indexOf(xs, x) {\n      if (xs.indexOf) {\n        return xs.indexOf(x);\n      }\n      for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) {\n          return i;\n        }\n      }\n      return -1;\n    }\n    function isMap(x) {\n      if (!mapSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        mapSize.call(x);\n        try {\n          setSize.call(x);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof Map;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakMap(x) {\n      if (!weakMapHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n          weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakMap;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakRef(x) {\n      if (!weakRefDeref || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakRefDeref.call(x);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isSet(x) {\n      if (!setSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        setSize.call(x);\n        try {\n          mapSize.call(x);\n        } catch (m) {\n          return true;\n        }\n        return x instanceof Set;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakSet(x) {\n      if (!weakSetHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n          weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakSet;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isElement(x) {\n      if (!x || typeof x !== \"object\") {\n        return false;\n      }\n      if (typeof HTMLElement !== \"undefined\" && x instanceof HTMLElement) {\n        return true;\n      }\n      return typeof x.nodeName === \"string\" && typeof x.getAttribute === \"function\";\n    }\n    function inspectString(str, opts) {\n      if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = \"... \" + remaining + \" more character\" + (remaining > 1 ? \"s\" : \"\");\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n      }\n      var quoteRE = quoteREs[opts.quoteStyle || \"single\"];\n      quoteRE.lastIndex = 0;\n      var s = $replace.call($replace.call(str, quoteRE, \"\\\\$1\"), /[\\x00-\\x1f]/g, lowbyte);\n      return wrapQuotes(s, \"single\", opts);\n    }\n    function lowbyte(c) {\n      var n = c.charCodeAt(0);\n      var x = {\n        8: \"b\",\n        9: \"t\",\n        10: \"n\",\n        12: \"f\",\n        13: \"r\"\n      }[n];\n      if (x) {\n        return \"\\\\\" + x;\n      }\n      return \"\\\\x\" + (n < 16 ? \"0\" : \"\") + $toUpperCase.call(n.toString(16));\n    }\n    function markBoxed(str) {\n      return \"Object(\" + str + \")\";\n    }\n    function weakCollectionOf(type) {\n      return type + \" { ? }\";\n    }\n    function collectionOf(type, size, entries, indent) {\n      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, \", \");\n      return type + \" (\" + size + \") {\" + joinedEntries + \"}\";\n    }\n    function singleLineValues(xs) {\n      for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], \"\\n\") >= 0) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function getIndent(opts, depth) {\n      var baseIndent;\n      if (opts.indent === \"\t\") {\n        baseIndent = \"\t\";\n      } else if (typeof opts.indent === \"number\" && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), \" \");\n      } else {\n        return null;\n      }\n      return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n      };\n    }\n    function indentedJoin(xs, indent) {\n      if (xs.length === 0) {\n        return \"\";\n      }\n      var lineJoiner = \"\\n\" + indent.prev + indent.base;\n      return lineJoiner + $join.call(xs, \",\" + lineJoiner) + \"\\n\" + indent.prev;\n    }\n    function arrObjKeys(obj, inspect) {\n      var isArr = isArray(obj);\n      var xs = [];\n      if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n          xs[i] = has(obj, i) ? inspect(obj[i], obj) : \"\";\n        }\n      }\n      var syms = typeof gOPS === \"function\" ? gOPS(obj) : [];\n      var symMap;\n      if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n          symMap[\"$\" + syms[k]] = syms[k];\n        }\n      }\n      for (var key in obj) {\n        if (!has(obj, key)) {\n          continue;\n        }\n        if (isArr && String(Number(key)) === key && key < obj.length) {\n          continue;\n        }\n        if (hasShammedSymbols && symMap[\"$\" + key] instanceof Symbol) {\n          continue;\n        } else if ($test.call(/[^\\w$]/, key)) {\n          xs.push(inspect(key, obj) + \": \" + inspect(obj[key], obj));\n        } else {\n          xs.push(key + \": \" + inspect(obj[key], obj));\n        }\n      }\n      if (typeof gOPS === \"function\") {\n        for (var j = 0; j < syms.length; j++) {\n          if (isEnumerable.call(obj, syms[j])) {\n            xs.push(\"[\" + inspect(syms[j]) + \"]: \" + inspect(obj[syms[j]], obj));\n          }\n        }\n      }\n      return xs;\n    }\n  }\n});\n\n// node_modules/side-channel-list/index.js\nvar require_side_channel_list = __commonJS({\n  \"node_modules/side-channel-list/index.js\"(exports2, module2) {\n    \"use strict\";\n    var inspect = require_object_inspect();\n    var $TypeError = require_type();\n    var listGetNode = function(list, key, isDelete) {\n      var prev = list;\n      var curr;\n      for (; (curr = prev.next) != null; prev = curr) {\n        if (curr.key === key) {\n          prev.next = curr.next;\n          if (!isDelete) {\n            curr.next = /** @type {NonNullable<typeof list.next>} */\n            list.next;\n            list.next = curr;\n          }\n          return curr;\n        }\n      }\n    };\n    var listGet = function(objects, key) {\n      if (!objects) {\n        return void 0;\n      }\n      var node = listGetNode(objects, key);\n      return node && node.value;\n    };\n    var listSet = function(objects, key, value) {\n      var node = listGetNode(objects, key);\n      if (node) {\n        node.value = value;\n      } else {\n        objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */\n        {\n          // eslint-disable-line no-param-reassign, no-extra-parens\n          key,\n          next: objects.next,\n          value\n        };\n      }\n    };\n    var listHas = function(objects, key) {\n      if (!objects) {\n        return false;\n      }\n      return !!listGetNode(objects, key);\n    };\n    var listDelete = function(objects, key) {\n      if (objects) {\n        return listGetNode(objects, key, true);\n      }\n    };\n    module2.exports = function getSideChannelList() {\n      var $o;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          var root = $o && $o.next;\n          var deletedNode = listDelete($o, key);\n          if (deletedNode && root && root === deletedNode) {\n            $o = void 0;\n          }\n          return !!deletedNode;\n        },\n        get: function(key) {\n          return listGet($o, key);\n        },\n        has: function(key) {\n          return listHas($o, key);\n        },\n        set: function(key, value) {\n          if (!$o) {\n            $o = {\n              next: void 0\n            };\n          }\n          listSet(\n            /** @type {NonNullable<typeof $o>} */\n            $o,\n            key,\n            value\n          );\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// node_modules/es-object-atoms/index.js\nvar require_es_object_atoms = __commonJS({\n  \"node_modules/es-object-atoms/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object;\n  }\n});\n\n// node_modules/es-errors/index.js\nvar require_es_errors = __commonJS({\n  \"node_modules/es-errors/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Error;\n  }\n});\n\n// node_modules/es-errors/eval.js\nvar require_eval = __commonJS({\n  \"node_modules/es-errors/eval.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = EvalError;\n  }\n});\n\n// node_modules/es-errors/range.js\nvar require_range = __commonJS({\n  \"node_modules/es-errors/range.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = RangeError;\n  }\n});\n\n// node_modules/es-errors/ref.js\nvar require_ref = __commonJS({\n  \"node_modules/es-errors/ref.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = ReferenceError;\n  }\n});\n\n// node_modules/es-errors/syntax.js\nvar require_syntax = __commonJS({\n  \"node_modules/es-errors/syntax.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = SyntaxError;\n  }\n});\n\n// node_modules/es-errors/uri.js\nvar require_uri = __commonJS({\n  \"node_modules/es-errors/uri.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = URIError;\n  }\n});\n\n// node_modules/math-intrinsics/abs.js\nvar require_abs = __commonJS({\n  \"node_modules/math-intrinsics/abs.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.abs;\n  }\n});\n\n// node_modules/math-intrinsics/floor.js\nvar require_floor = __commonJS({\n  \"node_modules/math-intrinsics/floor.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.floor;\n  }\n});\n\n// node_modules/math-intrinsics/max.js\nvar require_max = __commonJS({\n  \"node_modules/math-intrinsics/max.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.max;\n  }\n});\n\n// node_modules/math-intrinsics/min.js\nvar require_min = __commonJS({\n  \"node_modules/math-intrinsics/min.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.min;\n  }\n});\n\n// node_modules/math-intrinsics/pow.js\nvar require_pow = __commonJS({\n  \"node_modules/math-intrinsics/pow.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.pow;\n  }\n});\n\n// node_modules/math-intrinsics/round.js\nvar require_round = __commonJS({\n  \"node_modules/math-intrinsics/round.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Math.round;\n  }\n});\n\n// node_modules/math-intrinsics/isNaN.js\nvar require_isNaN = __commonJS({\n  \"node_modules/math-intrinsics/isNaN.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Number.isNaN || function isNaN2(a) {\n      return a !== a;\n    };\n  }\n});\n\n// node_modules/math-intrinsics/sign.js\nvar require_sign = __commonJS({\n  \"node_modules/math-intrinsics/sign.js\"(exports2, module2) {\n    \"use strict\";\n    var $isNaN = require_isNaN();\n    module2.exports = function sign(number) {\n      if ($isNaN(number) || number === 0) {\n        return number;\n      }\n      return number < 0 ? -1 : 1;\n    };\n  }\n});\n\n// node_modules/gopd/gOPD.js\nvar require_gOPD = __commonJS({\n  \"node_modules/gopd/gOPD.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Object.getOwnPropertyDescriptor;\n  }\n});\n\n// node_modules/gopd/index.js\nvar require_gopd = __commonJS({\n  \"node_modules/gopd/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $gOPD = require_gOPD();\n    if ($gOPD) {\n      try {\n        $gOPD([], \"length\");\n      } catch (e) {\n        $gOPD = null;\n      }\n    }\n    module2.exports = $gOPD;\n  }\n});\n\n// node_modules/es-define-property/index.js\nvar require_es_define_property = __commonJS({\n  \"node_modules/es-define-property/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $defineProperty = Object.defineProperty || false;\n    if ($defineProperty) {\n      try {\n        $defineProperty({}, \"a\", { value: 1 });\n      } catch (e) {\n        $defineProperty = false;\n      }\n    }\n    module2.exports = $defineProperty;\n  }\n});\n\n// node_modules/has-symbols/shams.js\nvar require_shams = __commonJS({\n  \"node_modules/has-symbols/shams.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = function hasSymbols() {\n      if (typeof Symbol !== \"function\" || typeof Object.getOwnPropertySymbols !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol.iterator === \"symbol\") {\n        return true;\n      }\n      var obj = {};\n      var sym = Symbol(\"test\");\n      var symObj = Object(sym);\n      if (typeof sym === \"string\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(sym) !== \"[object Symbol]\") {\n        return false;\n      }\n      if (Object.prototype.toString.call(symObj) !== \"[object Symbol]\") {\n        return false;\n      }\n      var symVal = 42;\n      obj[sym] = symVal;\n      for (var _2 in obj) {\n        return false;\n      }\n      if (typeof Object.keys === \"function\" && Object.keys(obj).length !== 0) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyNames === \"function\" && Object.getOwnPropertyNames(obj).length !== 0) {\n        return false;\n      }\n      var syms = Object.getOwnPropertySymbols(obj);\n      if (syms.length !== 1 || syms[0] !== sym) {\n        return false;\n      }\n      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {\n        return false;\n      }\n      if (typeof Object.getOwnPropertyDescriptor === \"function\") {\n        var descriptor = (\n          /** @type {PropertyDescriptor} */\n          Object.getOwnPropertyDescriptor(obj, sym)\n        );\n        if (descriptor.value !== symVal || descriptor.enumerable !== true) {\n          return false;\n        }\n      }\n      return true;\n    };\n  }\n});\n\n// node_modules/has-symbols/index.js\nvar require_has_symbols = __commonJS({\n  \"node_modules/has-symbols/index.js\"(exports2, module2) {\n    \"use strict\";\n    var origSymbol = typeof Symbol !== \"undefined\" && Symbol;\n    var hasSymbolSham = require_shams();\n    module2.exports = function hasNativeSymbols() {\n      if (typeof origSymbol !== \"function\") {\n        return false;\n      }\n      if (typeof Symbol !== \"function\") {\n        return false;\n      }\n      if (typeof origSymbol(\"foo\") !== \"symbol\") {\n        return false;\n      }\n      if (typeof Symbol(\"bar\") !== \"symbol\") {\n        return false;\n      }\n      return hasSymbolSham();\n    };\n  }\n});\n\n// node_modules/get-proto/Reflect.getPrototypeOf.js\nvar require_Reflect_getPrototypeOf = __commonJS({\n  \"node_modules/get-proto/Reflect.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect.getPrototypeOf || null;\n  }\n});\n\n// node_modules/get-proto/Object.getPrototypeOf.js\nvar require_Object_getPrototypeOf = __commonJS({\n  \"node_modules/get-proto/Object.getPrototypeOf.js\"(exports2, module2) {\n    \"use strict\";\n    var $Object = require_es_object_atoms();\n    module2.exports = $Object.getPrototypeOf || null;\n  }\n});\n\n// node_modules/function-bind/implementation.js\nvar require_implementation = __commonJS({\n  \"node_modules/function-bind/implementation.js\"(exports2, module2) {\n    \"use strict\";\n    var ERROR_MESSAGE = \"Function.prototype.bind called on incompatible \";\n    var toStr = Object.prototype.toString;\n    var max = Math.max;\n    var funcType = \"[object Function]\";\n    var concatty = function concatty2(a, b) {\n      var arr = [];\n      for (var i = 0; i < a.length; i += 1) {\n        arr[i] = a[i];\n      }\n      for (var j = 0; j < b.length; j += 1) {\n        arr[j + a.length] = b[j];\n      }\n      return arr;\n    };\n    var slicy = function slicy2(arrLike, offset) {\n      var arr = [];\n      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {\n        arr[j] = arrLike[i];\n      }\n      return arr;\n    };\n    var joiny = function(arr, joiner) {\n      var str = \"\";\n      for (var i = 0; i < arr.length; i += 1) {\n        str += arr[i];\n        if (i + 1 < arr.length) {\n          str += joiner;\n        }\n      }\n      return str;\n    };\n    module2.exports = function bind(that) {\n      var target = this;\n      if (typeof target !== \"function\" || toStr.apply(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n      }\n      var args = slicy(arguments, 1);\n      var bound;\n      var binder = function() {\n        if (this instanceof bound) {\n          var result = target.apply(\n            this,\n            concatty(args, arguments)\n          );\n          if (Object(result) === result) {\n            return result;\n          }\n          return this;\n        }\n        return target.apply(\n          that,\n          concatty(args, arguments)\n        );\n      };\n      var boundLength = max(0, target.length - args.length);\n      var boundArgs = [];\n      for (var i = 0; i < boundLength; i++) {\n        boundArgs[i] = \"$\" + i;\n      }\n      bound = Function(\"binder\", \"return function (\" + joiny(boundArgs, \",\") + \"){ return binder.apply(this,arguments); }\")(binder);\n      if (target.prototype) {\n        var Empty = function Empty2() {\n        };\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n      }\n      return bound;\n    };\n  }\n});\n\n// node_modules/function-bind/index.js\nvar require_function_bind = __commonJS({\n  \"node_modules/function-bind/index.js\"(exports2, module2) {\n    \"use strict\";\n    var implementation = require_implementation();\n    module2.exports = Function.prototype.bind || implementation;\n  }\n});\n\n// node_modules/call-bind-apply-helpers/functionCall.js\nvar require_functionCall = __commonJS({\n  \"node_modules/call-bind-apply-helpers/functionCall.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.call;\n  }\n});\n\n// node_modules/call-bind-apply-helpers/functionApply.js\nvar require_functionApply = __commonJS({\n  \"node_modules/call-bind-apply-helpers/functionApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = Function.prototype.apply;\n  }\n});\n\n// node_modules/call-bind-apply-helpers/reflectApply.js\nvar require_reflectApply = __commonJS({\n  \"node_modules/call-bind-apply-helpers/reflectApply.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = typeof Reflect !== \"undefined\" && Reflect && Reflect.apply;\n  }\n});\n\n// node_modules/call-bind-apply-helpers/actualApply.js\nvar require_actualApply = __commonJS({\n  \"node_modules/call-bind-apply-helpers/actualApply.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var $reflectApply = require_reflectApply();\n    module2.exports = $reflectApply || bind.call($call, $apply);\n  }\n});\n\n// node_modules/call-bind-apply-helpers/index.js\nvar require_call_bind_apply_helpers = __commonJS({\n  \"node_modules/call-bind-apply-helpers/index.js\"(exports2, module2) {\n    \"use strict\";\n    var bind = require_function_bind();\n    var $TypeError = require_type();\n    var $call = require_functionCall();\n    var $actualApply = require_actualApply();\n    module2.exports = function callBindBasic(args) {\n      if (args.length < 1 || typeof args[0] !== \"function\") {\n        throw new $TypeError(\"a function is required\");\n      }\n      return $actualApply(bind, $call, args);\n    };\n  }\n});\n\n// node_modules/dunder-proto/get.js\nvar require_get = __commonJS({\n  \"node_modules/dunder-proto/get.js\"(exports2, module2) {\n    \"use strict\";\n    var callBind = require_call_bind_apply_helpers();\n    var gOPD = require_gopd();\n    var hasProtoAccessor;\n    try {\n      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */\n      [].__proto__ === Array.prototype;\n    } catch (e) {\n      if (!e || typeof e !== \"object\" || !(\"code\" in e) || e.code !== \"ERR_PROTO_ACCESS\") {\n        throw e;\n      }\n    }\n    var desc = !!hasProtoAccessor && gOPD && gOPD(\n      Object.prototype,\n      /** @type {keyof typeof Object.prototype} */\n      \"__proto__\"\n    );\n    var $Object = Object;\n    var $getPrototypeOf = $Object.getPrototypeOf;\n    module2.exports = desc && typeof desc.get === \"function\" ? callBind([desc.get]) : typeof $getPrototypeOf === \"function\" ? (\n      /** @type {import('./get')} */\n      function getDunder(value) {\n        return $getPrototypeOf(value == null ? value : $Object(value));\n      }\n    ) : false;\n  }\n});\n\n// node_modules/get-proto/index.js\nvar require_get_proto = __commonJS({\n  \"node_modules/get-proto/index.js\"(exports2, module2) {\n    \"use strict\";\n    var reflectGetProto = require_Reflect_getPrototypeOf();\n    var originalGetProto = require_Object_getPrototypeOf();\n    var getDunderProto = require_get();\n    module2.exports = reflectGetProto ? function getProto(O) {\n      return reflectGetProto(O);\n    } : originalGetProto ? function getProto(O) {\n      if (!O || typeof O !== \"object\" && typeof O !== \"function\") {\n        throw new TypeError(\"getProto: not an object\");\n      }\n      return originalGetProto(O);\n    } : getDunderProto ? function getProto(O) {\n      return getDunderProto(O);\n    } : null;\n  }\n});\n\n// node_modules/hasown/index.js\nvar require_hasown = __commonJS({\n  \"node_modules/hasown/index.js\"(exports2, module2) {\n    \"use strict\";\n    var call = Function.prototype.call;\n    var $hasOwn = Object.prototype.hasOwnProperty;\n    var bind = require_function_bind();\n    module2.exports = bind.call(call, $hasOwn);\n  }\n});\n\n// node_modules/get-intrinsic/index.js\nvar require_get_intrinsic = __commonJS({\n  \"node_modules/get-intrinsic/index.js\"(exports2, module2) {\n    \"use strict\";\n    var undefined2;\n    var $Object = require_es_object_atoms();\n    var $Error = require_es_errors();\n    var $EvalError = require_eval();\n    var $RangeError = require_range();\n    var $ReferenceError = require_ref();\n    var $SyntaxError = require_syntax();\n    var $TypeError = require_type();\n    var $URIError = require_uri();\n    var abs = require_abs();\n    var floor = require_floor();\n    var max = require_max();\n    var min = require_min();\n    var pow = require_pow();\n    var round = require_round();\n    var sign = require_sign();\n    var $Function = Function;\n    var getEvalledConstructor = function(expressionSyntax) {\n      try {\n        return $Function('\"use strict\"; return (' + expressionSyntax + \").constructor;\")();\n      } catch (e) {\n      }\n    };\n    var $gOPD = require_gopd();\n    var $defineProperty = require_es_define_property();\n    var throwTypeError = function() {\n      throw new $TypeError();\n    };\n    var ThrowTypeError = $gOPD ? function() {\n      try {\n        arguments.callee;\n        return throwTypeError;\n      } catch (calleeThrows) {\n        try {\n          return $gOPD(arguments, \"callee\").get;\n        } catch (gOPDthrows) {\n          return throwTypeError;\n        }\n      }\n    }() : throwTypeError;\n    var hasSymbols = require_has_symbols()();\n    var getProto = require_get_proto();\n    var $ObjectGPO = require_Object_getPrototypeOf();\n    var $ReflectGPO = require_Reflect_getPrototypeOf();\n    var $apply = require_functionApply();\n    var $call = require_functionCall();\n    var needsEval = {};\n    var TypedArray = typeof Uint8Array === \"undefined\" || !getProto ? undefined2 : getProto(Uint8Array);\n    var INTRINSICS = {\n      __proto__: null,\n      \"%AggregateError%\": typeof AggregateError === \"undefined\" ? undefined2 : AggregateError,\n      \"%Array%\": Array,\n      \"%ArrayBuffer%\": typeof ArrayBuffer === \"undefined\" ? undefined2 : ArrayBuffer,\n      \"%ArrayIteratorPrototype%\": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,\n      \"%AsyncFromSyncIteratorPrototype%\": undefined2,\n      \"%AsyncFunction%\": needsEval,\n      \"%AsyncGenerator%\": needsEval,\n      \"%AsyncGeneratorFunction%\": needsEval,\n      \"%AsyncIteratorPrototype%\": needsEval,\n      \"%Atomics%\": typeof Atomics === \"undefined\" ? undefined2 : Atomics,\n      \"%BigInt%\": typeof BigInt === \"undefined\" ? undefined2 : BigInt,\n      \"%BigInt64Array%\": typeof BigInt64Array === \"undefined\" ? undefined2 : BigInt64Array,\n      \"%BigUint64Array%\": typeof BigUint64Array === \"undefined\" ? undefined2 : BigUint64Array,\n      \"%Boolean%\": Boolean,\n      \"%DataView%\": typeof DataView === \"undefined\" ? undefined2 : DataView,\n      \"%Date%\": Date,\n      \"%decodeURI%\": decodeURI,\n      \"%decodeURIComponent%\": decodeURIComponent,\n      \"%encodeURI%\": encodeURI,\n      \"%encodeURIComponent%\": encodeURIComponent,\n      \"%Error%\": $Error,\n      \"%eval%\": eval,\n      // eslint-disable-line no-eval\n      \"%EvalError%\": $EvalError,\n      \"%Float16Array%\": typeof Float16Array === \"undefined\" ? undefined2 : Float16Array,\n      \"%Float32Array%\": typeof Float32Array === \"undefined\" ? undefined2 : Float32Array,\n      \"%Float64Array%\": typeof Float64Array === \"undefined\" ? undefined2 : Float64Array,\n      \"%FinalizationRegistry%\": typeof FinalizationRegistry === \"undefined\" ? undefined2 : FinalizationRegistry,\n      \"%Function%\": $Function,\n      \"%GeneratorFunction%\": needsEval,\n      \"%Int8Array%\": typeof Int8Array === \"undefined\" ? undefined2 : Int8Array,\n      \"%Int16Array%\": typeof Int16Array === \"undefined\" ? undefined2 : Int16Array,\n      \"%Int32Array%\": typeof Int32Array === \"undefined\" ? undefined2 : Int32Array,\n      \"%isFinite%\": isFinite,\n      \"%isNaN%\": isNaN,\n      \"%IteratorPrototype%\": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,\n      \"%JSON%\": typeof JSON === \"object\" ? JSON : undefined2,\n      \"%Map%\": typeof Map === \"undefined\" ? undefined2 : Map,\n      \"%MapIteratorPrototype%\": typeof Map === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),\n      \"%Math%\": Math,\n      \"%Number%\": Number,\n      \"%Object%\": $Object,\n      \"%Object.getOwnPropertyDescriptor%\": $gOPD,\n      \"%parseFloat%\": parseFloat,\n      \"%parseInt%\": parseInt,\n      \"%Promise%\": typeof Promise === \"undefined\" ? undefined2 : Promise,\n      \"%Proxy%\": typeof Proxy === \"undefined\" ? undefined2 : Proxy,\n      \"%RangeError%\": $RangeError,\n      \"%ReferenceError%\": $ReferenceError,\n      \"%Reflect%\": typeof Reflect === \"undefined\" ? undefined2 : Reflect,\n      \"%RegExp%\": RegExp,\n      \"%Set%\": typeof Set === \"undefined\" ? undefined2 : Set,\n      \"%SetIteratorPrototype%\": typeof Set === \"undefined\" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),\n      \"%SharedArrayBuffer%\": typeof SharedArrayBuffer === \"undefined\" ? undefined2 : SharedArrayBuffer,\n      \"%String%\": String,\n      \"%StringIteratorPrototype%\": hasSymbols && getProto ? getProto(\"\"[Symbol.iterator]()) : undefined2,\n      \"%Symbol%\": hasSymbols ? Symbol : undefined2,\n      \"%SyntaxError%\": $SyntaxError,\n      \"%ThrowTypeError%\": ThrowTypeError,\n      \"%TypedArray%\": TypedArray,\n      \"%TypeError%\": $TypeError,\n      \"%Uint8Array%\": typeof Uint8Array === \"undefined\" ? undefined2 : Uint8Array,\n      \"%Uint8ClampedArray%\": typeof Uint8ClampedArray === \"undefined\" ? undefined2 : Uint8ClampedArray,\n      \"%Uint16Array%\": typeof Uint16Array === \"undefined\" ? undefined2 : Uint16Array,\n      \"%Uint32Array%\": typeof Uint32Array === \"undefined\" ? undefined2 : Uint32Array,\n      \"%URIError%\": $URIError,\n      \"%WeakMap%\": typeof WeakMap === \"undefined\" ? undefined2 : WeakMap,\n      \"%WeakRef%\": typeof WeakRef === \"undefined\" ? undefined2 : WeakRef,\n      \"%WeakSet%\": typeof WeakSet === \"undefined\" ? undefined2 : WeakSet,\n      \"%Function.prototype.call%\": $call,\n      \"%Function.prototype.apply%\": $apply,\n      \"%Object.defineProperty%\": $defineProperty,\n      \"%Object.getPrototypeOf%\": $ObjectGPO,\n      \"%Math.abs%\": abs,\n      \"%Math.floor%\": floor,\n      \"%Math.max%\": max,\n      \"%Math.min%\": min,\n      \"%Math.pow%\": pow,\n      \"%Math.round%\": round,\n      \"%Math.sign%\": sign,\n      \"%Reflect.getPrototypeOf%\": $ReflectGPO\n    };\n    if (getProto) {\n      try {\n        null.error;\n      } catch (e) {\n        errorProto = getProto(getProto(e));\n        INTRINSICS[\"%Error.prototype%\"] = errorProto;\n      }\n    }\n    var errorProto;\n    var doEval = function doEval2(name) {\n      var value;\n      if (name === \"%AsyncFunction%\") {\n        value = getEvalledConstructor(\"async function () {}\");\n      } else if (name === \"%GeneratorFunction%\") {\n        value = getEvalledConstructor(\"function* () {}\");\n      } else if (name === \"%AsyncGeneratorFunction%\") {\n        value = getEvalledConstructor(\"async function* () {}\");\n      } else if (name === \"%AsyncGenerator%\") {\n        var fn = doEval2(\"%AsyncGeneratorFunction%\");\n        if (fn) {\n          value = fn.prototype;\n        }\n      } else if (name === \"%AsyncIteratorPrototype%\") {\n        var gen = doEval2(\"%AsyncGenerator%\");\n        if (gen && getProto) {\n          value = getProto(gen.prototype);\n        }\n      }\n      INTRINSICS[name] = value;\n      return value;\n    };\n    var LEGACY_ALIASES = {\n      __proto__: null,\n      \"%ArrayBufferPrototype%\": [\"ArrayBuffer\", \"prototype\"],\n      \"%ArrayPrototype%\": [\"Array\", \"prototype\"],\n      \"%ArrayProto_entries%\": [\"Array\", \"prototype\", \"entries\"],\n      \"%ArrayProto_forEach%\": [\"Array\", \"prototype\", \"forEach\"],\n      \"%ArrayProto_keys%\": [\"Array\", \"prototype\", \"keys\"],\n      \"%ArrayProto_values%\": [\"Array\", \"prototype\", \"values\"],\n      \"%AsyncFunctionPrototype%\": [\"AsyncFunction\", \"prototype\"],\n      \"%AsyncGenerator%\": [\"AsyncGeneratorFunction\", \"prototype\"],\n      \"%AsyncGeneratorPrototype%\": [\"AsyncGeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%BooleanPrototype%\": [\"Boolean\", \"prototype\"],\n      \"%DataViewPrototype%\": [\"DataView\", \"prototype\"],\n      \"%DatePrototype%\": [\"Date\", \"prototype\"],\n      \"%ErrorPrototype%\": [\"Error\", \"prototype\"],\n      \"%EvalErrorPrototype%\": [\"EvalError\", \"prototype\"],\n      \"%Float32ArrayPrototype%\": [\"Float32Array\", \"prototype\"],\n      \"%Float64ArrayPrototype%\": [\"Float64Array\", \"prototype\"],\n      \"%FunctionPrototype%\": [\"Function\", \"prototype\"],\n      \"%Generator%\": [\"GeneratorFunction\", \"prototype\"],\n      \"%GeneratorPrototype%\": [\"GeneratorFunction\", \"prototype\", \"prototype\"],\n      \"%Int8ArrayPrototype%\": [\"Int8Array\", \"prototype\"],\n      \"%Int16ArrayPrototype%\": [\"Int16Array\", \"prototype\"],\n      \"%Int32ArrayPrototype%\": [\"Int32Array\", \"prototype\"],\n      \"%JSONParse%\": [\"JSON\", \"parse\"],\n      \"%JSONStringify%\": [\"JSON\", \"stringify\"],\n      \"%MapPrototype%\": [\"Map\", \"prototype\"],\n      \"%NumberPrototype%\": [\"Number\", \"prototype\"],\n      \"%ObjectPrototype%\": [\"Object\", \"prototype\"],\n      \"%ObjProto_toString%\": [\"Object\", \"prototype\", \"toString\"],\n      \"%ObjProto_valueOf%\": [\"Object\", \"prototype\", \"valueOf\"],\n      \"%PromisePrototype%\": [\"Promise\", \"prototype\"],\n      \"%PromiseProto_then%\": [\"Promise\", \"prototype\", \"then\"],\n      \"%Promise_all%\": [\"Promise\", \"all\"],\n      \"%Promise_reject%\": [\"Promise\", \"reject\"],\n      \"%Promise_resolve%\": [\"Promise\", \"resolve\"],\n      \"%RangeErrorPrototype%\": [\"RangeError\", \"prototype\"],\n      \"%ReferenceErrorPrototype%\": [\"ReferenceError\", \"prototype\"],\n      \"%RegExpPrototype%\": [\"RegExp\", \"prototype\"],\n      \"%SetPrototype%\": [\"Set\", \"prototype\"],\n      \"%SharedArrayBufferPrototype%\": [\"SharedArrayBuffer\", \"prototype\"],\n      \"%StringPrototype%\": [\"String\", \"prototype\"],\n      \"%SymbolPrototype%\": [\"Symbol\", \"prototype\"],\n      \"%SyntaxErrorPrototype%\": [\"SyntaxError\", \"prototype\"],\n      \"%TypedArrayPrototype%\": [\"TypedArray\", \"prototype\"],\n      \"%TypeErrorPrototype%\": [\"TypeError\", \"prototype\"],\n      \"%Uint8ArrayPrototype%\": [\"Uint8Array\", \"prototype\"],\n      \"%Uint8ClampedArrayPrototype%\": [\"Uint8ClampedArray\", \"prototype\"],\n      \"%Uint16ArrayPrototype%\": [\"Uint16Array\", \"prototype\"],\n      \"%Uint32ArrayPrototype%\": [\"Uint32Array\", \"prototype\"],\n      \"%URIErrorPrototype%\": [\"URIError\", \"prototype\"],\n      \"%WeakMapPrototype%\": [\"WeakMap\", \"prototype\"],\n      \"%WeakSetPrototype%\": [\"WeakSet\", \"prototype\"]\n    };\n    var bind = require_function_bind();\n    var hasOwn = require_hasown();\n    var $concat = bind.call($call, Array.prototype.concat);\n    var $spliceApply = bind.call($apply, Array.prototype.splice);\n    var $replace = bind.call($call, String.prototype.replace);\n    var $strSlice = bind.call($call, String.prototype.slice);\n    var $exec = bind.call($call, RegExp.prototype.exec);\n    var rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\n    var reEscapeChar = /\\\\(\\\\)?/g;\n    var stringToPath = function stringToPath2(string) {\n      var first = $strSlice(string, 0, 1);\n      var last = $strSlice(string, -1);\n      if (first === \"%\" && last !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected closing `%`\");\n      } else if (last === \"%\" && first !== \"%\") {\n        throw new $SyntaxError(\"invalid intrinsic syntax, expected opening `%`\");\n      }\n      var result = [];\n      $replace(string, rePropName, function(match, number, quote, subString) {\n        result[result.length] = quote ? $replace(subString, reEscapeChar, \"$1\") : number || match;\n      });\n      return result;\n    };\n    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {\n      var intrinsicName = name;\n      var alias;\n      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n        alias = LEGACY_ALIASES[intrinsicName];\n        intrinsicName = \"%\" + alias[0] + \"%\";\n      }\n      if (hasOwn(INTRINSICS, intrinsicName)) {\n        var value = INTRINSICS[intrinsicName];\n        if (value === needsEval) {\n          value = doEval(intrinsicName);\n        }\n        if (typeof value === \"undefined\" && !allowMissing) {\n          throw new $TypeError(\"intrinsic \" + name + \" exists, but is not available. Please file an issue!\");\n        }\n        return {\n          alias,\n          name: intrinsicName,\n          value\n        };\n      }\n      throw new $SyntaxError(\"intrinsic \" + name + \" does not exist!\");\n    };\n    module2.exports = function GetIntrinsic(name, allowMissing) {\n      if (typeof name !== \"string\" || name.length === 0) {\n        throw new $TypeError(\"intrinsic name must be a non-empty string\");\n      }\n      if (arguments.length > 1 && typeof allowMissing !== \"boolean\") {\n        throw new $TypeError('\"allowMissing\" argument must be a boolean');\n      }\n      if ($exec(/^%?[^%]*%?$/, name) === null) {\n        throw new $SyntaxError(\"`%` may not be present anywhere but at the beginning and end of the intrinsic name\");\n      }\n      var parts = stringToPath(name);\n      var intrinsicBaseName = parts.length > 0 ? parts[0] : \"\";\n      var intrinsic = getBaseIntrinsic(\"%\" + intrinsicBaseName + \"%\", allowMissing);\n      var intrinsicRealName = intrinsic.name;\n      var value = intrinsic.value;\n      var skipFurtherCaching = false;\n      var alias = intrinsic.alias;\n      if (alias) {\n        intrinsicBaseName = alias[0];\n        $spliceApply(parts, $concat([0, 1], alias));\n      }\n      for (var i = 1, isOwn = true; i < parts.length; i += 1) {\n        var part = parts[i];\n        var first = $strSlice(part, 0, 1);\n        var last = $strSlice(part, -1);\n        if ((first === '\"' || first === \"'\" || first === \"`\" || (last === '\"' || last === \"'\" || last === \"`\")) && first !== last) {\n          throw new $SyntaxError(\"property names with quotes must have matching quotes\");\n        }\n        if (part === \"constructor\" || !isOwn) {\n          skipFurtherCaching = true;\n        }\n        intrinsicBaseName += \".\" + part;\n        intrinsicRealName = \"%\" + intrinsicBaseName + \"%\";\n        if (hasOwn(INTRINSICS, intrinsicRealName)) {\n          value = INTRINSICS[intrinsicRealName];\n        } else if (value != null) {\n          if (!(part in value)) {\n            if (!allowMissing) {\n              throw new $TypeError(\"base intrinsic for \" + name + \" exists, but the property is not available.\");\n            }\n            return void undefined2;\n          }\n          if ($gOPD && i + 1 >= parts.length) {\n            var desc = $gOPD(value, part);\n            isOwn = !!desc;\n            if (isOwn && \"get\" in desc && !(\"originalValue\" in desc.get)) {\n              value = desc.get;\n            } else {\n              value = value[part];\n            }\n          } else {\n            isOwn = hasOwn(value, part);\n            value = value[part];\n          }\n          if (isOwn && !skipFurtherCaching) {\n            INTRINSICS[intrinsicRealName] = value;\n          }\n        }\n      }\n      return value;\n    };\n  }\n});\n\n// node_modules/call-bound/index.js\nvar require_call_bound = __commonJS({\n  \"node_modules/call-bound/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBindBasic = require_call_bind_apply_helpers();\n    var $indexOf = callBindBasic([GetIntrinsic(\"%String.prototype.indexOf%\")]);\n    module2.exports = function callBoundIntrinsic(name, allowMissing) {\n      var intrinsic = (\n        /** @type {(this: unknown, ...args: unknown[]) => unknown} */\n        GetIntrinsic(name, !!allowMissing)\n      );\n      if (typeof intrinsic === \"function\" && $indexOf(name, \".prototype.\") > -1) {\n        return callBindBasic(\n          /** @type {const} */\n          [intrinsic]\n        );\n      }\n      return intrinsic;\n    };\n  }\n});\n\n// node_modules/side-channel-map/index.js\nvar require_side_channel_map = __commonJS({\n  \"node_modules/side-channel-map/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBound = require_call_bound();\n    var inspect = require_object_inspect();\n    var $TypeError = require_type();\n    var $Map = GetIntrinsic(\"%Map%\", true);\n    var $mapGet = callBound(\"Map.prototype.get\", true);\n    var $mapSet = callBound(\"Map.prototype.set\", true);\n    var $mapHas = callBound(\"Map.prototype.has\", true);\n    var $mapDelete = callBound(\"Map.prototype.delete\", true);\n    var $mapSize = callBound(\"Map.prototype.size\", true);\n    module2.exports = !!$Map && /** @type {Exclude<import('.'), false>} */\n    function getSideChannelMap() {\n      var $m;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          if ($m) {\n            var result = $mapDelete($m, key);\n            if ($mapSize($m) === 0) {\n              $m = void 0;\n            }\n            return result;\n          }\n          return false;\n        },\n        get: function(key) {\n          if ($m) {\n            return $mapGet($m, key);\n          }\n        },\n        has: function(key) {\n          if ($m) {\n            return $mapHas($m, key);\n          }\n          return false;\n        },\n        set: function(key, value) {\n          if (!$m) {\n            $m = new $Map();\n          }\n          $mapSet($m, key, value);\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// node_modules/side-channel-weakmap/index.js\nvar require_side_channel_weakmap = __commonJS({\n  \"node_modules/side-channel-weakmap/index.js\"(exports2, module2) {\n    \"use strict\";\n    var GetIntrinsic = require_get_intrinsic();\n    var callBound = require_call_bound();\n    var inspect = require_object_inspect();\n    var getSideChannelMap = require_side_channel_map();\n    var $TypeError = require_type();\n    var $WeakMap = GetIntrinsic(\"%WeakMap%\", true);\n    var $weakMapGet = callBound(\"WeakMap.prototype.get\", true);\n    var $weakMapSet = callBound(\"WeakMap.prototype.set\", true);\n    var $weakMapHas = callBound(\"WeakMap.prototype.has\", true);\n    var $weakMapDelete = callBound(\"WeakMap.prototype.delete\", true);\n    module2.exports = $WeakMap ? (\n      /** @type {Exclude<import('.'), false>} */\n      function getSideChannelWeakMap() {\n        var $wm;\n        var $m;\n        var channel = {\n          assert: function(key) {\n            if (!channel.has(key)) {\n              throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n            }\n          },\n          \"delete\": function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapDelete($wm, key);\n              }\n            } else if (getSideChannelMap) {\n              if ($m) {\n                return $m[\"delete\"](key);\n              }\n            }\n            return false;\n          },\n          get: function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapGet($wm, key);\n              }\n            }\n            return $m && $m.get(key);\n          },\n          has: function(key) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if ($wm) {\n                return $weakMapHas($wm, key);\n              }\n            }\n            return !!$m && $m.has(key);\n          },\n          set: function(key, value) {\n            if ($WeakMap && key && (typeof key === \"object\" || typeof key === \"function\")) {\n              if (!$wm) {\n                $wm = new $WeakMap();\n              }\n              $weakMapSet($wm, key, value);\n            } else if (getSideChannelMap) {\n              if (!$m) {\n                $m = getSideChannelMap();\n              }\n              $m.set(key, value);\n            }\n          }\n        };\n        return channel;\n      }\n    ) : getSideChannelMap;\n  }\n});\n\n// node_modules/side-channel/index.js\nvar require_side_channel = __commonJS({\n  \"node_modules/side-channel/index.js\"(exports2, module2) {\n    \"use strict\";\n    var $TypeError = require_type();\n    var inspect = require_object_inspect();\n    var getSideChannelList = require_side_channel_list();\n    var getSideChannelMap = require_side_channel_map();\n    var getSideChannelWeakMap = require_side_channel_weakmap();\n    var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;\n    module2.exports = function getSideChannel() {\n      var $channelData;\n      var channel = {\n        assert: function(key) {\n          if (!channel.has(key)) {\n            throw new $TypeError(\"Side channel does not contain \" + inspect(key));\n          }\n        },\n        \"delete\": function(key) {\n          return !!$channelData && $channelData[\"delete\"](key);\n        },\n        get: function(key) {\n          return $channelData && $channelData.get(key);\n        },\n        has: function(key) {\n          return !!$channelData && $channelData.has(key);\n        },\n        set: function(key, value) {\n          if (!$channelData) {\n            $channelData = makeChannel();\n          }\n          $channelData.set(key, value);\n        }\n      };\n      return channel;\n    };\n  }\n});\n\n// node_modules/qs/lib/formats.js\nvar require_formats = __commonJS({\n  \"node_modules/qs/lib/formats.js\"(exports2, module2) {\n    \"use strict\";\n    var replace = String.prototype.replace;\n    var percentTwenties = /%20/g;\n    var Format = {\n      RFC1738: \"RFC1738\",\n      RFC3986: \"RFC3986\"\n    };\n    module2.exports = {\n      \"default\": Format.RFC3986,\n      formatters: {\n        RFC1738: function(value) {\n          return replace.call(value, percentTwenties, \"+\");\n        },\n        RFC3986: function(value) {\n          return String(value);\n        }\n      },\n      RFC1738: Format.RFC1738,\n      RFC3986: Format.RFC3986\n    };\n  }\n});\n\n// node_modules/qs/lib/utils.js\nvar require_utils2 = __commonJS({\n  \"node_modules/qs/lib/utils.js\"(exports2, module2) {\n    \"use strict\";\n    var formats = require_formats();\n    var has = Object.prototype.hasOwnProperty;\n    var isArray = Array.isArray;\n    var hexTable = function() {\n      var array = [];\n      for (var i = 0; i < 256; ++i) {\n        array.push(\"%\" + ((i < 16 ? \"0\" : \"\") + i.toString(16)).toUpperCase());\n      }\n      return array;\n    }();\n    var compactQueue = function compactQueue2(queue) {\n      while (queue.length > 1) {\n        var item = queue.pop();\n        var obj = item.obj[item.prop];\n        if (isArray(obj)) {\n          var compacted = [];\n          for (var j = 0; j < obj.length; ++j) {\n            if (typeof obj[j] !== \"undefined\") {\n              compacted.push(obj[j]);\n            }\n          }\n          item.obj[item.prop] = compacted;\n        }\n      }\n    };\n    var arrayToObject = function arrayToObject2(source, options) {\n      var obj = options && options.plainObjects ? { __proto__: null } : {};\n      for (var i = 0; i < source.length; ++i) {\n        if (typeof source[i] !== \"undefined\") {\n          obj[i] = source[i];\n        }\n      }\n      return obj;\n    };\n    var merge = function merge2(target, source, options) {\n      if (!source) {\n        return target;\n      }\n      if (typeof source !== \"object\" && typeof source !== \"function\") {\n        if (isArray(target)) {\n          target.push(source);\n        } else if (target && typeof target === \"object\") {\n          if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {\n            target[source] = true;\n          }\n        } else {\n          return [target, source];\n        }\n        return target;\n      }\n      if (!target || typeof target !== \"object\") {\n        return [target].concat(source);\n      }\n      var mergeTarget = target;\n      if (isArray(target) && !isArray(source)) {\n        mergeTarget = arrayToObject(target, options);\n      }\n      if (isArray(target) && isArray(source)) {\n        source.forEach(function(item, i) {\n          if (has.call(target, i)) {\n            var targetItem = target[i];\n            if (targetItem && typeof targetItem === \"object\" && item && typeof item === \"object\") {\n              target[i] = merge2(targetItem, item, options);\n            } else {\n              target.push(item);\n            }\n          } else {\n            target[i] = item;\n          }\n        });\n        return target;\n      }\n      return Object.keys(source).reduce(function(acc, key) {\n        var value = source[key];\n        if (has.call(acc, key)) {\n          acc[key] = merge2(acc[key], value, options);\n        } else {\n          acc[key] = value;\n        }\n        return acc;\n      }, mergeTarget);\n    };\n    var assign = function assignSingleSource(target, source) {\n      return Object.keys(source).reduce(function(acc, key) {\n        acc[key] = source[key];\n        return acc;\n      }, target);\n    };\n    var decode = function(str, defaultDecoder, charset) {\n      var strWithoutPlus = str.replace(/\\+/g, \" \");\n      if (charset === \"iso-8859-1\") {\n        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n      }\n      try {\n        return decodeURIComponent(strWithoutPlus);\n      } catch (e) {\n        return strWithoutPlus;\n      }\n    };\n    var limit = 1024;\n    var encode = function encode2(str, defaultEncoder, charset, kind, format) {\n      if (str.length === 0) {\n        return str;\n      }\n      var string = str;\n      if (typeof str === \"symbol\") {\n        string = Symbol.prototype.toString.call(str);\n      } else if (typeof str !== \"string\") {\n        string = String(str);\n      }\n      if (charset === \"iso-8859-1\") {\n        return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {\n          return \"%26%23\" + parseInt($0.slice(2), 16) + \"%3B\";\n        });\n      }\n      var out = \"\";\n      for (var j = 0; j < string.length; j += limit) {\n        var segment = string.length >= limit ? string.slice(j, j + limit) : string;\n        var arr = [];\n        for (var i = 0; i < segment.length; ++i) {\n          var c = segment.charCodeAt(i);\n          if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats.RFC1738 && (c === 40 || c === 41)) {\n            arr[arr.length] = segment.charAt(i);\n            continue;\n          }\n          if (c < 128) {\n            arr[arr.length] = hexTable[c];\n            continue;\n          }\n          if (c < 2048) {\n            arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];\n            continue;\n          }\n          if (c < 55296 || c >= 57344) {\n            arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];\n            continue;\n          }\n          i += 1;\n          c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);\n          arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];\n        }\n        out += arr.join(\"\");\n      }\n      return out;\n    };\n    var compact = function compact2(value) {\n      var queue = [{ obj: { o: value }, prop: \"o\" }];\n      var refs = [];\n      for (var i = 0; i < queue.length; ++i) {\n        var item = queue[i];\n        var obj = item.obj[item.prop];\n        var keys = Object.keys(obj);\n        for (var j = 0; j < keys.length; ++j) {\n          var key = keys[j];\n          var val = obj[key];\n          if (typeof val === \"object\" && val !== null && refs.indexOf(val) === -1) {\n            queue.push({ obj, prop: key });\n            refs.push(val);\n          }\n        }\n      }\n      compactQueue(queue);\n      return value;\n    };\n    var isRegExp = function isRegExp2(obj) {\n      return Object.prototype.toString.call(obj) === \"[object RegExp]\";\n    };\n    var isBuffer = function isBuffer2(obj) {\n      if (!obj || typeof obj !== \"object\") {\n        return false;\n      }\n      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n    };\n    var combine = function combine2(a, b) {\n      return [].concat(a, b);\n    };\n    var maybeMap = function maybeMap2(val, fn) {\n      if (isArray(val)) {\n        var mapped = [];\n        for (var i = 0; i < val.length; i += 1) {\n          mapped.push(fn(val[i]));\n        }\n        return mapped;\n      }\n      return fn(val);\n    };\n    module2.exports = {\n      arrayToObject,\n      assign,\n      combine,\n      compact,\n      decode,\n      encode,\n      isBuffer,\n      isRegExp,\n      maybeMap,\n      merge\n    };\n  }\n});\n\n// node_modules/qs/lib/stringify.js\nvar require_stringify = __commonJS({\n  \"node_modules/qs/lib/stringify.js\"(exports2, module2) {\n    \"use strict\";\n    var getSideChannel = require_side_channel();\n    var utils = require_utils2();\n    var formats = require_formats();\n    var has = Object.prototype.hasOwnProperty;\n    var arrayPrefixGenerators = {\n      brackets: function brackets(prefix) {\n        return prefix + \"[]\";\n      },\n      comma: \"comma\",\n      indices: function indices(prefix, key) {\n        return prefix + \"[\" + key + \"]\";\n      },\n      repeat: function repeat(prefix) {\n        return prefix;\n      }\n    };\n    var isArray = Array.isArray;\n    var push = Array.prototype.push;\n    var pushToArray = function(arr, valueOrArray) {\n      push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n    };\n    var toISO = Date.prototype.toISOString;\n    var defaultFormat = formats[\"default\"];\n    var defaults = {\n      addQueryPrefix: false,\n      allowDots: false,\n      allowEmptyArrays: false,\n      arrayFormat: \"indices\",\n      charset: \"utf-8\",\n      charsetSentinel: false,\n      commaRoundTrip: false,\n      delimiter: \"&\",\n      encode: true,\n      encodeDotInKeys: false,\n      encoder: utils.encode,\n      encodeValuesOnly: false,\n      filter: void 0,\n      format: defaultFormat,\n      formatter: formats.formatters[defaultFormat],\n      // deprecated\n      indices: false,\n      serializeDate: function serializeDate(date) {\n        return toISO.call(date);\n      },\n      skipNulls: false,\n      strictNullHandling: false\n    };\n    var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {\n      return typeof v === \"string\" || typeof v === \"number\" || typeof v === \"boolean\" || typeof v === \"symbol\" || typeof v === \"bigint\";\n    };\n    var sentinel = {};\n    var stringify = function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {\n      var obj = object;\n      var tmpSc = sideChannel;\n      var step = 0;\n      var findFlag = false;\n      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {\n        var pos = tmpSc.get(object);\n        step += 1;\n        if (typeof pos !== \"undefined\") {\n          if (pos === step) {\n            throw new RangeError(\"Cyclic object value\");\n          } else {\n            findFlag = true;\n          }\n        }\n        if (typeof tmpSc.get(sentinel) === \"undefined\") {\n          step = 0;\n        }\n      }\n      if (typeof filter === \"function\") {\n        obj = filter(prefix, obj);\n      } else if (obj instanceof Date) {\n        obj = serializeDate(obj);\n      } else if (generateArrayPrefix === \"comma\" && isArray(obj)) {\n        obj = utils.maybeMap(obj, function(value2) {\n          if (value2 instanceof Date) {\n            return serializeDate(value2);\n          }\n          return value2;\n        });\n      }\n      if (obj === null) {\n        if (strictNullHandling) {\n          return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, \"key\", format) : prefix;\n        }\n        obj = \"\";\n      }\n      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n        if (encoder) {\n          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, \"key\", format);\n          return [formatter(keyValue) + \"=\" + formatter(encoder(obj, defaults.encoder, charset, \"value\", format))];\n        }\n        return [formatter(prefix) + \"=\" + formatter(String(obj))];\n      }\n      var values = [];\n      if (typeof obj === \"undefined\") {\n        return values;\n      }\n      var objKeys;\n      if (generateArrayPrefix === \"comma\" && isArray(obj)) {\n        if (encodeValuesOnly && encoder) {\n          obj = utils.maybeMap(obj, encoder);\n        }\n        objKeys = [{ value: obj.length > 0 ? obj.join(\",\") || null : void 0 }];\n      } else if (isArray(filter)) {\n        objKeys = filter;\n      } else {\n        var keys = Object.keys(obj);\n        objKeys = sort ? keys.sort(sort) : keys;\n      }\n      var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\\./g, \"%2E\") : String(prefix);\n      var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + \"[]\" : encodedPrefix;\n      if (allowEmptyArrays && isArray(obj) && obj.length === 0) {\n        return adjustedPrefix + \"[]\";\n      }\n      for (var j = 0; j < objKeys.length; ++j) {\n        var key = objKeys[j];\n        var value = typeof key === \"object\" && key && typeof key.value !== \"undefined\" ? key.value : obj[key];\n        if (skipNulls && value === null) {\n          continue;\n        }\n        var encodedKey = allowDots && encodeDotInKeys ? String(key).replace(/\\./g, \"%2E\") : String(key);\n        var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === \"function\" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? \".\" + encodedKey : \"[\" + encodedKey + \"]\");\n        sideChannel.set(object, step);\n        var valueSideChannel = getSideChannel();\n        valueSideChannel.set(sentinel, sideChannel);\n        pushToArray(values, stringify2(\n          value,\n          keyPrefix,\n          generateArrayPrefix,\n          commaRoundTrip,\n          allowEmptyArrays,\n          strictNullHandling,\n          skipNulls,\n          encodeDotInKeys,\n          generateArrayPrefix === \"comma\" && encodeValuesOnly && isArray(obj) ? null : encoder,\n          filter,\n          sort,\n          allowDots,\n          serializeDate,\n          format,\n          formatter,\n          encodeValuesOnly,\n          charset,\n          valueSideChannel\n        ));\n      }\n      return values;\n    };\n    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {\n      if (!opts) {\n        return defaults;\n      }\n      if (typeof opts.allowEmptyArrays !== \"undefined\" && typeof opts.allowEmptyArrays !== \"boolean\") {\n        throw new TypeError(\"`allowEmptyArrays` option can only be `true` or `false`, when provided\");\n      }\n      if (typeof opts.encodeDotInKeys !== \"undefined\" && typeof opts.encodeDotInKeys !== \"boolean\") {\n        throw new TypeError(\"`encodeDotInKeys` option can only be `true` or `false`, when provided\");\n      }\n      if (opts.encoder !== null && typeof opts.encoder !== \"undefined\" && typeof opts.encoder !== \"function\") {\n        throw new TypeError(\"Encoder has to be a function.\");\n      }\n      var charset = opts.charset || defaults.charset;\n      if (typeof opts.charset !== \"undefined\" && opts.charset !== \"utf-8\" && opts.charset !== \"iso-8859-1\") {\n        throw new TypeError(\"The charset option must be either utf-8, iso-8859-1, or undefined\");\n      }\n      var format = formats[\"default\"];\n      if (typeof opts.format !== \"undefined\") {\n        if (!has.call(formats.formatters, opts.format)) {\n          throw new TypeError(\"Unknown format option provided.\");\n        }\n        format = opts.format;\n      }\n      var formatter = formats.formatters[format];\n      var filter = defaults.filter;\n      if (typeof opts.filter === \"function\" || isArray(opts.filter)) {\n        filter = opts.filter;\n      }\n      var arrayFormat;\n      if (opts.arrayFormat in arrayPrefixGenerators) {\n        arrayFormat = opts.arrayFormat;\n      } else if (\"indices\" in opts) {\n        arrayFormat = opts.indices ? \"indices\" : \"repeat\";\n      } else {\n        arrayFormat = defaults.arrayFormat;\n      }\n      if (\"commaRoundTrip\" in opts && typeof opts.commaRoundTrip !== \"boolean\") {\n        throw new TypeError(\"`commaRoundTrip` must be a boolean, or absent\");\n      }\n      var allowDots = typeof opts.allowDots === \"undefined\" ? opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n      return {\n        addQueryPrefix: typeof opts.addQueryPrefix === \"boolean\" ? opts.addQueryPrefix : defaults.addQueryPrefix,\n        allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === \"boolean\" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        arrayFormat,\n        charset,\n        charsetSentinel: typeof opts.charsetSentinel === \"boolean\" ? opts.charsetSentinel : defaults.charsetSentinel,\n        commaRoundTrip: !!opts.commaRoundTrip,\n        delimiter: typeof opts.delimiter === \"undefined\" ? defaults.delimiter : opts.delimiter,\n        encode: typeof opts.encode === \"boolean\" ? opts.encode : defaults.encode,\n        encodeDotInKeys: typeof opts.encodeDotInKeys === \"boolean\" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,\n        encoder: typeof opts.encoder === \"function\" ? opts.encoder : defaults.encoder,\n        encodeValuesOnly: typeof opts.encodeValuesOnly === \"boolean\" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n        filter,\n        format,\n        formatter,\n        serializeDate: typeof opts.serializeDate === \"function\" ? opts.serializeDate : defaults.serializeDate,\n        skipNulls: typeof opts.skipNulls === \"boolean\" ? opts.skipNulls : defaults.skipNulls,\n        sort: typeof opts.sort === \"function\" ? opts.sort : null,\n        strictNullHandling: typeof opts.strictNullHandling === \"boolean\" ? opts.strictNullHandling : defaults.strictNullHandling\n      };\n    };\n    module2.exports = function(object, opts) {\n      var obj = object;\n      var options = normalizeStringifyOptions(opts);\n      var objKeys;\n      var filter;\n      if (typeof options.filter === \"function\") {\n        filter = options.filter;\n        obj = filter(\"\", obj);\n      } else if (isArray(options.filter)) {\n        filter = options.filter;\n        objKeys = filter;\n      }\n      var keys = [];\n      if (typeof obj !== \"object\" || obj === null) {\n        return \"\";\n      }\n      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];\n      var commaRoundTrip = generateArrayPrefix === \"comma\" && options.commaRoundTrip;\n      if (!objKeys) {\n        objKeys = Object.keys(obj);\n      }\n      if (options.sort) {\n        objKeys.sort(options.sort);\n      }\n      var sideChannel = getSideChannel();\n      for (var i = 0; i < objKeys.length; ++i) {\n        var key = objKeys[i];\n        var value = obj[key];\n        if (options.skipNulls && value === null) {\n          continue;\n        }\n        pushToArray(keys, stringify(\n          value,\n          key,\n          generateArrayPrefix,\n          commaRoundTrip,\n          options.allowEmptyArrays,\n          options.strictNullHandling,\n          options.skipNulls,\n          options.encodeDotInKeys,\n          options.encode ? options.encoder : null,\n          options.filter,\n          options.sort,\n          options.allowDots,\n          options.serializeDate,\n          options.format,\n          options.formatter,\n          options.encodeValuesOnly,\n          options.charset,\n          sideChannel\n        ));\n      }\n      var joined = keys.join(options.delimiter);\n      var prefix = options.addQueryPrefix === true ? \"?\" : \"\";\n      if (options.charsetSentinel) {\n        if (options.charset === \"iso-8859-1\") {\n          prefix += \"utf8=%26%2310003%3B&\";\n        } else {\n          prefix += \"utf8=%E2%9C%93&\";\n        }\n      }\n      return joined.length > 0 ? prefix + joined : \"\";\n    };\n  }\n});\n\n// node_modules/qs/lib/parse.js\nvar require_parse = __commonJS({\n  \"node_modules/qs/lib/parse.js\"(exports2, module2) {\n    \"use strict\";\n    var utils = require_utils2();\n    var has = Object.prototype.hasOwnProperty;\n    var isArray = Array.isArray;\n    var defaults = {\n      allowDots: false,\n      allowEmptyArrays: false,\n      allowPrototypes: false,\n      allowSparse: false,\n      arrayLimit: 20,\n      charset: \"utf-8\",\n      charsetSentinel: false,\n      comma: false,\n      decodeDotInKeys: false,\n      decoder: utils.decode,\n      delimiter: \"&\",\n      depth: 5,\n      duplicates: \"combine\",\n      ignoreQueryPrefix: false,\n      interpretNumericEntities: false,\n      parameterLimit: 1e3,\n      parseArrays: true,\n      plainObjects: false,\n      strictDepth: false,\n      strictNullHandling: false,\n      throwOnLimitExceeded: false\n    };\n    var interpretNumericEntities = function(str) {\n      return str.replace(/&#(\\d+);/g, function($0, numberStr) {\n        return String.fromCharCode(parseInt(numberStr, 10));\n      });\n    };\n    var parseArrayValue = function(val, options, currentArrayLength) {\n      if (val && typeof val === \"string\" && options.comma && val.indexOf(\",\") > -1) {\n        return val.split(\",\");\n      }\n      if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {\n        throw new RangeError(\"Array limit exceeded. Only \" + options.arrayLimit + \" element\" + (options.arrayLimit === 1 ? \"\" : \"s\") + \" allowed in an array.\");\n      }\n      return val;\n    };\n    var isoSentinel = \"utf8=%26%2310003%3B\";\n    var charsetSentinel = \"utf8=%E2%9C%93\";\n    var parseValues = function parseQueryStringValues(str, options) {\n      var obj = { __proto__: null };\n      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, \"\") : str;\n      cleanStr = cleanStr.replace(/%5B/gi, \"[\").replace(/%5D/gi, \"]\");\n      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;\n      var parts = cleanStr.split(\n        options.delimiter,\n        options.throwOnLimitExceeded ? limit + 1 : limit\n      );\n      if (options.throwOnLimitExceeded && parts.length > limit) {\n        throw new RangeError(\"Parameter limit exceeded. Only \" + limit + \" parameter\" + (limit === 1 ? \"\" : \"s\") + \" allowed.\");\n      }\n      var skipIndex = -1;\n      var i;\n      var charset = options.charset;\n      if (options.charsetSentinel) {\n        for (i = 0; i < parts.length; ++i) {\n          if (parts[i].indexOf(\"utf8=\") === 0) {\n            if (parts[i] === charsetSentinel) {\n              charset = \"utf-8\";\n            } else if (parts[i] === isoSentinel) {\n              charset = \"iso-8859-1\";\n            }\n            skipIndex = i;\n            i = parts.length;\n          }\n        }\n      }\n      for (i = 0; i < parts.length; ++i) {\n        if (i === skipIndex) {\n          continue;\n        }\n        var part = parts[i];\n        var bracketEqualsPos = part.indexOf(\"]=\");\n        var pos = bracketEqualsPos === -1 ? part.indexOf(\"=\") : bracketEqualsPos + 1;\n        var key;\n        var val;\n        if (pos === -1) {\n          key = options.decoder(part, defaults.decoder, charset, \"key\");\n          val = options.strictNullHandling ? null : \"\";\n        } else {\n          key = options.decoder(part.slice(0, pos), defaults.decoder, charset, \"key\");\n          val = utils.maybeMap(\n            parseArrayValue(\n              part.slice(pos + 1),\n              options,\n              isArray(obj[key]) ? obj[key].length : 0\n            ),\n            function(encodedVal) {\n              return options.decoder(encodedVal, defaults.decoder, charset, \"value\");\n            }\n          );\n        }\n        if (val && options.interpretNumericEntities && charset === \"iso-8859-1\") {\n          val = interpretNumericEntities(String(val));\n        }\n        if (part.indexOf(\"[]=\") > -1) {\n          val = isArray(val) ? [val] : val;\n        }\n        var existing = has.call(obj, key);\n        if (existing && options.duplicates === \"combine\") {\n          obj[key] = utils.combine(obj[key], val);\n        } else if (!existing || options.duplicates === \"last\") {\n          obj[key] = val;\n        }\n      }\n      return obj;\n    };\n    var parseObject = function(chain, val, options, valuesParsed) {\n      var currentArrayLength = 0;\n      if (chain.length > 0 && chain[chain.length - 1] === \"[]\") {\n        var parentKey = chain.slice(0, -1).join(\"\");\n        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;\n      }\n      var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);\n      for (var i = chain.length - 1; i >= 0; --i) {\n        var obj;\n        var root = chain[i];\n        if (root === \"[]\" && options.parseArrays) {\n          obj = options.allowEmptyArrays && (leaf === \"\" || options.strictNullHandling && leaf === null) ? [] : utils.combine([], leaf);\n        } else {\n          obj = options.plainObjects ? { __proto__: null } : {};\n          var cleanRoot = root.charAt(0) === \"[\" && root.charAt(root.length - 1) === \"]\" ? root.slice(1, -1) : root;\n          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, \".\") : cleanRoot;\n          var index = parseInt(decodedRoot, 10);\n          if (!options.parseArrays && decodedRoot === \"\") {\n            obj = { 0: leaf };\n          } else if (!isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) {\n            obj = [];\n            obj[index] = leaf;\n          } else if (decodedRoot !== \"__proto__\") {\n            obj[decodedRoot] = leaf;\n          }\n        }\n        leaf = obj;\n      }\n      return leaf;\n    };\n    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {\n      if (!givenKey) {\n        return;\n      }\n      var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, \"[$1]\") : givenKey;\n      var brackets = /(\\[[^[\\]]*])/;\n      var child = /(\\[[^[\\]]*])/g;\n      var segment = options.depth > 0 && brackets.exec(key);\n      var parent = segment ? key.slice(0, segment.index) : key;\n      var keys = [];\n      if (parent) {\n        if (!options.plainObjects && has.call(Object.prototype, parent)) {\n          if (!options.allowPrototypes) {\n            return;\n          }\n        }\n        keys.push(parent);\n      }\n      var i = 0;\n      while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {\n        i += 1;\n        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {\n          if (!options.allowPrototypes) {\n            return;\n          }\n        }\n        keys.push(segment[1]);\n      }\n      if (segment) {\n        if (options.strictDepth === true) {\n          throw new RangeError(\"Input depth exceeded depth option of \" + options.depth + \" and strictDepth is true\");\n        }\n        keys.push(\"[\" + key.slice(segment.index) + \"]\");\n      }\n      return parseObject(keys, val, options, valuesParsed);\n    };\n    var normalizeParseOptions = function normalizeParseOptions2(opts) {\n      if (!opts) {\n        return defaults;\n      }\n      if (typeof opts.allowEmptyArrays !== \"undefined\" && typeof opts.allowEmptyArrays !== \"boolean\") {\n        throw new TypeError(\"`allowEmptyArrays` option can only be `true` or `false`, when provided\");\n      }\n      if (typeof opts.decodeDotInKeys !== \"undefined\" && typeof opts.decodeDotInKeys !== \"boolean\") {\n        throw new TypeError(\"`decodeDotInKeys` option can only be `true` or `false`, when provided\");\n      }\n      if (opts.decoder !== null && typeof opts.decoder !== \"undefined\" && typeof opts.decoder !== \"function\") {\n        throw new TypeError(\"Decoder has to be a function.\");\n      }\n      if (typeof opts.charset !== \"undefined\" && opts.charset !== \"utf-8\" && opts.charset !== \"iso-8859-1\") {\n        throw new TypeError(\"The charset option must be either utf-8, iso-8859-1, or undefined\");\n      }\n      if (typeof opts.throwOnLimitExceeded !== \"undefined\" && typeof opts.throwOnLimitExceeded !== \"boolean\") {\n        throw new TypeError(\"`throwOnLimitExceeded` option must be a boolean\");\n      }\n      var charset = typeof opts.charset === \"undefined\" ? defaults.charset : opts.charset;\n      var duplicates = typeof opts.duplicates === \"undefined\" ? defaults.duplicates : opts.duplicates;\n      if (duplicates !== \"combine\" && duplicates !== \"first\" && duplicates !== \"last\") {\n        throw new TypeError(\"The duplicates option must be either combine, first, or last\");\n      }\n      var allowDots = typeof opts.allowDots === \"undefined\" ? opts.decodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;\n      return {\n        allowDots,\n        allowEmptyArrays: typeof opts.allowEmptyArrays === \"boolean\" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,\n        allowPrototypes: typeof opts.allowPrototypes === \"boolean\" ? opts.allowPrototypes : defaults.allowPrototypes,\n        allowSparse: typeof opts.allowSparse === \"boolean\" ? opts.allowSparse : defaults.allowSparse,\n        arrayLimit: typeof opts.arrayLimit === \"number\" ? opts.arrayLimit : defaults.arrayLimit,\n        charset,\n        charsetSentinel: typeof opts.charsetSentinel === \"boolean\" ? opts.charsetSentinel : defaults.charsetSentinel,\n        comma: typeof opts.comma === \"boolean\" ? opts.comma : defaults.comma,\n        decodeDotInKeys: typeof opts.decodeDotInKeys === \"boolean\" ? opts.decodeDotInKeys : defaults.decodeDotInKeys,\n        decoder: typeof opts.decoder === \"function\" ? opts.decoder : defaults.decoder,\n        delimiter: typeof opts.delimiter === \"string\" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n        // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n        depth: typeof opts.depth === \"number\" || opts.depth === false ? +opts.depth : defaults.depth,\n        duplicates,\n        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n        interpretNumericEntities: typeof opts.interpretNumericEntities === \"boolean\" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n        parameterLimit: typeof opts.parameterLimit === \"number\" ? opts.parameterLimit : defaults.parameterLimit,\n        parseArrays: opts.parseArrays !== false,\n        plainObjects: typeof opts.plainObjects === \"boolean\" ? opts.plainObjects : defaults.plainObjects,\n        strictDepth: typeof opts.strictDepth === \"boolean\" ? !!opts.strictDepth : defaults.strictDepth,\n        strictNullHandling: typeof opts.strictNullHandling === \"boolean\" ? opts.strictNullHandling : defaults.strictNullHandling,\n        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === \"boolean\" ? opts.throwOnLimitExceeded : false\n      };\n    };\n    module2.exports = function(str, opts) {\n      var options = normalizeParseOptions(opts);\n      if (str === \"\" || str === null || typeof str === \"undefined\") {\n        return options.plainObjects ? { __proto__: null } : {};\n      }\n      var tempObj = typeof str === \"string\" ? parseValues(str, options) : str;\n      var obj = options.plainObjects ? { __proto__: null } : {};\n      var keys = Object.keys(tempObj);\n      for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var newObj = parseKeys(key, tempObj[key], options, typeof str === \"string\");\n        obj = utils.merge(obj, newObj, options);\n      }\n      if (options.allowSparse === true) {\n        return obj;\n      }\n      return utils.compact(obj);\n    };\n  }\n});\n\n// node_modules/qs/lib/index.js\nvar require_lib3 = __commonJS({\n  \"node_modules/qs/lib/index.js\"(exports2, module2) {\n    \"use strict\";\n    var stringify = require_stringify();\n    var parse = require_parse();\n    var formats = require_formats();\n    module2.exports = {\n      formats,\n      parse,\n      stringify\n    };\n  }\n});\n\n// node_modules/body-parser/lib/types/urlencoded.js\nvar require_urlencoded = __commonJS({\n  \"node_modules/body-parser/lib/types/urlencoded.js\"(exports2, module2) {\n    \"use strict\";\n    var createError = require_http_errors();\n    var debug = require_src()(\"body-parser:urlencoded\");\n    var isFinished = require_on_finished().isFinished;\n    var read = require_read();\n    var typeis = require_type_is();\n    var qs = require_lib3();\n    var { getCharset, normalizeOptions } = require_utils();\n    module2.exports = urlencoded;\n    function urlencoded(options) {\n      var { inflate, limit, verify, shouldParse } = normalizeOptions(options, \"application/x-www-form-urlencoded\");\n      var defaultCharset = options?.defaultCharset || \"utf-8\";\n      if (defaultCharset !== \"utf-8\" && defaultCharset !== \"iso-8859-1\") {\n        throw new TypeError(\"option defaultCharset must be either utf-8 or iso-8859-1\");\n      }\n      var queryparse = createQueryParser(options);\n      function parse(body, encoding) {\n        return body.length ? queryparse(body, encoding) : {};\n      }\n      return function urlencodedParser(req, res, next) {\n        if (isFinished(req)) {\n          debug(\"body already parsed\");\n          next();\n          return;\n        }\n        if (!(\"body\" in req)) {\n          req.body = void 0;\n        }\n        if (!typeis.hasBody(req)) {\n          debug(\"skip empty body\");\n          next();\n          return;\n        }\n        debug(\"content-type %j\", req.headers[\"content-type\"]);\n        if (!shouldParse(req)) {\n          debug(\"skip parsing\");\n          next();\n          return;\n        }\n        var charset = getCharset(req) || defaultCharset;\n        if (charset !== \"utf-8\" && charset !== \"iso-8859-1\") {\n          debug(\"invalid charset\");\n          next(createError(415, 'unsupported charset \"' + charset.toUpperCase() + '\"', {\n            charset,\n            type: \"charset.unsupported\"\n          }));\n          return;\n        }\n        read(req, res, next, parse, debug, {\n          encoding: charset,\n          inflate,\n          limit,\n          verify\n        });\n      };\n    }\n    function createQueryParser(options) {\n      var extended = Boolean(options?.extended);\n      var parameterLimit = options?.parameterLimit !== void 0 ? options?.parameterLimit : 1e3;\n      var charsetSentinel = options?.charsetSentinel;\n      var interpretNumericEntities = options?.interpretNumericEntities;\n      var depth = extended ? options?.depth !== void 0 ? options?.depth : 32 : 0;\n      if (isNaN(parameterLimit) || parameterLimit < 1) {\n        throw new TypeError(\"option parameterLimit must be a positive number\");\n      }\n      if (isNaN(depth) || depth < 0) {\n        throw new TypeError(\"option depth must be a zero or a positive number\");\n      }\n      if (isFinite(parameterLimit)) {\n        parameterLimit = parameterLimit | 0;\n      }\n      return function queryparse(body, encoding) {\n        var paramCount = parameterCount(body, parameterLimit);\n        if (paramCount === void 0) {\n          debug(\"too many parameters\");\n          throw createError(413, \"too many parameters\", {\n            type: \"parameters.too.many\"\n          });\n        }\n        var arrayLimit = extended ? Math.max(100, paramCount) : 0;\n        debug(\"parse \" + (extended ? \"extended \" : \"\") + \"urlencoding\");\n        try {\n          return qs.parse(body, {\n            allowPrototypes: true,\n            arrayLimit,\n            depth,\n            charsetSentinel,\n            interpretNumericEntities,\n            charset: encoding,\n            parameterLimit,\n            strictDepth: true\n          });\n        } catch (err2) {\n          if (err2 instanceof RangeError) {\n            throw createError(400, \"The input exceeded the depth\", {\n              type: \"querystring.parse.rangeError\"\n            });\n          } else {\n            throw err2;\n          }\n        }\n      };\n    }\n    function parameterCount(body, limit) {\n      var len = body.split(\"&\").length;\n      return len > limit ? void 0 : len - 1;\n    }\n  }\n});\n\n// node_modules/body-parser/index.js\nvar require_body_parser = __commonJS({\n  \"node_modules/body-parser/index.js\"(exports2, module2) {\n    \"use strict\";\n    exports2 = module2.exports = bodyParser;\n    Object.defineProperty(exports2, \"json\", {\n      configurable: true,\n      enumerable: true,\n      get: () => require_json()\n    });\n    Object.defineProperty(exports2, \"raw\", {\n      configurable: true,\n      enumerable: true,\n      get: () => require_raw()\n    });\n    Object.defineProperty(exports2, \"text\", {\n      configurable: true,\n      enumerable: true,\n      get: () => require_text()\n    });\n    Object.defineProperty(exports2, \"urlencoded\", {\n      configurable: true,\n      enumerable: true,\n      get: () => require_urlencoded()\n    });\n    function bodyParser() {\n      throw new Error(\"The bodyParser() generic has been split into individual middleware to use instead.\");\n    }\n  }\n});\n\n// node_modules/merge-descriptors/index.js\nvar require_merge_descriptors = __commonJS({\n  \"node_modules/merge-descriptors/index.js\"(exports2, module2) {\n    \"use strict\";\n    function mergeDescriptors(destination, source, overwrite = true) {\n      if (!destination) {\n        throw new TypeError(\"The `destination` argument is required.\");\n      }\n      if (!source) {\n        throw new TypeError(\"The `source` argument is required.\");\n      }\n      for (const name of Object.getOwnPropertyNames(source)) {\n        if (!overwrite && Object.hasOwn(destination, name)) {\n          continue;\n        }\n        const descriptor = Object.getOwnPropertyDescriptor(source, name);\n        Object.defineProperty(destination, name, descriptor);\n      }\n      return destination;\n    }\n    module2.exports = mergeDescriptors;\n  }\n});\n\n// node_modules/encodeurl/index.js\nvar require_encodeurl = __commonJS({\n  \"node_modules/encodeurl/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = encodeUrl;\n    var ENCODE_CHARS_REGEXP = /(?:[^\\x21\\x23-\\x3B\\x3D\\x3F-\\x5F\\x61-\\x7A\\x7C\\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;\n    var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF]([^\\uDC00-\\uDFFF]|$)/g;\n    var UNMATCHED_SURROGATE_PAIR_REPLACE = \"$1\\uFFFD$2\";\n    function encodeUrl(url) {\n      return String(url).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);\n    }\n  }\n});\n\n// node_modules/escape-html/index.js\nvar require_escape_html = __commonJS({\n  \"node_modules/escape-html/index.js\"(exports2, module2) {\n    \"use strict\";\n    var matchHtmlRegExp = /[\"'&<>]/;\n    module2.exports = escapeHtml;\n    function escapeHtml(string) {\n      var str = \"\" + string;\n      var match = matchHtmlRegExp.exec(str);\n      if (!match) {\n        return str;\n      }\n      var escape2;\n      var html = \"\";\n      var index = 0;\n      var lastIndex = 0;\n      for (index = match.index; index < str.length; index++) {\n        switch (str.charCodeAt(index)) {\n          case 34:\n            escape2 = \"&quot;\";\n            break;\n          case 38:\n            escape2 = \"&amp;\";\n            break;\n          case 39:\n            escape2 = \"&#39;\";\n            break;\n          case 60:\n            escape2 = \"&lt;\";\n            break;\n          case 62:\n            escape2 = \"&gt;\";\n            break;\n          default:\n            continue;\n        }\n        if (lastIndex !== index) {\n          html += str.substring(lastIndex, index);\n        }\n        lastIndex = index + 1;\n        html += escape2;\n      }\n      return lastIndex !== index ? html + str.substring(lastIndex, index) : html;\n    }\n  }\n});\n\n// node_modules/parseurl/index.js\nvar require_parseurl = __commonJS({\n  \"node_modules/parseurl/index.js\"(exports2, module2) {\n    \"use strict\";\n    var url = require(\"url\");\n    var parse = url.parse;\n    var Url = url.Url;\n    module2.exports = parseurl;\n    module2.exports.original = originalurl;\n    function parseurl(req) {\n      var url2 = req.url;\n      if (url2 === void 0) {\n        return void 0;\n      }\n      var parsed = req._parsedUrl;\n      if (fresh(url2, parsed)) {\n        return parsed;\n      }\n      parsed = fastparse(url2);\n      parsed._raw = url2;\n      return req._parsedUrl = parsed;\n    }\n    function originalurl(req) {\n      var url2 = req.originalUrl;\n      if (typeof url2 !== \"string\") {\n        return parseurl(req);\n      }\n      var parsed = req._parsedOriginalUrl;\n      if (fresh(url2, parsed)) {\n        return parsed;\n      }\n      parsed = fastparse(url2);\n      parsed._raw = url2;\n      return req._parsedOriginalUrl = parsed;\n    }\n    function fastparse(str) {\n      if (typeof str !== \"string\" || str.charCodeAt(0) !== 47) {\n        return parse(str);\n      }\n      var pathname = str;\n      var query = null;\n      var search = null;\n      for (var i = 1; i < str.length; i++) {\n        switch (str.charCodeAt(i)) {\n          case 63:\n            if (search === null) {\n              pathname = str.substring(0, i);\n              query = str.substring(i + 1);\n              search = str.substring(i);\n            }\n            break;\n          case 9:\n          /* \\t */\n          case 10:\n          /* \\n */\n          case 12:\n          /* \\f */\n          case 13:\n          /* \\r */\n          case 32:\n          /*    */\n          case 35:\n          /* #  */\n          case 160:\n          case 65279:\n            return parse(str);\n        }\n      }\n      var url2 = Url !== void 0 ? new Url() : {};\n      url2.path = str;\n      url2.href = str;\n      url2.pathname = pathname;\n      if (search !== null) {\n        url2.query = query;\n        url2.search = search;\n      }\n      return url2;\n    }\n    function fresh(url2, parsedUrl) {\n      return typeof parsedUrl === \"object\" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url2;\n    }\n  }\n});\n\n// node_modules/finalhandler/index.js\nvar require_finalhandler = __commonJS({\n  \"node_modules/finalhandler/index.js\"(exports2, module2) {\n    \"use strict\";\n    var debug = require_src()(\"finalhandler\");\n    var encodeUrl = require_encodeurl();\n    var escapeHtml = require_escape_html();\n    var onFinished = require_on_finished();\n    var parseUrl = require_parseurl();\n    var statuses = require_statuses();\n    var isFinished = onFinished.isFinished;\n    function createHtmlDocument(message) {\n      var body = escapeHtml(message).replaceAll(\"\\n\", \"<br>\").replaceAll(\"  \", \" &nbsp;\");\n      return '<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n<meta charset=\"utf-8\">\\n<title>Error</title>\\n</head>\\n<body>\\n<pre>' + body + \"</pre>\\n</body>\\n</html>\\n\";\n    }\n    module2.exports = finalhandler;\n    function finalhandler(req, res, options) {\n      var opts = options || {};\n      var env = opts.env || process.env.NODE_ENV || \"development\";\n      var onerror = opts.onerror;\n      return function(err2) {\n        var headers;\n        var msg;\n        var status;\n        if (!err2 && res.headersSent) {\n          debug(\"cannot 404 after headers sent\");\n          return;\n        }\n        if (err2) {\n          status = getErrorStatusCode(err2);\n          if (status === void 0) {\n            status = getResponseStatusCode(res);\n          } else {\n            headers = getErrorHeaders(err2);\n          }\n          msg = getErrorMessage(err2, status, env);\n        } else {\n          status = 404;\n          msg = \"Cannot \" + req.method + \" \" + encodeUrl(getResourceName(req));\n        }\n        debug(\"default %s\", status);\n        if (err2 && onerror) {\n          setImmediate(onerror, err2, req, res);\n        }\n        if (res.headersSent) {\n          debug(\"cannot %d after headers sent\", status);\n          if (req.socket) {\n            req.socket.destroy();\n          }\n          return;\n        }\n        send(req, res, status, headers, msg);\n      };\n    }\n    function getErrorHeaders(err2) {\n      if (!err2.headers || typeof err2.headers !== \"object\") {\n        return void 0;\n      }\n      return { ...err2.headers };\n    }\n    function getErrorMessage(err2, status, env) {\n      var msg;\n      if (env !== \"production\") {\n        msg = err2.stack;\n        if (!msg && typeof err2.toString === \"function\") {\n          msg = err2.toString();\n        }\n      }\n      return msg || statuses.message[status];\n    }\n    function getErrorStatusCode(err2) {\n      if (typeof err2.status === \"number\" && err2.status >= 400 && err2.status < 600) {\n        return err2.status;\n      }\n      if (typeof err2.statusCode === \"number\" && err2.statusCode >= 400 && err2.statusCode < 600) {\n        return err2.statusCode;\n      }\n      return void 0;\n    }\n    function getResourceName(req) {\n      try {\n        return parseUrl.original(req).pathname;\n      } catch (e) {\n        return \"resource\";\n      }\n    }\n    function getResponseStatusCode(res) {\n      var status = res.statusCode;\n      if (typeof status !== \"number\" || status < 400 || status > 599) {\n        status = 500;\n      }\n      return status;\n    }\n    function send(req, res, status, headers, message) {\n      function write() {\n        var body = createHtmlDocument(message);\n        res.statusCode = status;\n        if (req.httpVersionMajor < 2) {\n          res.statusMessage = statuses.message[status];\n        }\n        res.removeHeader(\"Content-Encoding\");\n        res.removeHeader(\"Content-Language\");\n        res.removeHeader(\"Content-Range\");\n        for (const [key, value] of Object.entries(headers ?? {})) {\n          res.setHeader(key, value);\n        }\n        res.setHeader(\"Content-Security-Policy\", \"default-src 'none'\");\n        res.setHeader(\"X-Content-Type-Options\", \"nosniff\");\n        res.setHeader(\"Content-Type\", \"text/html; charset=utf-8\");\n        res.setHeader(\"Content-Length\", Buffer.byteLength(body, \"utf8\"));\n        if (req.method === \"HEAD\") {\n          res.end();\n          return;\n        }\n        res.end(body, \"utf8\");\n      }\n      if (isFinished(req)) {\n        write();\n        return;\n      }\n      req.unpipe();\n      onFinished(req, write);\n      req.resume();\n    }\n  }\n});\n\n// node_modules/express/lib/view.js\nvar require_view = __commonJS({\n  \"node_modules/express/lib/view.js\"(exports2, module2) {\n    \"use strict\";\n    var debug = require_src()(\"express:view\");\n    var path = require(\"node:path\");\n    var fs = require(\"node:fs\");\n    var dirname = path.dirname;\n    var basename = path.basename;\n    var extname = path.extname;\n    var join = path.join;\n    var resolve = path.resolve;\n    module2.exports = View;\n    function View(name, options) {\n      var opts = options || {};\n      this.defaultEngine = opts.defaultEngine;\n      this.ext = extname(name);\n      this.name = name;\n      this.root = opts.root;\n      if (!this.ext && !this.defaultEngine) {\n        throw new Error(\"No default engine was specified and no extension was provided.\");\n      }\n      var fileName = name;\n      if (!this.ext) {\n        this.ext = this.defaultEngine[0] !== \".\" ? \".\" + this.defaultEngine : this.defaultEngine;\n        fileName += this.ext;\n      }\n      if (!opts.engines[this.ext]) {\n        var mod = this.ext.slice(1);\n        debug('require \"%s\"', mod);\n        var fn = require(mod).__express;\n        if (typeof fn !== \"function\") {\n          throw new Error('Module \"' + mod + '\" does not provide a view engine.');\n        }\n        opts.engines[this.ext] = fn;\n      }\n      this.engine = opts.engines[this.ext];\n      this.path = this.lookup(fileName);\n    }\n    View.prototype.lookup = function lookup(name) {\n      var path2;\n      var roots = [].concat(this.root);\n      debug('lookup \"%s\"', name);\n      for (var i = 0; i < roots.length && !path2; i++) {\n        var root = roots[i];\n        var loc = resolve(root, name);\n        var dir = dirname(loc);\n        var file = basename(loc);\n        path2 = this.resolve(dir, file);\n      }\n      return path2;\n    };\n    View.prototype.render = function render(options, callback) {\n      var sync = true;\n      debug('render \"%s\"', this.path);\n      this.engine(this.path, options, function onRender() {\n        if (!sync) {\n          return callback.apply(this, arguments);\n        }\n        var args = new Array(arguments.length);\n        var cntx = this;\n        for (var i = 0; i < arguments.length; i++) {\n          args[i] = arguments[i];\n        }\n        return process.nextTick(function renderTick() {\n          return callback.apply(cntx, args);\n        });\n      });\n      sync = false;\n    };\n    View.prototype.resolve = function resolve2(dir, file) {\n      var ext = this.ext;\n      var path2 = join(dir, file);\n      var stat = tryStat(path2);\n      if (stat && stat.isFile()) {\n        return path2;\n      }\n      path2 = join(dir, basename(file, ext), \"index\" + ext);\n      stat = tryStat(path2);\n      if (stat && stat.isFile()) {\n        return path2;\n      }\n    };\n    function tryStat(path2) {\n      debug('stat \"%s\"', path2);\n      try {\n        return fs.statSync(path2);\n      } catch (e) {\n        return void 0;\n      }\n    }\n  }\n});\n\n// node_modules/etag/index.js\nvar require_etag = __commonJS({\n  \"node_modules/etag/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = etag;\n    var crypto = require(\"crypto\");\n    var Stats = require(\"fs\").Stats;\n    var toString = Object.prototype.toString;\n    function entitytag(entity) {\n      if (entity.length === 0) {\n        return '\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"';\n      }\n      var hash = crypto.createHash(\"sha1\").update(entity, \"utf8\").digest(\"base64\").substring(0, 27);\n      var len = typeof entity === \"string\" ? Buffer.byteLength(entity, \"utf8\") : entity.length;\n      return '\"' + len.toString(16) + \"-\" + hash + '\"';\n    }\n    function etag(entity, options) {\n      if (entity == null) {\n        throw new TypeError(\"argument entity is required\");\n      }\n      var isStats = isstats(entity);\n      var weak = options && typeof options.weak === \"boolean\" ? options.weak : isStats;\n      if (!isStats && typeof entity !== \"string\" && !Buffer.isBuffer(entity)) {\n        throw new TypeError(\"argument entity must be string, Buffer, or fs.Stats\");\n      }\n      var tag = isStats ? stattag(entity) : entitytag(entity);\n      return weak ? \"W/\" + tag : tag;\n    }\n    function isstats(obj) {\n      if (typeof Stats === \"function\" && obj instanceof Stats) {\n        return true;\n      }\n      return obj && typeof obj === \"object\" && \"ctime\" in obj && toString.call(obj.ctime) === \"[object Date]\" && \"mtime\" in obj && toString.call(obj.mtime) === \"[object Date]\" && \"ino\" in obj && typeof obj.ino === \"number\" && \"size\" in obj && typeof obj.size === \"number\";\n    }\n    function stattag(stat) {\n      var mtime = stat.mtime.getTime().toString(16);\n      var size = stat.size.toString(16);\n      return '\"' + size + \"-\" + mtime + '\"';\n    }\n  }\n});\n\n// node_modules/express/node_modules/mime-db/db.json\nvar require_db2 = __commonJS({\n  \"node_modules/express/node_modules/mime-db/db.json\"(exports2, module2) {\n    module2.exports = {\n      \"application/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"application/3gpdash-qoe-report+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/3gpp-ims+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphalforms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/a2l\": {\n        source: \"iana\"\n      },\n      \"application/ace+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ace-groupcomm+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace-trl+cbor\": {\n        source: \"iana\"\n      },\n      \"application/activemessage\": {\n        source: \"iana\"\n      },\n      \"application/activity+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aif+cbor\": {\n        source: \"iana\"\n      },\n      \"application/aif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdni+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdnifilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-directory+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcost+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcostparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointprop+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointpropparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-error+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmapparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tips+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tipsparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamcontrol+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aml\": {\n        source: \"iana\"\n      },\n      \"application/andrew-inset\": {\n        source: \"iana\",\n        extensions: [\"ez\"]\n      },\n      \"application/appinstaller\": {\n        compressible: false,\n        extensions: [\"appinstaller\"]\n      },\n      \"application/applefile\": {\n        source: \"iana\"\n      },\n      \"application/applixware\": {\n        source: \"apache\",\n        extensions: [\"aw\"]\n      },\n      \"application/appx\": {\n        compressible: false,\n        extensions: [\"appx\"]\n      },\n      \"application/appxbundle\": {\n        compressible: false,\n        extensions: [\"appxbundle\"]\n      },\n      \"application/at+jwt\": {\n        source: \"iana\"\n      },\n      \"application/atf\": {\n        source: \"iana\"\n      },\n      \"application/atfx\": {\n        source: \"iana\"\n      },\n      \"application/atom+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atom\"]\n      },\n      \"application/atomcat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomcat\"]\n      },\n      \"application/atomdeleted+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomdeleted\"]\n      },\n      \"application/atomicmail\": {\n        source: \"iana\"\n      },\n      \"application/atomsvc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomsvc\"]\n      },\n      \"application/atsc-dwd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dwd\"]\n      },\n      \"application/atsc-dynamic-event-message\": {\n        source: \"iana\"\n      },\n      \"application/atsc-held+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"held\"]\n      },\n      \"application/atsc-rdt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/atsc-rsat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsat\"]\n      },\n      \"application/atxml\": {\n        source: \"iana\"\n      },\n      \"application/auth-policy+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/automationml-aml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"aml\"]\n      },\n      \"application/automationml-amlx+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"amlx\"]\n      },\n      \"application/bacnet-xdd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/batch-smtp\": {\n        source: \"iana\"\n      },\n      \"application/bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/beep+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/bufr\": {\n        source: \"iana\"\n      },\n      \"application/c2pa\": {\n        source: \"iana\"\n      },\n      \"application/calendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/calendar+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xcs\"]\n      },\n      \"application/call-completion\": {\n        source: \"iana\"\n      },\n      \"application/cals-1840\": {\n        source: \"iana\"\n      },\n      \"application/captive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cbor\": {\n        source: \"iana\"\n      },\n      \"application/cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/cccex\": {\n        source: \"iana\"\n      },\n      \"application/ccmp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ccxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ccxml\"]\n      },\n      \"application/cda+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/cdfx+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdfx\"]\n      },\n      \"application/cdmi-capability\": {\n        source: \"iana\",\n        extensions: [\"cdmia\"]\n      },\n      \"application/cdmi-container\": {\n        source: \"iana\",\n        extensions: [\"cdmic\"]\n      },\n      \"application/cdmi-domain\": {\n        source: \"iana\",\n        extensions: [\"cdmid\"]\n      },\n      \"application/cdmi-object\": {\n        source: \"iana\",\n        extensions: [\"cdmio\"]\n      },\n      \"application/cdmi-queue\": {\n        source: \"iana\",\n        extensions: [\"cdmiq\"]\n      },\n      \"application/cdni\": {\n        source: \"iana\"\n      },\n      \"application/ce+cbor\": {\n        source: \"iana\"\n      },\n      \"application/cea\": {\n        source: \"iana\"\n      },\n      \"application/cea-2018+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cellml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cfw\": {\n        source: \"iana\"\n      },\n      \"application/cid-edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/city+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/city+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/clr\": {\n        source: \"iana\"\n      },\n      \"application/clue+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/clue_info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cms\": {\n        source: \"iana\"\n      },\n      \"application/cnrp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-eap\": {\n        source: \"iana\"\n      },\n      \"application/coap-group+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-payload\": {\n        source: \"iana\"\n      },\n      \"application/commonground\": {\n        source: \"iana\"\n      },\n      \"application/concise-problem-details+cbor\": {\n        source: \"iana\"\n      },\n      \"application/conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cose\": {\n        source: \"iana\"\n      },\n      \"application/cose-key\": {\n        source: \"iana\"\n      },\n      \"application/cose-key-set\": {\n        source: \"iana\"\n      },\n      \"application/cose-x509\": {\n        source: \"iana\"\n      },\n      \"application/cpl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cpl\"]\n      },\n      \"application/csrattrs\": {\n        source: \"iana\"\n      },\n      \"application/csta+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cstadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/csvm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cu-seeme\": {\n        source: \"apache\",\n        extensions: [\"cu\"]\n      },\n      \"application/cwl\": {\n        source: \"iana\",\n        extensions: [\"cwl\"]\n      },\n      \"application/cwl+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cwl+yaml\": {\n        source: \"iana\"\n      },\n      \"application/cwt\": {\n        source: \"iana\"\n      },\n      \"application/cybercash\": {\n        source: \"iana\"\n      },\n      \"application/dart\": {\n        compressible: true\n      },\n      \"application/dash+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpd\"]\n      },\n      \"application/dash-patch+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpp\"]\n      },\n      \"application/dashdelta\": {\n        source: \"iana\"\n      },\n      \"application/davmount+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"davmount\"]\n      },\n      \"application/dca-rft\": {\n        source: \"iana\"\n      },\n      \"application/dcd\": {\n        source: \"iana\"\n      },\n      \"application/dec-dx\": {\n        source: \"iana\"\n      },\n      \"application/dialog-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom\": {\n        source: \"iana\",\n        extensions: [\"dcm\"]\n      },\n      \"application/dicom+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dii\": {\n        source: \"iana\"\n      },\n      \"application/dit\": {\n        source: \"iana\"\n      },\n      \"application/dns\": {\n        source: \"iana\"\n      },\n      \"application/dns+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dns-message\": {\n        source: \"iana\"\n      },\n      \"application/docbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dbk\"]\n      },\n      \"application/dots+cbor\": {\n        source: \"iana\"\n      },\n      \"application/dpop+jwt\": {\n        source: \"iana\"\n      },\n      \"application/dskpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dssc+der\": {\n        source: \"iana\",\n        extensions: [\"dssc\"]\n      },\n      \"application/dssc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdssc\"]\n      },\n      \"application/dvcs\": {\n        source: \"iana\"\n      },\n      \"application/eat+cwt\": {\n        source: \"iana\"\n      },\n      \"application/eat+jwt\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/eat-ucs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-ucs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ecmascript\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ecma\"]\n      },\n      \"application/edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/edi-consent\": {\n        source: \"iana\"\n      },\n      \"application/edi-x12\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/edifact\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/efi\": {\n        source: \"iana\"\n      },\n      \"application/elm+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/elm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.cap+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/emergencycalldata.comment+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.deviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.ecall.msd\": {\n        source: \"iana\"\n      },\n      \"application/emergencycalldata.legacyesn+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.providerinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.serviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.subscriberinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.veds+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emma+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emma\"]\n      },\n      \"application/emotionml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emotionml\"]\n      },\n      \"application/encaprtp\": {\n        source: \"iana\"\n      },\n      \"application/entity-statement+jwt\": {\n        source: \"iana\"\n      },\n      \"application/epp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/epub+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"epub\"]\n      },\n      \"application/eshop\": {\n        source: \"iana\"\n      },\n      \"application/exi\": {\n        source: \"iana\",\n        extensions: [\"exi\"]\n      },\n      \"application/expect-ct-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/express\": {\n        source: \"iana\",\n        extensions: [\"exp\"]\n      },\n      \"application/fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/fastsoap\": {\n        source: \"iana\"\n      },\n      \"application/fdf\": {\n        source: \"iana\",\n        extensions: [\"fdf\"]\n      },\n      \"application/fdt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fdt\"]\n      },\n      \"application/fhir+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fhir+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fido.trusted-apps+json\": {\n        compressible: true\n      },\n      \"application/fits\": {\n        source: \"iana\"\n      },\n      \"application/flexfec\": {\n        source: \"iana\"\n      },\n      \"application/font-sfnt\": {\n        source: \"iana\"\n      },\n      \"application/font-tdpfr\": {\n        source: \"iana\",\n        extensions: [\"pfr\"]\n      },\n      \"application/font-woff\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/framework-attributes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geo+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"geojson\"]\n      },\n      \"application/geo+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/geopackage+sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/geopose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/gltf-buffer\": {\n        source: \"iana\"\n      },\n      \"application/gml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gml\"]\n      },\n      \"application/gnap-binding-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gpx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"gpx\"]\n      },\n      \"application/grib\": {\n        source: \"iana\"\n      },\n      \"application/gxf\": {\n        source: \"apache\",\n        extensions: [\"gxf\"]\n      },\n      \"application/gzip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gz\"]\n      },\n      \"application/h224\": {\n        source: \"iana\"\n      },\n      \"application/held+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/hjson\": {\n        extensions: [\"hjson\"]\n      },\n      \"application/hl7v2+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/http\": {\n        source: \"iana\"\n      },\n      \"application/hyperstudio\": {\n        source: \"iana\",\n        extensions: [\"stk\"]\n      },\n      \"application/ibe-key-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pkg-reply+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pp-data\": {\n        source: \"iana\"\n      },\n      \"application/iges\": {\n        source: \"iana\"\n      },\n      \"application/im-iscomposing+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/index\": {\n        source: \"iana\"\n      },\n      \"application/index.cmd\": {\n        source: \"iana\"\n      },\n      \"application/index.obj\": {\n        source: \"iana\"\n      },\n      \"application/index.response\": {\n        source: \"iana\"\n      },\n      \"application/index.vnd\": {\n        source: \"iana\"\n      },\n      \"application/inkml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ink\", \"inkml\"]\n      },\n      \"application/iotp\": {\n        source: \"iana\"\n      },\n      \"application/ipfix\": {\n        source: \"iana\",\n        extensions: [\"ipfix\"]\n      },\n      \"application/ipp\": {\n        source: \"iana\"\n      },\n      \"application/isup\": {\n        source: \"iana\"\n      },\n      \"application/its+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"its\"]\n      },\n      \"application/java-archive\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jar\", \"war\", \"ear\"]\n      },\n      \"application/java-serialized-object\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"ser\"]\n      },\n      \"application/java-vm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"class\"]\n      },\n      \"application/javascript\": {\n        source: \"apache\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\"]\n      },\n      \"application/jf2feed+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jose\": {\n        source: \"iana\"\n      },\n      \"application/jose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jrd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscalendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscontact+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"json\", \"map\"]\n      },\n      \"application/json-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json-seq\": {\n        source: \"iana\"\n      },\n      \"application/json5\": {\n        extensions: [\"json5\"]\n      },\n      \"application/jsonml+json\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"jsonml\"]\n      },\n      \"application/jsonpath\": {\n        source: \"iana\"\n      },\n      \"application/jwk+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+jwt\": {\n        source: \"iana\"\n      },\n      \"application/jwt\": {\n        source: \"iana\"\n      },\n      \"application/kpml-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/kpml-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ld+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"jsonld\"]\n      },\n      \"application/lgr+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lgr\"]\n      },\n      \"application/link-format\": {\n        source: \"iana\"\n      },\n      \"application/linkset\": {\n        source: \"iana\"\n      },\n      \"application/linkset+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/load-control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/logout+jwt\": {\n        source: \"iana\"\n      },\n      \"application/lost+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lostxml\"]\n      },\n      \"application/lostsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/lpf+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/lxf\": {\n        source: \"iana\"\n      },\n      \"application/mac-binhex40\": {\n        source: \"iana\",\n        extensions: [\"hqx\"]\n      },\n      \"application/mac-compactpro\": {\n        source: \"apache\",\n        extensions: [\"cpt\"]\n      },\n      \"application/macwriteii\": {\n        source: \"iana\"\n      },\n      \"application/mads+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mads\"]\n      },\n      \"application/manifest+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"webmanifest\"]\n      },\n      \"application/marc\": {\n        source: \"iana\",\n        extensions: [\"mrc\"]\n      },\n      \"application/marcxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mrcx\"]\n      },\n      \"application/mathematica\": {\n        source: \"iana\",\n        extensions: [\"ma\", \"nb\", \"mb\"]\n      },\n      \"application/mathml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mathml\"]\n      },\n      \"application/mathml-content+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mathml-presentation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-associated-procedure-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-deregister+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-envelope+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-protection-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-reception-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-user-service-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbox\": {\n        source: \"iana\",\n        extensions: [\"mbox\"]\n      },\n      \"application/media-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpf\"]\n      },\n      \"application/media_control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mediaservercontrol+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mscml\"]\n      },\n      \"application/merge-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/metalink+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"metalink\"]\n      },\n      \"application/metalink4+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"meta4\"]\n      },\n      \"application/mets+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mets\"]\n      },\n      \"application/mf4\": {\n        source: \"iana\"\n      },\n      \"application/mikey\": {\n        source: \"iana\"\n      },\n      \"application/mipc\": {\n        source: \"iana\"\n      },\n      \"application/missing-blocks+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/mmt-aei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"maei\"]\n      },\n      \"application/mmt-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musd\"]\n      },\n      \"application/mods+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mods\"]\n      },\n      \"application/moss-keys\": {\n        source: \"iana\"\n      },\n      \"application/moss-signature\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-data\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-request\": {\n        source: \"iana\"\n      },\n      \"application/mp21\": {\n        source: \"iana\",\n        extensions: [\"m21\", \"mp21\"]\n      },\n      \"application/mp4\": {\n        source: \"iana\",\n        extensions: [\"mp4\", \"mpg4\", \"mp4s\", \"m4p\"]\n      },\n      \"application/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod-xmt\": {\n        source: \"iana\"\n      },\n      \"application/mrb-consumer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mrb-publish+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/msc-ivr+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msc-mixer+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msix\": {\n        compressible: false,\n        extensions: [\"msix\"]\n      },\n      \"application/msixbundle\": {\n        compressible: false,\n        extensions: [\"msixbundle\"]\n      },\n      \"application/msword\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"doc\", \"dot\"]\n      },\n      \"application/mud+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/multipart-core\": {\n        source: \"iana\"\n      },\n      \"application/mxf\": {\n        source: \"iana\",\n        extensions: [\"mxf\"]\n      },\n      \"application/n-quads\": {\n        source: \"iana\",\n        extensions: [\"nq\"]\n      },\n      \"application/n-triples\": {\n        source: \"iana\",\n        extensions: [\"nt\"]\n      },\n      \"application/nasdata\": {\n        source: \"iana\"\n      },\n      \"application/news-checkgroups\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-groupinfo\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-transmission\": {\n        source: \"iana\"\n      },\n      \"application/nlsml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/node\": {\n        source: \"iana\",\n        extensions: [\"cjs\"]\n      },\n      \"application/nss\": {\n        source: \"iana\"\n      },\n      \"application/oauth-authz-req+jwt\": {\n        source: \"iana\"\n      },\n      \"application/oblivious-dns-message\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-request\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-response\": {\n        source: \"iana\"\n      },\n      \"application/octet-stream\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bin\", \"dms\", \"lrf\", \"mar\", \"so\", \"dist\", \"distz\", \"pkg\", \"bpk\", \"dump\", \"elc\", \"deploy\", \"exe\", \"dll\", \"deb\", \"dmg\", \"iso\", \"img\", \"msi\", \"msp\", \"msm\", \"buffer\"]\n      },\n      \"application/oda\": {\n        source: \"iana\",\n        extensions: [\"oda\"]\n      },\n      \"application/odm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/odx\": {\n        source: \"iana\"\n      },\n      \"application/oebps-package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"opf\"]\n      },\n      \"application/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogx\"]\n      },\n      \"application/ohttp-keys\": {\n        source: \"iana\"\n      },\n      \"application/omdoc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"omdoc\"]\n      },\n      \"application/onenote\": {\n        source: \"apache\",\n        extensions: [\"onetoc\", \"onetoc2\", \"onetmp\", \"onepkg\", \"one\", \"onea\"]\n      },\n      \"application/opc-nodeset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/oscore\": {\n        source: \"iana\"\n      },\n      \"application/oxps\": {\n        source: \"iana\",\n        extensions: [\"oxps\"]\n      },\n      \"application/p21\": {\n        source: \"iana\"\n      },\n      \"application/p21+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/p2p-overlay+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"relo\"]\n      },\n      \"application/parityfec\": {\n        source: \"iana\"\n      },\n      \"application/passport\": {\n        source: \"iana\"\n      },\n      \"application/patch-ops-error+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xer\"]\n      },\n      \"application/pdf\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pdf\"]\n      },\n      \"application/pdx\": {\n        source: \"iana\"\n      },\n      \"application/pem-certificate-chain\": {\n        source: \"iana\"\n      },\n      \"application/pgp-encrypted\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pgp\"]\n      },\n      \"application/pgp-keys\": {\n        source: \"iana\",\n        extensions: [\"asc\"]\n      },\n      \"application/pgp-signature\": {\n        source: \"iana\",\n        extensions: [\"sig\", \"asc\"]\n      },\n      \"application/pics-rules\": {\n        source: \"apache\",\n        extensions: [\"prf\"]\n      },\n      \"application/pidf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pidf-diff+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pkcs10\": {\n        source: \"iana\",\n        extensions: [\"p10\"]\n      },\n      \"application/pkcs12\": {\n        source: \"iana\"\n      },\n      \"application/pkcs7-mime\": {\n        source: \"iana\",\n        extensions: [\"p7m\", \"p7c\"]\n      },\n      \"application/pkcs7-signature\": {\n        source: \"iana\",\n        extensions: [\"p7s\"]\n      },\n      \"application/pkcs8\": {\n        source: \"iana\",\n        extensions: [\"p8\"]\n      },\n      \"application/pkcs8-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/pkix-attr-cert\": {\n        source: \"iana\",\n        extensions: [\"ac\"]\n      },\n      \"application/pkix-cert\": {\n        source: \"iana\",\n        extensions: [\"cer\"]\n      },\n      \"application/pkix-crl\": {\n        source: \"iana\",\n        extensions: [\"crl\"]\n      },\n      \"application/pkix-pkipath\": {\n        source: \"iana\",\n        extensions: [\"pkipath\"]\n      },\n      \"application/pkixcmp\": {\n        source: \"iana\",\n        extensions: [\"pki\"]\n      },\n      \"application/pls+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pls\"]\n      },\n      \"application/poc-settings+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/postscript\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ai\", \"eps\", \"ps\"]\n      },\n      \"application/ppsp-tracker+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/private-token-issuer-directory\": {\n        source: \"iana\"\n      },\n      \"application/private-token-request\": {\n        source: \"iana\"\n      },\n      \"application/private-token-response\": {\n        source: \"iana\"\n      },\n      \"application/problem+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/problem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/provenance+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"provx\"]\n      },\n      \"application/provided-claims+jwt\": {\n        source: \"iana\"\n      },\n      \"application/prs.alvestrand.titrax-sheet\": {\n        source: \"iana\"\n      },\n      \"application/prs.cww\": {\n        source: \"iana\",\n        extensions: [\"cww\"]\n      },\n      \"application/prs.cyn\": {\n        source: \"iana\",\n        charset: \"7-BIT\"\n      },\n      \"application/prs.hpub+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/prs.implied-document+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-executable\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-object+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+yaml\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-structure\": {\n        source: \"iana\"\n      },\n      \"application/prs.mayfile\": {\n        source: \"iana\"\n      },\n      \"application/prs.nprend\": {\n        source: \"iana\"\n      },\n      \"application/prs.plucker\": {\n        source: \"iana\"\n      },\n      \"application/prs.rdf-xml-crypt\": {\n        source: \"iana\"\n      },\n      \"application/prs.vcfbzip2\": {\n        source: \"iana\"\n      },\n      \"application/prs.xsf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsf\"]\n      },\n      \"application/pskc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pskcxml\"]\n      },\n      \"application/pvd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/qsig\": {\n        source: \"iana\"\n      },\n      \"application/raml+yaml\": {\n        compressible: true,\n        extensions: [\"raml\"]\n      },\n      \"application/raptorfec\": {\n        source: \"iana\"\n      },\n      \"application/rdap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rdf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rdf\", \"owl\"]\n      },\n      \"application/reginfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rif\"]\n      },\n      \"application/relax-ng-compact-syntax\": {\n        source: \"iana\",\n        extensions: [\"rnc\"]\n      },\n      \"application/remote-printing\": {\n        source: \"apache\"\n      },\n      \"application/reputon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/resolve-response+jwt\": {\n        source: \"iana\"\n      },\n      \"application/resource-lists+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rl\"]\n      },\n      \"application/resource-lists-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rld\"]\n      },\n      \"application/rfc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/riscos\": {\n        source: \"iana\"\n      },\n      \"application/rlmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rls-services+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rs\"]\n      },\n      \"application/route-apd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rapd\"]\n      },\n      \"application/route-s-tsid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sls\"]\n      },\n      \"application/route-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rusd\"]\n      },\n      \"application/rpki-checklist\": {\n        source: \"iana\"\n      },\n      \"application/rpki-ghostbusters\": {\n        source: \"iana\",\n        extensions: [\"gbr\"]\n      },\n      \"application/rpki-manifest\": {\n        source: \"iana\",\n        extensions: [\"mft\"]\n      },\n      \"application/rpki-publication\": {\n        source: \"iana\"\n      },\n      \"application/rpki-roa\": {\n        source: \"iana\",\n        extensions: [\"roa\"]\n      },\n      \"application/rpki-signed-tal\": {\n        source: \"iana\"\n      },\n      \"application/rpki-updown\": {\n        source: \"iana\"\n      },\n      \"application/rsd+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rsd\"]\n      },\n      \"application/rss+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rss\"]\n      },\n      \"application/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"application/rtploopback\": {\n        source: \"iana\"\n      },\n      \"application/rtx\": {\n        source: \"iana\"\n      },\n      \"application/samlassertion+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/samlmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif-external-properties+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sbe\": {\n        source: \"iana\"\n      },\n      \"application/sbml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sbml\"]\n      },\n      \"application/scaip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scim+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scvp-cv-request\": {\n        source: \"iana\",\n        extensions: [\"scq\"]\n      },\n      \"application/scvp-cv-response\": {\n        source: \"iana\",\n        extensions: [\"scs\"]\n      },\n      \"application/scvp-vp-request\": {\n        source: \"iana\",\n        extensions: [\"spq\"]\n      },\n      \"application/scvp-vp-response\": {\n        source: \"iana\",\n        extensions: [\"spp\"]\n      },\n      \"application/sdp\": {\n        source: \"iana\",\n        extensions: [\"sdp\"]\n      },\n      \"application/secevent+jwt\": {\n        source: \"iana\"\n      },\n      \"application/senml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"senmlx\"]\n      },\n      \"application/senml-etch+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml-etch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sensml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/sensml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sensml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sensmlx\"]\n      },\n      \"application/sensml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sep+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sep-exi\": {\n        source: \"iana\"\n      },\n      \"application/session-info\": {\n        source: \"iana\"\n      },\n      \"application/set-payment\": {\n        source: \"iana\"\n      },\n      \"application/set-payment-initiation\": {\n        source: \"iana\",\n        extensions: [\"setpay\"]\n      },\n      \"application/set-registration\": {\n        source: \"iana\"\n      },\n      \"application/set-registration-initiation\": {\n        source: \"iana\",\n        extensions: [\"setreg\"]\n      },\n      \"application/sgml\": {\n        source: \"iana\"\n      },\n      \"application/sgml-open-catalog\": {\n        source: \"iana\"\n      },\n      \"application/shf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"shf\"]\n      },\n      \"application/sieve\": {\n        source: \"iana\",\n        extensions: [\"siv\", \"sieve\"]\n      },\n      \"application/simple-filter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/simple-message-summary\": {\n        source: \"iana\"\n      },\n      \"application/simplesymbolcontainer\": {\n        source: \"iana\"\n      },\n      \"application/sipc\": {\n        source: \"iana\"\n      },\n      \"application/slate\": {\n        source: \"iana\"\n      },\n      \"application/smil\": {\n        source: \"apache\"\n      },\n      \"application/smil+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"smi\", \"smil\"]\n      },\n      \"application/smpte336m\": {\n        source: \"iana\"\n      },\n      \"application/soap+fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/soap+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sparql-query\": {\n        source: \"iana\",\n        extensions: [\"rq\"]\n      },\n      \"application/sparql-results+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"srx\"]\n      },\n      \"application/spdx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/spirits-event+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sql\": {\n        source: \"iana\",\n        extensions: [\"sql\"]\n      },\n      \"application/srgs\": {\n        source: \"iana\",\n        extensions: [\"gram\"]\n      },\n      \"application/srgs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"grxml\"]\n      },\n      \"application/sru+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sru\"]\n      },\n      \"application/ssdl+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ssdl\"]\n      },\n      \"application/sslkeylogfile\": {\n        source: \"iana\"\n      },\n      \"application/ssml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ssml\"]\n      },\n      \"application/st2110-41\": {\n        source: \"iana\"\n      },\n      \"application/stix+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/stratum\": {\n        source: \"iana\"\n      },\n      \"application/swid+cbor\": {\n        source: \"iana\"\n      },\n      \"application/swid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"swidtag\"]\n      },\n      \"application/tamp-apex-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-apex-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-error\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-query\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-response\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tar\": {\n        compressible: true\n      },\n      \"application/taxii+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/td+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tei\", \"teicorpus\"]\n      },\n      \"application/tetra_isi\": {\n        source: \"iana\"\n      },\n      \"application/thraud+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tfi\"]\n      },\n      \"application/timestamp-query\": {\n        source: \"iana\"\n      },\n      \"application/timestamp-reply\": {\n        source: \"iana\"\n      },\n      \"application/timestamped-data\": {\n        source: \"iana\",\n        extensions: [\"tsd\"]\n      },\n      \"application/tlsrpt+gzip\": {\n        source: \"iana\"\n      },\n      \"application/tlsrpt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tnauthlist\": {\n        source: \"iana\"\n      },\n      \"application/toc+cbor\": {\n        source: \"iana\"\n      },\n      \"application/token-introspection+jwt\": {\n        source: \"iana\"\n      },\n      \"application/toml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"toml\"]\n      },\n      \"application/trickle-ice-sdpfrag\": {\n        source: \"iana\"\n      },\n      \"application/trig\": {\n        source: \"iana\",\n        extensions: [\"trig\"]\n      },\n      \"application/trust-chain+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/trust-mark+jwt\": {\n        source: \"iana\"\n      },\n      \"application/trust-mark-delegation+jwt\": {\n        source: \"iana\"\n      },\n      \"application/ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttml\"]\n      },\n      \"application/tve-trigger\": {\n        source: \"iana\"\n      },\n      \"application/tzif\": {\n        source: \"iana\"\n      },\n      \"application/tzif-leap\": {\n        source: \"iana\"\n      },\n      \"application/ubjson\": {\n        compressible: false,\n        extensions: [\"ubj\"]\n      },\n      \"application/uccs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ujcs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ulpfec\": {\n        source: \"iana\"\n      },\n      \"application/urc-grpsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/urc-ressheet+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsheet\"]\n      },\n      \"application/urc-targetdesc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"td\"]\n      },\n      \"application/urc-uisocketdesc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vc\": {\n        source: \"iana\"\n      },\n      \"application/vc+cose\": {\n        source: \"iana\"\n      },\n      \"application/vc+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vcard+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vcard+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vemmi\": {\n        source: \"iana\"\n      },\n      \"application/vividence.scriptfile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.1000minds.decision-model+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"1km\"]\n      },\n      \"application/vnd.1ob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp-prose+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3a+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ach+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc8+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-v2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gnas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.access-transfer-events+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.bsf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.crs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.current-location-discovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gmop+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gtpc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.interworking-data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.lpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mc-signalling-ear\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-payload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-signalling\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-floor-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-signed+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-init-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-transmission-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mid-call+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ngap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pfcp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pic-bw-large\": {\n        source: \"iana\",\n        extensions: [\"plb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-small\": {\n        source: \"iana\",\n        extensions: [\"psb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-var\": {\n        source: \"iana\",\n        extensions: [\"pvb\"]\n      },\n      \"application/vnd.3gpp.pinapp-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.s1ap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.seal-group-doc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-network-qos-management-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-ue-config-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-unicast-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-user-profile-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.sms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-ext+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.state-and-event-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ussd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.v2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.vae-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.bcmcsinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp2.tcap\": {\n        source: \"iana\",\n        extensions: [\"tcap\"]\n      },\n      \"application/vnd.3lightssoftware.imagescal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3m.post-it-notes\": {\n        source: \"iana\",\n        extensions: [\"pwn\"]\n      },\n      \"application/vnd.accpac.simply.aso\": {\n        source: \"iana\",\n        extensions: [\"aso\"]\n      },\n      \"application/vnd.accpac.simply.imp\": {\n        source: \"iana\",\n        extensions: [\"imp\"]\n      },\n      \"application/vnd.acm.addressxfer+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acm.chatbot+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acucobol\": {\n        source: \"iana\",\n        extensions: [\"acu\"]\n      },\n      \"application/vnd.acucorp\": {\n        source: \"iana\",\n        extensions: [\"atc\", \"acutc\"]\n      },\n      \"application/vnd.adobe.air-application-installer-package+zip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"air\"]\n      },\n      \"application/vnd.adobe.flash.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.formscentral.fcdt\": {\n        source: \"iana\",\n        extensions: [\"fcdt\"]\n      },\n      \"application/vnd.adobe.fxp\": {\n        source: \"iana\",\n        extensions: [\"fxp\", \"fxpl\"]\n      },\n      \"application/vnd.adobe.partial-upload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.xdp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdp\"]\n      },\n      \"application/vnd.adobe.xfdf\": {\n        source: \"apache\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/vnd.aether.imp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata-pagedef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.cmoca-cmresource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-charset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codedfont\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codepage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-cmtable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-formdef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-mediummap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-objectcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-overlay\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-pagesegment\": {\n        source: \"iana\"\n      },\n      \"application/vnd.age\": {\n        source: \"iana\",\n        extensions: [\"age\"]\n      },\n      \"application/vnd.ah-barcode\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ahead.space\": {\n        source: \"iana\",\n        extensions: [\"ahead\"]\n      },\n      \"application/vnd.airzip.filesecure.azf\": {\n        source: \"iana\",\n        extensions: [\"azf\"]\n      },\n      \"application/vnd.airzip.filesecure.azs\": {\n        source: \"iana\",\n        extensions: [\"azs\"]\n      },\n      \"application/vnd.amadeus+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.amazon.ebook\": {\n        source: \"apache\",\n        extensions: [\"azw\"]\n      },\n      \"application/vnd.amazon.mobi8-ebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.americandynamics.acc\": {\n        source: \"iana\",\n        extensions: [\"acc\"]\n      },\n      \"application/vnd.amiga.ami\": {\n        source: \"iana\",\n        extensions: [\"ami\"]\n      },\n      \"application/vnd.amundsen.maze+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.android.ota\": {\n        source: \"iana\"\n      },\n      \"application/vnd.android.package-archive\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"apk\"]\n      },\n      \"application/vnd.anki\": {\n        source: \"iana\"\n      },\n      \"application/vnd.anser-web-certificate-issue-initiation\": {\n        source: \"iana\",\n        extensions: [\"cii\"]\n      },\n      \"application/vnd.anser-web-funds-transfer-initiation\": {\n        source: \"apache\",\n        extensions: [\"fti\"]\n      },\n      \"application/vnd.antix.game-component\": {\n        source: \"iana\",\n        extensions: [\"atx\"]\n      },\n      \"application/vnd.apache.arrow.file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.arrow.stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.parquet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.compact\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apexlang\": {\n        source: \"iana\"\n      },\n      \"application/vnd.api+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.aplextor.warrp+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apothekende.reservation+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apple.installer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpkg\"]\n      },\n      \"application/vnd.apple.keynote\": {\n        source: \"iana\",\n        extensions: [\"key\"]\n      },\n      \"application/vnd.apple.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"m3u8\"]\n      },\n      \"application/vnd.apple.numbers\": {\n        source: \"iana\",\n        extensions: [\"numbers\"]\n      },\n      \"application/vnd.apple.pages\": {\n        source: \"iana\",\n        extensions: [\"pages\"]\n      },\n      \"application/vnd.apple.pkpass\": {\n        compressible: false,\n        extensions: [\"pkpass\"]\n      },\n      \"application/vnd.arastra.swi\": {\n        source: \"apache\"\n      },\n      \"application/vnd.aristanetworks.swi\": {\n        source: \"iana\",\n        extensions: [\"swi\"]\n      },\n      \"application/vnd.artisan+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.artsquare\": {\n        source: \"iana\"\n      },\n      \"application/vnd.astraea-software.iota\": {\n        source: \"iana\",\n        extensions: [\"iota\"]\n      },\n      \"application/vnd.audiograph\": {\n        source: \"iana\",\n        extensions: [\"aep\"]\n      },\n      \"application/vnd.autodesk.fbx\": {\n        extensions: [\"fbx\"]\n      },\n      \"application/vnd.autopackage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.avalon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.avistar+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.balsamiq.bmml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmml\"]\n      },\n      \"application/vnd.balsamiq.bmpr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.banana-accounting\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.error\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bekitzur-stech+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.belightsoft.lhzd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.belightsoft.lhzl+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.bint.med-content\": {\n        source: \"iana\"\n      },\n      \"application/vnd.biopax.rdf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.blink-idb-value-wrapper\": {\n        source: \"iana\"\n      },\n      \"application/vnd.blueice.multipass\": {\n        source: \"iana\",\n        extensions: [\"mpm\"]\n      },\n      \"application/vnd.bluetooth.ep.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bluetooth.le.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bmi\": {\n        source: \"iana\",\n        extensions: [\"bmi\"]\n      },\n      \"application/vnd.bpf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bpf3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.businessobjects\": {\n        source: \"iana\",\n        extensions: [\"rep\"]\n      },\n      \"application/vnd.byu.uapi+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bzip3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.c3voc.schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cab-jscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-cpdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-lips\": {\n        source: \"iana\"\n      },\n      \"application/vnd.capasystems-pg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cendio.thinlinc.clientconf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.century-systems.tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chemdraw+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdxml\"]\n      },\n      \"application/vnd.chess-pgn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chipnuts.karaoke-mmd\": {\n        source: \"iana\",\n        extensions: [\"mmd\"]\n      },\n      \"application/vnd.ciedi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cinderella\": {\n        source: \"iana\",\n        extensions: [\"cdy\"]\n      },\n      \"application/vnd.cirpack.isdn-ext\": {\n        source: \"iana\"\n      },\n      \"application/vnd.citationstyles.style+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csl\"]\n      },\n      \"application/vnd.claymore\": {\n        source: \"iana\",\n        extensions: [\"cla\"]\n      },\n      \"application/vnd.cloanto.rp9\": {\n        source: \"iana\",\n        extensions: [\"rp9\"]\n      },\n      \"application/vnd.clonk.c4group\": {\n        source: \"iana\",\n        extensions: [\"c4g\", \"c4d\", \"c4f\", \"c4p\", \"c4u\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config\": {\n        source: \"iana\",\n        extensions: [\"c11amc\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config-pkg\": {\n        source: \"iana\",\n        extensions: [\"c11amz\"]\n      },\n      \"application/vnd.cncf.helm.chart.content.v1.tar+gzip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.chart.provenance.v1.prov\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.config.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.coffeescript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collection+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.doc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.next+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.comicbook+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.comicbook-rar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commerce-battelle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commonspace\": {\n        source: \"iana\",\n        extensions: [\"csp\"]\n      },\n      \"application/vnd.contact.cmsg\": {\n        source: \"iana\",\n        extensions: [\"cdbcmsg\"]\n      },\n      \"application/vnd.coreos.ignition+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cosmocaller\": {\n        source: \"iana\",\n        extensions: [\"cmc\"]\n      },\n      \"application/vnd.crick.clicker\": {\n        source: \"iana\",\n        extensions: [\"clkx\"]\n      },\n      \"application/vnd.crick.clicker.keyboard\": {\n        source: \"iana\",\n        extensions: [\"clkk\"]\n      },\n      \"application/vnd.crick.clicker.palette\": {\n        source: \"iana\",\n        extensions: [\"clkp\"]\n      },\n      \"application/vnd.crick.clicker.template\": {\n        source: \"iana\",\n        extensions: [\"clkt\"]\n      },\n      \"application/vnd.crick.clicker.wordbank\": {\n        source: \"iana\",\n        extensions: [\"clkw\"]\n      },\n      \"application/vnd.criticaltools.wbs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wbs\"]\n      },\n      \"application/vnd.cryptii.pipe+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.crypto-shade-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.vault\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ctc-posml\": {\n        source: \"iana\",\n        extensions: [\"pml\"]\n      },\n      \"application/vnd.ctct.ws+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cups-pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-postscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-ppd\": {\n        source: \"iana\",\n        extensions: [\"ppd\"]\n      },\n      \"application/vnd.cups-raster\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl.car\": {\n        source: \"apache\",\n        extensions: [\"car\"]\n      },\n      \"application/vnd.curl.pcurl\": {\n        source: \"apache\",\n        extensions: [\"pcurl\"]\n      },\n      \"application/vnd.cyan.dean.root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cybank\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cyclonedx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cyclonedx+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.d2l.coursepackage1p0+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.d3m-dataset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.d3m-problem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dart\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dart\"]\n      },\n      \"application/vnd.data-vision.rdz\": {\n        source: \"iana\",\n        extensions: [\"rdz\"]\n      },\n      \"application/vnd.datalog\": {\n        source: \"iana\"\n      },\n      \"application/vnd.datapackage+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dataresource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dbf\": {\n        source: \"iana\",\n        extensions: [\"dbf\"]\n      },\n      \"application/vnd.dcmp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dcmp\"]\n      },\n      \"application/vnd.debian.binary-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dece.data\": {\n        source: \"iana\",\n        extensions: [\"uvf\", \"uvvf\", \"uvd\", \"uvvd\"]\n      },\n      \"application/vnd.dece.ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uvt\", \"uvvt\"]\n      },\n      \"application/vnd.dece.unspecified\": {\n        source: \"iana\",\n        extensions: [\"uvx\", \"uvvx\"]\n      },\n      \"application/vnd.dece.zip\": {\n        source: \"iana\",\n        extensions: [\"uvz\", \"uvvz\"]\n      },\n      \"application/vnd.denovo.fcselayout-link\": {\n        source: \"iana\",\n        extensions: [\"fe_launch\"]\n      },\n      \"application/vnd.desmume.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dir-bi.plate-dl-nosuffix\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dm.delegation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dna\": {\n        source: \"iana\",\n        extensions: [\"dna\"]\n      },\n      \"application/vnd.document+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dolby.mlp\": {\n        source: \"apache\",\n        extensions: [\"mlp\"]\n      },\n      \"application/vnd.dolby.mobile.1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dolby.mobile.2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.doremir.scorecloud-binary-document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dpgraph\": {\n        source: \"iana\",\n        extensions: [\"dpg\"]\n      },\n      \"application/vnd.dreamfactory\": {\n        source: \"iana\",\n        extensions: [\"dfac\"]\n      },\n      \"application/vnd.drive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ds-keypoint\": {\n        source: \"apache\",\n        extensions: [\"kpxx\"]\n      },\n      \"application/vnd.dtg.local\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.flash\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ait\": {\n        source: \"iana\",\n        extensions: [\"ait\"]\n      },\n      \"application/vnd.dvb.dvbisl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.dvbj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.esgcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcdftnotifaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgpdd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcroaming\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-enhancement\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.notif-aggregate-root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-container+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-generic+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-msglist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-init+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.pfr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.service\": {\n        source: \"iana\",\n        extensions: [\"svc\"]\n      },\n      \"application/vnd.dxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dynageo\": {\n        source: \"iana\",\n        extensions: [\"geo\"]\n      },\n      \"application/vnd.dzr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.easykaraoke.cdgdownload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecdis-update\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecip.rlp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eclipse.ditto+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ecowin.chart\": {\n        source: \"iana\",\n        extensions: [\"mag\"]\n      },\n      \"application/vnd.ecowin.filerequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.fileupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.series\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesrequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.img\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.iso\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eln+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.emclient.accessrequest+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.enliven\": {\n        source: \"iana\",\n        extensions: [\"nml\"]\n      },\n      \"application/vnd.enphase.envoy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eprints.data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.epson.esf\": {\n        source: \"iana\",\n        extensions: [\"esf\"]\n      },\n      \"application/vnd.epson.msf\": {\n        source: \"iana\",\n        extensions: [\"msf\"]\n      },\n      \"application/vnd.epson.quickanime\": {\n        source: \"iana\",\n        extensions: [\"qam\"]\n      },\n      \"application/vnd.epson.salt\": {\n        source: \"iana\",\n        extensions: [\"slt\"]\n      },\n      \"application/vnd.epson.ssf\": {\n        source: \"iana\",\n        extensions: [\"ssf\"]\n      },\n      \"application/vnd.ericsson.quickcall\": {\n        source: \"iana\"\n      },\n      \"application/vnd.erofs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.espass-espass+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.eszigno3+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"es3\", \"et3\"]\n      },\n      \"application/vnd.etsi.aoc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.asic-e+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.asic-s+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.cug+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvcommand+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-bc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-cod+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-npvr+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvservice+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mcid+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mheg5\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.overload-control-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.pstn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.sci+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.simservs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.timestamp-token\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.tsl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.tsl.der\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eu.kasparian.car+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.eudora.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.profile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.settings\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.theme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.exstream-empower+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.exstream-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ezpix-album\": {\n        source: \"iana\",\n        extensions: [\"ez2\"]\n      },\n      \"application/vnd.ezpix-package\": {\n        source: \"iana\",\n        extensions: [\"ez3\"]\n      },\n      \"application/vnd.f-secure.mobile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.familysearch.gedcom+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.fastcopy-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fdf\": {\n        source: \"apache\",\n        extensions: [\"fdf\"]\n      },\n      \"application/vnd.fdsn.mseed\": {\n        source: \"iana\",\n        extensions: [\"mseed\"]\n      },\n      \"application/vnd.fdsn.seed\": {\n        source: \"iana\",\n        extensions: [\"seed\", \"dataless\"]\n      },\n      \"application/vnd.fdsn.stationxml+xml\": {\n        source: \"iana\",\n        charset: \"XML-BASED\",\n        compressible: true\n      },\n      \"application/vnd.ffsns\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ficlab.flb+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.filmit.zfc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fints\": {\n        source: \"iana\"\n      },\n      \"application/vnd.firemonkeys.cloudcell\": {\n        source: \"iana\"\n      },\n      \"application/vnd.flographit\": {\n        source: \"iana\",\n        extensions: [\"gph\"]\n      },\n      \"application/vnd.fluxtime.clip\": {\n        source: \"iana\",\n        extensions: [\"ftc\"]\n      },\n      \"application/vnd.font-fontforge-sfd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.framemaker\": {\n        source: \"iana\",\n        extensions: [\"fm\", \"frame\", \"maker\", \"book\"]\n      },\n      \"application/vnd.freelog.comic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.frogans.fnc\": {\n        source: \"apache\",\n        extensions: [\"fnc\"]\n      },\n      \"application/vnd.frogans.ltf\": {\n        source: \"apache\",\n        extensions: [\"ltf\"]\n      },\n      \"application/vnd.fsc.weblaunch\": {\n        source: \"iana\",\n        extensions: [\"fsc\"]\n      },\n      \"application/vnd.fujifilm.fb.docuworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.binder\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.jfi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fujitsu.oasys\": {\n        source: \"iana\",\n        extensions: [\"oas\"]\n      },\n      \"application/vnd.fujitsu.oasys2\": {\n        source: \"iana\",\n        extensions: [\"oa2\"]\n      },\n      \"application/vnd.fujitsu.oasys3\": {\n        source: \"iana\",\n        extensions: [\"oa3\"]\n      },\n      \"application/vnd.fujitsu.oasysgp\": {\n        source: \"iana\",\n        extensions: [\"fg5\"]\n      },\n      \"application/vnd.fujitsu.oasysprs\": {\n        source: \"iana\",\n        extensions: [\"bh2\"]\n      },\n      \"application/vnd.fujixerox.art-ex\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.art4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.ddd\": {\n        source: \"iana\",\n        extensions: [\"ddd\"]\n      },\n      \"application/vnd.fujixerox.docuworks\": {\n        source: \"iana\",\n        extensions: [\"xdw\"]\n      },\n      \"application/vnd.fujixerox.docuworks.binder\": {\n        source: \"iana\",\n        extensions: [\"xbd\"]\n      },\n      \"application/vnd.fujixerox.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.hbpl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fut-misnet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fuzzysheet\": {\n        source: \"iana\",\n        extensions: [\"fzs\"]\n      },\n      \"application/vnd.ga4gh.passport+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.genomatix.tuxedo\": {\n        source: \"iana\",\n        extensions: [\"txd\"]\n      },\n      \"application/vnd.genozip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentics.grd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.catmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.ebuild\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.eclass\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.gpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.manifest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.pkgmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.xpak\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geo+json\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geocube+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geogebra.file\": {\n        source: \"iana\",\n        extensions: [\"ggb\"]\n      },\n      \"application/vnd.geogebra.pinboard\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geogebra.slides\": {\n        source: \"iana\",\n        extensions: [\"ggs\"]\n      },\n      \"application/vnd.geogebra.tool\": {\n        source: \"iana\",\n        extensions: [\"ggt\"]\n      },\n      \"application/vnd.geometry-explorer\": {\n        source: \"iana\",\n        extensions: [\"gex\", \"gre\"]\n      },\n      \"application/vnd.geonext\": {\n        source: \"iana\",\n        extensions: [\"gxt\"]\n      },\n      \"application/vnd.geoplan\": {\n        source: \"iana\",\n        extensions: [\"g2w\"]\n      },\n      \"application/vnd.geospace\": {\n        source: \"iana\",\n        extensions: [\"g3w\"]\n      },\n      \"application/vnd.gerber\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gmx\": {\n        source: \"iana\",\n        extensions: [\"gmx\"]\n      },\n      \"application/vnd.gnu.taler.exchange+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gnu.taler.merchant+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.google-apps.audio\": {},\n      \"application/vnd.google-apps.document\": {\n        compressible: false,\n        extensions: [\"gdoc\"]\n      },\n      \"application/vnd.google-apps.drawing\": {\n        compressible: false,\n        extensions: [\"gdraw\"]\n      },\n      \"application/vnd.google-apps.drive-sdk\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.file\": {},\n      \"application/vnd.google-apps.folder\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.form\": {\n        compressible: false,\n        extensions: [\"gform\"]\n      },\n      \"application/vnd.google-apps.fusiontable\": {},\n      \"application/vnd.google-apps.jam\": {\n        compressible: false,\n        extensions: [\"gjam\"]\n      },\n      \"application/vnd.google-apps.mail-layout\": {},\n      \"application/vnd.google-apps.map\": {\n        compressible: false,\n        extensions: [\"gmap\"]\n      },\n      \"application/vnd.google-apps.photo\": {},\n      \"application/vnd.google-apps.presentation\": {\n        compressible: false,\n        extensions: [\"gslides\"]\n      },\n      \"application/vnd.google-apps.script\": {\n        compressible: false,\n        extensions: [\"gscript\"]\n      },\n      \"application/vnd.google-apps.shortcut\": {},\n      \"application/vnd.google-apps.site\": {\n        compressible: false,\n        extensions: [\"gsite\"]\n      },\n      \"application/vnd.google-apps.spreadsheet\": {\n        compressible: false,\n        extensions: [\"gsheet\"]\n      },\n      \"application/vnd.google-apps.unknown\": {},\n      \"application/vnd.google-apps.video\": {},\n      \"application/vnd.google-earth.kml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"kml\"]\n      },\n      \"application/vnd.google-earth.kmz\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"kmz\"]\n      },\n      \"application/vnd.gov.sk.e-form+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.gov.sk.e-form+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.gov.sk.xmldatacontainer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdcf\"]\n      },\n      \"application/vnd.gpxsee.map+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.grafeq\": {\n        source: \"iana\",\n        extensions: [\"gqf\", \"gqs\"]\n      },\n      \"application/vnd.gridmp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.groove-account\": {\n        source: \"iana\",\n        extensions: [\"gac\"]\n      },\n      \"application/vnd.groove-help\": {\n        source: \"iana\",\n        extensions: [\"ghf\"]\n      },\n      \"application/vnd.groove-identity-message\": {\n        source: \"iana\",\n        extensions: [\"gim\"]\n      },\n      \"application/vnd.groove-injector\": {\n        source: \"iana\",\n        extensions: [\"grv\"]\n      },\n      \"application/vnd.groove-tool-message\": {\n        source: \"iana\",\n        extensions: [\"gtm\"]\n      },\n      \"application/vnd.groove-tool-template\": {\n        source: \"iana\",\n        extensions: [\"tpl\"]\n      },\n      \"application/vnd.groove-vcard\": {\n        source: \"iana\",\n        extensions: [\"vcg\"]\n      },\n      \"application/vnd.hal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hal+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"hal\"]\n      },\n      \"application/vnd.handheld-entertainment+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zmm\"]\n      },\n      \"application/vnd.hbci\": {\n        source: \"iana\",\n        extensions: [\"hbci\"]\n      },\n      \"application/vnd.hc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hcl-bireports\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hdt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.heroku+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hhe.lesson-player\": {\n        source: \"iana\",\n        extensions: [\"les\"]\n      },\n      \"application/vnd.hp-hpgl\": {\n        source: \"iana\",\n        extensions: [\"hpgl\"]\n      },\n      \"application/vnd.hp-hpid\": {\n        source: \"iana\",\n        extensions: [\"hpid\"]\n      },\n      \"application/vnd.hp-hps\": {\n        source: \"iana\",\n        extensions: [\"hps\"]\n      },\n      \"application/vnd.hp-jlyt\": {\n        source: \"iana\",\n        extensions: [\"jlt\"]\n      },\n      \"application/vnd.hp-pcl\": {\n        source: \"iana\",\n        extensions: [\"pcl\"]\n      },\n      \"application/vnd.hp-pclxl\": {\n        source: \"iana\",\n        extensions: [\"pclxl\"]\n      },\n      \"application/vnd.hsl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.httphone\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hydrostatix.sof-data\": {\n        source: \"iana\",\n        extensions: [\"sfd-hdstx\"]\n      },\n      \"application/vnd.hyper+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyper-item+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyperdrive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hzn-3d-crossword\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.afplinedata\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ibm.electronic-media\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.minipay\": {\n        source: \"iana\",\n        extensions: [\"mpy\"]\n      },\n      \"application/vnd.ibm.modcap\": {\n        source: \"apache\",\n        extensions: [\"afp\", \"listafp\", \"list3820\"]\n      },\n      \"application/vnd.ibm.rights-management\": {\n        source: \"iana\",\n        extensions: [\"irm\"]\n      },\n      \"application/vnd.ibm.secure-container\": {\n        source: \"iana\",\n        extensions: [\"sc\"]\n      },\n      \"application/vnd.iccprofile\": {\n        source: \"iana\",\n        extensions: [\"icc\", \"icm\"]\n      },\n      \"application/vnd.ieee.1905\": {\n        source: \"iana\"\n      },\n      \"application/vnd.igloader\": {\n        source: \"iana\",\n        extensions: [\"igl\"]\n      },\n      \"application/vnd.imagemeter.folder+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.imagemeter.image+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.immervision-ivp\": {\n        source: \"iana\",\n        extensions: [\"ivp\"]\n      },\n      \"application/vnd.immervision-ivu\": {\n        source: \"iana\",\n        extensions: [\"ivu\"]\n      },\n      \"application/vnd.ims.imsccv1p1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.lis.v2.result+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolconsumerprofile+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy.id+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings.simple+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informedcontrol.rms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informix-visionary\": {\n        source: \"apache\"\n      },\n      \"application/vnd.infotech.project\": {\n        source: \"iana\"\n      },\n      \"application/vnd.infotech.project+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.innopath.wamp.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.insors.igm\": {\n        source: \"iana\",\n        extensions: [\"igm\"]\n      },\n      \"application/vnd.intercon.formnet\": {\n        source: \"iana\",\n        extensions: [\"xpw\", \"xpx\"]\n      },\n      \"application/vnd.intergeo\": {\n        source: \"iana\",\n        extensions: [\"i2g\"]\n      },\n      \"application/vnd.intertrust.digibox\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intertrust.nncp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intu.qbo\": {\n        source: \"iana\",\n        extensions: [\"qbo\"]\n      },\n      \"application/vnd.intu.qfx\": {\n        source: \"iana\",\n        extensions: [\"qfx\"]\n      },\n      \"application/vnd.ipfs.ipns-record\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.car\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.iptc.g2.catalogitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.conceptitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.knowledgeitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.packageitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.planningitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ipunplugged.rcprofile\": {\n        source: \"iana\",\n        extensions: [\"rcprofile\"]\n      },\n      \"application/vnd.irepository.package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"irp\"]\n      },\n      \"application/vnd.is-xpr\": {\n        source: \"iana\",\n        extensions: [\"xpr\"]\n      },\n      \"application/vnd.isac.fcs\": {\n        source: \"iana\",\n        extensions: [\"fcs\"]\n      },\n      \"application/vnd.iso11783-10+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.jam\": {\n        source: \"iana\",\n        extensions: [\"jam\"]\n      },\n      \"application/vnd.japannet-directory-service\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-jpnstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-payment-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-setstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.jcp.javame.midlet-rms\": {\n        source: \"iana\",\n        extensions: [\"rms\"]\n      },\n      \"application/vnd.jisp\": {\n        source: \"iana\",\n        extensions: [\"jisp\"]\n      },\n      \"application/vnd.joost.joda-archive\": {\n        source: \"iana\",\n        extensions: [\"joda\"]\n      },\n      \"application/vnd.jsk.isdn-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kahootz\": {\n        source: \"iana\",\n        extensions: [\"ktz\", \"ktr\"]\n      },\n      \"application/vnd.kde.karbon\": {\n        source: \"iana\",\n        extensions: [\"karbon\"]\n      },\n      \"application/vnd.kde.kchart\": {\n        source: \"iana\",\n        extensions: [\"chrt\"]\n      },\n      \"application/vnd.kde.kformula\": {\n        source: \"iana\",\n        extensions: [\"kfo\"]\n      },\n      \"application/vnd.kde.kivio\": {\n        source: \"iana\",\n        extensions: [\"flw\"]\n      },\n      \"application/vnd.kde.kontour\": {\n        source: \"iana\",\n        extensions: [\"kon\"]\n      },\n      \"application/vnd.kde.kpresenter\": {\n        source: \"iana\",\n        extensions: [\"kpr\", \"kpt\"]\n      },\n      \"application/vnd.kde.kspread\": {\n        source: \"iana\",\n        extensions: [\"ksp\"]\n      },\n      \"application/vnd.kde.kword\": {\n        source: \"iana\",\n        extensions: [\"kwd\", \"kwt\"]\n      },\n      \"application/vnd.kdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kenameaapp\": {\n        source: \"iana\",\n        extensions: [\"htke\"]\n      },\n      \"application/vnd.keyman.kmp+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.keyman.kmx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kidspiration\": {\n        source: \"iana\",\n        extensions: [\"kia\"]\n      },\n      \"application/vnd.kinar\": {\n        source: \"iana\",\n        extensions: [\"kne\", \"knp\"]\n      },\n      \"application/vnd.koan\": {\n        source: \"iana\",\n        extensions: [\"skp\", \"skd\", \"skt\", \"skm\"]\n      },\n      \"application/vnd.kodak-descriptor\": {\n        source: \"iana\",\n        extensions: [\"sse\"]\n      },\n      \"application/vnd.las\": {\n        source: \"iana\"\n      },\n      \"application/vnd.las.las+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.las.las+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lasxml\"]\n      },\n      \"application/vnd.laszip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ldev.productlicensing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.leap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.liberty-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.llamagraphics.life-balance.desktop\": {\n        source: \"iana\",\n        extensions: [\"lbd\"]\n      },\n      \"application/vnd.llamagraphics.life-balance.exchange+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lbe\"]\n      },\n      \"application/vnd.logipipe.circuit+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.loom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.lotus-1-2-3\": {\n        source: \"iana\",\n        extensions: [\"123\"]\n      },\n      \"application/vnd.lotus-approach\": {\n        source: \"iana\",\n        extensions: [\"apr\"]\n      },\n      \"application/vnd.lotus-freelance\": {\n        source: \"iana\",\n        extensions: [\"pre\"]\n      },\n      \"application/vnd.lotus-notes\": {\n        source: \"iana\",\n        extensions: [\"nsf\"]\n      },\n      \"application/vnd.lotus-organizer\": {\n        source: \"iana\",\n        extensions: [\"org\"]\n      },\n      \"application/vnd.lotus-screencam\": {\n        source: \"iana\",\n        extensions: [\"scm\"]\n      },\n      \"application/vnd.lotus-wordpro\": {\n        source: \"iana\",\n        extensions: [\"lwp\"]\n      },\n      \"application/vnd.macports.portpkg\": {\n        source: \"iana\",\n        extensions: [\"portpkg\"]\n      },\n      \"application/vnd.mapbox-vector-tile\": {\n        source: \"iana\",\n        extensions: [\"mvt\"]\n      },\n      \"application/vnd.marlin.drm.actiontoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.conftoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.license+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.mdcf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mason+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.maxar.archive.3tz+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.maxmind.maxmind-db\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mcd\": {\n        source: \"iana\",\n        extensions: [\"mcd\"]\n      },\n      \"application/vnd.mdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mdl-mbsdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.medcalcdata\": {\n        source: \"iana\",\n        extensions: [\"mc1\"]\n      },\n      \"application/vnd.mediastation.cdkey\": {\n        source: \"iana\",\n        extensions: [\"cdkey\"]\n      },\n      \"application/vnd.medicalholodeck.recordxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.meridian-slingshot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mermaid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mfer\": {\n        source: \"iana\",\n        extensions: [\"mwf\"]\n      },\n      \"application/vnd.mfmp\": {\n        source: \"iana\",\n        extensions: [\"mfm\"]\n      },\n      \"application/vnd.micro+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.micrografx.flo\": {\n        source: \"iana\",\n        extensions: [\"flo\"]\n      },\n      \"application/vnd.micrografx.igx\": {\n        source: \"iana\",\n        extensions: [\"igx\"]\n      },\n      \"application/vnd.microsoft.portable-executable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.microsoft.windows.thumbnail-cache\": {\n        source: \"iana\"\n      },\n      \"application/vnd.miele+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.mif\": {\n        source: \"iana\",\n        extensions: [\"mif\"]\n      },\n      \"application/vnd.minisoft-hp3000-save\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mitsubishi.misty-guard.trustweb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mobius.daf\": {\n        source: \"iana\",\n        extensions: [\"daf\"]\n      },\n      \"application/vnd.mobius.dis\": {\n        source: \"iana\",\n        extensions: [\"dis\"]\n      },\n      \"application/vnd.mobius.mbk\": {\n        source: \"iana\",\n        extensions: [\"mbk\"]\n      },\n      \"application/vnd.mobius.mqy\": {\n        source: \"iana\",\n        extensions: [\"mqy\"]\n      },\n      \"application/vnd.mobius.msl\": {\n        source: \"iana\",\n        extensions: [\"msl\"]\n      },\n      \"application/vnd.mobius.plc\": {\n        source: \"iana\",\n        extensions: [\"plc\"]\n      },\n      \"application/vnd.mobius.txf\": {\n        source: \"iana\",\n        extensions: [\"txf\"]\n      },\n      \"application/vnd.modl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mophun.application\": {\n        source: \"iana\",\n        extensions: [\"mpn\"]\n      },\n      \"application/vnd.mophun.certificate\": {\n        source: \"iana\",\n        extensions: [\"mpc\"]\n      },\n      \"application/vnd.motorola.flexsuite\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.adsi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.fis\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.gotap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.kmr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.ttc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.wem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.iprm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mozilla.xul+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xul\"]\n      },\n      \"application/vnd.ms-3mfdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-artgalry\": {\n        source: \"iana\",\n        extensions: [\"cil\"]\n      },\n      \"application/vnd.ms-asf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-cab-compressed\": {\n        source: \"iana\",\n        extensions: [\"cab\"]\n      },\n      \"application/vnd.ms-color.iccprofile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-excel\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xls\", \"xlm\", \"xla\", \"xlc\", \"xlt\", \"xlw\"]\n      },\n      \"application/vnd.ms-excel.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlam\"]\n      },\n      \"application/vnd.ms-excel.sheet.binary.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsb\"]\n      },\n      \"application/vnd.ms-excel.sheet.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsm\"]\n      },\n      \"application/vnd.ms-excel.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xltm\"]\n      },\n      \"application/vnd.ms-fontobject\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eot\"]\n      },\n      \"application/vnd.ms-htmlhelp\": {\n        source: \"iana\",\n        extensions: [\"chm\"]\n      },\n      \"application/vnd.ms-ims\": {\n        source: \"iana\",\n        extensions: [\"ims\"]\n      },\n      \"application/vnd.ms-lrm\": {\n        source: \"iana\",\n        extensions: [\"lrm\"]\n      },\n      \"application/vnd.ms-office.activex+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-officetheme\": {\n        source: \"iana\",\n        extensions: [\"thmx\"]\n      },\n      \"application/vnd.ms-opentype\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-outlook\": {\n        compressible: false,\n        extensions: [\"msg\"]\n      },\n      \"application/vnd.ms-package.obfuscated-opentype\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-pki.seccat\": {\n        source: \"apache\",\n        extensions: [\"cat\"]\n      },\n      \"application/vnd.ms-pki.stl\": {\n        source: \"apache\",\n        extensions: [\"stl\"]\n      },\n      \"application/vnd.ms-playready.initiator+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-powerpoint\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ppt\", \"pps\", \"pot\"]\n      },\n      \"application/vnd.ms-powerpoint.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppam\"]\n      },\n      \"application/vnd.ms-powerpoint.presentation.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"pptm\"]\n      },\n      \"application/vnd.ms-powerpoint.slide.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"sldm\"]\n      },\n      \"application/vnd.ms-powerpoint.slideshow.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppsm\"]\n      },\n      \"application/vnd.ms-powerpoint.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"potm\"]\n      },\n      \"application/vnd.ms-printdevicecapabilities+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-printing.printticket+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-printschematicket+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-project\": {\n        source: \"iana\",\n        extensions: [\"mpp\", \"mpt\"]\n      },\n      \"application/vnd.ms-tnef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-visio.viewer\": {\n        extensions: [\"vdx\"]\n      },\n      \"application/vnd.ms-windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.nwprinting.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.printerpairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.wsd.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-word.document.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"docm\"]\n      },\n      \"application/vnd.ms-word.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"dotm\"]\n      },\n      \"application/vnd.ms-works\": {\n        source: \"iana\",\n        extensions: [\"wps\", \"wks\", \"wcm\", \"wdb\"]\n      },\n      \"application/vnd.ms-wpl\": {\n        source: \"iana\",\n        extensions: [\"wpl\"]\n      },\n      \"application/vnd.ms-xpsdocument\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xps\"]\n      },\n      \"application/vnd.msa-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mseq\": {\n        source: \"iana\",\n        extensions: [\"mseq\"]\n      },\n      \"application/vnd.msgpack\": {\n        source: \"iana\"\n      },\n      \"application/vnd.msign\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator.cif\": {\n        source: \"iana\"\n      },\n      \"application/vnd.music-niff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.musician\": {\n        source: \"iana\",\n        extensions: [\"mus\"]\n      },\n      \"application/vnd.muvee.style\": {\n        source: \"iana\",\n        extensions: [\"msty\"]\n      },\n      \"application/vnd.mynfc\": {\n        source: \"iana\",\n        extensions: [\"taglet\"]\n      },\n      \"application/vnd.nacamar.ybrid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nato.bindingdataobject+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bdo\"]\n      },\n      \"application/vnd.nato.openxmlformats-package.iepd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.ncd.control\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ncd.reference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nearst.inv+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nebumind.line\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nervana\": {\n        source: \"iana\"\n      },\n      \"application/vnd.netfpx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.neurolanguage.nlu\": {\n        source: \"iana\",\n        extensions: [\"nlu\"]\n      },\n      \"application/vnd.nimn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.nitro.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.snes.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nitf\": {\n        source: \"iana\",\n        extensions: [\"ntf\", \"nitf\"]\n      },\n      \"application/vnd.noblenet-directory\": {\n        source: \"iana\",\n        extensions: [\"nnd\"]\n      },\n      \"application/vnd.noblenet-sealer\": {\n        source: \"iana\",\n        extensions: [\"nns\"]\n      },\n      \"application/vnd.noblenet-web\": {\n        source: \"iana\",\n        extensions: [\"nnw\"]\n      },\n      \"application/vnd.nokia.catalogs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.iptv.config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.isds-radio-presets\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.landmarkcollection+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.n-gage.ac+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ac\"]\n      },\n      \"application/vnd.nokia.n-gage.data\": {\n        source: \"iana\",\n        extensions: [\"ngdat\"]\n      },\n      \"application/vnd.nokia.n-gage.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"n-gage\"]\n      },\n      \"application/vnd.nokia.ncd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.radio-preset\": {\n        source: \"iana\",\n        extensions: [\"rpst\"]\n      },\n      \"application/vnd.nokia.radio-presets\": {\n        source: \"iana\",\n        extensions: [\"rpss\"]\n      },\n      \"application/vnd.novadigm.edm\": {\n        source: \"iana\",\n        extensions: [\"edm\"]\n      },\n      \"application/vnd.novadigm.edx\": {\n        source: \"iana\",\n        extensions: [\"edx\"]\n      },\n      \"application/vnd.novadigm.ext\": {\n        source: \"iana\",\n        extensions: [\"ext\"]\n      },\n      \"application/vnd.ntt-local.content-share\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.file-transfer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.ogw_remote-access\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_remote\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oai.workflows+yaml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.chart\": {\n        source: \"iana\",\n        extensions: [\"odc\"]\n      },\n      \"application/vnd.oasis.opendocument.chart-template\": {\n        source: \"iana\",\n        extensions: [\"otc\"]\n      },\n      \"application/vnd.oasis.opendocument.database\": {\n        source: \"apache\",\n        extensions: [\"odb\"]\n      },\n      \"application/vnd.oasis.opendocument.formula\": {\n        source: \"iana\",\n        extensions: [\"odf\"]\n      },\n      \"application/vnd.oasis.opendocument.formula-template\": {\n        source: \"iana\",\n        extensions: [\"odft\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odg\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics-template\": {\n        source: \"iana\",\n        extensions: [\"otg\"]\n      },\n      \"application/vnd.oasis.opendocument.image\": {\n        source: \"iana\",\n        extensions: [\"odi\"]\n      },\n      \"application/vnd.oasis.opendocument.image-template\": {\n        source: \"iana\",\n        extensions: [\"oti\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odp\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation-template\": {\n        source: \"iana\",\n        extensions: [\"otp\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ods\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet-template\": {\n        source: \"iana\",\n        extensions: [\"ots\"]\n      },\n      \"application/vnd.oasis.opendocument.text\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odt\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master\": {\n        source: \"iana\",\n        extensions: [\"odm\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.text-template\": {\n        source: \"iana\",\n        extensions: [\"ott\"]\n      },\n      \"application/vnd.oasis.opendocument.text-web\": {\n        source: \"iana\",\n        extensions: [\"oth\"]\n      },\n      \"application/vnd.obn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ocf+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oci.image.manifest.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oftn.l10n+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessdownload+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessstreaming+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.cspg-hexbinary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.dae.svg+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.dae.xhtml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.mippvcontrolmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.pae.gem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.spdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.spdlist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.ueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.userprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.olpc-sugar\": {\n        source: \"iana\",\n        extensions: [\"xo\"]\n      },\n      \"application/vnd.oma-scws-config\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-request\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.associated-procedure-parameter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.drm-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.imd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.ltkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.notification+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.provisioningtrigger\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgboot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgdd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sgdu\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.simple-symbol-container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.smartcard-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sprov+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.stkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.cab-address-book+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-feature-handler+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-pcc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-subs-invite+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-user-prefs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.dcd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dcdc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dd2+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dd2\"]\n      },\n      \"application/vnd.oma.drm.risd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.group-usage-list+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.lwm2m+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+tlv\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.pal+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.detailed-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.final-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.groups+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.invocation-descriptor+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.optimized-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.push\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.scidm.messages+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.xcap-directory+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.omads-email+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-file+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-folder+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omaloc-supl-init\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepager\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertat\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onvif.metadata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openblox.game+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"obgx\"]\n      },\n      \"application/vnd.openblox.game-binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openeye.oeb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openofficeorg.extension\": {\n        source: \"apache\",\n        extensions: [\"oxt\"]\n      },\n      \"application/vnd.openstreetmap.data+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osm\"]\n      },\n      \"application/vnd.opentimestamps.ots\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openvpi.dspx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.custom-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.customxmlproperties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawing+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chart+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.extended-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pptx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide\": {\n        source: \"iana\",\n        extensions: [\"sldx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow\": {\n        source: \"iana\",\n        extensions: [\"ppsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tags+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template\": {\n        source: \"iana\",\n        extensions: [\"potx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xlsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template\": {\n        source: \"iana\",\n        extensions: [\"xltx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.theme+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.themeoverride+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.vmldrawing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"docx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template\": {\n        source: \"iana\",\n        extensions: [\"dotx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.core-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.relationships+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oracle.resource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.orange.indata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osa.netdeploy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgeo.mapguide.package\": {\n        source: \"iana\",\n        extensions: [\"mgp\"]\n      },\n      \"application/vnd.osgi.bundle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgi.dp\": {\n        source: \"iana\",\n        extensions: [\"dp\"]\n      },\n      \"application/vnd.osgi.subsystem\": {\n        source: \"iana\",\n        extensions: [\"esa\"]\n      },\n      \"application/vnd.otps.ct-kip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oxli.countgraph\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pagerduty+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.palm\": {\n        source: \"iana\",\n        extensions: [\"pdb\", \"pqa\", \"oprc\"]\n      },\n      \"application/vnd.panoply\": {\n        source: \"iana\"\n      },\n      \"application/vnd.paos.xml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patentdive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patientecommsdoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pawaafile\": {\n        source: \"iana\",\n        extensions: [\"paw\"]\n      },\n      \"application/vnd.pcos\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pg.format\": {\n        source: \"iana\",\n        extensions: [\"str\"]\n      },\n      \"application/vnd.pg.osasli\": {\n        source: \"iana\",\n        extensions: [\"ei6\"]\n      },\n      \"application/vnd.piaccess.application-licence\": {\n        source: \"iana\"\n      },\n      \"application/vnd.picsel\": {\n        source: \"iana\",\n        extensions: [\"efif\"]\n      },\n      \"application/vnd.pmi.widget\": {\n        source: \"iana\",\n        extensions: [\"wg\"]\n      },\n      \"application/vnd.poc.group-advertisement+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.pocketlearn\": {\n        source: \"iana\",\n        extensions: [\"plf\"]\n      },\n      \"application/vnd.powerbuilder6\": {\n        source: \"iana\",\n        extensions: [\"pbd\"]\n      },\n      \"application/vnd.powerbuilder6-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.preminet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.previewsystems.box\": {\n        source: \"iana\",\n        extensions: [\"box\"]\n      },\n      \"application/vnd.procrate.brushset\": {\n        extensions: [\"brushset\"]\n      },\n      \"application/vnd.procreate.brush\": {\n        extensions: [\"brush\"]\n      },\n      \"application/vnd.procreate.dream\": {\n        extensions: [\"drm\"]\n      },\n      \"application/vnd.proteus.magazine\": {\n        source: \"iana\",\n        extensions: [\"mgz\"]\n      },\n      \"application/vnd.psfs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pt.mundusmundi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.publishare-delta-tree\": {\n        source: \"iana\",\n        extensions: [\"qps\"]\n      },\n      \"application/vnd.pvi.ptid1\": {\n        source: \"iana\",\n        extensions: [\"ptid\"]\n      },\n      \"application/vnd.pwg-multiplexed\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pwg-xhtml-print+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtm\"]\n      },\n      \"application/vnd.qualcomm.brew-app-res\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quarantainenet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quark.quarkxpress\": {\n        source: \"iana\",\n        extensions: [\"qxd\", \"qxt\", \"qwd\", \"qwt\", \"qxl\", \"qxb\"]\n      },\n      \"application/vnd.quobject-quoxdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.radisys.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-stream+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-base+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-detect+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-sendrecv+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-group+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-speech+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-transform+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rainstor.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rapid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rar\": {\n        source: \"iana\",\n        extensions: [\"rar\"]\n      },\n      \"application/vnd.realvnc.bed\": {\n        source: \"iana\",\n        extensions: [\"bed\"]\n      },\n      \"application/vnd.recordare.musicxml\": {\n        source: \"iana\",\n        extensions: [\"mxl\"]\n      },\n      \"application/vnd.recordare.musicxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musicxml\"]\n      },\n      \"application/vnd.relpipe\": {\n        source: \"iana\"\n      },\n      \"application/vnd.renlearn.rlprint\": {\n        source: \"iana\"\n      },\n      \"application/vnd.resilient.logic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.restful+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rig.cryptonote\": {\n        source: \"iana\",\n        extensions: [\"cryptonote\"]\n      },\n      \"application/vnd.rim.cod\": {\n        source: \"apache\",\n        extensions: [\"cod\"]\n      },\n      \"application/vnd.rn-realmedia\": {\n        source: \"apache\",\n        extensions: [\"rm\"]\n      },\n      \"application/vnd.rn-realmedia-vbr\": {\n        source: \"apache\",\n        extensions: [\"rmvb\"]\n      },\n      \"application/vnd.route66.link66+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"link66\"]\n      },\n      \"application/vnd.rs-274x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ruckus.download\": {\n        source: \"iana\"\n      },\n      \"application/vnd.s3sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sailingtracker.track\": {\n        source: \"iana\",\n        extensions: [\"st\"]\n      },\n      \"application/vnd.sar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.cid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.mid2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.scribus\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.3df\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.csf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.doc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.eml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.mht\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.net\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.ppt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.tiff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.xls\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.seemail\": {\n        source: \"iana\",\n        extensions: [\"see\"]\n      },\n      \"application/vnd.seis+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sema\": {\n        source: \"iana\",\n        extensions: [\"sema\"]\n      },\n      \"application/vnd.semd\": {\n        source: \"iana\",\n        extensions: [\"semd\"]\n      },\n      \"application/vnd.semf\": {\n        source: \"iana\",\n        extensions: [\"semf\"]\n      },\n      \"application/vnd.shade-save-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shana.informed.formdata\": {\n        source: \"iana\",\n        extensions: [\"ifm\"]\n      },\n      \"application/vnd.shana.informed.formtemplate\": {\n        source: \"iana\",\n        extensions: [\"itp\"]\n      },\n      \"application/vnd.shana.informed.interchange\": {\n        source: \"iana\",\n        extensions: [\"iif\"]\n      },\n      \"application/vnd.shana.informed.package\": {\n        source: \"iana\",\n        extensions: [\"ipk\"]\n      },\n      \"application/vnd.shootproof+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shopkick+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sigrok.session\": {\n        source: \"iana\"\n      },\n      \"application/vnd.simtech-mindmapper\": {\n        source: \"iana\",\n        extensions: [\"twd\", \"twds\"]\n      },\n      \"application/vnd.siren+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sketchometry\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smaf\": {\n        source: \"iana\",\n        extensions: [\"mmf\"]\n      },\n      \"application/vnd.smart.notebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smart.teacher\": {\n        source: \"iana\",\n        extensions: [\"teacher\"]\n      },\n      \"application/vnd.smintio.portals.archive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.snesdev-page-table\": {\n        source: \"iana\"\n      },\n      \"application/vnd.software602.filler.form+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fo\"]\n      },\n      \"application/vnd.software602.filler.form-xml-zip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.solent.sdkm+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sdkm\", \"sdkd\"]\n      },\n      \"application/vnd.spotfire.dxp\": {\n        source: \"iana\",\n        extensions: [\"dxp\"]\n      },\n      \"application/vnd.spotfire.sfs\": {\n        source: \"iana\",\n        extensions: [\"sfs\"]\n      },\n      \"application/vnd.sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-cod\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-dtf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-ntf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.stardivision.calc\": {\n        source: \"apache\",\n        extensions: [\"sdc\"]\n      },\n      \"application/vnd.stardivision.draw\": {\n        source: \"apache\",\n        extensions: [\"sda\"]\n      },\n      \"application/vnd.stardivision.impress\": {\n        source: \"apache\",\n        extensions: [\"sdd\"]\n      },\n      \"application/vnd.stardivision.math\": {\n        source: \"apache\",\n        extensions: [\"smf\"]\n      },\n      \"application/vnd.stardivision.writer\": {\n        source: \"apache\",\n        extensions: [\"sdw\", \"vor\"]\n      },\n      \"application/vnd.stardivision.writer-global\": {\n        source: \"apache\",\n        extensions: [\"sgl\"]\n      },\n      \"application/vnd.stepmania.package\": {\n        source: \"iana\",\n        extensions: [\"smzip\"]\n      },\n      \"application/vnd.stepmania.stepchart\": {\n        source: \"iana\",\n        extensions: [\"sm\"]\n      },\n      \"application/vnd.street-stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sun.wadl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wadl\"]\n      },\n      \"application/vnd.sun.xml.calc\": {\n        source: \"apache\",\n        extensions: [\"sxc\"]\n      },\n      \"application/vnd.sun.xml.calc.template\": {\n        source: \"apache\",\n        extensions: [\"stc\"]\n      },\n      \"application/vnd.sun.xml.draw\": {\n        source: \"apache\",\n        extensions: [\"sxd\"]\n      },\n      \"application/vnd.sun.xml.draw.template\": {\n        source: \"apache\",\n        extensions: [\"std\"]\n      },\n      \"application/vnd.sun.xml.impress\": {\n        source: \"apache\",\n        extensions: [\"sxi\"]\n      },\n      \"application/vnd.sun.xml.impress.template\": {\n        source: \"apache\",\n        extensions: [\"sti\"]\n      },\n      \"application/vnd.sun.xml.math\": {\n        source: \"apache\",\n        extensions: [\"sxm\"]\n      },\n      \"application/vnd.sun.xml.writer\": {\n        source: \"apache\",\n        extensions: [\"sxw\"]\n      },\n      \"application/vnd.sun.xml.writer.global\": {\n        source: \"apache\",\n        extensions: [\"sxg\"]\n      },\n      \"application/vnd.sun.xml.writer.template\": {\n        source: \"apache\",\n        extensions: [\"stw\"]\n      },\n      \"application/vnd.sus-calendar\": {\n        source: \"iana\",\n        extensions: [\"sus\", \"susp\"]\n      },\n      \"application/vnd.svd\": {\n        source: \"iana\",\n        extensions: [\"svd\"]\n      },\n      \"application/vnd.swiftview-ics\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sybyl.mol2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sycle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.syft+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"sis\", \"sisx\"]\n      },\n      \"application/vnd.syncml+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xsm\"]\n      },\n      \"application/vnd.syncml.dm+wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"bdm\"]\n      },\n      \"application/vnd.syncml.dm+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xdm\"]\n      },\n      \"application/vnd.syncml.dm.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"ddf\"]\n      },\n      \"application/vnd.syncml.dmtnds+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmtnds+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.syncml.ds.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tableschema+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tao.intent-module-archive\": {\n        source: \"iana\",\n        extensions: [\"tao\"]\n      },\n      \"application/vnd.tcpdump.pcap\": {\n        source: \"iana\",\n        extensions: [\"pcap\", \"cap\", \"dmp\"]\n      },\n      \"application/vnd.think-cell.ppttc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tmd.mediaflex.api+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tmobile-livetv\": {\n        source: \"iana\",\n        extensions: [\"tmo\"]\n      },\n      \"application/vnd.tri.onesource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.trid.tpt\": {\n        source: \"iana\",\n        extensions: [\"tpt\"]\n      },\n      \"application/vnd.triscape.mxs\": {\n        source: \"iana\",\n        extensions: [\"mxs\"]\n      },\n      \"application/vnd.trueapp\": {\n        source: \"iana\",\n        extensions: [\"tra\"]\n      },\n      \"application/vnd.truedoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ubisoft.webplayer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ufdl\": {\n        source: \"iana\",\n        extensions: [\"ufd\", \"ufdl\"]\n      },\n      \"application/vnd.uic.osdm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.uiq.theme\": {\n        source: \"iana\",\n        extensions: [\"utz\"]\n      },\n      \"application/vnd.umajin\": {\n        source: \"iana\",\n        extensions: [\"umj\"]\n      },\n      \"application/vnd.unity\": {\n        source: \"iana\",\n        extensions: [\"unityweb\"]\n      },\n      \"application/vnd.uoml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uoml\", \"uo\"]\n      },\n      \"application/vnd.uplanet.alert\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.alert-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.signal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uri-map\": {\n        source: \"iana\"\n      },\n      \"application/vnd.valve.source.material\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vcx\": {\n        source: \"iana\",\n        extensions: [\"vcx\"]\n      },\n      \"application/vnd.vd-study\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vectorworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vel+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veraison.tsm-report+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veraison.tsm-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.verimatrix.vcas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veritone.aion+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veryant.thin\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ves.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vidsoft.vidconference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.visio\": {\n        source: \"iana\",\n        extensions: [\"vsd\", \"vst\", \"vss\", \"vsw\", \"vsdx\", \"vtx\"]\n      },\n      \"application/vnd.visionary\": {\n        source: \"iana\",\n        extensions: [\"vis\"]\n      },\n      \"application/vnd.vividence.scriptfile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vocalshaper.vsp4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vsf\": {\n        source: \"iana\",\n        extensions: [\"vsf\"]\n      },\n      \"application/vnd.wap.sic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.slc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"wbxml\"]\n      },\n      \"application/vnd.wap.wmlc\": {\n        source: \"iana\",\n        extensions: [\"wmlc\"]\n      },\n      \"application/vnd.wap.wmlscriptc\": {\n        source: \"iana\",\n        extensions: [\"wmlsc\"]\n      },\n      \"application/vnd.wasmflow.wafl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.webturbo\": {\n        source: \"iana\",\n        extensions: [\"wtb\"]\n      },\n      \"application/vnd.wfa.dpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.p2p\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.wsc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmf.bootstrap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica.package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.player\": {\n        source: \"iana\",\n        extensions: [\"nbp\"]\n      },\n      \"application/vnd.wordlift\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wordperfect\": {\n        source: \"iana\",\n        extensions: [\"wpd\"]\n      },\n      \"application/vnd.wqd\": {\n        source: \"iana\",\n        extensions: [\"wqd\"]\n      },\n      \"application/vnd.wrq-hp3000-labelled\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wt.stf\": {\n        source: \"iana\",\n        extensions: [\"stf\"]\n      },\n      \"application/vnd.wv.csp+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wv.csp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.wv.ssp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xara\": {\n        source: \"iana\",\n        extensions: [\"xar\"]\n      },\n      \"application/vnd.xarin.cpj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xecrets-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xfdl\": {\n        source: \"iana\",\n        extensions: [\"xfdl\"]\n      },\n      \"application/vnd.xfdl.webform\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xmpie.cpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.dpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.plan\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.ppkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.xlim\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.hv-dic\": {\n        source: \"iana\",\n        extensions: [\"hvd\"]\n      },\n      \"application/vnd.yamaha.hv-script\": {\n        source: \"iana\",\n        extensions: [\"hvs\"]\n      },\n      \"application/vnd.yamaha.hv-voice\": {\n        source: \"iana\",\n        extensions: [\"hvp\"]\n      },\n      \"application/vnd.yamaha.openscoreformat\": {\n        source: \"iana\",\n        extensions: [\"osf\"]\n      },\n      \"application/vnd.yamaha.openscoreformat.osfpvg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osfpvg\"]\n      },\n      \"application/vnd.yamaha.remote-setup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.smaf-audio\": {\n        source: \"iana\",\n        extensions: [\"saf\"]\n      },\n      \"application/vnd.yamaha.smaf-phrase\": {\n        source: \"iana\",\n        extensions: [\"spf\"]\n      },\n      \"application/vnd.yamaha.through-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.tunnel-udpencap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yaoweme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yellowriver-custom-menu\": {\n        source: \"iana\",\n        extensions: [\"cmp\"]\n      },\n      \"application/vnd.zul\": {\n        source: \"iana\",\n        extensions: [\"zir\", \"zirz\"]\n      },\n      \"application/vnd.zzazz.deck+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zaz\"]\n      },\n      \"application/voicexml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vxml\"]\n      },\n      \"application/voucher-cms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/voucher-jws+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vp\": {\n        source: \"iana\"\n      },\n      \"application/vp+cose\": {\n        source: \"iana\"\n      },\n      \"application/vp+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vq-rtcpxr\": {\n        source: \"iana\"\n      },\n      \"application/wasm\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wasm\"]\n      },\n      \"application/watcherinfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wif\"]\n      },\n      \"application/webpush-options+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/whoispp-query\": {\n        source: \"iana\"\n      },\n      \"application/whoispp-response\": {\n        source: \"iana\"\n      },\n      \"application/widget\": {\n        source: \"iana\",\n        extensions: [\"wgt\"]\n      },\n      \"application/winhlp\": {\n        source: \"apache\",\n        extensions: [\"hlp\"]\n      },\n      \"application/wita\": {\n        source: \"iana\"\n      },\n      \"application/wordperfect5.1\": {\n        source: \"iana\"\n      },\n      \"application/wsdl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wsdl\"]\n      },\n      \"application/wspolicy+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wspolicy\"]\n      },\n      \"application/x-7z-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"7z\"]\n      },\n      \"application/x-abiword\": {\n        source: \"apache\",\n        extensions: [\"abw\"]\n      },\n      \"application/x-ace-compressed\": {\n        source: \"apache\",\n        extensions: [\"ace\"]\n      },\n      \"application/x-amf\": {\n        source: \"apache\"\n      },\n      \"application/x-apple-diskimage\": {\n        source: \"apache\",\n        extensions: [\"dmg\"]\n      },\n      \"application/x-arj\": {\n        compressible: false,\n        extensions: [\"arj\"]\n      },\n      \"application/x-authorware-bin\": {\n        source: \"apache\",\n        extensions: [\"aab\", \"x32\", \"u32\", \"vox\"]\n      },\n      \"application/x-authorware-map\": {\n        source: \"apache\",\n        extensions: [\"aam\"]\n      },\n      \"application/x-authorware-seg\": {\n        source: \"apache\",\n        extensions: [\"aas\"]\n      },\n      \"application/x-bcpio\": {\n        source: \"apache\",\n        extensions: [\"bcpio\"]\n      },\n      \"application/x-bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/x-bittorrent\": {\n        source: \"apache\",\n        extensions: [\"torrent\"]\n      },\n      \"application/x-blender\": {\n        extensions: [\"blend\"]\n      },\n      \"application/x-blorb\": {\n        source: \"apache\",\n        extensions: [\"blb\", \"blorb\"]\n      },\n      \"application/x-bzip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz\"]\n      },\n      \"application/x-bzip2\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz2\", \"boz\"]\n      },\n      \"application/x-cbr\": {\n        source: \"apache\",\n        extensions: [\"cbr\", \"cba\", \"cbt\", \"cbz\", \"cb7\"]\n      },\n      \"application/x-cdlink\": {\n        source: \"apache\",\n        extensions: [\"vcd\"]\n      },\n      \"application/x-cfs-compressed\": {\n        source: \"apache\",\n        extensions: [\"cfs\"]\n      },\n      \"application/x-chat\": {\n        source: \"apache\",\n        extensions: [\"chat\"]\n      },\n      \"application/x-chess-pgn\": {\n        source: \"apache\",\n        extensions: [\"pgn\"]\n      },\n      \"application/x-chrome-extension\": {\n        extensions: [\"crx\"]\n      },\n      \"application/x-cocoa\": {\n        source: \"nginx\",\n        extensions: [\"cco\"]\n      },\n      \"application/x-compress\": {\n        source: \"apache\"\n      },\n      \"application/x-compressed\": {\n        extensions: [\"rar\"]\n      },\n      \"application/x-conference\": {\n        source: \"apache\",\n        extensions: [\"nsc\"]\n      },\n      \"application/x-cpio\": {\n        source: \"apache\",\n        extensions: [\"cpio\"]\n      },\n      \"application/x-csh\": {\n        source: \"apache\",\n        extensions: [\"csh\"]\n      },\n      \"application/x-deb\": {\n        compressible: false\n      },\n      \"application/x-debian-package\": {\n        source: \"apache\",\n        extensions: [\"deb\", \"udeb\"]\n      },\n      \"application/x-dgc-compressed\": {\n        source: \"apache\",\n        extensions: [\"dgc\"]\n      },\n      \"application/x-director\": {\n        source: \"apache\",\n        extensions: [\"dir\", \"dcr\", \"dxr\", \"cst\", \"cct\", \"cxt\", \"w3d\", \"fgd\", \"swa\"]\n      },\n      \"application/x-doom\": {\n        source: \"apache\",\n        extensions: [\"wad\"]\n      },\n      \"application/x-dtbncx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ncx\"]\n      },\n      \"application/x-dtbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dtb\"]\n      },\n      \"application/x-dtbresource+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"res\"]\n      },\n      \"application/x-dvi\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"dvi\"]\n      },\n      \"application/x-envoy\": {\n        source: \"apache\",\n        extensions: [\"evy\"]\n      },\n      \"application/x-eva\": {\n        source: \"apache\",\n        extensions: [\"eva\"]\n      },\n      \"application/x-font-bdf\": {\n        source: \"apache\",\n        extensions: [\"bdf\"]\n      },\n      \"application/x-font-dos\": {\n        source: \"apache\"\n      },\n      \"application/x-font-framemaker\": {\n        source: \"apache\"\n      },\n      \"application/x-font-ghostscript\": {\n        source: \"apache\",\n        extensions: [\"gsf\"]\n      },\n      \"application/x-font-libgrx\": {\n        source: \"apache\"\n      },\n      \"application/x-font-linux-psf\": {\n        source: \"apache\",\n        extensions: [\"psf\"]\n      },\n      \"application/x-font-pcf\": {\n        source: \"apache\",\n        extensions: [\"pcf\"]\n      },\n      \"application/x-font-snf\": {\n        source: \"apache\",\n        extensions: [\"snf\"]\n      },\n      \"application/x-font-speedo\": {\n        source: \"apache\"\n      },\n      \"application/x-font-sunos-news\": {\n        source: \"apache\"\n      },\n      \"application/x-font-type1\": {\n        source: \"apache\",\n        extensions: [\"pfa\", \"pfb\", \"pfm\", \"afm\"]\n      },\n      \"application/x-font-vfont\": {\n        source: \"apache\"\n      },\n      \"application/x-freearc\": {\n        source: \"apache\",\n        extensions: [\"arc\"]\n      },\n      \"application/x-futuresplash\": {\n        source: \"apache\",\n        extensions: [\"spl\"]\n      },\n      \"application/x-gca-compressed\": {\n        source: \"apache\",\n        extensions: [\"gca\"]\n      },\n      \"application/x-glulx\": {\n        source: \"apache\",\n        extensions: [\"ulx\"]\n      },\n      \"application/x-gnumeric\": {\n        source: \"apache\",\n        extensions: [\"gnumeric\"]\n      },\n      \"application/x-gramps-xml\": {\n        source: \"apache\",\n        extensions: [\"gramps\"]\n      },\n      \"application/x-gtar\": {\n        source: \"apache\",\n        extensions: [\"gtar\"]\n      },\n      \"application/x-gzip\": {\n        source: \"apache\"\n      },\n      \"application/x-hdf\": {\n        source: \"apache\",\n        extensions: [\"hdf\"]\n      },\n      \"application/x-httpd-php\": {\n        compressible: true,\n        extensions: [\"php\"]\n      },\n      \"application/x-install-instructions\": {\n        source: \"apache\",\n        extensions: [\"install\"]\n      },\n      \"application/x-ipynb+json\": {\n        compressible: true,\n        extensions: [\"ipynb\"]\n      },\n      \"application/x-iso9660-image\": {\n        source: \"apache\",\n        extensions: [\"iso\"]\n      },\n      \"application/x-iwork-keynote-sffkey\": {\n        extensions: [\"key\"]\n      },\n      \"application/x-iwork-numbers-sffnumbers\": {\n        extensions: [\"numbers\"]\n      },\n      \"application/x-iwork-pages-sffpages\": {\n        extensions: [\"pages\"]\n      },\n      \"application/x-java-archive-diff\": {\n        source: \"nginx\",\n        extensions: [\"jardiff\"]\n      },\n      \"application/x-java-jnlp-file\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"jnlp\"]\n      },\n      \"application/x-javascript\": {\n        compressible: true\n      },\n      \"application/x-keepass2\": {\n        extensions: [\"kdbx\"]\n      },\n      \"application/x-latex\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"latex\"]\n      },\n      \"application/x-lua-bytecode\": {\n        extensions: [\"luac\"]\n      },\n      \"application/x-lzh-compressed\": {\n        source: \"apache\",\n        extensions: [\"lzh\", \"lha\"]\n      },\n      \"application/x-makeself\": {\n        source: \"nginx\",\n        extensions: [\"run\"]\n      },\n      \"application/x-mie\": {\n        source: \"apache\",\n        extensions: [\"mie\"]\n      },\n      \"application/x-mobipocket-ebook\": {\n        source: \"apache\",\n        extensions: [\"prc\", \"mobi\"]\n      },\n      \"application/x-mpegurl\": {\n        compressible: false\n      },\n      \"application/x-ms-application\": {\n        source: \"apache\",\n        extensions: [\"application\"]\n      },\n      \"application/x-ms-shortcut\": {\n        source: \"apache\",\n        extensions: [\"lnk\"]\n      },\n      \"application/x-ms-wmd\": {\n        source: \"apache\",\n        extensions: [\"wmd\"]\n      },\n      \"application/x-ms-wmz\": {\n        source: \"apache\",\n        extensions: [\"wmz\"]\n      },\n      \"application/x-ms-xbap\": {\n        source: \"apache\",\n        extensions: [\"xbap\"]\n      },\n      \"application/x-msaccess\": {\n        source: \"apache\",\n        extensions: [\"mdb\"]\n      },\n      \"application/x-msbinder\": {\n        source: \"apache\",\n        extensions: [\"obd\"]\n      },\n      \"application/x-mscardfile\": {\n        source: \"apache\",\n        extensions: [\"crd\"]\n      },\n      \"application/x-msclip\": {\n        source: \"apache\",\n        extensions: [\"clp\"]\n      },\n      \"application/x-msdos-program\": {\n        extensions: [\"exe\"]\n      },\n      \"application/x-msdownload\": {\n        source: \"apache\",\n        extensions: [\"exe\", \"dll\", \"com\", \"bat\", \"msi\"]\n      },\n      \"application/x-msmediaview\": {\n        source: \"apache\",\n        extensions: [\"mvb\", \"m13\", \"m14\"]\n      },\n      \"application/x-msmetafile\": {\n        source: \"apache\",\n        extensions: [\"wmf\", \"wmz\", \"emf\", \"emz\"]\n      },\n      \"application/x-msmoney\": {\n        source: \"apache\",\n        extensions: [\"mny\"]\n      },\n      \"application/x-mspublisher\": {\n        source: \"apache\",\n        extensions: [\"pub\"]\n      },\n      \"application/x-msschedule\": {\n        source: \"apache\",\n        extensions: [\"scd\"]\n      },\n      \"application/x-msterminal\": {\n        source: \"apache\",\n        extensions: [\"trm\"]\n      },\n      \"application/x-mswrite\": {\n        source: \"apache\",\n        extensions: [\"wri\"]\n      },\n      \"application/x-netcdf\": {\n        source: \"apache\",\n        extensions: [\"nc\", \"cdf\"]\n      },\n      \"application/x-ns-proxy-autoconfig\": {\n        compressible: true,\n        extensions: [\"pac\"]\n      },\n      \"application/x-nzb\": {\n        source: \"apache\",\n        extensions: [\"nzb\"]\n      },\n      \"application/x-perl\": {\n        source: \"nginx\",\n        extensions: [\"pl\", \"pm\"]\n      },\n      \"application/x-pilot\": {\n        source: \"nginx\",\n        extensions: [\"prc\", \"pdb\"]\n      },\n      \"application/x-pkcs12\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"p12\", \"pfx\"]\n      },\n      \"application/x-pkcs7-certificates\": {\n        source: \"apache\",\n        extensions: [\"p7b\", \"spc\"]\n      },\n      \"application/x-pkcs7-certreqresp\": {\n        source: \"apache\",\n        extensions: [\"p7r\"]\n      },\n      \"application/x-pki-message\": {\n        source: \"iana\"\n      },\n      \"application/x-rar-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"rar\"]\n      },\n      \"application/x-redhat-package-manager\": {\n        source: \"nginx\",\n        extensions: [\"rpm\"]\n      },\n      \"application/x-research-info-systems\": {\n        source: \"apache\",\n        extensions: [\"ris\"]\n      },\n      \"application/x-sea\": {\n        source: \"nginx\",\n        extensions: [\"sea\"]\n      },\n      \"application/x-sh\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"sh\"]\n      },\n      \"application/x-shar\": {\n        source: \"apache\",\n        extensions: [\"shar\"]\n      },\n      \"application/x-shockwave-flash\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"swf\"]\n      },\n      \"application/x-silverlight-app\": {\n        source: \"apache\",\n        extensions: [\"xap\"]\n      },\n      \"application/x-sql\": {\n        source: \"apache\",\n        extensions: [\"sql\"]\n      },\n      \"application/x-stuffit\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"sit\"]\n      },\n      \"application/x-stuffitx\": {\n        source: \"apache\",\n        extensions: [\"sitx\"]\n      },\n      \"application/x-subrip\": {\n        source: \"apache\",\n        extensions: [\"srt\"]\n      },\n      \"application/x-sv4cpio\": {\n        source: \"apache\",\n        extensions: [\"sv4cpio\"]\n      },\n      \"application/x-sv4crc\": {\n        source: \"apache\",\n        extensions: [\"sv4crc\"]\n      },\n      \"application/x-t3vm-image\": {\n        source: \"apache\",\n        extensions: [\"t3\"]\n      },\n      \"application/x-tads\": {\n        source: \"apache\",\n        extensions: [\"gam\"]\n      },\n      \"application/x-tar\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"tar\"]\n      },\n      \"application/x-tcl\": {\n        source: \"apache\",\n        extensions: [\"tcl\", \"tk\"]\n      },\n      \"application/x-tex\": {\n        source: \"apache\",\n        extensions: [\"tex\"]\n      },\n      \"application/x-tex-tfm\": {\n        source: \"apache\",\n        extensions: [\"tfm\"]\n      },\n      \"application/x-texinfo\": {\n        source: \"apache\",\n        extensions: [\"texinfo\", \"texi\"]\n      },\n      \"application/x-tgif\": {\n        source: \"apache\",\n        extensions: [\"obj\"]\n      },\n      \"application/x-ustar\": {\n        source: \"apache\",\n        extensions: [\"ustar\"]\n      },\n      \"application/x-virtualbox-hdd\": {\n        compressible: true,\n        extensions: [\"hdd\"]\n      },\n      \"application/x-virtualbox-ova\": {\n        compressible: true,\n        extensions: [\"ova\"]\n      },\n      \"application/x-virtualbox-ovf\": {\n        compressible: true,\n        extensions: [\"ovf\"]\n      },\n      \"application/x-virtualbox-vbox\": {\n        compressible: true,\n        extensions: [\"vbox\"]\n      },\n      \"application/x-virtualbox-vbox-extpack\": {\n        compressible: false,\n        extensions: [\"vbox-extpack\"]\n      },\n      \"application/x-virtualbox-vdi\": {\n        compressible: true,\n        extensions: [\"vdi\"]\n      },\n      \"application/x-virtualbox-vhd\": {\n        compressible: true,\n        extensions: [\"vhd\"]\n      },\n      \"application/x-virtualbox-vmdk\": {\n        compressible: true,\n        extensions: [\"vmdk\"]\n      },\n      \"application/x-wais-source\": {\n        source: \"apache\",\n        extensions: [\"src\"]\n      },\n      \"application/x-web-app-manifest+json\": {\n        compressible: true,\n        extensions: [\"webapp\"]\n      },\n      \"application/x-www-form-urlencoded\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/x-x509-ca-cert\": {\n        source: \"iana\",\n        extensions: [\"der\", \"crt\", \"pem\"]\n      },\n      \"application/x-x509-ca-ra-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-x509-next-ca-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-xfig\": {\n        source: \"apache\",\n        extensions: [\"fig\"]\n      },\n      \"application/x-xliff+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/x-xpinstall\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"xpi\"]\n      },\n      \"application/x-xz\": {\n        source: \"apache\",\n        extensions: [\"xz\"]\n      },\n      \"application/x-zip-compressed\": {\n        extensions: [\"zip\"]\n      },\n      \"application/x-zmachine\": {\n        source: \"apache\",\n        extensions: [\"z1\", \"z2\", \"z3\", \"z4\", \"z5\", \"z6\", \"z7\", \"z8\"]\n      },\n      \"application/x400-bp\": {\n        source: \"iana\"\n      },\n      \"application/xacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xaml+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xaml\"]\n      },\n      \"application/xcap-att+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xav\"]\n      },\n      \"application/xcap-caps+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xca\"]\n      },\n      \"application/xcap-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdf\"]\n      },\n      \"application/xcap-el+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xel\"]\n      },\n      \"application/xcap-error+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcap-ns+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xns\"]\n      },\n      \"application/xcon-conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcon-conference-info-diff+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xenc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xenc\"]\n      },\n      \"application/xfdf\": {\n        source: \"iana\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/xhtml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtml\", \"xht\"]\n      },\n      \"application/xhtml-voice+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/xliff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\", \"xsl\", \"xsd\", \"rng\"]\n      },\n      \"application/xml-dtd\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dtd\"]\n      },\n      \"application/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"application/xml-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xmpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xop+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xop\"]\n      },\n      \"application/xproc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xpl\"]\n      },\n      \"application/xslt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsl\", \"xslt\"]\n      },\n      \"application/xspf+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xspf\"]\n      },\n      \"application/xv+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mxml\", \"xhvml\", \"xvml\", \"xvm\"]\n      },\n      \"application/yaml\": {\n        source: \"iana\"\n      },\n      \"application/yang\": {\n        source: \"iana\",\n        extensions: [\"yang\"]\n      },\n      \"application/yang-data+cbor\": {\n        source: \"iana\"\n      },\n      \"application/yang-data+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-sid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yin+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"yin\"]\n      },\n      \"application/zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"zip\"]\n      },\n      \"application/zip+dotlottie\": {\n        extensions: [\"lottie\"]\n      },\n      \"application/zlib\": {\n        source: \"iana\"\n      },\n      \"application/zstd\": {\n        source: \"iana\"\n      },\n      \"audio/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/3gpp\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"3gpp\"]\n      },\n      \"audio/3gpp2\": {\n        source: \"iana\"\n      },\n      \"audio/aac\": {\n        source: \"iana\",\n        extensions: [\"adts\", \"aac\"]\n      },\n      \"audio/ac3\": {\n        source: \"iana\"\n      },\n      \"audio/adpcm\": {\n        source: \"apache\",\n        extensions: [\"adp\"]\n      },\n      \"audio/amr\": {\n        source: \"iana\",\n        extensions: [\"amr\"]\n      },\n      \"audio/amr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/amr-wb+\": {\n        source: \"iana\"\n      },\n      \"audio/aptx\": {\n        source: \"iana\"\n      },\n      \"audio/asc\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-advanced-lossless\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-x\": {\n        source: \"iana\"\n      },\n      \"audio/atrac3\": {\n        source: \"iana\"\n      },\n      \"audio/basic\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"au\", \"snd\"]\n      },\n      \"audio/bv16\": {\n        source: \"iana\"\n      },\n      \"audio/bv32\": {\n        source: \"iana\"\n      },\n      \"audio/clearmode\": {\n        source: \"iana\"\n      },\n      \"audio/cn\": {\n        source: \"iana\"\n      },\n      \"audio/dat12\": {\n        source: \"iana\"\n      },\n      \"audio/dls\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es201108\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202050\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202211\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202212\": {\n        source: \"iana\"\n      },\n      \"audio/dv\": {\n        source: \"iana\"\n      },\n      \"audio/dvi4\": {\n        source: \"iana\"\n      },\n      \"audio/eac3\": {\n        source: \"iana\"\n      },\n      \"audio/encaprtp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc\": {\n        source: \"iana\"\n      },\n      \"audio/evrc-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc0\": {\n        source: \"iana\"\n      },\n      \"audio/evrc1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb1\": {\n        source: \"iana\"\n      },\n      \"audio/evs\": {\n        source: \"iana\"\n      },\n      \"audio/flac\": {\n        source: \"iana\"\n      },\n      \"audio/flexfec\": {\n        source: \"iana\"\n      },\n      \"audio/fwdred\": {\n        source: \"iana\"\n      },\n      \"audio/g711-0\": {\n        source: \"iana\"\n      },\n      \"audio/g719\": {\n        source: \"iana\"\n      },\n      \"audio/g722\": {\n        source: \"iana\"\n      },\n      \"audio/g7221\": {\n        source: \"iana\"\n      },\n      \"audio/g723\": {\n        source: \"iana\"\n      },\n      \"audio/g726-16\": {\n        source: \"iana\"\n      },\n      \"audio/g726-24\": {\n        source: \"iana\"\n      },\n      \"audio/g726-32\": {\n        source: \"iana\"\n      },\n      \"audio/g726-40\": {\n        source: \"iana\"\n      },\n      \"audio/g728\": {\n        source: \"iana\"\n      },\n      \"audio/g729\": {\n        source: \"iana\"\n      },\n      \"audio/g7291\": {\n        source: \"iana\"\n      },\n      \"audio/g729d\": {\n        source: \"iana\"\n      },\n      \"audio/g729e\": {\n        source: \"iana\"\n      },\n      \"audio/gsm\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-efr\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-hr-08\": {\n        source: \"iana\"\n      },\n      \"audio/ilbc\": {\n        source: \"iana\"\n      },\n      \"audio/ip-mr_v2.5\": {\n        source: \"iana\"\n      },\n      \"audio/isac\": {\n        source: \"apache\"\n      },\n      \"audio/l16\": {\n        source: \"iana\"\n      },\n      \"audio/l20\": {\n        source: \"iana\"\n      },\n      \"audio/l24\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/l8\": {\n        source: \"iana\"\n      },\n      \"audio/lpc\": {\n        source: \"iana\"\n      },\n      \"audio/matroska\": {\n        source: \"iana\"\n      },\n      \"audio/melp\": {\n        source: \"iana\"\n      },\n      \"audio/melp1200\": {\n        source: \"iana\"\n      },\n      \"audio/melp2400\": {\n        source: \"iana\"\n      },\n      \"audio/melp600\": {\n        source: \"iana\"\n      },\n      \"audio/mhas\": {\n        source: \"iana\"\n      },\n      \"audio/midi\": {\n        source: \"apache\",\n        extensions: [\"mid\", \"midi\", \"kar\", \"rmi\"]\n      },\n      \"audio/midi-clip\": {\n        source: \"iana\"\n      },\n      \"audio/mobile-xmf\": {\n        source: \"iana\",\n        extensions: [\"mxmf\"]\n      },\n      \"audio/mp3\": {\n        compressible: false,\n        extensions: [\"mp3\"]\n      },\n      \"audio/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"m4a\", \"mp4a\", \"m4b\"]\n      },\n      \"audio/mp4a-latm\": {\n        source: \"iana\"\n      },\n      \"audio/mpa\": {\n        source: \"iana\"\n      },\n      \"audio/mpa-robust\": {\n        source: \"iana\"\n      },\n      \"audio/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpga\", \"mp2\", \"mp2a\", \"mp3\", \"m2a\", \"m3a\"]\n      },\n      \"audio/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"audio/musepack\": {\n        source: \"apache\"\n      },\n      \"audio/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"oga\", \"ogg\", \"spx\", \"opus\"]\n      },\n      \"audio/opus\": {\n        source: \"iana\"\n      },\n      \"audio/parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/pcma\": {\n        source: \"iana\"\n      },\n      \"audio/pcma-wb\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu-wb\": {\n        source: \"iana\"\n      },\n      \"audio/prs.sid\": {\n        source: \"iana\"\n      },\n      \"audio/qcelp\": {\n        source: \"iana\"\n      },\n      \"audio/raptorfec\": {\n        source: \"iana\"\n      },\n      \"audio/red\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/rtploopback\": {\n        source: \"iana\"\n      },\n      \"audio/rtx\": {\n        source: \"iana\"\n      },\n      \"audio/s3m\": {\n        source: \"apache\",\n        extensions: [\"s3m\"]\n      },\n      \"audio/scip\": {\n        source: \"iana\"\n      },\n      \"audio/silk\": {\n        source: \"apache\",\n        extensions: [\"sil\"]\n      },\n      \"audio/smv\": {\n        source: \"iana\"\n      },\n      \"audio/smv-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/smv0\": {\n        source: \"iana\"\n      },\n      \"audio/sofa\": {\n        source: \"iana\"\n      },\n      \"audio/sp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/speex\": {\n        source: \"iana\"\n      },\n      \"audio/t140c\": {\n        source: \"iana\"\n      },\n      \"audio/t38\": {\n        source: \"iana\"\n      },\n      \"audio/telephone-event\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp_bb\": {\n        source: \"iana\"\n      },\n      \"audio/tone\": {\n        source: \"iana\"\n      },\n      \"audio/tsvcis\": {\n        source: \"iana\"\n      },\n      \"audio/uemclip\": {\n        source: \"iana\"\n      },\n      \"audio/ulpfec\": {\n        source: \"iana\"\n      },\n      \"audio/usac\": {\n        source: \"iana\"\n      },\n      \"audio/vdvi\": {\n        source: \"iana\"\n      },\n      \"audio/vmr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.3gpp.iufp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.4sb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.audiokoz\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.celp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cisco.nse\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cmles.radio-events\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.anp1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.inf1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dece.audio\": {\n        source: \"iana\",\n        extensions: [\"uva\", \"uvva\"]\n      },\n      \"audio/vnd.digital-winds\": {\n        source: \"iana\",\n        extensions: [\"eol\"]\n      },\n      \"audio/vnd.dlna.adts\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mlp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mps\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2x\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2z\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pulse.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dra\": {\n        source: \"iana\",\n        extensions: [\"dra\"]\n      },\n      \"audio/vnd.dts\": {\n        source: \"iana\",\n        extensions: [\"dts\"]\n      },\n      \"audio/vnd.dts.hd\": {\n        source: \"iana\",\n        extensions: [\"dtshd\"]\n      },\n      \"audio/vnd.dts.uhd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dvb.file\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.everad.plj\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.hns.audio\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.lucent.voice\": {\n        source: \"iana\",\n        extensions: [\"lvp\"]\n      },\n      \"audio/vnd.ms-playready.media.pya\": {\n        source: \"iana\",\n        extensions: [\"pya\"]\n      },\n      \"audio/vnd.nokia.mobile-xmf\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nortel.vbk\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nuera.ecelp4800\": {\n        source: \"iana\",\n        extensions: [\"ecelp4800\"]\n      },\n      \"audio/vnd.nuera.ecelp7470\": {\n        source: \"iana\",\n        extensions: [\"ecelp7470\"]\n      },\n      \"audio/vnd.nuera.ecelp9600\": {\n        source: \"iana\",\n        extensions: [\"ecelp9600\"]\n      },\n      \"audio/vnd.octel.sbc\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.presonus.multitrack\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.qcelp\": {\n        source: \"apache\"\n      },\n      \"audio/vnd.rhetorex.32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.rip\": {\n        source: \"iana\",\n        extensions: [\"rip\"]\n      },\n      \"audio/vnd.rn-realaudio\": {\n        compressible: false\n      },\n      \"audio/vnd.sealedmedia.softseal.mpeg\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.vmx.cvsd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.wave\": {\n        compressible: false\n      },\n      \"audio/vorbis\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/vorbis-config\": {\n        source: \"iana\"\n      },\n      \"audio/wav\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/wave\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"weba\"]\n      },\n      \"audio/x-aac\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"aac\"]\n      },\n      \"audio/x-aiff\": {\n        source: \"apache\",\n        extensions: [\"aif\", \"aiff\", \"aifc\"]\n      },\n      \"audio/x-caf\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"caf\"]\n      },\n      \"audio/x-flac\": {\n        source: \"apache\",\n        extensions: [\"flac\"]\n      },\n      \"audio/x-m4a\": {\n        source: \"nginx\",\n        extensions: [\"m4a\"]\n      },\n      \"audio/x-matroska\": {\n        source: \"apache\",\n        extensions: [\"mka\"]\n      },\n      \"audio/x-mpegurl\": {\n        source: \"apache\",\n        extensions: [\"m3u\"]\n      },\n      \"audio/x-ms-wax\": {\n        source: \"apache\",\n        extensions: [\"wax\"]\n      },\n      \"audio/x-ms-wma\": {\n        source: \"apache\",\n        extensions: [\"wma\"]\n      },\n      \"audio/x-pn-realaudio\": {\n        source: \"apache\",\n        extensions: [\"ram\", \"ra\"]\n      },\n      \"audio/x-pn-realaudio-plugin\": {\n        source: \"apache\",\n        extensions: [\"rmp\"]\n      },\n      \"audio/x-realaudio\": {\n        source: \"nginx\",\n        extensions: [\"ra\"]\n      },\n      \"audio/x-tta\": {\n        source: \"apache\"\n      },\n      \"audio/x-wav\": {\n        source: \"apache\",\n        extensions: [\"wav\"]\n      },\n      \"audio/xm\": {\n        source: \"apache\",\n        extensions: [\"xm\"]\n      },\n      \"chemical/x-cdx\": {\n        source: \"apache\",\n        extensions: [\"cdx\"]\n      },\n      \"chemical/x-cif\": {\n        source: \"apache\",\n        extensions: [\"cif\"]\n      },\n      \"chemical/x-cmdf\": {\n        source: \"apache\",\n        extensions: [\"cmdf\"]\n      },\n      \"chemical/x-cml\": {\n        source: \"apache\",\n        extensions: [\"cml\"]\n      },\n      \"chemical/x-csml\": {\n        source: \"apache\",\n        extensions: [\"csml\"]\n      },\n      \"chemical/x-pdb\": {\n        source: \"apache\"\n      },\n      \"chemical/x-xyz\": {\n        source: \"apache\",\n        extensions: [\"xyz\"]\n      },\n      \"font/collection\": {\n        source: \"iana\",\n        extensions: [\"ttc\"]\n      },\n      \"font/otf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"otf\"]\n      },\n      \"font/sfnt\": {\n        source: \"iana\"\n      },\n      \"font/ttf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttf\"]\n      },\n      \"font/woff\": {\n        source: \"iana\",\n        extensions: [\"woff\"]\n      },\n      \"font/woff2\": {\n        source: \"iana\",\n        extensions: [\"woff2\"]\n      },\n      \"image/aces\": {\n        source: \"iana\",\n        extensions: [\"exr\"]\n      },\n      \"image/apng\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"apng\"]\n      },\n      \"image/avci\": {\n        source: \"iana\",\n        extensions: [\"avci\"]\n      },\n      \"image/avcs\": {\n        source: \"iana\",\n        extensions: [\"avcs\"]\n      },\n      \"image/avif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"avif\"]\n      },\n      \"image/bmp\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmp\", \"dib\"]\n      },\n      \"image/cgm\": {\n        source: \"iana\",\n        extensions: [\"cgm\"]\n      },\n      \"image/dicom-rle\": {\n        source: \"iana\",\n        extensions: [\"drle\"]\n      },\n      \"image/dpx\": {\n        source: \"iana\",\n        extensions: [\"dpx\"]\n      },\n      \"image/emf\": {\n        source: \"iana\",\n        extensions: [\"emf\"]\n      },\n      \"image/fits\": {\n        source: \"iana\",\n        extensions: [\"fits\"]\n      },\n      \"image/g3fax\": {\n        source: \"iana\",\n        extensions: [\"g3\"]\n      },\n      \"image/gif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gif\"]\n      },\n      \"image/heic\": {\n        source: \"iana\",\n        extensions: [\"heic\"]\n      },\n      \"image/heic-sequence\": {\n        source: \"iana\",\n        extensions: [\"heics\"]\n      },\n      \"image/heif\": {\n        source: \"iana\",\n        extensions: [\"heif\"]\n      },\n      \"image/heif-sequence\": {\n        source: \"iana\",\n        extensions: [\"heifs\"]\n      },\n      \"image/hej2k\": {\n        source: \"iana\",\n        extensions: [\"hej2\"]\n      },\n      \"image/ief\": {\n        source: \"iana\",\n        extensions: [\"ief\"]\n      },\n      \"image/j2c\": {\n        source: \"iana\"\n      },\n      \"image/jaii\": {\n        source: \"iana\",\n        extensions: [\"jaii\"]\n      },\n      \"image/jais\": {\n        source: \"iana\",\n        extensions: [\"jais\"]\n      },\n      \"image/jls\": {\n        source: \"iana\",\n        extensions: [\"jls\"]\n      },\n      \"image/jp2\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jp2\", \"jpg2\"]\n      },\n      \"image/jpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpg\", \"jpeg\", \"jpe\"]\n      },\n      \"image/jph\": {\n        source: \"iana\",\n        extensions: [\"jph\"]\n      },\n      \"image/jphc\": {\n        source: \"iana\",\n        extensions: [\"jhc\"]\n      },\n      \"image/jpm\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"image/jpx\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpx\", \"jpf\"]\n      },\n      \"image/jxl\": {\n        source: \"iana\",\n        extensions: [\"jxl\"]\n      },\n      \"image/jxr\": {\n        source: \"iana\",\n        extensions: [\"jxr\"]\n      },\n      \"image/jxra\": {\n        source: \"iana\",\n        extensions: [\"jxra\"]\n      },\n      \"image/jxrs\": {\n        source: \"iana\",\n        extensions: [\"jxrs\"]\n      },\n      \"image/jxs\": {\n        source: \"iana\",\n        extensions: [\"jxs\"]\n      },\n      \"image/jxsc\": {\n        source: \"iana\",\n        extensions: [\"jxsc\"]\n      },\n      \"image/jxsi\": {\n        source: \"iana\",\n        extensions: [\"jxsi\"]\n      },\n      \"image/jxss\": {\n        source: \"iana\",\n        extensions: [\"jxss\"]\n      },\n      \"image/ktx\": {\n        source: \"iana\",\n        extensions: [\"ktx\"]\n      },\n      \"image/ktx2\": {\n        source: \"iana\",\n        extensions: [\"ktx2\"]\n      },\n      \"image/naplps\": {\n        source: \"iana\"\n      },\n      \"image/pjpeg\": {\n        compressible: false,\n        extensions: [\"jfif\"]\n      },\n      \"image/png\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"png\"]\n      },\n      \"image/prs.btif\": {\n        source: \"iana\",\n        extensions: [\"btif\", \"btf\"]\n      },\n      \"image/prs.pti\": {\n        source: \"iana\",\n        extensions: [\"pti\"]\n      },\n      \"image/pwg-raster\": {\n        source: \"iana\"\n      },\n      \"image/sgi\": {\n        source: \"apache\",\n        extensions: [\"sgi\"]\n      },\n      \"image/svg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"svg\", \"svgz\"]\n      },\n      \"image/t38\": {\n        source: \"iana\",\n        extensions: [\"t38\"]\n      },\n      \"image/tiff\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"tif\", \"tiff\"]\n      },\n      \"image/tiff-fx\": {\n        source: \"iana\",\n        extensions: [\"tfx\"]\n      },\n      \"image/vnd.adobe.photoshop\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"psd\"]\n      },\n      \"image/vnd.airzip.accelerator.azv\": {\n        source: \"iana\",\n        extensions: [\"azv\"]\n      },\n      \"image/vnd.clip\": {\n        source: \"iana\"\n      },\n      \"image/vnd.cns.inf2\": {\n        source: \"iana\"\n      },\n      \"image/vnd.dece.graphic\": {\n        source: \"iana\",\n        extensions: [\"uvi\", \"uvvi\", \"uvg\", \"uvvg\"]\n      },\n      \"image/vnd.djvu\": {\n        source: \"iana\",\n        extensions: [\"djvu\", \"djv\"]\n      },\n      \"image/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"image/vnd.dwg\": {\n        source: \"iana\",\n        extensions: [\"dwg\"]\n      },\n      \"image/vnd.dxf\": {\n        source: \"iana\",\n        extensions: [\"dxf\"]\n      },\n      \"image/vnd.fastbidsheet\": {\n        source: \"iana\",\n        extensions: [\"fbs\"]\n      },\n      \"image/vnd.fpx\": {\n        source: \"iana\",\n        extensions: [\"fpx\"]\n      },\n      \"image/vnd.fst\": {\n        source: \"iana\",\n        extensions: [\"fst\"]\n      },\n      \"image/vnd.fujixerox.edmics-mmr\": {\n        source: \"iana\",\n        extensions: [\"mmr\"]\n      },\n      \"image/vnd.fujixerox.edmics-rlc\": {\n        source: \"iana\",\n        extensions: [\"rlc\"]\n      },\n      \"image/vnd.globalgraphics.pgb\": {\n        source: \"iana\"\n      },\n      \"image/vnd.microsoft.icon\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/vnd.mix\": {\n        source: \"iana\"\n      },\n      \"image/vnd.mozilla.apng\": {\n        source: \"iana\"\n      },\n      \"image/vnd.ms-dds\": {\n        compressible: true,\n        extensions: [\"dds\"]\n      },\n      \"image/vnd.ms-modi\": {\n        source: \"iana\",\n        extensions: [\"mdi\"]\n      },\n      \"image/vnd.ms-photo\": {\n        source: \"apache\",\n        extensions: [\"wdp\"]\n      },\n      \"image/vnd.net-fpx\": {\n        source: \"iana\",\n        extensions: [\"npx\"]\n      },\n      \"image/vnd.pco.b16\": {\n        source: \"iana\",\n        extensions: [\"b16\"]\n      },\n      \"image/vnd.radiance\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealed.png\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.gif\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.jpg\": {\n        source: \"iana\"\n      },\n      \"image/vnd.svf\": {\n        source: \"iana\"\n      },\n      \"image/vnd.tencent.tap\": {\n        source: \"iana\",\n        extensions: [\"tap\"]\n      },\n      \"image/vnd.valve.source.texture\": {\n        source: \"iana\",\n        extensions: [\"vtf\"]\n      },\n      \"image/vnd.wap.wbmp\": {\n        source: \"iana\",\n        extensions: [\"wbmp\"]\n      },\n      \"image/vnd.xiff\": {\n        source: \"iana\",\n        extensions: [\"xif\"]\n      },\n      \"image/vnd.zbrush.pcx\": {\n        source: \"iana\",\n        extensions: [\"pcx\"]\n      },\n      \"image/webp\": {\n        source: \"iana\",\n        extensions: [\"webp\"]\n      },\n      \"image/wmf\": {\n        source: \"iana\",\n        extensions: [\"wmf\"]\n      },\n      \"image/x-3ds\": {\n        source: \"apache\",\n        extensions: [\"3ds\"]\n      },\n      \"image/x-adobe-dng\": {\n        extensions: [\"dng\"]\n      },\n      \"image/x-cmu-raster\": {\n        source: \"apache\",\n        extensions: [\"ras\"]\n      },\n      \"image/x-cmx\": {\n        source: \"apache\",\n        extensions: [\"cmx\"]\n      },\n      \"image/x-emf\": {\n        source: \"iana\"\n      },\n      \"image/x-freehand\": {\n        source: \"apache\",\n        extensions: [\"fh\", \"fhc\", \"fh4\", \"fh5\", \"fh7\"]\n      },\n      \"image/x-icon\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/x-jng\": {\n        source: \"nginx\",\n        extensions: [\"jng\"]\n      },\n      \"image/x-mrsid-image\": {\n        source: \"apache\",\n        extensions: [\"sid\"]\n      },\n      \"image/x-ms-bmp\": {\n        source: \"nginx\",\n        compressible: true,\n        extensions: [\"bmp\"]\n      },\n      \"image/x-pcx\": {\n        source: \"apache\",\n        extensions: [\"pcx\"]\n      },\n      \"image/x-pict\": {\n        source: \"apache\",\n        extensions: [\"pic\", \"pct\"]\n      },\n      \"image/x-portable-anymap\": {\n        source: \"apache\",\n        extensions: [\"pnm\"]\n      },\n      \"image/x-portable-bitmap\": {\n        source: \"apache\",\n        extensions: [\"pbm\"]\n      },\n      \"image/x-portable-graymap\": {\n        source: \"apache\",\n        extensions: [\"pgm\"]\n      },\n      \"image/x-portable-pixmap\": {\n        source: \"apache\",\n        extensions: [\"ppm\"]\n      },\n      \"image/x-rgb\": {\n        source: \"apache\",\n        extensions: [\"rgb\"]\n      },\n      \"image/x-tga\": {\n        source: \"apache\",\n        extensions: [\"tga\"]\n      },\n      \"image/x-wmf\": {\n        source: \"iana\"\n      },\n      \"image/x-xbitmap\": {\n        source: \"apache\",\n        extensions: [\"xbm\"]\n      },\n      \"image/x-xcf\": {\n        compressible: false\n      },\n      \"image/x-xpixmap\": {\n        source: \"apache\",\n        extensions: [\"xpm\"]\n      },\n      \"image/x-xwindowdump\": {\n        source: \"apache\",\n        extensions: [\"xwd\"]\n      },\n      \"message/bhttp\": {\n        source: \"iana\"\n      },\n      \"message/cpim\": {\n        source: \"iana\"\n      },\n      \"message/delivery-status\": {\n        source: \"iana\"\n      },\n      \"message/disposition-notification\": {\n        source: \"iana\",\n        extensions: [\n          \"disposition-notification\"\n        ]\n      },\n      \"message/external-body\": {\n        source: \"iana\"\n      },\n      \"message/feedback-report\": {\n        source: \"iana\"\n      },\n      \"message/global\": {\n        source: \"iana\",\n        extensions: [\"u8msg\"]\n      },\n      \"message/global-delivery-status\": {\n        source: \"iana\",\n        extensions: [\"u8dsn\"]\n      },\n      \"message/global-disposition-notification\": {\n        source: \"iana\",\n        extensions: [\"u8mdn\"]\n      },\n      \"message/global-headers\": {\n        source: \"iana\",\n        extensions: [\"u8hdr\"]\n      },\n      \"message/http\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/imdn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"message/mls\": {\n        source: \"iana\"\n      },\n      \"message/news\": {\n        source: \"apache\"\n      },\n      \"message/ohttp-req\": {\n        source: \"iana\"\n      },\n      \"message/ohttp-res\": {\n        source: \"iana\"\n      },\n      \"message/partial\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/rfc822\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eml\", \"mime\", \"mht\", \"mhtml\"]\n      },\n      \"message/s-http\": {\n        source: \"apache\"\n      },\n      \"message/sip\": {\n        source: \"iana\"\n      },\n      \"message/sipfrag\": {\n        source: \"iana\"\n      },\n      \"message/tracking-status\": {\n        source: \"iana\"\n      },\n      \"message/vnd.si.simp\": {\n        source: \"apache\"\n      },\n      \"message/vnd.wfa.wsc\": {\n        source: \"iana\",\n        extensions: [\"wsc\"]\n      },\n      \"model/3mf\": {\n        source: \"iana\",\n        extensions: [\"3mf\"]\n      },\n      \"model/e57\": {\n        source: \"iana\"\n      },\n      \"model/gltf+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gltf\"]\n      },\n      \"model/gltf-binary\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"glb\"]\n      },\n      \"model/iges\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"igs\", \"iges\"]\n      },\n      \"model/jt\": {\n        source: \"iana\",\n        extensions: [\"jt\"]\n      },\n      \"model/mesh\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"msh\", \"mesh\", \"silo\"]\n      },\n      \"model/mtl\": {\n        source: \"iana\",\n        extensions: [\"mtl\"]\n      },\n      \"model/obj\": {\n        source: \"iana\",\n        extensions: [\"obj\"]\n      },\n      \"model/prc\": {\n        source: \"iana\",\n        extensions: [\"prc\"]\n      },\n      \"model/step\": {\n        source: \"iana\",\n        extensions: [\"step\", \"stp\", \"stpnc\", \"p21\", \"210\"]\n      },\n      \"model/step+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"stpx\"]\n      },\n      \"model/step+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpz\"]\n      },\n      \"model/step-xml+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpxz\"]\n      },\n      \"model/stl\": {\n        source: \"iana\",\n        extensions: [\"stl\"]\n      },\n      \"model/u3d\": {\n        source: \"iana\",\n        extensions: [\"u3d\"]\n      },\n      \"model/vnd.bary\": {\n        source: \"iana\",\n        extensions: [\"bary\"]\n      },\n      \"model/vnd.cld\": {\n        source: \"iana\",\n        extensions: [\"cld\"]\n      },\n      \"model/vnd.collada+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dae\"]\n      },\n      \"model/vnd.dwf\": {\n        source: \"iana\",\n        extensions: [\"dwf\"]\n      },\n      \"model/vnd.flatland.3dml\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gdl\": {\n        source: \"iana\",\n        extensions: [\"gdl\"]\n      },\n      \"model/vnd.gs-gdl\": {\n        source: \"apache\"\n      },\n      \"model/vnd.gs.gdl\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gtw\": {\n        source: \"iana\",\n        extensions: [\"gtw\"]\n      },\n      \"model/vnd.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"model/vnd.mts\": {\n        source: \"iana\",\n        extensions: [\"mts\"]\n      },\n      \"model/vnd.opengex\": {\n        source: \"iana\",\n        extensions: [\"ogex\"]\n      },\n      \"model/vnd.parasolid.transmit.binary\": {\n        source: \"iana\",\n        extensions: [\"x_b\"]\n      },\n      \"model/vnd.parasolid.transmit.text\": {\n        source: \"iana\",\n        extensions: [\"x_t\"]\n      },\n      \"model/vnd.pytha.pyox\": {\n        source: \"iana\",\n        extensions: [\"pyo\", \"pyox\"]\n      },\n      \"model/vnd.rosette.annotated-data-model\": {\n        source: \"iana\"\n      },\n      \"model/vnd.sap.vds\": {\n        source: \"iana\",\n        extensions: [\"vds\"]\n      },\n      \"model/vnd.usda\": {\n        source: \"iana\",\n        extensions: [\"usda\"]\n      },\n      \"model/vnd.usdz+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"usdz\"]\n      },\n      \"model/vnd.valve.source.compiled-map\": {\n        source: \"iana\",\n        extensions: [\"bsp\"]\n      },\n      \"model/vnd.vtu\": {\n        source: \"iana\",\n        extensions: [\"vtu\"]\n      },\n      \"model/vrml\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"wrl\", \"vrml\"]\n      },\n      \"model/x3d+binary\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3db\", \"x3dbz\"]\n      },\n      \"model/x3d+fastinfoset\": {\n        source: \"iana\",\n        extensions: [\"x3db\"]\n      },\n      \"model/x3d+vrml\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3dv\", \"x3dvz\"]\n      },\n      \"model/x3d+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"x3d\", \"x3dz\"]\n      },\n      \"model/x3d-vrml\": {\n        source: \"iana\",\n        extensions: [\"x3dv\"]\n      },\n      \"multipart/alternative\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/appledouble\": {\n        source: \"iana\"\n      },\n      \"multipart/byteranges\": {\n        source: \"iana\"\n      },\n      \"multipart/digest\": {\n        source: \"iana\"\n      },\n      \"multipart/encrypted\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/form-data\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/header-set\": {\n        source: \"iana\"\n      },\n      \"multipart/mixed\": {\n        source: \"iana\"\n      },\n      \"multipart/multilingual\": {\n        source: \"iana\"\n      },\n      \"multipart/parallel\": {\n        source: \"iana\"\n      },\n      \"multipart/related\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/report\": {\n        source: \"iana\"\n      },\n      \"multipart/signed\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/vnd.bint.med-plus\": {\n        source: \"iana\"\n      },\n      \"multipart/voice-message\": {\n        source: \"iana\"\n      },\n      \"multipart/x-mixed-replace\": {\n        source: \"iana\"\n      },\n      \"text/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"text/cache-manifest\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"appcache\", \"manifest\"]\n      },\n      \"text/calendar\": {\n        source: \"iana\",\n        extensions: [\"ics\", \"ifb\"]\n      },\n      \"text/calender\": {\n        compressible: true\n      },\n      \"text/cmd\": {\n        compressible: true\n      },\n      \"text/coffeescript\": {\n        extensions: [\"coffee\", \"litcoffee\"]\n      },\n      \"text/cql\": {\n        source: \"iana\"\n      },\n      \"text/cql-expression\": {\n        source: \"iana\"\n      },\n      \"text/cql-identifier\": {\n        source: \"iana\"\n      },\n      \"text/css\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"css\"]\n      },\n      \"text/csv\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csv\"]\n      },\n      \"text/csv-schema\": {\n        source: \"iana\"\n      },\n      \"text/directory\": {\n        source: \"iana\"\n      },\n      \"text/dns\": {\n        source: \"iana\"\n      },\n      \"text/ecmascript\": {\n        source: \"apache\"\n      },\n      \"text/encaprtp\": {\n        source: \"iana\"\n      },\n      \"text/enriched\": {\n        source: \"iana\"\n      },\n      \"text/fhirpath\": {\n        source: \"iana\"\n      },\n      \"text/flexfec\": {\n        source: \"iana\"\n      },\n      \"text/fwdred\": {\n        source: \"iana\"\n      },\n      \"text/gff3\": {\n        source: \"iana\"\n      },\n      \"text/grammar-ref-list\": {\n        source: \"iana\"\n      },\n      \"text/hl7v2\": {\n        source: \"iana\"\n      },\n      \"text/html\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"html\", \"htm\", \"shtml\"]\n      },\n      \"text/jade\": {\n        extensions: [\"jade\"]\n      },\n      \"text/javascript\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\", \"mjs\"]\n      },\n      \"text/jcr-cnd\": {\n        source: \"iana\"\n      },\n      \"text/jsx\": {\n        compressible: true,\n        extensions: [\"jsx\"]\n      },\n      \"text/less\": {\n        compressible: true,\n        extensions: [\"less\"]\n      },\n      \"text/markdown\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"md\", \"markdown\"]\n      },\n      \"text/mathml\": {\n        source: \"nginx\",\n        extensions: [\"mml\"]\n      },\n      \"text/mdx\": {\n        compressible: true,\n        extensions: [\"mdx\"]\n      },\n      \"text/mizar\": {\n        source: \"iana\"\n      },\n      \"text/n3\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"n3\"]\n      },\n      \"text/parameters\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/parityfec\": {\n        source: \"iana\"\n      },\n      \"text/plain\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"txt\", \"text\", \"conf\", \"def\", \"list\", \"log\", \"in\", \"ini\"]\n      },\n      \"text/provenance-notation\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/prs.fallenstein.rst\": {\n        source: \"iana\"\n      },\n      \"text/prs.lines.tag\": {\n        source: \"iana\",\n        extensions: [\"dsc\"]\n      },\n      \"text/prs.prop.logic\": {\n        source: \"iana\"\n      },\n      \"text/prs.texi\": {\n        source: \"iana\"\n      },\n      \"text/raptorfec\": {\n        source: \"iana\"\n      },\n      \"text/red\": {\n        source: \"iana\"\n      },\n      \"text/rfc822-headers\": {\n        source: \"iana\"\n      },\n      \"text/richtext\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtx\"]\n      },\n      \"text/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"text/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"text/rtploopback\": {\n        source: \"iana\"\n      },\n      \"text/rtx\": {\n        source: \"iana\"\n      },\n      \"text/sgml\": {\n        source: \"iana\",\n        extensions: [\"sgml\", \"sgm\"]\n      },\n      \"text/shaclc\": {\n        source: \"iana\"\n      },\n      \"text/shex\": {\n        source: \"iana\",\n        extensions: [\"shex\"]\n      },\n      \"text/slim\": {\n        extensions: [\"slim\", \"slm\"]\n      },\n      \"text/spdx\": {\n        source: \"iana\",\n        extensions: [\"spdx\"]\n      },\n      \"text/strings\": {\n        source: \"iana\"\n      },\n      \"text/stylus\": {\n        extensions: [\"stylus\", \"styl\"]\n      },\n      \"text/t140\": {\n        source: \"iana\"\n      },\n      \"text/tab-separated-values\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tsv\"]\n      },\n      \"text/troff\": {\n        source: \"iana\",\n        extensions: [\"t\", \"tr\", \"roff\", \"man\", \"me\", \"ms\"]\n      },\n      \"text/turtle\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"ttl\"]\n      },\n      \"text/ulpfec\": {\n        source: \"iana\"\n      },\n      \"text/uri-list\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uri\", \"uris\", \"urls\"]\n      },\n      \"text/vcard\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vcard\"]\n      },\n      \"text/vnd.a\": {\n        source: \"iana\"\n      },\n      \"text/vnd.abc\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ascii-art\": {\n        source: \"iana\"\n      },\n      \"text/vnd.curl\": {\n        source: \"iana\",\n        extensions: [\"curl\"]\n      },\n      \"text/vnd.curl.dcurl\": {\n        source: \"apache\",\n        extensions: [\"dcurl\"]\n      },\n      \"text/vnd.curl.mcurl\": {\n        source: \"apache\",\n        extensions: [\"mcurl\"]\n      },\n      \"text/vnd.curl.scurl\": {\n        source: \"apache\",\n        extensions: [\"scurl\"]\n      },\n      \"text/vnd.debian.copyright\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.dmclientscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"text/vnd.esmertec.theme-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.exchangeable\": {\n        source: \"iana\"\n      },\n      \"text/vnd.familysearch.gedcom\": {\n        source: \"iana\",\n        extensions: [\"ged\"]\n      },\n      \"text/vnd.ficlab.flt\": {\n        source: \"iana\"\n      },\n      \"text/vnd.fly\": {\n        source: \"iana\",\n        extensions: [\"fly\"]\n      },\n      \"text/vnd.fmi.flexstor\": {\n        source: \"iana\",\n        extensions: [\"flx\"]\n      },\n      \"text/vnd.gml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.graphviz\": {\n        source: \"iana\",\n        extensions: [\"gv\"]\n      },\n      \"text/vnd.hans\": {\n        source: \"iana\"\n      },\n      \"text/vnd.hgl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.in3d.3dml\": {\n        source: \"iana\",\n        extensions: [\"3dml\"]\n      },\n      \"text/vnd.in3d.spot\": {\n        source: \"iana\",\n        extensions: [\"spot\"]\n      },\n      \"text/vnd.iptc.newsml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.iptc.nitf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.latex-z\": {\n        source: \"iana\"\n      },\n      \"text/vnd.motorola.reflex\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ms-mediapackage\": {\n        source: \"iana\"\n      },\n      \"text/vnd.net2phone.commcenter.command\": {\n        source: \"iana\"\n      },\n      \"text/vnd.radisys.msml-basic-layout\": {\n        source: \"iana\"\n      },\n      \"text/vnd.senx.warpscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.si.uricatalogue\": {\n        source: \"apache\"\n      },\n      \"text/vnd.sosi\": {\n        source: \"iana\"\n      },\n      \"text/vnd.sun.j2me.app-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"jad\"]\n      },\n      \"text/vnd.trolltech.linguist\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.vcf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.si\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.sl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.wml\": {\n        source: \"iana\",\n        extensions: [\"wml\"]\n      },\n      \"text/vnd.wap.wmlscript\": {\n        source: \"iana\",\n        extensions: [\"wmls\"]\n      },\n      \"text/vnd.zoo.kcl\": {\n        source: \"iana\"\n      },\n      \"text/vtt\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"vtt\"]\n      },\n      \"text/wgsl\": {\n        source: \"iana\",\n        extensions: [\"wgsl\"]\n      },\n      \"text/x-asm\": {\n        source: \"apache\",\n        extensions: [\"s\", \"asm\"]\n      },\n      \"text/x-c\": {\n        source: \"apache\",\n        extensions: [\"c\", \"cc\", \"cxx\", \"cpp\", \"h\", \"hh\", \"dic\"]\n      },\n      \"text/x-component\": {\n        source: \"nginx\",\n        extensions: [\"htc\"]\n      },\n      \"text/x-fortran\": {\n        source: \"apache\",\n        extensions: [\"f\", \"for\", \"f77\", \"f90\"]\n      },\n      \"text/x-gwt-rpc\": {\n        compressible: true\n      },\n      \"text/x-handlebars-template\": {\n        extensions: [\"hbs\"]\n      },\n      \"text/x-java-source\": {\n        source: \"apache\",\n        extensions: [\"java\"]\n      },\n      \"text/x-jquery-tmpl\": {\n        compressible: true\n      },\n      \"text/x-lua\": {\n        extensions: [\"lua\"]\n      },\n      \"text/x-markdown\": {\n        compressible: true,\n        extensions: [\"mkd\"]\n      },\n      \"text/x-nfo\": {\n        source: \"apache\",\n        extensions: [\"nfo\"]\n      },\n      \"text/x-opml\": {\n        source: \"apache\",\n        extensions: [\"opml\"]\n      },\n      \"text/x-org\": {\n        compressible: true,\n        extensions: [\"org\"]\n      },\n      \"text/x-pascal\": {\n        source: \"apache\",\n        extensions: [\"p\", \"pas\"]\n      },\n      \"text/x-processing\": {\n        compressible: true,\n        extensions: [\"pde\"]\n      },\n      \"text/x-sass\": {\n        extensions: [\"sass\"]\n      },\n      \"text/x-scss\": {\n        extensions: [\"scss\"]\n      },\n      \"text/x-setext\": {\n        source: \"apache\",\n        extensions: [\"etx\"]\n      },\n      \"text/x-sfv\": {\n        source: \"apache\",\n        extensions: [\"sfv\"]\n      },\n      \"text/x-suse-ymp\": {\n        compressible: true,\n        extensions: [\"ymp\"]\n      },\n      \"text/x-uuencode\": {\n        source: \"apache\",\n        extensions: [\"uu\"]\n      },\n      \"text/x-vcalendar\": {\n        source: \"apache\",\n        extensions: [\"vcs\"]\n      },\n      \"text/x-vcard\": {\n        source: \"apache\",\n        extensions: [\"vcf\"]\n      },\n      \"text/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\"]\n      },\n      \"text/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"text/yaml\": {\n        compressible: true,\n        extensions: [\"yaml\", \"yml\"]\n      },\n      \"video/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"video/3gpp\": {\n        source: \"iana\",\n        extensions: [\"3gp\", \"3gpp\"]\n      },\n      \"video/3gpp-tt\": {\n        source: \"iana\"\n      },\n      \"video/3gpp2\": {\n        source: \"iana\",\n        extensions: [\"3g2\"]\n      },\n      \"video/av1\": {\n        source: \"iana\"\n      },\n      \"video/bmpeg\": {\n        source: \"iana\"\n      },\n      \"video/bt656\": {\n        source: \"iana\"\n      },\n      \"video/celb\": {\n        source: \"iana\"\n      },\n      \"video/dv\": {\n        source: \"iana\"\n      },\n      \"video/encaprtp\": {\n        source: \"iana\"\n      },\n      \"video/evc\": {\n        source: \"iana\"\n      },\n      \"video/ffv1\": {\n        source: \"iana\"\n      },\n      \"video/flexfec\": {\n        source: \"iana\"\n      },\n      \"video/h261\": {\n        source: \"iana\",\n        extensions: [\"h261\"]\n      },\n      \"video/h263\": {\n        source: \"iana\",\n        extensions: [\"h263\"]\n      },\n      \"video/h263-1998\": {\n        source: \"iana\"\n      },\n      \"video/h263-2000\": {\n        source: \"iana\"\n      },\n      \"video/h264\": {\n        source: \"iana\",\n        extensions: [\"h264\"]\n      },\n      \"video/h264-rcdo\": {\n        source: \"iana\"\n      },\n      \"video/h264-svc\": {\n        source: \"iana\"\n      },\n      \"video/h265\": {\n        source: \"iana\"\n      },\n      \"video/h266\": {\n        source: \"iana\"\n      },\n      \"video/iso.segment\": {\n        source: \"iana\",\n        extensions: [\"m4s\"]\n      },\n      \"video/jpeg\": {\n        source: \"iana\",\n        extensions: [\"jpgv\"]\n      },\n      \"video/jpeg2000\": {\n        source: \"iana\"\n      },\n      \"video/jpm\": {\n        source: \"apache\",\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"video/jxsv\": {\n        source: \"iana\"\n      },\n      \"video/lottie+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"video/matroska\": {\n        source: \"iana\"\n      },\n      \"video/matroska-3d\": {\n        source: \"iana\"\n      },\n      \"video/mj2\": {\n        source: \"iana\",\n        extensions: [\"mj2\", \"mjp2\"]\n      },\n      \"video/mp1s\": {\n        source: \"iana\"\n      },\n      \"video/mp2p\": {\n        source: \"iana\"\n      },\n      \"video/mp2t\": {\n        source: \"iana\",\n        extensions: [\"ts\", \"m2t\", \"m2ts\", \"mts\"]\n      },\n      \"video/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mp4\", \"mp4v\", \"mpg4\"]\n      },\n      \"video/mp4v-es\": {\n        source: \"iana\"\n      },\n      \"video/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpeg\", \"mpg\", \"mpe\", \"m1v\", \"m2v\"]\n      },\n      \"video/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"video/mpv\": {\n        source: \"iana\"\n      },\n      \"video/nv\": {\n        source: \"iana\"\n      },\n      \"video/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogv\"]\n      },\n      \"video/parityfec\": {\n        source: \"iana\"\n      },\n      \"video/pointer\": {\n        source: \"iana\"\n      },\n      \"video/quicktime\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"qt\", \"mov\"]\n      },\n      \"video/raptorfec\": {\n        source: \"iana\"\n      },\n      \"video/raw\": {\n        source: \"iana\"\n      },\n      \"video/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"video/rtploopback\": {\n        source: \"iana\"\n      },\n      \"video/rtx\": {\n        source: \"iana\"\n      },\n      \"video/scip\": {\n        source: \"iana\"\n      },\n      \"video/smpte291\": {\n        source: \"iana\"\n      },\n      \"video/smpte292m\": {\n        source: \"iana\"\n      },\n      \"video/ulpfec\": {\n        source: \"iana\"\n      },\n      \"video/vc1\": {\n        source: \"iana\"\n      },\n      \"video/vc2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.cctv\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.hd\": {\n        source: \"iana\",\n        extensions: [\"uvh\", \"uvvh\"]\n      },\n      \"video/vnd.dece.mobile\": {\n        source: \"iana\",\n        extensions: [\"uvm\", \"uvvm\"]\n      },\n      \"video/vnd.dece.mp4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.pd\": {\n        source: \"iana\",\n        extensions: [\"uvp\", \"uvvp\"]\n      },\n      \"video/vnd.dece.sd\": {\n        source: \"iana\",\n        extensions: [\"uvs\", \"uvvs\"]\n      },\n      \"video/vnd.dece.video\": {\n        source: \"iana\",\n        extensions: [\"uvv\", \"uvvv\"]\n      },\n      \"video/vnd.directv.mpeg\": {\n        source: \"iana\"\n      },\n      \"video/vnd.directv.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dlna.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dvb.file\": {\n        source: \"iana\",\n        extensions: [\"dvb\"]\n      },\n      \"video/vnd.fvt\": {\n        source: \"iana\",\n        extensions: [\"fvt\"]\n      },\n      \"video/vnd.hns.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsavc\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsmpeg2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.videop\": {\n        source: \"iana\"\n      },\n      \"video/vnd.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"mxu\", \"m4u\"]\n      },\n      \"video/vnd.ms-playready.media.pyv\": {\n        source: \"iana\",\n        extensions: [\"pyv\"]\n      },\n      \"video/vnd.nokia.interleaved-multimedia\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.mp4vr\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.videovoip\": {\n        source: \"iana\"\n      },\n      \"video/vnd.objectvideo\": {\n        source: \"iana\"\n      },\n      \"video/vnd.planar\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.bink\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.smacker\": {\n        source: \"apache\"\n      },\n      \"video/vnd.sealed.mpeg1\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.mpeg4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.swf\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealedmedia.softseal.mov\": {\n        source: \"iana\"\n      },\n      \"video/vnd.uvvu.mp4\": {\n        source: \"iana\",\n        extensions: [\"uvu\", \"uvvu\"]\n      },\n      \"video/vnd.vivo\": {\n        source: \"iana\",\n        extensions: [\"viv\"]\n      },\n      \"video/vnd.youtube.yt\": {\n        source: \"iana\"\n      },\n      \"video/vp8\": {\n        source: \"iana\"\n      },\n      \"video/vp9\": {\n        source: \"iana\"\n      },\n      \"video/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"webm\"]\n      },\n      \"video/x-f4v\": {\n        source: \"apache\",\n        extensions: [\"f4v\"]\n      },\n      \"video/x-fli\": {\n        source: \"apache\",\n        extensions: [\"fli\"]\n      },\n      \"video/x-flv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"flv\"]\n      },\n      \"video/x-m4v\": {\n        source: \"apache\",\n        extensions: [\"m4v\"]\n      },\n      \"video/x-matroska\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"mkv\", \"mk3d\", \"mks\"]\n      },\n      \"video/x-mng\": {\n        source: \"apache\",\n        extensions: [\"mng\"]\n      },\n      \"video/x-ms-asf\": {\n        source: \"apache\",\n        extensions: [\"asf\", \"asx\"]\n      },\n      \"video/x-ms-vob\": {\n        source: \"apache\",\n        extensions: [\"vob\"]\n      },\n      \"video/x-ms-wm\": {\n        source: \"apache\",\n        extensions: [\"wm\"]\n      },\n      \"video/x-ms-wmv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"wmv\"]\n      },\n      \"video/x-ms-wmx\": {\n        source: \"apache\",\n        extensions: [\"wmx\"]\n      },\n      \"video/x-ms-wvx\": {\n        source: \"apache\",\n        extensions: [\"wvx\"]\n      },\n      \"video/x-msvideo\": {\n        source: \"apache\",\n        extensions: [\"avi\"]\n      },\n      \"video/x-sgi-movie\": {\n        source: \"apache\",\n        extensions: [\"movie\"]\n      },\n      \"video/x-smv\": {\n        source: \"apache\",\n        extensions: [\"smv\"]\n      },\n      \"x-conference/x-cooltalk\": {\n        source: \"apache\",\n        extensions: [\"ice\"]\n      },\n      \"x-shader/x-fragment\": {\n        compressible: true\n      },\n      \"x-shader/x-vertex\": {\n        compressible: true\n      }\n    };\n  }\n});\n\n// node_modules/express/node_modules/mime-db/index.js\nvar require_mime_db2 = __commonJS({\n  \"node_modules/express/node_modules/mime-db/index.js\"(exports2, module2) {\n    module2.exports = require_db2();\n  }\n});\n\n// node_modules/express/node_modules/mime-types/mimeScore.js\nvar require_mimeScore2 = __commonJS({\n  \"node_modules/express/node_modules/mime-types/mimeScore.js\"(exports2, module2) {\n    var FACET_SCORES = {\n      \"prs.\": 100,\n      \"x-\": 200,\n      \"x.\": 300,\n      \"vnd.\": 400,\n      default: 900\n    };\n    var SOURCE_SCORES = {\n      nginx: 10,\n      apache: 20,\n      iana: 40,\n      default: 30\n      // definitions added by `jshttp/mime-db` project?\n    };\n    var TYPE_SCORES = {\n      // prefer application/xml over text/xml\n      // prefer application/rtf over text/rtf\n      application: 1,\n      // prefer font/woff over application/font-woff\n      font: 2,\n      default: 0\n    };\n    module2.exports = function mimeScore(mimeType, source = \"default\") {\n      if (mimeType === \"application/octet-stream\") {\n        return 0;\n      }\n      const [type, subtype] = mimeType.split(\"/\");\n      const facet = subtype.replace(/(\\.|x-).*/, \"$1\");\n      const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;\n      const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;\n      const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;\n      const lengthScore = 1 - mimeType.length / 100;\n      return facetScore + sourceScore + typeScore + lengthScore;\n    };\n  }\n});\n\n// node_modules/express/node_modules/mime-types/index.js\nvar require_mime_types2 = __commonJS({\n  \"node_modules/express/node_modules/mime-types/index.js\"(exports2) {\n    \"use strict\";\n    var db = require_mime_db2();\n    var extname = require(\"path\").extname;\n    var mimeScore = require_mimeScore2();\n    var EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/;\n    var TEXT_TYPE_REGEXP = /^text\\//i;\n    exports2.charset = charset;\n    exports2.charsets = { lookup: charset };\n    exports2.contentType = contentType2;\n    exports2.extension = extension;\n    exports2.extensions = /* @__PURE__ */ Object.create(null);\n    exports2.lookup = lookup;\n    exports2.types = /* @__PURE__ */ Object.create(null);\n    exports2._extensionConflicts = [];\n    populateMaps(exports2.extensions, exports2.types);\n    function charset(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var mime = match && db[match[1].toLowerCase()];\n      if (mime && mime.charset) {\n        return mime.charset;\n      }\n      if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n        return \"UTF-8\";\n      }\n      return false;\n    }\n    function contentType2(str) {\n      if (!str || typeof str !== \"string\") {\n        return false;\n      }\n      var mime = str.indexOf(\"/\") === -1 ? exports2.lookup(str) : str;\n      if (!mime) {\n        return false;\n      }\n      if (mime.indexOf(\"charset\") === -1) {\n        var charset2 = exports2.charset(mime);\n        if (charset2) mime += \"; charset=\" + charset2.toLowerCase();\n      }\n      return mime;\n    }\n    function extension(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var exts = match && exports2.extensions[match[1].toLowerCase()];\n      if (!exts || !exts.length) {\n        return false;\n      }\n      return exts[0];\n    }\n    function lookup(path) {\n      if (!path || typeof path !== \"string\") {\n        return false;\n      }\n      var extension2 = extname(\"x.\" + path).toLowerCase().slice(1);\n      if (!extension2) {\n        return false;\n      }\n      return exports2.types[extension2] || false;\n    }\n    function populateMaps(extensions, types) {\n      Object.keys(db).forEach(function forEachMimeType(type) {\n        var mime = db[type];\n        var exts = mime.extensions;\n        if (!exts || !exts.length) {\n          return;\n        }\n        extensions[type] = exts;\n        for (var i = 0; i < exts.length; i++) {\n          var extension2 = exts[i];\n          types[extension2] = _preferredType(extension2, types[extension2], type);\n          const legacyType = _preferredTypeLegacy(\n            extension2,\n            types[extension2],\n            type\n          );\n          if (legacyType !== types[extension2]) {\n            exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]);\n          }\n        }\n      });\n    }\n    function _preferredType(ext, type0, type1) {\n      var score0 = type0 ? mimeScore(type0, db[type0].source) : 0;\n      var score1 = type1 ? mimeScore(type1, db[type1].source) : 0;\n      return score0 > score1 ? type0 : type1;\n    }\n    function _preferredTypeLegacy(ext, type0, type1) {\n      var SOURCE_RANK = [\"nginx\", \"apache\", void 0, \"iana\"];\n      var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0;\n      var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0;\n      if (exports2.types[extension] !== \"application/octet-stream\" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === \"application/\")) {\n        return type0;\n      }\n      return score0 > score1 ? type0 : type1;\n    }\n  }\n});\n\n// node_modules/forwarded/index.js\nvar require_forwarded = __commonJS({\n  \"node_modules/forwarded/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = forwarded;\n    function forwarded(req) {\n      if (!req) {\n        throw new TypeError(\"argument req is required\");\n      }\n      var proxyAddrs = parse(req.headers[\"x-forwarded-for\"] || \"\");\n      var socketAddr = getSocketAddr(req);\n      var addrs = [socketAddr].concat(proxyAddrs);\n      return addrs;\n    }\n    function getSocketAddr(req) {\n      return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress;\n    }\n    function parse(header) {\n      var end = header.length;\n      var list = [];\n      var start = header.length;\n      for (var i = header.length - 1; i >= 0; i--) {\n        switch (header.charCodeAt(i)) {\n          case 32:\n            if (start === end) {\n              start = end = i;\n            }\n            break;\n          case 44:\n            if (start !== end) {\n              list.push(header.substring(start, end));\n            }\n            start = end = i;\n            break;\n          default:\n            start = i;\n            break;\n        }\n      }\n      if (start !== end) {\n        list.push(header.substring(start, end));\n      }\n      return list;\n    }\n  }\n});\n\n// node_modules/ipaddr.js/lib/ipaddr.js\nvar require_ipaddr = __commonJS({\n  \"node_modules/ipaddr.js/lib/ipaddr.js\"(exports2, module2) {\n    (function() {\n      var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;\n      ipaddr = {};\n      root = this;\n      if (typeof module2 !== \"undefined\" && module2 !== null && module2.exports) {\n        module2.exports = ipaddr;\n      } else {\n        root[\"ipaddr\"] = ipaddr;\n      }\n      matchCIDR = function(first, second, partSize, cidrBits) {\n        var part, shift;\n        if (first.length !== second.length) {\n          throw new Error(\"ipaddr: cannot match CIDR for objects with different lengths\");\n        }\n        part = 0;\n        while (cidrBits > 0) {\n          shift = partSize - cidrBits;\n          if (shift < 0) {\n            shift = 0;\n          }\n          if (first[part] >> shift !== second[part] >> shift) {\n            return false;\n          }\n          cidrBits -= partSize;\n          part += 1;\n        }\n        return true;\n      };\n      ipaddr.subnetMatch = function(address, rangeList, defaultName) {\n        var k, len, rangeName, rangeSubnets, subnet;\n        if (defaultName == null) {\n          defaultName = \"unicast\";\n        }\n        for (rangeName in rangeList) {\n          rangeSubnets = rangeList[rangeName];\n          if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {\n            rangeSubnets = [rangeSubnets];\n          }\n          for (k = 0, len = rangeSubnets.length; k < len; k++) {\n            subnet = rangeSubnets[k];\n            if (address.kind() === subnet[0].kind()) {\n              if (address.match.apply(address, subnet)) {\n                return rangeName;\n              }\n            }\n          }\n        }\n        return defaultName;\n      };\n      ipaddr.IPv4 = function() {\n        function IPv4(octets) {\n          var k, len, octet;\n          if (octets.length !== 4) {\n            throw new Error(\"ipaddr: ipv4 octet count should be 4\");\n          }\n          for (k = 0, len = octets.length; k < len; k++) {\n            octet = octets[k];\n            if (!(0 <= octet && octet <= 255)) {\n              throw new Error(\"ipaddr: ipv4 octet should fit in 8 bits\");\n            }\n          }\n          this.octets = octets;\n        }\n        IPv4.prototype.kind = function() {\n          return \"ipv4\";\n        };\n        IPv4.prototype.toString = function() {\n          return this.octets.join(\".\");\n        };\n        IPv4.prototype.toNormalizedString = function() {\n          return this.toString();\n        };\n        IPv4.prototype.toByteArray = function() {\n          return this.octets.slice(0);\n        };\n        IPv4.prototype.match = function(other, cidrRange) {\n          var ref;\n          if (cidrRange === void 0) {\n            ref = other, other = ref[0], cidrRange = ref[1];\n          }\n          if (other.kind() !== \"ipv4\") {\n            throw new Error(\"ipaddr: cannot match ipv4 address with non-ipv4 one\");\n          }\n          return matchCIDR(this.octets, other.octets, 8, cidrRange);\n        };\n        IPv4.prototype.SpecialRanges = {\n          unspecified: [[new IPv4([0, 0, 0, 0]), 8]],\n          broadcast: [[new IPv4([255, 255, 255, 255]), 32]],\n          multicast: [[new IPv4([224, 0, 0, 0]), 4]],\n          linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],\n          loopback: [[new IPv4([127, 0, 0, 0]), 8]],\n          carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],\n          \"private\": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]],\n          reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]]\n        };\n        IPv4.prototype.range = function() {\n          return ipaddr.subnetMatch(this, this.SpecialRanges);\n        };\n        IPv4.prototype.toIPv4MappedAddress = function() {\n          return ipaddr.IPv6.parse(\"::ffff:\" + this.toString());\n        };\n        IPv4.prototype.prefixLengthFromSubnetMask = function() {\n          var cidr, i, k, octet, stop, zeros, zerotable;\n          zerotable = {\n            0: 8,\n            128: 7,\n            192: 6,\n            224: 5,\n            240: 4,\n            248: 3,\n            252: 2,\n            254: 1,\n            255: 0\n          };\n          cidr = 0;\n          stop = false;\n          for (i = k = 3; k >= 0; i = k += -1) {\n            octet = this.octets[i];\n            if (octet in zerotable) {\n              zeros = zerotable[octet];\n              if (stop && zeros !== 0) {\n                return null;\n              }\n              if (zeros !== 8) {\n                stop = true;\n              }\n              cidr += zeros;\n            } else {\n              return null;\n            }\n          }\n          return 32 - cidr;\n        };\n        return IPv4;\n      }();\n      ipv4Part = \"(0?\\\\d+|0x[a-f0-9]+)\";\n      ipv4Regexes = {\n        fourOctet: new RegExp(\"^\" + ipv4Part + \"\\\\.\" + ipv4Part + \"\\\\.\" + ipv4Part + \"\\\\.\" + ipv4Part + \"$\", \"i\"),\n        longValue: new RegExp(\"^\" + ipv4Part + \"$\", \"i\")\n      };\n      ipaddr.IPv4.parser = function(string) {\n        var match, parseIntAuto, part, shift, value;\n        parseIntAuto = function(string2) {\n          if (string2[0] === \"0\" && string2[1] !== \"x\") {\n            return parseInt(string2, 8);\n          } else {\n            return parseInt(string2);\n          }\n        };\n        if (match = string.match(ipv4Regexes.fourOctet)) {\n          return function() {\n            var k, len, ref, results;\n            ref = match.slice(1, 6);\n            results = [];\n            for (k = 0, len = ref.length; k < len; k++) {\n              part = ref[k];\n              results.push(parseIntAuto(part));\n            }\n            return results;\n          }();\n        } else if (match = string.match(ipv4Regexes.longValue)) {\n          value = parseIntAuto(match[1]);\n          if (value > 4294967295 || value < 0) {\n            throw new Error(\"ipaddr: address outside defined range\");\n          }\n          return function() {\n            var k, results;\n            results = [];\n            for (shift = k = 0; k <= 24; shift = k += 8) {\n              results.push(value >> shift & 255);\n            }\n            return results;\n          }().reverse();\n        } else {\n          return null;\n        }\n      };\n      ipaddr.IPv6 = function() {\n        function IPv6(parts, zoneId) {\n          var i, k, l, len, part, ref;\n          if (parts.length === 16) {\n            this.parts = [];\n            for (i = k = 0; k <= 14; i = k += 2) {\n              this.parts.push(parts[i] << 8 | parts[i + 1]);\n            }\n          } else if (parts.length === 8) {\n            this.parts = parts;\n          } else {\n            throw new Error(\"ipaddr: ipv6 part count should be 8 or 16\");\n          }\n          ref = this.parts;\n          for (l = 0, len = ref.length; l < len; l++) {\n            part = ref[l];\n            if (!(0 <= part && part <= 65535)) {\n              throw new Error(\"ipaddr: ipv6 part should fit in 16 bits\");\n            }\n          }\n          if (zoneId) {\n            this.zoneId = zoneId;\n          }\n        }\n        IPv6.prototype.kind = function() {\n          return \"ipv6\";\n        };\n        IPv6.prototype.toString = function() {\n          return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, \"::\");\n        };\n        IPv6.prototype.toRFC5952String = function() {\n          var bestMatchIndex, bestMatchLength, match, regex, string;\n          regex = /((^|:)(0(:|$)){2,})/g;\n          string = this.toNormalizedString();\n          bestMatchIndex = 0;\n          bestMatchLength = -1;\n          while (match = regex.exec(string)) {\n            if (match[0].length > bestMatchLength) {\n              bestMatchIndex = match.index;\n              bestMatchLength = match[0].length;\n            }\n          }\n          if (bestMatchLength < 0) {\n            return string;\n          }\n          return string.substring(0, bestMatchIndex) + \"::\" + string.substring(bestMatchIndex + bestMatchLength);\n        };\n        IPv6.prototype.toByteArray = function() {\n          var bytes, k, len, part, ref;\n          bytes = [];\n          ref = this.parts;\n          for (k = 0, len = ref.length; k < len; k++) {\n            part = ref[k];\n            bytes.push(part >> 8);\n            bytes.push(part & 255);\n          }\n          return bytes;\n        };\n        IPv6.prototype.toNormalizedString = function() {\n          var addr, part, suffix;\n          addr = function() {\n            var k, len, ref, results;\n            ref = this.parts;\n            results = [];\n            for (k = 0, len = ref.length; k < len; k++) {\n              part = ref[k];\n              results.push(part.toString(16));\n            }\n            return results;\n          }.call(this).join(\":\");\n          suffix = \"\";\n          if (this.zoneId) {\n            suffix = \"%\" + this.zoneId;\n          }\n          return addr + suffix;\n        };\n        IPv6.prototype.toFixedLengthString = function() {\n          var addr, part, suffix;\n          addr = function() {\n            var k, len, ref, results;\n            ref = this.parts;\n            results = [];\n            for (k = 0, len = ref.length; k < len; k++) {\n              part = ref[k];\n              results.push(part.toString(16).padStart(4, \"0\"));\n            }\n            return results;\n          }.call(this).join(\":\");\n          suffix = \"\";\n          if (this.zoneId) {\n            suffix = \"%\" + this.zoneId;\n          }\n          return addr + suffix;\n        };\n        IPv6.prototype.match = function(other, cidrRange) {\n          var ref;\n          if (cidrRange === void 0) {\n            ref = other, other = ref[0], cidrRange = ref[1];\n          }\n          if (other.kind() !== \"ipv6\") {\n            throw new Error(\"ipaddr: cannot match ipv6 address with non-ipv6 one\");\n          }\n          return matchCIDR(this.parts, other.parts, 16, cidrRange);\n        };\n        IPv6.prototype.SpecialRanges = {\n          unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],\n          linkLocal: [new IPv6([65152, 0, 0, 0, 0, 0, 0, 0]), 10],\n          multicast: [new IPv6([65280, 0, 0, 0, 0, 0, 0, 0]), 8],\n          loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],\n          uniqueLocal: [new IPv6([64512, 0, 0, 0, 0, 0, 0, 0]), 7],\n          ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 65535, 0, 0]), 96],\n          rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96],\n          rfc6052: [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96],\n          \"6to4\": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16],\n          teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32],\n          reserved: [[new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32]]\n        };\n        IPv6.prototype.range = function() {\n          return ipaddr.subnetMatch(this, this.SpecialRanges);\n        };\n        IPv6.prototype.isIPv4MappedAddress = function() {\n          return this.range() === \"ipv4Mapped\";\n        };\n        IPv6.prototype.toIPv4Address = function() {\n          var high, low, ref;\n          if (!this.isIPv4MappedAddress()) {\n            throw new Error(\"ipaddr: trying to convert a generic ipv6 address to ipv4\");\n          }\n          ref = this.parts.slice(-2), high = ref[0], low = ref[1];\n          return new ipaddr.IPv4([high >> 8, high & 255, low >> 8, low & 255]);\n        };\n        IPv6.prototype.prefixLengthFromSubnetMask = function() {\n          var cidr, i, k, part, stop, zeros, zerotable;\n          zerotable = {\n            0: 16,\n            32768: 15,\n            49152: 14,\n            57344: 13,\n            61440: 12,\n            63488: 11,\n            64512: 10,\n            65024: 9,\n            65280: 8,\n            65408: 7,\n            65472: 6,\n            65504: 5,\n            65520: 4,\n            65528: 3,\n            65532: 2,\n            65534: 1,\n            65535: 0\n          };\n          cidr = 0;\n          stop = false;\n          for (i = k = 7; k >= 0; i = k += -1) {\n            part = this.parts[i];\n            if (part in zerotable) {\n              zeros = zerotable[part];\n              if (stop && zeros !== 0) {\n                return null;\n              }\n              if (zeros !== 16) {\n                stop = true;\n              }\n              cidr += zeros;\n            } else {\n              return null;\n            }\n          }\n          return 128 - cidr;\n        };\n        return IPv6;\n      }();\n      ipv6Part = \"(?:[0-9a-f]+::?)+\";\n      zoneIndex = \"%[0-9a-z]{1,}\";\n      ipv6Regexes = {\n        zoneIndex: new RegExp(zoneIndex, \"i\"),\n        \"native\": new RegExp(\"^(::)?(\" + ipv6Part + \")?([0-9a-f]+)?(::)?(\" + zoneIndex + \")?$\", \"i\"),\n        transitional: new RegExp(\"^((?:\" + ipv6Part + \")|(?:::)(?:\" + ipv6Part + \")?)\" + (ipv4Part + \"\\\\.\" + ipv4Part + \"\\\\.\" + ipv4Part + \"\\\\.\" + ipv4Part) + (\"(\" + zoneIndex + \")?$\"), \"i\")\n      };\n      expandIPv6 = function(string, parts) {\n        var colonCount, lastColon, part, replacement, replacementCount, zoneId;\n        if (string.indexOf(\"::\") !== string.lastIndexOf(\"::\")) {\n          return null;\n        }\n        zoneId = (string.match(ipv6Regexes[\"zoneIndex\"]) || [])[0];\n        if (zoneId) {\n          zoneId = zoneId.substring(1);\n          string = string.replace(/%.+$/, \"\");\n        }\n        colonCount = 0;\n        lastColon = -1;\n        while ((lastColon = string.indexOf(\":\", lastColon + 1)) >= 0) {\n          colonCount++;\n        }\n        if (string.substr(0, 2) === \"::\") {\n          colonCount--;\n        }\n        if (string.substr(-2, 2) === \"::\") {\n          colonCount--;\n        }\n        if (colonCount > parts) {\n          return null;\n        }\n        replacementCount = parts - colonCount;\n        replacement = \":\";\n        while (replacementCount--) {\n          replacement += \"0:\";\n        }\n        string = string.replace(\"::\", replacement);\n        if (string[0] === \":\") {\n          string = string.slice(1);\n        }\n        if (string[string.length - 1] === \":\") {\n          string = string.slice(0, -1);\n        }\n        parts = function() {\n          var k, len, ref, results;\n          ref = string.split(\":\");\n          results = [];\n          for (k = 0, len = ref.length; k < len; k++) {\n            part = ref[k];\n            results.push(parseInt(part, 16));\n          }\n          return results;\n        }();\n        return {\n          parts,\n          zoneId\n        };\n      };\n      ipaddr.IPv6.parser = function(string) {\n        var addr, k, len, match, octet, octets, zoneId;\n        if (ipv6Regexes[\"native\"].test(string)) {\n          return expandIPv6(string, 8);\n        } else if (match = string.match(ipv6Regexes[\"transitional\"])) {\n          zoneId = match[6] || \"\";\n          addr = expandIPv6(match[1].slice(0, -1) + zoneId, 6);\n          if (addr.parts) {\n            octets = [parseInt(match[2]), parseInt(match[3]), parseInt(match[4]), parseInt(match[5])];\n            for (k = 0, len = octets.length; k < len; k++) {\n              octet = octets[k];\n              if (!(0 <= octet && octet <= 255)) {\n                return null;\n              }\n            }\n            addr.parts.push(octets[0] << 8 | octets[1]);\n            addr.parts.push(octets[2] << 8 | octets[3]);\n            return {\n              parts: addr.parts,\n              zoneId: addr.zoneId\n            };\n          }\n        }\n        return null;\n      };\n      ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string) {\n        return this.parser(string) !== null;\n      };\n      ipaddr.IPv4.isValid = function(string) {\n        var e;\n        try {\n          new this(this.parser(string));\n          return true;\n        } catch (error1) {\n          e = error1;\n          return false;\n        }\n      };\n      ipaddr.IPv4.isValidFourPartDecimal = function(string) {\n        if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\\d*)(\\.(0|[1-9]\\d*)){3}$/)) {\n          return true;\n        } else {\n          return false;\n        }\n      };\n      ipaddr.IPv6.isValid = function(string) {\n        var addr, e;\n        if (typeof string === \"string\" && string.indexOf(\":\") === -1) {\n          return false;\n        }\n        try {\n          addr = this.parser(string);\n          new this(addr.parts, addr.zoneId);\n          return true;\n        } catch (error1) {\n          e = error1;\n          return false;\n        }\n      };\n      ipaddr.IPv4.parse = function(string) {\n        var parts;\n        parts = this.parser(string);\n        if (parts === null) {\n          throw new Error(\"ipaddr: string is not formatted like ip address\");\n        }\n        return new this(parts);\n      };\n      ipaddr.IPv6.parse = function(string) {\n        var addr;\n        addr = this.parser(string);\n        if (addr.parts === null) {\n          throw new Error(\"ipaddr: string is not formatted like ip address\");\n        }\n        return new this(addr.parts, addr.zoneId);\n      };\n      ipaddr.IPv4.parseCIDR = function(string) {\n        var maskLength, match, parsed;\n        if (match = string.match(/^(.+)\\/(\\d+)$/)) {\n          maskLength = parseInt(match[2]);\n          if (maskLength >= 0 && maskLength <= 32) {\n            parsed = [this.parse(match[1]), maskLength];\n            Object.defineProperty(parsed, \"toString\", {\n              value: function() {\n                return this.join(\"/\");\n              }\n            });\n            return parsed;\n          }\n        }\n        throw new Error(\"ipaddr: string is not formatted like an IPv4 CIDR range\");\n      };\n      ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {\n        var filledOctetCount, j, octets;\n        prefix = parseInt(prefix);\n        if (prefix < 0 || prefix > 32) {\n          throw new Error(\"ipaddr: invalid IPv4 prefix length\");\n        }\n        octets = [0, 0, 0, 0];\n        j = 0;\n        filledOctetCount = Math.floor(prefix / 8);\n        while (j < filledOctetCount) {\n          octets[j] = 255;\n          j++;\n        }\n        if (filledOctetCount < 4) {\n          octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;\n        }\n        return new this(octets);\n      };\n      ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {\n        var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;\n        try {\n          cidr = this.parseCIDR(string);\n          ipInterfaceOctets = cidr[0].toByteArray();\n          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();\n          octets = [];\n          i = 0;\n          while (i < 4) {\n            octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);\n            i++;\n          }\n          return new this(octets);\n        } catch (error1) {\n          error = error1;\n          throw new Error(\"ipaddr: the address does not have IPv4 CIDR format\");\n        }\n      };\n      ipaddr.IPv4.networkAddressFromCIDR = function(string) {\n        var cidr, error, i, ipInterfaceOctets, octets, subnetMaskOctets;\n        try {\n          cidr = this.parseCIDR(string);\n          ipInterfaceOctets = cidr[0].toByteArray();\n          subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();\n          octets = [];\n          i = 0;\n          while (i < 4) {\n            octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));\n            i++;\n          }\n          return new this(octets);\n        } catch (error1) {\n          error = error1;\n          throw new Error(\"ipaddr: the address does not have IPv4 CIDR format\");\n        }\n      };\n      ipaddr.IPv6.parseCIDR = function(string) {\n        var maskLength, match, parsed;\n        if (match = string.match(/^(.+)\\/(\\d+)$/)) {\n          maskLength = parseInt(match[2]);\n          if (maskLength >= 0 && maskLength <= 128) {\n            parsed = [this.parse(match[1]), maskLength];\n            Object.defineProperty(parsed, \"toString\", {\n              value: function() {\n                return this.join(\"/\");\n              }\n            });\n            return parsed;\n          }\n        }\n        throw new Error(\"ipaddr: string is not formatted like an IPv6 CIDR range\");\n      };\n      ipaddr.isValid = function(string) {\n        return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);\n      };\n      ipaddr.parse = function(string) {\n        if (ipaddr.IPv6.isValid(string)) {\n          return ipaddr.IPv6.parse(string);\n        } else if (ipaddr.IPv4.isValid(string)) {\n          return ipaddr.IPv4.parse(string);\n        } else {\n          throw new Error(\"ipaddr: the address has neither IPv6 nor IPv4 format\");\n        }\n      };\n      ipaddr.parseCIDR = function(string) {\n        var e;\n        try {\n          return ipaddr.IPv6.parseCIDR(string);\n        } catch (error1) {\n          e = error1;\n          try {\n            return ipaddr.IPv4.parseCIDR(string);\n          } catch (error12) {\n            e = error12;\n            throw new Error(\"ipaddr: the address has neither IPv6 nor IPv4 CIDR format\");\n          }\n        }\n      };\n      ipaddr.fromByteArray = function(bytes) {\n        var length;\n        length = bytes.length;\n        if (length === 4) {\n          return new ipaddr.IPv4(bytes);\n        } else if (length === 16) {\n          return new ipaddr.IPv6(bytes);\n        } else {\n          throw new Error(\"ipaddr: the binary input is neither an IPv6 nor IPv4 address\");\n        }\n      };\n      ipaddr.process = function(string) {\n        var addr;\n        addr = this.parse(string);\n        if (addr.kind() === \"ipv6\" && addr.isIPv4MappedAddress()) {\n          return addr.toIPv4Address();\n        } else {\n          return addr;\n        }\n      };\n    }).call(exports2);\n  }\n});\n\n// node_modules/proxy-addr/index.js\nvar require_proxy_addr = __commonJS({\n  \"node_modules/proxy-addr/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = proxyaddr;\n    module2.exports.all = alladdrs;\n    module2.exports.compile = compile;\n    var forwarded = require_forwarded();\n    var ipaddr = require_ipaddr();\n    var DIGIT_REGEXP = /^[0-9]+$/;\n    var isip = ipaddr.isValid;\n    var parseip = ipaddr.parse;\n    var IP_RANGES = {\n      linklocal: [\"169.254.0.0/16\", \"fe80::/10\"],\n      loopback: [\"127.0.0.1/8\", \"::1/128\"],\n      uniquelocal: [\"10.0.0.0/8\", \"172.16.0.0/12\", \"192.168.0.0/16\", \"fc00::/7\"]\n    };\n    function alladdrs(req, trust) {\n      var addrs = forwarded(req);\n      if (!trust) {\n        return addrs;\n      }\n      if (typeof trust !== \"function\") {\n        trust = compile(trust);\n      }\n      for (var i = 0; i < addrs.length - 1; i++) {\n        if (trust(addrs[i], i)) continue;\n        addrs.length = i + 1;\n      }\n      return addrs;\n    }\n    function compile(val) {\n      if (!val) {\n        throw new TypeError(\"argument is required\");\n      }\n      var trust;\n      if (typeof val === \"string\") {\n        trust = [val];\n      } else if (Array.isArray(val)) {\n        trust = val.slice();\n      } else {\n        throw new TypeError(\"unsupported trust argument\");\n      }\n      for (var i = 0; i < trust.length; i++) {\n        val = trust[i];\n        if (!Object.prototype.hasOwnProperty.call(IP_RANGES, val)) {\n          continue;\n        }\n        val = IP_RANGES[val];\n        trust.splice.apply(trust, [i, 1].concat(val));\n        i += val.length - 1;\n      }\n      return compileTrust(compileRangeSubnets(trust));\n    }\n    function compileRangeSubnets(arr) {\n      var rangeSubnets = new Array(arr.length);\n      for (var i = 0; i < arr.length; i++) {\n        rangeSubnets[i] = parseipNotation(arr[i]);\n      }\n      return rangeSubnets;\n    }\n    function compileTrust(rangeSubnets) {\n      var len = rangeSubnets.length;\n      return len === 0 ? trustNone : len === 1 ? trustSingle(rangeSubnets[0]) : trustMulti(rangeSubnets);\n    }\n    function parseipNotation(note) {\n      var pos = note.lastIndexOf(\"/\");\n      var str = pos !== -1 ? note.substring(0, pos) : note;\n      if (!isip(str)) {\n        throw new TypeError(\"invalid IP address: \" + str);\n      }\n      var ip = parseip(str);\n      if (pos === -1 && ip.kind() === \"ipv6\" && ip.isIPv4MappedAddress()) {\n        ip = ip.toIPv4Address();\n      }\n      var max = ip.kind() === \"ipv6\" ? 128 : 32;\n      var range = pos !== -1 ? note.substring(pos + 1, note.length) : null;\n      if (range === null) {\n        range = max;\n      } else if (DIGIT_REGEXP.test(range)) {\n        range = parseInt(range, 10);\n      } else if (ip.kind() === \"ipv4\" && isip(range)) {\n        range = parseNetmask(range);\n      } else {\n        range = null;\n      }\n      if (range <= 0 || range > max) {\n        throw new TypeError(\"invalid range on address: \" + note);\n      }\n      return [ip, range];\n    }\n    function parseNetmask(netmask) {\n      var ip = parseip(netmask);\n      var kind = ip.kind();\n      return kind === \"ipv4\" ? ip.prefixLengthFromSubnetMask() : null;\n    }\n    function proxyaddr(req, trust) {\n      if (!req) {\n        throw new TypeError(\"req argument is required\");\n      }\n      if (!trust) {\n        throw new TypeError(\"trust argument is required\");\n      }\n      var addrs = alladdrs(req, trust);\n      var addr = addrs[addrs.length - 1];\n      return addr;\n    }\n    function trustNone() {\n      return false;\n    }\n    function trustMulti(subnets) {\n      return function trust(addr) {\n        if (!isip(addr)) return false;\n        var ip = parseip(addr);\n        var ipconv;\n        var kind = ip.kind();\n        for (var i = 0; i < subnets.length; i++) {\n          var subnet = subnets[i];\n          var subnetip = subnet[0];\n          var subnetkind = subnetip.kind();\n          var subnetrange = subnet[1];\n          var trusted = ip;\n          if (kind !== subnetkind) {\n            if (subnetkind === \"ipv4\" && !ip.isIPv4MappedAddress()) {\n              continue;\n            }\n            if (!ipconv) {\n              ipconv = subnetkind === \"ipv4\" ? ip.toIPv4Address() : ip.toIPv4MappedAddress();\n            }\n            trusted = ipconv;\n          }\n          if (trusted.match(subnetip, subnetrange)) {\n            return true;\n          }\n        }\n        return false;\n      };\n    }\n    function trustSingle(subnet) {\n      var subnetip = subnet[0];\n      var subnetkind = subnetip.kind();\n      var subnetisipv4 = subnetkind === \"ipv4\";\n      var subnetrange = subnet[1];\n      return function trust(addr) {\n        if (!isip(addr)) return false;\n        var ip = parseip(addr);\n        var kind = ip.kind();\n        if (kind !== subnetkind) {\n          if (subnetisipv4 && !ip.isIPv4MappedAddress()) {\n            return false;\n          }\n          ip = subnetisipv4 ? ip.toIPv4Address() : ip.toIPv4MappedAddress();\n        }\n        return ip.match(subnetip, subnetrange);\n      };\n    }\n  }\n});\n\n// node_modules/express/lib/utils.js\nvar require_utils3 = __commonJS({\n  \"node_modules/express/lib/utils.js\"(exports2) {\n    \"use strict\";\n    var { METHODS } = require(\"node:http\");\n    var contentType2 = require_content_type();\n    var etag = require_etag();\n    var mime = require_mime_types2();\n    var proxyaddr = require_proxy_addr();\n    var qs = require_lib3();\n    var querystring = require(\"querystring\");\n    exports2.methods = METHODS.map((method) => method.toLowerCase());\n    exports2.etag = createETagGenerator({ weak: false });\n    exports2.wetag = createETagGenerator({ weak: true });\n    exports2.normalizeType = function(type) {\n      return ~type.indexOf(\"/\") ? acceptParams(type) : { value: mime.lookup(type) || \"application/octet-stream\", params: {} };\n    };\n    exports2.normalizeTypes = function(types) {\n      return types.map(exports2.normalizeType);\n    };\n    function acceptParams(str) {\n      var length = str.length;\n      var colonIndex = str.indexOf(\";\");\n      var index = colonIndex === -1 ? length : colonIndex;\n      var ret = { value: str.slice(0, index).trim(), quality: 1, params: {} };\n      while (index < length) {\n        var splitIndex = str.indexOf(\"=\", index);\n        if (splitIndex === -1) break;\n        var colonIndex = str.indexOf(\";\", index);\n        var endIndex = colonIndex === -1 ? length : colonIndex;\n        if (splitIndex > endIndex) {\n          index = str.lastIndexOf(\";\", splitIndex - 1) + 1;\n          continue;\n        }\n        var key = str.slice(index, splitIndex).trim();\n        var value = str.slice(splitIndex + 1, endIndex).trim();\n        if (key === \"q\") {\n          ret.quality = parseFloat(value);\n        } else {\n          ret.params[key] = value;\n        }\n        index = endIndex + 1;\n      }\n      return ret;\n    }\n    exports2.compileETag = function(val) {\n      var fn;\n      if (typeof val === \"function\") {\n        return val;\n      }\n      switch (val) {\n        case true:\n        case \"weak\":\n          fn = exports2.wetag;\n          break;\n        case false:\n          break;\n        case \"strong\":\n          fn = exports2.etag;\n          break;\n        default:\n          throw new TypeError(\"unknown value for etag function: \" + val);\n      }\n      return fn;\n    };\n    exports2.compileQueryParser = function compileQueryParser(val) {\n      var fn;\n      if (typeof val === \"function\") {\n        return val;\n      }\n      switch (val) {\n        case true:\n        case \"simple\":\n          fn = querystring.parse;\n          break;\n        case false:\n          break;\n        case \"extended\":\n          fn = parseExtendedQueryString;\n          break;\n        default:\n          throw new TypeError(\"unknown value for query parser function: \" + val);\n      }\n      return fn;\n    };\n    exports2.compileTrust = function(val) {\n      if (typeof val === \"function\") return val;\n      if (val === true) {\n        return function() {\n          return true;\n        };\n      }\n      if (typeof val === \"number\") {\n        return function(a, i) {\n          return i < val;\n        };\n      }\n      if (typeof val === \"string\") {\n        val = val.split(\",\").map(function(v) {\n          return v.trim();\n        });\n      }\n      return proxyaddr.compile(val || []);\n    };\n    exports2.setCharset = function setCharset(type, charset) {\n      if (!type || !charset) {\n        return type;\n      }\n      var parsed = contentType2.parse(type);\n      parsed.parameters.charset = charset;\n      return contentType2.format(parsed);\n    };\n    function createETagGenerator(options) {\n      return function generateETag(body, encoding) {\n        var buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;\n        return etag(buf, options);\n      };\n    }\n    function parseExtendedQueryString(str) {\n      return qs.parse(str, {\n        allowPrototypes: true\n      });\n    }\n  }\n});\n\n// node_modules/wrappy/wrappy.js\nvar require_wrappy = __commonJS({\n  \"node_modules/wrappy/wrappy.js\"(exports2, module2) {\n    module2.exports = wrappy;\n    function wrappy(fn, cb) {\n      if (fn && cb) return wrappy(fn)(cb);\n      if (typeof fn !== \"function\")\n        throw new TypeError(\"need wrapper function\");\n      Object.keys(fn).forEach(function(k) {\n        wrapper[k] = fn[k];\n      });\n      return wrapper;\n      function wrapper() {\n        var args = new Array(arguments.length);\n        for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i];\n        }\n        var ret = fn.apply(this, args);\n        var cb2 = args[args.length - 1];\n        if (typeof ret === \"function\" && ret !== cb2) {\n          Object.keys(cb2).forEach(function(k) {\n            ret[k] = cb2[k];\n          });\n        }\n        return ret;\n      }\n    }\n  }\n});\n\n// node_modules/once/once.js\nvar require_once = __commonJS({\n  \"node_modules/once/once.js\"(exports2, module2) {\n    var wrappy = require_wrappy();\n    module2.exports = wrappy(once);\n    module2.exports.strict = wrappy(onceStrict);\n    once.proto = once(function() {\n      Object.defineProperty(Function.prototype, \"once\", {\n        value: function() {\n          return once(this);\n        },\n        configurable: true\n      });\n      Object.defineProperty(Function.prototype, \"onceStrict\", {\n        value: function() {\n          return onceStrict(this);\n        },\n        configurable: true\n      });\n    });\n    function once(fn) {\n      var f = function() {\n        if (f.called) return f.value;\n        f.called = true;\n        return f.value = fn.apply(this, arguments);\n      };\n      f.called = false;\n      return f;\n    }\n    function onceStrict(fn) {\n      var f = function() {\n        if (f.called)\n          throw new Error(f.onceError);\n        f.called = true;\n        return f.value = fn.apply(this, arguments);\n      };\n      var name = fn.name || \"Function wrapped with `once`\";\n      f.onceError = name + \" shouldn't be called more than once\";\n      f.called = false;\n      return f;\n    }\n  }\n});\n\n// node_modules/is-promise/index.js\nvar require_is_promise = __commonJS({\n  \"node_modules/is-promise/index.js\"(exports2, module2) {\n    module2.exports = isPromise;\n    module2.exports.default = isPromise;\n    function isPromise(obj) {\n      return !!obj && (typeof obj === \"object\" || typeof obj === \"function\") && typeof obj.then === \"function\";\n    }\n  }\n});\n\n// node_modules/path-to-regexp/dist/index.js\nvar require_dist = __commonJS({\n  \"node_modules/path-to-regexp/dist/index.js\"(exports2) {\n    \"use strict\";\n    Object.defineProperty(exports2, \"__esModule\", { value: true });\n    exports2.TokenData = void 0;\n    exports2.parse = parse;\n    exports2.compile = compile;\n    exports2.match = match;\n    exports2.pathToRegexp = pathToRegexp;\n    exports2.stringify = stringify;\n    var DEFAULT_DELIMITER = \"/\";\n    var NOOP_VALUE = (value) => value;\n    var ID_START = /^[$_\\p{ID_Start}]$/u;\n    var ID_CONTINUE = /^[$\\u200c\\u200d\\p{ID_Continue}]$/u;\n    var DEBUG_URL = \"https://git.new/pathToRegexpError\";\n    var SIMPLE_TOKENS = {\n      // Groups.\n      \"{\": \"{\",\n      \"}\": \"}\",\n      // Reserved.\n      \"(\": \"(\",\n      \")\": \")\",\n      \"[\": \"[\",\n      \"]\": \"]\",\n      \"+\": \"+\",\n      \"?\": \"?\",\n      \"!\": \"!\"\n    };\n    function escapeText(str) {\n      return str.replace(/[{}()\\[\\]+?!:*]/g, \"\\\\$&\");\n    }\n    function escape2(str) {\n      return str.replace(/[.+*?^${}()[\\]|/\\\\]/g, \"\\\\$&\");\n    }\n    function* lexer(str) {\n      const chars = [...str];\n      let i = 0;\n      function name() {\n        let value = \"\";\n        if (ID_START.test(chars[++i])) {\n          value += chars[i];\n          while (ID_CONTINUE.test(chars[++i])) {\n            value += chars[i];\n          }\n        } else if (chars[i] === '\"') {\n          let pos = i;\n          while (i < chars.length) {\n            if (chars[++i] === '\"') {\n              i++;\n              pos = 0;\n              break;\n            }\n            if (chars[i] === \"\\\\\") {\n              value += chars[++i];\n            } else {\n              value += chars[i];\n            }\n          }\n          if (pos) {\n            throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);\n          }\n        }\n        if (!value) {\n          throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);\n        }\n        return value;\n      }\n      while (i < chars.length) {\n        const value = chars[i];\n        const type = SIMPLE_TOKENS[value];\n        if (type) {\n          yield { type, index: i++, value };\n        } else if (value === \"\\\\\") {\n          yield { type: \"ESCAPED\", index: i++, value: chars[i++] };\n        } else if (value === \":\") {\n          const value2 = name();\n          yield { type: \"PARAM\", index: i, value: value2 };\n        } else if (value === \"*\") {\n          const value2 = name();\n          yield { type: \"WILDCARD\", index: i, value: value2 };\n        } else {\n          yield { type: \"CHAR\", index: i, value: chars[i++] };\n        }\n      }\n      return { type: \"END\", index: i, value: \"\" };\n    }\n    var Iter = class {\n      constructor(tokens) {\n        this.tokens = tokens;\n      }\n      peek() {\n        if (!this._peek) {\n          const next = this.tokens.next();\n          this._peek = next.value;\n        }\n        return this._peek;\n      }\n      tryConsume(type) {\n        const token = this.peek();\n        if (token.type !== type)\n          return;\n        this._peek = void 0;\n        return token.value;\n      }\n      consume(type) {\n        const value = this.tryConsume(type);\n        if (value !== void 0)\n          return value;\n        const { type: nextType, index } = this.peek();\n        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);\n      }\n      text() {\n        let result = \"\";\n        let value;\n        while (value = this.tryConsume(\"CHAR\") || this.tryConsume(\"ESCAPED\")) {\n          result += value;\n        }\n        return result;\n      }\n    };\n    var TokenData = class {\n      constructor(tokens) {\n        this.tokens = tokens;\n      }\n    };\n    exports2.TokenData = TokenData;\n    function parse(str, options = {}) {\n      const { encodePath = NOOP_VALUE } = options;\n      const it = new Iter(lexer(str));\n      function consume(endType) {\n        const tokens2 = [];\n        while (true) {\n          const path = it.text();\n          if (path)\n            tokens2.push({ type: \"text\", value: encodePath(path) });\n          const param = it.tryConsume(\"PARAM\");\n          if (param) {\n            tokens2.push({\n              type: \"param\",\n              name: param\n            });\n            continue;\n          }\n          const wildcard = it.tryConsume(\"WILDCARD\");\n          if (wildcard) {\n            tokens2.push({\n              type: \"wildcard\",\n              name: wildcard\n            });\n            continue;\n          }\n          const open = it.tryConsume(\"{\");\n          if (open) {\n            tokens2.push({\n              type: \"group\",\n              tokens: consume(\"}\")\n            });\n            continue;\n          }\n          it.consume(endType);\n          return tokens2;\n        }\n      }\n      const tokens = consume(\"END\");\n      return new TokenData(tokens);\n    }\n    function compile(path, options = {}) {\n      const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n      const data = path instanceof TokenData ? path : parse(path, options);\n      const fn = tokensToFunction(data.tokens, delimiter, encode);\n      return function path2(data2 = {}) {\n        const [path3, ...missing] = fn(data2);\n        if (missing.length) {\n          throw new TypeError(`Missing parameters: ${missing.join(\", \")}`);\n        }\n        return path3;\n      };\n    }\n    function tokensToFunction(tokens, delimiter, encode) {\n      const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));\n      return (data) => {\n        const result = [\"\"];\n        for (const encoder of encoders) {\n          const [value, ...extras] = encoder(data);\n          result[0] += value;\n          result.push(...extras);\n        }\n        return result;\n      };\n    }\n    function tokenToFunction(token, delimiter, encode) {\n      if (token.type === \"text\")\n        return () => [token.value];\n      if (token.type === \"group\") {\n        const fn = tokensToFunction(token.tokens, delimiter, encode);\n        return (data) => {\n          const [value, ...missing] = fn(data);\n          if (!missing.length)\n            return [value];\n          return [\"\"];\n        };\n      }\n      const encodeValue = encode || NOOP_VALUE;\n      if (token.type === \"wildcard\" && encode !== false) {\n        return (data) => {\n          const value = data[token.name];\n          if (value == null)\n            return [\"\", token.name];\n          if (!Array.isArray(value) || value.length === 0) {\n            throw new TypeError(`Expected \"${token.name}\" to be a non-empty array`);\n          }\n          return [\n            value.map((value2, index) => {\n              if (typeof value2 !== \"string\") {\n                throw new TypeError(`Expected \"${token.name}/${index}\" to be a string`);\n              }\n              return encodeValue(value2);\n            }).join(delimiter)\n          ];\n        };\n      }\n      return (data) => {\n        const value = data[token.name];\n        if (value == null)\n          return [\"\", token.name];\n        if (typeof value !== \"string\") {\n          throw new TypeError(`Expected \"${token.name}\" to be a string`);\n        }\n        return [encodeValue(value)];\n      };\n    }\n    function match(path, options = {}) {\n      const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n      const { regexp, keys } = pathToRegexp(path, options);\n      const decoders = keys.map((key) => {\n        if (decode === false)\n          return NOOP_VALUE;\n        if (key.type === \"param\")\n          return decode;\n        return (value) => value.split(delimiter).map(decode);\n      });\n      return function match2(input) {\n        const m = regexp.exec(input);\n        if (!m)\n          return false;\n        const path2 = m[0];\n        const params = /* @__PURE__ */ Object.create(null);\n        for (let i = 1; i < m.length; i++) {\n          if (m[i] === void 0)\n            continue;\n          const key = keys[i - 1];\n          const decoder = decoders[i - 1];\n          params[key.name] = decoder(m[i]);\n        }\n        return { path: path2, params };\n      };\n    }\n    function pathToRegexp(path, options = {}) {\n      const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;\n      const keys = [];\n      const sources = [];\n      const flags = sensitive ? \"\" : \"i\";\n      const paths = Array.isArray(path) ? path : [path];\n      const items = paths.map((path2) => path2 instanceof TokenData ? path2 : parse(path2, options));\n      for (const { tokens } of items) {\n        for (const seq of flatten(tokens, 0, [])) {\n          const regexp2 = sequenceToRegExp(seq, delimiter, keys);\n          sources.push(regexp2);\n        }\n      }\n      let pattern = `^(?:${sources.join(\"|\")})`;\n      if (trailing)\n        pattern += `(?:${escape2(delimiter)}$)?`;\n      pattern += end ? \"$\" : `(?=${escape2(delimiter)}|$)`;\n      const regexp = new RegExp(pattern, flags);\n      return { regexp, keys };\n    }\n    function* flatten(tokens, index, init) {\n      if (index === tokens.length) {\n        return yield init;\n      }\n      const token = tokens[index];\n      if (token.type === \"group\") {\n        const fork = init.slice();\n        for (const seq of flatten(token.tokens, 0, fork)) {\n          yield* flatten(tokens, index + 1, seq);\n        }\n      } else {\n        init.push(token);\n      }\n      yield* flatten(tokens, index + 1, init);\n    }\n    function sequenceToRegExp(tokens, delimiter, keys) {\n      let result = \"\";\n      let backtrack = \"\";\n      let isSafeSegmentParam = true;\n      for (let i = 0; i < tokens.length; i++) {\n        const token = tokens[i];\n        if (token.type === \"text\") {\n          result += escape2(token.value);\n          backtrack += token.value;\n          isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));\n          continue;\n        }\n        if (token.type === \"param\" || token.type === \"wildcard\") {\n          if (!isSafeSegmentParam && !backtrack) {\n            throw new TypeError(`Missing text after \"${token.name}\": ${DEBUG_URL}`);\n          }\n          if (token.type === \"param\") {\n            result += `(${negate(delimiter, isSafeSegmentParam ? \"\" : backtrack)}+)`;\n          } else {\n            result += `([\\\\s\\\\S]+)`;\n          }\n          keys.push(token);\n          backtrack = \"\";\n          isSafeSegmentParam = false;\n          continue;\n        }\n      }\n      return result;\n    }\n    function negate(delimiter, backtrack) {\n      if (backtrack.length < 2) {\n        if (delimiter.length < 2)\n          return `[^${escape2(delimiter + backtrack)}]`;\n        return `(?:(?!${escape2(delimiter)})[^${escape2(backtrack)}])`;\n      }\n      if (delimiter.length < 2) {\n        return `(?:(?!${escape2(backtrack)})[^${escape2(delimiter)}])`;\n      }\n      return `(?:(?!${escape2(backtrack)}|${escape2(delimiter)})[\\\\s\\\\S])`;\n    }\n    function stringify(data) {\n      return data.tokens.map(function stringifyToken(token, index, tokens) {\n        if (token.type === \"text\")\n          return escapeText(token.value);\n        if (token.type === \"group\") {\n          return `{${token.tokens.map(stringifyToken).join(\"\")}}`;\n        }\n        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);\n        const key = isSafe ? token.name : JSON.stringify(token.name);\n        if (token.type === \"param\")\n          return `:${key}`;\n        if (token.type === \"wildcard\")\n          return `*${key}`;\n        throw new TypeError(`Unexpected token: ${token}`);\n      }).join(\"\");\n    }\n    function isNameSafe(name) {\n      const [first, ...rest] = name;\n      if (!ID_START.test(first))\n        return false;\n      return rest.every((char) => ID_CONTINUE.test(char));\n    }\n    function isNextNameSafe(token) {\n      if ((token === null || token === void 0 ? void 0 : token.type) !== \"text\")\n        return true;\n      return !ID_CONTINUE.test(token.value[0]);\n    }\n  }\n});\n\n// node_modules/router/lib/layer.js\nvar require_layer = __commonJS({\n  \"node_modules/router/lib/layer.js\"(exports2, module2) {\n    \"use strict\";\n    var isPromise = require_is_promise();\n    var pathRegexp = require_dist();\n    var debug = require_src()(\"router:layer\");\n    var deprecate = require_depd()(\"router\");\n    var TRAILING_SLASH_REGEXP = /\\/+$/;\n    var MATCHING_GROUP_REGEXP = /\\((?:\\?<(.*?)>)?(?!\\?)/g;\n    module2.exports = Layer;\n    function Layer(path, options, fn) {\n      if (!(this instanceof Layer)) {\n        return new Layer(path, options, fn);\n      }\n      debug(\"new %o\", path);\n      const opts = options || {};\n      this.handle = fn;\n      this.keys = [];\n      this.name = fn.name || \"<anonymous>\";\n      this.params = void 0;\n      this.path = void 0;\n      this.slash = path === \"/\" && opts.end === false;\n      function matcher(_path) {\n        if (_path instanceof RegExp) {\n          const keys = [];\n          let name = 0;\n          let m;\n          while (m = MATCHING_GROUP_REGEXP.exec(_path.source)) {\n            keys.push({\n              name: m[1] || name++,\n              offset: m.index\n            });\n          }\n          return function regexpMatcher(p) {\n            const match = _path.exec(p);\n            if (!match) {\n              return false;\n            }\n            const params = {};\n            for (let i = 1; i < match.length; i++) {\n              const key = keys[i - 1];\n              const prop = key.name;\n              const val = decodeParam(match[i]);\n              if (val !== void 0) {\n                params[prop] = val;\n              }\n            }\n            return {\n              params,\n              path: match[0]\n            };\n          };\n        }\n        return pathRegexp.match(opts.strict ? _path : loosen(_path), {\n          sensitive: opts.sensitive,\n          end: opts.end,\n          trailing: !opts.strict,\n          decode: decodeParam\n        });\n      }\n      this.matchers = Array.isArray(path) ? path.map(matcher) : [matcher(path)];\n    }\n    Layer.prototype.handleError = function handleError(error, req, res, next) {\n      const fn = this.handle;\n      if (fn.length !== 4) {\n        return next(error);\n      }\n      try {\n        const ret = fn(error, req, res, next);\n        if (isPromise(ret)) {\n          if (!(ret instanceof Promise)) {\n            deprecate(\"handlers that are Promise-like are deprecated, use a native Promise instead\");\n          }\n          ret.then(null, function(error2) {\n            next(error2 || new Error(\"Rejected promise\"));\n          });\n        }\n      } catch (err2) {\n        next(err2);\n      }\n    };\n    Layer.prototype.handleRequest = function handleRequest(req, res, next) {\n      const fn = this.handle;\n      if (fn.length > 3) {\n        return next();\n      }\n      try {\n        const ret = fn(req, res, next);\n        if (isPromise(ret)) {\n          if (!(ret instanceof Promise)) {\n            deprecate(\"handlers that are Promise-like are deprecated, use a native Promise instead\");\n          }\n          ret.then(null, function(error) {\n            next(error || new Error(\"Rejected promise\"));\n          });\n        }\n      } catch (err2) {\n        next(err2);\n      }\n    };\n    Layer.prototype.match = function match(path) {\n      let match2;\n      if (path != null) {\n        if (this.slash) {\n          this.params = {};\n          this.path = \"\";\n          return true;\n        }\n        let i = 0;\n        while (!match2 && i < this.matchers.length) {\n          match2 = this.matchers[i](path);\n          i++;\n        }\n      }\n      if (!match2) {\n        this.params = void 0;\n        this.path = void 0;\n        return false;\n      }\n      this.params = match2.params;\n      this.path = match2.path;\n      this.keys = Object.keys(match2.params);\n      return true;\n    };\n    function decodeParam(val) {\n      if (typeof val !== \"string\" || val.length === 0) {\n        return val;\n      }\n      try {\n        return decodeURIComponent(val);\n      } catch (err2) {\n        if (err2 instanceof URIError) {\n          err2.message = \"Failed to decode param '\" + val + \"'\";\n          err2.status = 400;\n        }\n        throw err2;\n      }\n    }\n    function loosen(path) {\n      if (path instanceof RegExp || path === \"/\") {\n        return path;\n      }\n      return Array.isArray(path) ? path.map(function(p) {\n        return loosen(p);\n      }) : String(path).replace(TRAILING_SLASH_REGEXP, \"\");\n    }\n  }\n});\n\n// node_modules/router/lib/route.js\nvar require_route = __commonJS({\n  \"node_modules/router/lib/route.js\"(exports2, module2) {\n    \"use strict\";\n    var debug = require_src()(\"router:route\");\n    var Layer = require_layer();\n    var { METHODS } = require(\"node:http\");\n    var slice = Array.prototype.slice;\n    var flatten = Array.prototype.flat;\n    var methods = METHODS.map((method) => method.toLowerCase());\n    module2.exports = Route;\n    function Route(path) {\n      debug(\"new %o\", path);\n      this.path = path;\n      this.stack = [];\n      this.methods = /* @__PURE__ */ Object.create(null);\n    }\n    Route.prototype._handlesMethod = function _handlesMethod(method) {\n      if (this.methods._all) {\n        return true;\n      }\n      let name = typeof method === \"string\" ? method.toLowerCase() : method;\n      if (name === \"head\" && !this.methods.head) {\n        name = \"get\";\n      }\n      return Boolean(this.methods[name]);\n    };\n    Route.prototype._methods = function _methods() {\n      const methods2 = Object.keys(this.methods);\n      if (this.methods.get && !this.methods.head) {\n        methods2.push(\"head\");\n      }\n      for (let i = 0; i < methods2.length; i++) {\n        methods2[i] = methods2[i].toUpperCase();\n      }\n      return methods2;\n    };\n    Route.prototype.dispatch = function dispatch(req, res, done) {\n      let idx = 0;\n      const stack = this.stack;\n      let sync = 0;\n      if (stack.length === 0) {\n        return done();\n      }\n      let method = typeof req.method === \"string\" ? req.method.toLowerCase() : req.method;\n      if (method === \"head\" && !this.methods.head) {\n        method = \"get\";\n      }\n      req.route = this;\n      next();\n      function next(err2) {\n        if (err2 && err2 === \"route\") {\n          return done();\n        }\n        if (err2 && err2 === \"router\") {\n          return done(err2);\n        }\n        if (idx >= stack.length) {\n          return done(err2);\n        }\n        if (++sync > 100) {\n          return setImmediate(next, err2);\n        }\n        let layer;\n        let match;\n        while (match !== true && idx < stack.length) {\n          layer = stack[idx++];\n          match = !layer.method || layer.method === method;\n        }\n        if (match !== true) {\n          return done(err2);\n        }\n        if (err2) {\n          layer.handleError(err2, req, res, next);\n        } else {\n          layer.handleRequest(req, res, next);\n        }\n        sync = 0;\n      }\n    };\n    Route.prototype.all = function all(handler) {\n      const callbacks = flatten.call(slice.call(arguments), Infinity);\n      if (callbacks.length === 0) {\n        throw new TypeError(\"argument handler is required\");\n      }\n      for (let i = 0; i < callbacks.length; i++) {\n        const fn = callbacks[i];\n        if (typeof fn !== \"function\") {\n          throw new TypeError(\"argument handler must be a function\");\n        }\n        const layer = Layer(\"/\", {}, fn);\n        layer.method = void 0;\n        this.methods._all = true;\n        this.stack.push(layer);\n      }\n      return this;\n    };\n    methods.forEach(function(method) {\n      Route.prototype[method] = function(handler) {\n        const callbacks = flatten.call(slice.call(arguments), Infinity);\n        if (callbacks.length === 0) {\n          throw new TypeError(\"argument handler is required\");\n        }\n        for (let i = 0; i < callbacks.length; i++) {\n          const fn = callbacks[i];\n          if (typeof fn !== \"function\") {\n            throw new TypeError(\"argument handler must be a function\");\n          }\n          debug(\"%s %s\", method, this.path);\n          const layer = Layer(\"/\", {}, fn);\n          layer.method = method;\n          this.methods[method] = true;\n          this.stack.push(layer);\n        }\n        return this;\n      };\n    });\n  }\n});\n\n// node_modules/router/index.js\nvar require_router = __commonJS({\n  \"node_modules/router/index.js\"(exports2, module2) {\n    \"use strict\";\n    var isPromise = require_is_promise();\n    var Layer = require_layer();\n    var { METHODS } = require(\"node:http\");\n    var parseUrl = require_parseurl();\n    var Route = require_route();\n    var debug = require_src()(\"router\");\n    var deprecate = require_depd()(\"router\");\n    var slice = Array.prototype.slice;\n    var flatten = Array.prototype.flat;\n    var methods = METHODS.map((method) => method.toLowerCase());\n    module2.exports = Router;\n    module2.exports.Route = Route;\n    function Router(options) {\n      if (!(this instanceof Router)) {\n        return new Router(options);\n      }\n      const opts = options || {};\n      function router(req, res, next) {\n        router.handle(req, res, next);\n      }\n      Object.setPrototypeOf(router, this);\n      router.caseSensitive = opts.caseSensitive;\n      router.mergeParams = opts.mergeParams;\n      router.params = {};\n      router.strict = opts.strict;\n      router.stack = [];\n      return router;\n    }\n    Router.prototype = function() {\n    };\n    Router.prototype.param = function param(name, fn) {\n      if (!name) {\n        throw new TypeError(\"argument name is required\");\n      }\n      if (typeof name !== \"string\") {\n        throw new TypeError(\"argument name must be a string\");\n      }\n      if (!fn) {\n        throw new TypeError(\"argument fn is required\");\n      }\n      if (typeof fn !== \"function\") {\n        throw new TypeError(\"argument fn must be a function\");\n      }\n      let params = this.params[name];\n      if (!params) {\n        params = this.params[name] = [];\n      }\n      params.push(fn);\n      return this;\n    };\n    Router.prototype.handle = function handle(req, res, callback) {\n      if (!callback) {\n        throw new TypeError(\"argument callback is required\");\n      }\n      debug(\"dispatching %s %s\", req.method, req.url);\n      let idx = 0;\n      let methods2;\n      const protohost = getProtohost(req.url) || \"\";\n      let removed = \"\";\n      const self2 = this;\n      let slashAdded = false;\n      let sync = 0;\n      const paramcalled = {};\n      const stack = this.stack;\n      const parentParams = req.params;\n      const parentUrl = req.baseUrl || \"\";\n      let done = restore(callback, req, \"baseUrl\", \"next\", \"params\");\n      req.next = next;\n      if (req.method === \"OPTIONS\") {\n        methods2 = [];\n        done = wrap(done, generateOptionsResponder(res, methods2));\n      }\n      req.baseUrl = parentUrl;\n      req.originalUrl = req.originalUrl || req.url;\n      next();\n      function next(err2) {\n        let layerError = err2 === \"route\" ? null : err2;\n        if (slashAdded) {\n          req.url = req.url.slice(1);\n          slashAdded = false;\n        }\n        if (removed.length !== 0) {\n          req.baseUrl = parentUrl;\n          req.url = protohost + removed + req.url.slice(protohost.length);\n          removed = \"\";\n        }\n        if (layerError === \"router\") {\n          setImmediate(done, null);\n          return;\n        }\n        if (idx >= stack.length) {\n          setImmediate(done, layerError);\n          return;\n        }\n        if (++sync > 100) {\n          return setImmediate(next, err2);\n        }\n        const path = getPathname(req);\n        if (path == null) {\n          return done(layerError);\n        }\n        let layer;\n        let match;\n        let route;\n        while (match !== true && idx < stack.length) {\n          layer = stack[idx++];\n          match = matchLayer(layer, path);\n          route = layer.route;\n          if (typeof match !== \"boolean\") {\n            layerError = layerError || match;\n          }\n          if (match !== true) {\n            continue;\n          }\n          if (!route) {\n            continue;\n          }\n          if (layerError) {\n            match = false;\n            continue;\n          }\n          const method = req.method;\n          const hasMethod = route._handlesMethod(method);\n          if (!hasMethod && method === \"OPTIONS\" && methods2) {\n            methods2.push.apply(methods2, route._methods());\n          }\n          if (!hasMethod && method !== \"HEAD\") {\n            match = false;\n          }\n        }\n        if (match !== true) {\n          return done(layerError);\n        }\n        if (route) {\n          req.route = route;\n        }\n        req.params = self2.mergeParams ? mergeParams(layer.params, parentParams) : layer.params;\n        const layerPath = layer.path;\n        processParams(self2.params, layer, paramcalled, req, res, function(err3) {\n          if (err3) {\n            next(layerError || err3);\n          } else if (route) {\n            layer.handleRequest(req, res, next);\n          } else {\n            trimPrefix(layer, layerError, layerPath, path);\n          }\n          sync = 0;\n        });\n      }\n      function trimPrefix(layer, layerError, layerPath, path) {\n        if (layerPath.length !== 0) {\n          if (layerPath !== path.substring(0, layerPath.length)) {\n            next(layerError);\n            return;\n          }\n          const c = path[layerPath.length];\n          if (c && c !== \"/\") {\n            next(layerError);\n            return;\n          }\n          debug(\"trim prefix (%s) from url %s\", layerPath, req.url);\n          removed = layerPath;\n          req.url = protohost + req.url.slice(protohost.length + removed.length);\n          if (!protohost && req.url[0] !== \"/\") {\n            req.url = \"/\" + req.url;\n            slashAdded = true;\n          }\n          req.baseUrl = parentUrl + (removed[removed.length - 1] === \"/\" ? removed.substring(0, removed.length - 1) : removed);\n        }\n        debug(\"%s %s : %s\", layer.name, layerPath, req.originalUrl);\n        if (layerError) {\n          layer.handleError(layerError, req, res, next);\n        } else {\n          layer.handleRequest(req, res, next);\n        }\n      }\n    };\n    Router.prototype.use = function use(handler) {\n      let offset = 0;\n      let path = \"/\";\n      if (typeof handler !== \"function\") {\n        let arg = handler;\n        while (Array.isArray(arg) && arg.length !== 0) {\n          arg = arg[0];\n        }\n        if (typeof arg !== \"function\") {\n          offset = 1;\n          path = handler;\n        }\n      }\n      const callbacks = flatten.call(slice.call(arguments, offset), Infinity);\n      if (callbacks.length === 0) {\n        throw new TypeError(\"argument handler is required\");\n      }\n      for (let i = 0; i < callbacks.length; i++) {\n        const fn = callbacks[i];\n        if (typeof fn !== \"function\") {\n          throw new TypeError(\"argument handler must be a function\");\n        }\n        debug(\"use %o %s\", path, fn.name || \"<anonymous>\");\n        const layer = new Layer(path, {\n          sensitive: this.caseSensitive,\n          strict: false,\n          end: false\n        }, fn);\n        layer.route = void 0;\n        this.stack.push(layer);\n      }\n      return this;\n    };\n    Router.prototype.route = function route(path) {\n      const route2 = new Route(path);\n      const layer = new Layer(path, {\n        sensitive: this.caseSensitive,\n        strict: this.strict,\n        end: true\n      }, handle);\n      function handle(req, res, next) {\n        route2.dispatch(req, res, next);\n      }\n      layer.route = route2;\n      this.stack.push(layer);\n      return route2;\n    };\n    methods.concat(\"all\").forEach(function(method) {\n      Router.prototype[method] = function(path) {\n        const route = this.route(path);\n        route[method].apply(route, slice.call(arguments, 1));\n        return this;\n      };\n    });\n    function generateOptionsResponder(res, methods2) {\n      return function onDone(fn, err2) {\n        if (err2 || methods2.length === 0) {\n          return fn(err2);\n        }\n        trySendOptionsResponse(res, methods2, fn);\n      };\n    }\n    function getPathname(req) {\n      try {\n        return parseUrl(req).pathname;\n      } catch (err2) {\n        return void 0;\n      }\n    }\n    function getProtohost(url) {\n      if (typeof url !== \"string\" || url.length === 0 || url[0] === \"/\") {\n        return void 0;\n      }\n      const searchIndex = url.indexOf(\"?\");\n      const pathLength = searchIndex !== -1 ? searchIndex : url.length;\n      const fqdnIndex = url.substring(0, pathLength).indexOf(\"://\");\n      return fqdnIndex !== -1 ? url.substring(0, url.indexOf(\"/\", 3 + fqdnIndex)) : void 0;\n    }\n    function matchLayer(layer, path) {\n      try {\n        return layer.match(path);\n      } catch (err2) {\n        return err2;\n      }\n    }\n    function mergeParams(params, parent) {\n      if (typeof parent !== \"object\" || !parent) {\n        return params;\n      }\n      const obj = Object.assign({}, parent);\n      if (!(0 in params) || !(0 in parent)) {\n        return Object.assign(obj, params);\n      }\n      let i = 0;\n      let o = 0;\n      while (i in params) {\n        i++;\n      }\n      while (o in parent) {\n        o++;\n      }\n      for (i--; i >= 0; i--) {\n        params[i + o] = params[i];\n        if (i < o) {\n          delete params[i];\n        }\n      }\n      return Object.assign(obj, params);\n    }\n    function processParams(params, layer, called, req, res, done) {\n      const keys = layer.keys;\n      if (!keys || keys.length === 0) {\n        return done();\n      }\n      let i = 0;\n      let paramIndex = 0;\n      let key;\n      let paramVal;\n      let paramCallbacks;\n      let paramCalled;\n      function param(err2) {\n        if (err2) {\n          return done(err2);\n        }\n        if (i >= keys.length) {\n          return done();\n        }\n        paramIndex = 0;\n        key = keys[i++];\n        paramVal = req.params[key];\n        paramCallbacks = params[key];\n        paramCalled = called[key];\n        if (paramVal === void 0 || !paramCallbacks) {\n          return param();\n        }\n        if (paramCalled && (paramCalled.match === paramVal || paramCalled.error && paramCalled.error !== \"route\")) {\n          req.params[key] = paramCalled.value;\n          return param(paramCalled.error);\n        }\n        called[key] = paramCalled = {\n          error: null,\n          match: paramVal,\n          value: paramVal\n        };\n        paramCallback();\n      }\n      function paramCallback(err2) {\n        const fn = paramCallbacks[paramIndex++];\n        paramCalled.value = req.params[key];\n        if (err2) {\n          paramCalled.error = err2;\n          param(err2);\n          return;\n        }\n        if (!fn) return param();\n        try {\n          const ret = fn(req, res, paramCallback, paramVal, key);\n          if (isPromise(ret)) {\n            if (!(ret instanceof Promise)) {\n              deprecate(\"parameters that are Promise-like are deprecated, use a native Promise instead\");\n            }\n            ret.then(null, function(error) {\n              paramCallback(error || new Error(\"Rejected promise\"));\n            });\n          }\n        } catch (e) {\n          paramCallback(e);\n        }\n      }\n      param();\n    }\n    function restore(fn, obj) {\n      const props = new Array(arguments.length - 2);\n      const vals = new Array(arguments.length - 2);\n      for (let i = 0; i < props.length; i++) {\n        props[i] = arguments[i + 2];\n        vals[i] = obj[props[i]];\n      }\n      return function() {\n        for (let i = 0; i < props.length; i++) {\n          obj[props[i]] = vals[i];\n        }\n        return fn.apply(this, arguments);\n      };\n    }\n    function sendOptionsResponse(res, methods2) {\n      const options = /* @__PURE__ */ Object.create(null);\n      for (let i = 0; i < methods2.length; i++) {\n        options[methods2[i]] = true;\n      }\n      const allow = Object.keys(options).sort().join(\", \");\n      res.setHeader(\"Allow\", allow);\n      res.setHeader(\"Content-Length\", Buffer.byteLength(allow));\n      res.setHeader(\"Content-Type\", \"text/plain\");\n      res.setHeader(\"X-Content-Type-Options\", \"nosniff\");\n      res.end(allow);\n    }\n    function trySendOptionsResponse(res, methods2, next) {\n      try {\n        sendOptionsResponse(res, methods2);\n      } catch (err2) {\n        next(err2);\n      }\n    }\n    function wrap(old, fn) {\n      return function proxy() {\n        const args = new Array(arguments.length + 1);\n        args[0] = old;\n        for (let i = 0, len = arguments.length; i < len; i++) {\n          args[i + 1] = arguments[i];\n        }\n        fn.apply(this, args);\n      };\n    }\n  }\n});\n\n// node_modules/express/lib/application.js\nvar require_application = __commonJS({\n  \"node_modules/express/lib/application.js\"(exports2, module2) {\n    \"use strict\";\n    var finalhandler = require_finalhandler();\n    var debug = require_src()(\"express:application\");\n    var View = require_view();\n    var http = require(\"node:http\");\n    var methods = require_utils3().methods;\n    var compileETag = require_utils3().compileETag;\n    var compileQueryParser = require_utils3().compileQueryParser;\n    var compileTrust = require_utils3().compileTrust;\n    var resolve = require(\"node:path\").resolve;\n    var once = require_once();\n    var Router = require_router();\n    var slice = Array.prototype.slice;\n    var flatten = Array.prototype.flat;\n    var app = exports2 = module2.exports = {};\n    var trustProxyDefaultSymbol = \"@@symbol:trust_proxy_default\";\n    app.init = function init() {\n      var router = null;\n      this.cache = /* @__PURE__ */ Object.create(null);\n      this.engines = /* @__PURE__ */ Object.create(null);\n      this.settings = /* @__PURE__ */ Object.create(null);\n      this.defaultConfiguration();\n      Object.defineProperty(this, \"router\", {\n        configurable: true,\n        enumerable: true,\n        get: function getrouter() {\n          if (router === null) {\n            router = new Router({\n              caseSensitive: this.enabled(\"case sensitive routing\"),\n              strict: this.enabled(\"strict routing\")\n            });\n          }\n          return router;\n        }\n      });\n    };\n    app.defaultConfiguration = function defaultConfiguration() {\n      var env = process.env.NODE_ENV || \"development\";\n      this.enable(\"x-powered-by\");\n      this.set(\"etag\", \"weak\");\n      this.set(\"env\", env);\n      this.set(\"query parser\", \"simple\");\n      this.set(\"subdomain offset\", 2);\n      this.set(\"trust proxy\", false);\n      Object.defineProperty(this.settings, trustProxyDefaultSymbol, {\n        configurable: true,\n        value: true\n      });\n      debug(\"booting in %s mode\", env);\n      this.on(\"mount\", function onmount(parent) {\n        if (this.settings[trustProxyDefaultSymbol] === true && typeof parent.settings[\"trust proxy fn\"] === \"function\") {\n          delete this.settings[\"trust proxy\"];\n          delete this.settings[\"trust proxy fn\"];\n        }\n        Object.setPrototypeOf(this.request, parent.request);\n        Object.setPrototypeOf(this.response, parent.response);\n        Object.setPrototypeOf(this.engines, parent.engines);\n        Object.setPrototypeOf(this.settings, parent.settings);\n      });\n      this.locals = /* @__PURE__ */ Object.create(null);\n      this.mountpath = \"/\";\n      this.locals.settings = this.settings;\n      this.set(\"view\", View);\n      this.set(\"views\", resolve(\"views\"));\n      this.set(\"jsonp callback name\", \"callback\");\n      if (env === \"production\") {\n        this.enable(\"view cache\");\n      }\n    };\n    app.handle = function handle(req, res, callback) {\n      var done = callback || finalhandler(req, res, {\n        env: this.get(\"env\"),\n        onerror: logerror.bind(this)\n      });\n      if (this.enabled(\"x-powered-by\")) {\n        res.setHeader(\"X-Powered-By\", \"Express\");\n      }\n      req.res = res;\n      res.req = req;\n      Object.setPrototypeOf(req, this.request);\n      Object.setPrototypeOf(res, this.response);\n      if (!res.locals) {\n        res.locals = /* @__PURE__ */ Object.create(null);\n      }\n      this.router.handle(req, res, done);\n    };\n    app.use = function use(fn) {\n      var offset = 0;\n      var path = \"/\";\n      if (typeof fn !== \"function\") {\n        var arg = fn;\n        while (Array.isArray(arg) && arg.length !== 0) {\n          arg = arg[0];\n        }\n        if (typeof arg !== \"function\") {\n          offset = 1;\n          path = fn;\n        }\n      }\n      var fns = flatten.call(slice.call(arguments, offset), Infinity);\n      if (fns.length === 0) {\n        throw new TypeError(\"app.use() requires a middleware function\");\n      }\n      var router = this.router;\n      fns.forEach(function(fn2) {\n        if (!fn2 || !fn2.handle || !fn2.set) {\n          return router.use(path, fn2);\n        }\n        debug(\".use app under %s\", path);\n        fn2.mountpath = path;\n        fn2.parent = this;\n        router.use(path, function mounted_app(req, res, next) {\n          var orig = req.app;\n          fn2.handle(req, res, function(err2) {\n            Object.setPrototypeOf(req, orig.request);\n            Object.setPrototypeOf(res, orig.response);\n            next(err2);\n          });\n        });\n        fn2.emit(\"mount\", this);\n      }, this);\n      return this;\n    };\n    app.route = function route(path) {\n      return this.router.route(path);\n    };\n    app.engine = function engine(ext, fn) {\n      if (typeof fn !== \"function\") {\n        throw new Error(\"callback function required\");\n      }\n      var extension = ext[0] !== \".\" ? \".\" + ext : ext;\n      this.engines[extension] = fn;\n      return this;\n    };\n    app.param = function param(name, fn) {\n      if (Array.isArray(name)) {\n        for (var i = 0; i < name.length; i++) {\n          this.param(name[i], fn);\n        }\n        return this;\n      }\n      this.router.param(name, fn);\n      return this;\n    };\n    app.set = function set(setting, val) {\n      if (arguments.length === 1) {\n        return this.settings[setting];\n      }\n      debug('set \"%s\" to %o', setting, val);\n      this.settings[setting] = val;\n      switch (setting) {\n        case \"etag\":\n          this.set(\"etag fn\", compileETag(val));\n          break;\n        case \"query parser\":\n          this.set(\"query parser fn\", compileQueryParser(val));\n          break;\n        case \"trust proxy\":\n          this.set(\"trust proxy fn\", compileTrust(val));\n          Object.defineProperty(this.settings, trustProxyDefaultSymbol, {\n            configurable: true,\n            value: false\n          });\n          break;\n      }\n      return this;\n    };\n    app.path = function path() {\n      return this.parent ? this.parent.path() + this.mountpath : \"\";\n    };\n    app.enabled = function enabled(setting) {\n      return Boolean(this.set(setting));\n    };\n    app.disabled = function disabled(setting) {\n      return !this.set(setting);\n    };\n    app.enable = function enable(setting) {\n      return this.set(setting, true);\n    };\n    app.disable = function disable(setting) {\n      return this.set(setting, false);\n    };\n    methods.forEach(function(method) {\n      app[method] = function(path) {\n        if (method === \"get\" && arguments.length === 1) {\n          return this.set(path);\n        }\n        var route = this.route(path);\n        route[method].apply(route, slice.call(arguments, 1));\n        return this;\n      };\n    });\n    app.all = function all(path) {\n      var route = this.route(path);\n      var args = slice.call(arguments, 1);\n      for (var i = 0; i < methods.length; i++) {\n        route[methods[i]].apply(route, args);\n      }\n      return this;\n    };\n    app.render = function render(name, options, callback) {\n      var cache = this.cache;\n      var done = callback;\n      var engines = this.engines;\n      var opts = options;\n      var view;\n      if (typeof options === \"function\") {\n        done = options;\n        opts = {};\n      }\n      var renderOptions = { ...this.locals, ...opts._locals, ...opts };\n      if (renderOptions.cache == null) {\n        renderOptions.cache = this.enabled(\"view cache\");\n      }\n      if (renderOptions.cache) {\n        view = cache[name];\n      }\n      if (!view) {\n        var View2 = this.get(\"view\");\n        view = new View2(name, {\n          defaultEngine: this.get(\"view engine\"),\n          root: this.get(\"views\"),\n          engines\n        });\n        if (!view.path) {\n          var dirs = Array.isArray(view.root) && view.root.length > 1 ? 'directories \"' + view.root.slice(0, -1).join('\", \"') + '\" or \"' + view.root[view.root.length - 1] + '\"' : 'directory \"' + view.root + '\"';\n          var err2 = new Error('Failed to lookup view \"' + name + '\" in views ' + dirs);\n          err2.view = view;\n          return done(err2);\n        }\n        if (renderOptions.cache) {\n          cache[name] = view;\n        }\n      }\n      tryRender(view, renderOptions, done);\n    };\n    app.listen = function listen() {\n      var server = http.createServer(this);\n      var args = Array.prototype.slice.call(arguments);\n      if (typeof args[args.length - 1] === \"function\") {\n        var done = args[args.length - 1] = once(args[args.length - 1]);\n        server.once(\"error\", done);\n      }\n      return server.listen.apply(server, args);\n    };\n    function logerror(err2) {\n      if (this.get(\"env\") !== \"test\") console.error(err2.stack || err2.toString());\n    }\n    function tryRender(view, options, callback) {\n      try {\n        view.render(options, callback);\n      } catch (err2) {\n        callback(err2);\n      }\n    }\n  }\n});\n\n// node_modules/negotiator/lib/charset.js\nvar require_charset = __commonJS({\n  \"node_modules/negotiator/lib/charset.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = preferredCharsets;\n    module2.exports.preferredCharsets = preferredCharsets;\n    var simpleCharsetRegExp = /^\\s*([^\\s;]+)\\s*(?:;(.*))?$/;\n    function parseAcceptCharset(accept) {\n      var accepts = accept.split(\",\");\n      for (var i = 0, j = 0; i < accepts.length; i++) {\n        var charset = parseCharset(accepts[i].trim(), i);\n        if (charset) {\n          accepts[j++] = charset;\n        }\n      }\n      accepts.length = j;\n      return accepts;\n    }\n    function parseCharset(str, i) {\n      var match = simpleCharsetRegExp.exec(str);\n      if (!match) return null;\n      var charset = match[1];\n      var q = 1;\n      if (match[2]) {\n        var params = match[2].split(\";\");\n        for (var j = 0; j < params.length; j++) {\n          var p = params[j].trim().split(\"=\");\n          if (p[0] === \"q\") {\n            q = parseFloat(p[1]);\n            break;\n          }\n        }\n      }\n      return {\n        charset,\n        q,\n        i\n      };\n    }\n    function getCharsetPriority(charset, accepted, index) {\n      var priority = { o: -1, q: 0, s: 0 };\n      for (var i = 0; i < accepted.length; i++) {\n        var spec = specify(charset, accepted[i], index);\n        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {\n          priority = spec;\n        }\n      }\n      return priority;\n    }\n    function specify(charset, spec, index) {\n      var s = 0;\n      if (spec.charset.toLowerCase() === charset.toLowerCase()) {\n        s |= 1;\n      } else if (spec.charset !== \"*\") {\n        return null;\n      }\n      return {\n        i: index,\n        o: spec.i,\n        q: spec.q,\n        s\n      };\n    }\n    function preferredCharsets(accept, provided) {\n      var accepts = parseAcceptCharset(accept === void 0 ? \"*\" : accept || \"\");\n      if (!provided) {\n        return accepts.filter(isQuality).sort(compareSpecs).map(getFullCharset);\n      }\n      var priorities = provided.map(function getPriority(type, index) {\n        return getCharsetPriority(type, accepts, index);\n      });\n      return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(priority) {\n        return provided[priorities.indexOf(priority)];\n      });\n    }\n    function compareSpecs(a, b) {\n      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;\n    }\n    function getFullCharset(spec) {\n      return spec.charset;\n    }\n    function isQuality(spec) {\n      return spec.q > 0;\n    }\n  }\n});\n\n// node_modules/negotiator/lib/encoding.js\nvar require_encoding = __commonJS({\n  \"node_modules/negotiator/lib/encoding.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = preferredEncodings;\n    module2.exports.preferredEncodings = preferredEncodings;\n    var simpleEncodingRegExp = /^\\s*([^\\s;]+)\\s*(?:;(.*))?$/;\n    function parseAcceptEncoding(accept) {\n      var accepts = accept.split(\",\");\n      var hasIdentity = false;\n      var minQuality = 1;\n      for (var i = 0, j = 0; i < accepts.length; i++) {\n        var encoding = parseEncoding(accepts[i].trim(), i);\n        if (encoding) {\n          accepts[j++] = encoding;\n          hasIdentity = hasIdentity || specify(\"identity\", encoding);\n          minQuality = Math.min(minQuality, encoding.q || 1);\n        }\n      }\n      if (!hasIdentity) {\n        accepts[j++] = {\n          encoding: \"identity\",\n          q: minQuality,\n          i\n        };\n      }\n      accepts.length = j;\n      return accepts;\n    }\n    function parseEncoding(str, i) {\n      var match = simpleEncodingRegExp.exec(str);\n      if (!match) return null;\n      var encoding = match[1];\n      var q = 1;\n      if (match[2]) {\n        var params = match[2].split(\";\");\n        for (var j = 0; j < params.length; j++) {\n          var p = params[j].trim().split(\"=\");\n          if (p[0] === \"q\") {\n            q = parseFloat(p[1]);\n            break;\n          }\n        }\n      }\n      return {\n        encoding,\n        q,\n        i\n      };\n    }\n    function getEncodingPriority(encoding, accepted, index) {\n      var priority = { encoding, o: -1, q: 0, s: 0 };\n      for (var i = 0; i < accepted.length; i++) {\n        var spec = specify(encoding, accepted[i], index);\n        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {\n          priority = spec;\n        }\n      }\n      return priority;\n    }\n    function specify(encoding, spec, index) {\n      var s = 0;\n      if (spec.encoding.toLowerCase() === encoding.toLowerCase()) {\n        s |= 1;\n      } else if (spec.encoding !== \"*\") {\n        return null;\n      }\n      return {\n        encoding,\n        i: index,\n        o: spec.i,\n        q: spec.q,\n        s\n      };\n    }\n    function preferredEncodings(accept, provided, preferred) {\n      var accepts = parseAcceptEncoding(accept || \"\");\n      var comparator = preferred ? function comparator2(a, b) {\n        if (a.q !== b.q) {\n          return b.q - a.q;\n        }\n        var aPreferred = preferred.indexOf(a.encoding);\n        var bPreferred = preferred.indexOf(b.encoding);\n        if (aPreferred === -1 && bPreferred === -1) {\n          return b.s - a.s || a.o - b.o || a.i - b.i;\n        }\n        if (aPreferred !== -1 && bPreferred !== -1) {\n          return aPreferred - bPreferred;\n        }\n        return aPreferred === -1 ? 1 : -1;\n      } : compareSpecs;\n      if (!provided) {\n        return accepts.filter(isQuality).sort(comparator).map(getFullEncoding);\n      }\n      var priorities = provided.map(function getPriority(type, index) {\n        return getEncodingPriority(type, accepts, index);\n      });\n      return priorities.filter(isQuality).sort(comparator).map(function getEncoding(priority) {\n        return provided[priorities.indexOf(priority)];\n      });\n    }\n    function compareSpecs(a, b) {\n      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i;\n    }\n    function getFullEncoding(spec) {\n      return spec.encoding;\n    }\n    function isQuality(spec) {\n      return spec.q > 0;\n    }\n  }\n});\n\n// node_modules/negotiator/lib/language.js\nvar require_language = __commonJS({\n  \"node_modules/negotiator/lib/language.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = preferredLanguages;\n    module2.exports.preferredLanguages = preferredLanguages;\n    var simpleLanguageRegExp = /^\\s*([^\\s\\-;]+)(?:-([^\\s;]+))?\\s*(?:;(.*))?$/;\n    function parseAcceptLanguage(accept) {\n      var accepts = accept.split(\",\");\n      for (var i = 0, j = 0; i < accepts.length; i++) {\n        var language = parseLanguage(accepts[i].trim(), i);\n        if (language) {\n          accepts[j++] = language;\n        }\n      }\n      accepts.length = j;\n      return accepts;\n    }\n    function parseLanguage(str, i) {\n      var match = simpleLanguageRegExp.exec(str);\n      if (!match) return null;\n      var prefix = match[1];\n      var suffix = match[2];\n      var full = prefix;\n      if (suffix) full += \"-\" + suffix;\n      var q = 1;\n      if (match[3]) {\n        var params = match[3].split(\";\");\n        for (var j = 0; j < params.length; j++) {\n          var p = params[j].split(\"=\");\n          if (p[0] === \"q\") q = parseFloat(p[1]);\n        }\n      }\n      return {\n        prefix,\n        suffix,\n        q,\n        i,\n        full\n      };\n    }\n    function getLanguagePriority(language, accepted, index) {\n      var priority = { o: -1, q: 0, s: 0 };\n      for (var i = 0; i < accepted.length; i++) {\n        var spec = specify(language, accepted[i], index);\n        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {\n          priority = spec;\n        }\n      }\n      return priority;\n    }\n    function specify(language, spec, index) {\n      var p = parseLanguage(language);\n      if (!p) return null;\n      var s = 0;\n      if (spec.full.toLowerCase() === p.full.toLowerCase()) {\n        s |= 4;\n      } else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) {\n        s |= 2;\n      } else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {\n        s |= 1;\n      } else if (spec.full !== \"*\") {\n        return null;\n      }\n      return {\n        i: index,\n        o: spec.i,\n        q: spec.q,\n        s\n      };\n    }\n    function preferredLanguages(accept, provided) {\n      var accepts = parseAcceptLanguage(accept === void 0 ? \"*\" : accept || \"\");\n      if (!provided) {\n        return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage);\n      }\n      var priorities = provided.map(function getPriority(type, index) {\n        return getLanguagePriority(type, accepts, index);\n      });\n      return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) {\n        return provided[priorities.indexOf(priority)];\n      });\n    }\n    function compareSpecs(a, b) {\n      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;\n    }\n    function getFullLanguage(spec) {\n      return spec.full;\n    }\n    function isQuality(spec) {\n      return spec.q > 0;\n    }\n  }\n});\n\n// node_modules/negotiator/lib/mediaType.js\nvar require_mediaType = __commonJS({\n  \"node_modules/negotiator/lib/mediaType.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = preferredMediaTypes;\n    module2.exports.preferredMediaTypes = preferredMediaTypes;\n    var simpleMediaTypeRegExp = /^\\s*([^\\s\\/;]+)\\/([^;\\s]+)\\s*(?:;(.*))?$/;\n    function parseAccept(accept) {\n      var accepts = splitMediaTypes(accept);\n      for (var i = 0, j = 0; i < accepts.length; i++) {\n        var mediaType = parseMediaType(accepts[i].trim(), i);\n        if (mediaType) {\n          accepts[j++] = mediaType;\n        }\n      }\n      accepts.length = j;\n      return accepts;\n    }\n    function parseMediaType(str, i) {\n      var match = simpleMediaTypeRegExp.exec(str);\n      if (!match) return null;\n      var params = /* @__PURE__ */ Object.create(null);\n      var q = 1;\n      var subtype = match[2];\n      var type = match[1];\n      if (match[3]) {\n        var kvps = splitParameters(match[3]).map(splitKeyValuePair);\n        for (var j = 0; j < kvps.length; j++) {\n          var pair = kvps[j];\n          var key = pair[0].toLowerCase();\n          var val = pair[1];\n          var value = val && val[0] === '\"' && val[val.length - 1] === '\"' ? val.slice(1, -1) : val;\n          if (key === \"q\") {\n            q = parseFloat(value);\n            break;\n          }\n          params[key] = value;\n        }\n      }\n      return {\n        type,\n        subtype,\n        params,\n        q,\n        i\n      };\n    }\n    function getMediaTypePriority(type, accepted, index) {\n      var priority = { o: -1, q: 0, s: 0 };\n      for (var i = 0; i < accepted.length; i++) {\n        var spec = specify(type, accepted[i], index);\n        if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {\n          priority = spec;\n        }\n      }\n      return priority;\n    }\n    function specify(type, spec, index) {\n      var p = parseMediaType(type);\n      var s = 0;\n      if (!p) {\n        return null;\n      }\n      if (spec.type.toLowerCase() == p.type.toLowerCase()) {\n        s |= 4;\n      } else if (spec.type != \"*\") {\n        return null;\n      }\n      if (spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {\n        s |= 2;\n      } else if (spec.subtype != \"*\") {\n        return null;\n      }\n      var keys = Object.keys(spec.params);\n      if (keys.length > 0) {\n        if (keys.every(function(k) {\n          return spec.params[k] == \"*\" || (spec.params[k] || \"\").toLowerCase() == (p.params[k] || \"\").toLowerCase();\n        })) {\n          s |= 1;\n        } else {\n          return null;\n        }\n      }\n      return {\n        i: index,\n        o: spec.i,\n        q: spec.q,\n        s\n      };\n    }\n    function preferredMediaTypes(accept, provided) {\n      var accepts = parseAccept(accept === void 0 ? \"*/*\" : accept || \"\");\n      if (!provided) {\n        return accepts.filter(isQuality).sort(compareSpecs).map(getFullType);\n      }\n      var priorities = provided.map(function getPriority(type, index) {\n        return getMediaTypePriority(type, accepts, index);\n      });\n      return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {\n        return provided[priorities.indexOf(priority)];\n      });\n    }\n    function compareSpecs(a, b) {\n      return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;\n    }\n    function getFullType(spec) {\n      return spec.type + \"/\" + spec.subtype;\n    }\n    function isQuality(spec) {\n      return spec.q > 0;\n    }\n    function quoteCount(string) {\n      var count = 0;\n      var index = 0;\n      while ((index = string.indexOf('\"', index)) !== -1) {\n        count++;\n        index++;\n      }\n      return count;\n    }\n    function splitKeyValuePair(str) {\n      var index = str.indexOf(\"=\");\n      var key;\n      var val;\n      if (index === -1) {\n        key = str;\n      } else {\n        key = str.slice(0, index);\n        val = str.slice(index + 1);\n      }\n      return [key, val];\n    }\n    function splitMediaTypes(accept) {\n      var accepts = accept.split(\",\");\n      for (var i = 1, j = 0; i < accepts.length; i++) {\n        if (quoteCount(accepts[j]) % 2 == 0) {\n          accepts[++j] = accepts[i];\n        } else {\n          accepts[j] += \",\" + accepts[i];\n        }\n      }\n      accepts.length = j + 1;\n      return accepts;\n    }\n    function splitParameters(str) {\n      var parameters = str.split(\";\");\n      for (var i = 1, j = 0; i < parameters.length; i++) {\n        if (quoteCount(parameters[j]) % 2 == 0) {\n          parameters[++j] = parameters[i];\n        } else {\n          parameters[j] += \";\" + parameters[i];\n        }\n      }\n      parameters.length = j + 1;\n      for (var i = 0; i < parameters.length; i++) {\n        parameters[i] = parameters[i].trim();\n      }\n      return parameters;\n    }\n  }\n});\n\n// node_modules/negotiator/index.js\nvar require_negotiator = __commonJS({\n  \"node_modules/negotiator/index.js\"(exports2, module2) {\n    \"use strict\";\n    var preferredCharsets = require_charset();\n    var preferredEncodings = require_encoding();\n    var preferredLanguages = require_language();\n    var preferredMediaTypes = require_mediaType();\n    module2.exports = Negotiator;\n    module2.exports.Negotiator = Negotiator;\n    function Negotiator(request) {\n      if (!(this instanceof Negotiator)) {\n        return new Negotiator(request);\n      }\n      this.request = request;\n    }\n    Negotiator.prototype.charset = function charset(available) {\n      var set = this.charsets(available);\n      return set && set[0];\n    };\n    Negotiator.prototype.charsets = function charsets(available) {\n      return preferredCharsets(this.request.headers[\"accept-charset\"], available);\n    };\n    Negotiator.prototype.encoding = function encoding(available, opts) {\n      var set = this.encodings(available, opts);\n      return set && set[0];\n    };\n    Negotiator.prototype.encodings = function encodings(available, options) {\n      var opts = options || {};\n      return preferredEncodings(this.request.headers[\"accept-encoding\"], available, opts.preferred);\n    };\n    Negotiator.prototype.language = function language(available) {\n      var set = this.languages(available);\n      return set && set[0];\n    };\n    Negotiator.prototype.languages = function languages(available) {\n      return preferredLanguages(this.request.headers[\"accept-language\"], available);\n    };\n    Negotiator.prototype.mediaType = function mediaType(available) {\n      var set = this.mediaTypes(available);\n      return set && set[0];\n    };\n    Negotiator.prototype.mediaTypes = function mediaTypes(available) {\n      return preferredMediaTypes(this.request.headers.accept, available);\n    };\n    Negotiator.prototype.preferredCharset = Negotiator.prototype.charset;\n    Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets;\n    Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding;\n    Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings;\n    Negotiator.prototype.preferredLanguage = Negotiator.prototype.language;\n    Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages;\n    Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType;\n    Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes;\n  }\n});\n\n// node_modules/accepts/node_modules/mime-db/db.json\nvar require_db3 = __commonJS({\n  \"node_modules/accepts/node_modules/mime-db/db.json\"(exports2, module2) {\n    module2.exports = {\n      \"application/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"application/3gpdash-qoe-report+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/3gpp-ims+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphalforms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/a2l\": {\n        source: \"iana\"\n      },\n      \"application/ace+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ace-groupcomm+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace-trl+cbor\": {\n        source: \"iana\"\n      },\n      \"application/activemessage\": {\n        source: \"iana\"\n      },\n      \"application/activity+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aif+cbor\": {\n        source: \"iana\"\n      },\n      \"application/aif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdni+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdnifilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-directory+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcost+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcostparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointprop+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointpropparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-error+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmapparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tips+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tipsparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamcontrol+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aml\": {\n        source: \"iana\"\n      },\n      \"application/andrew-inset\": {\n        source: \"iana\",\n        extensions: [\"ez\"]\n      },\n      \"application/appinstaller\": {\n        compressible: false,\n        extensions: [\"appinstaller\"]\n      },\n      \"application/applefile\": {\n        source: \"iana\"\n      },\n      \"application/applixware\": {\n        source: \"apache\",\n        extensions: [\"aw\"]\n      },\n      \"application/appx\": {\n        compressible: false,\n        extensions: [\"appx\"]\n      },\n      \"application/appxbundle\": {\n        compressible: false,\n        extensions: [\"appxbundle\"]\n      },\n      \"application/at+jwt\": {\n        source: \"iana\"\n      },\n      \"application/atf\": {\n        source: \"iana\"\n      },\n      \"application/atfx\": {\n        source: \"iana\"\n      },\n      \"application/atom+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atom\"]\n      },\n      \"application/atomcat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomcat\"]\n      },\n      \"application/atomdeleted+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomdeleted\"]\n      },\n      \"application/atomicmail\": {\n        source: \"iana\"\n      },\n      \"application/atomsvc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomsvc\"]\n      },\n      \"application/atsc-dwd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dwd\"]\n      },\n      \"application/atsc-dynamic-event-message\": {\n        source: \"iana\"\n      },\n      \"application/atsc-held+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"held\"]\n      },\n      \"application/atsc-rdt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/atsc-rsat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsat\"]\n      },\n      \"application/atxml\": {\n        source: \"iana\"\n      },\n      \"application/auth-policy+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/automationml-aml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"aml\"]\n      },\n      \"application/automationml-amlx+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"amlx\"]\n      },\n      \"application/bacnet-xdd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/batch-smtp\": {\n        source: \"iana\"\n      },\n      \"application/bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/beep+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/bufr\": {\n        source: \"iana\"\n      },\n      \"application/c2pa\": {\n        source: \"iana\"\n      },\n      \"application/calendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/calendar+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xcs\"]\n      },\n      \"application/call-completion\": {\n        source: \"iana\"\n      },\n      \"application/cals-1840\": {\n        source: \"iana\"\n      },\n      \"application/captive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cbor\": {\n        source: \"iana\"\n      },\n      \"application/cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/cccex\": {\n        source: \"iana\"\n      },\n      \"application/ccmp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ccxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ccxml\"]\n      },\n      \"application/cda+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/cdfx+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdfx\"]\n      },\n      \"application/cdmi-capability\": {\n        source: \"iana\",\n        extensions: [\"cdmia\"]\n      },\n      \"application/cdmi-container\": {\n        source: \"iana\",\n        extensions: [\"cdmic\"]\n      },\n      \"application/cdmi-domain\": {\n        source: \"iana\",\n        extensions: [\"cdmid\"]\n      },\n      \"application/cdmi-object\": {\n        source: \"iana\",\n        extensions: [\"cdmio\"]\n      },\n      \"application/cdmi-queue\": {\n        source: \"iana\",\n        extensions: [\"cdmiq\"]\n      },\n      \"application/cdni\": {\n        source: \"iana\"\n      },\n      \"application/ce+cbor\": {\n        source: \"iana\"\n      },\n      \"application/cea\": {\n        source: \"iana\"\n      },\n      \"application/cea-2018+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cellml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cfw\": {\n        source: \"iana\"\n      },\n      \"application/cid-edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/city+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/city+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/clr\": {\n        source: \"iana\"\n      },\n      \"application/clue+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/clue_info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cms\": {\n        source: \"iana\"\n      },\n      \"application/cnrp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-eap\": {\n        source: \"iana\"\n      },\n      \"application/coap-group+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-payload\": {\n        source: \"iana\"\n      },\n      \"application/commonground\": {\n        source: \"iana\"\n      },\n      \"application/concise-problem-details+cbor\": {\n        source: \"iana\"\n      },\n      \"application/conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cose\": {\n        source: \"iana\"\n      },\n      \"application/cose-key\": {\n        source: \"iana\"\n      },\n      \"application/cose-key-set\": {\n        source: \"iana\"\n      },\n      \"application/cose-x509\": {\n        source: \"iana\"\n      },\n      \"application/cpl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cpl\"]\n      },\n      \"application/csrattrs\": {\n        source: \"iana\"\n      },\n      \"application/csta+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cstadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/csvm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cu-seeme\": {\n        source: \"apache\",\n        extensions: [\"cu\"]\n      },\n      \"application/cwl\": {\n        source: \"iana\",\n        extensions: [\"cwl\"]\n      },\n      \"application/cwl+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cwl+yaml\": {\n        source: \"iana\"\n      },\n      \"application/cwt\": {\n        source: \"iana\"\n      },\n      \"application/cybercash\": {\n        source: \"iana\"\n      },\n      \"application/dart\": {\n        compressible: true\n      },\n      \"application/dash+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpd\"]\n      },\n      \"application/dash-patch+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpp\"]\n      },\n      \"application/dashdelta\": {\n        source: \"iana\"\n      },\n      \"application/davmount+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"davmount\"]\n      },\n      \"application/dca-rft\": {\n        source: \"iana\"\n      },\n      \"application/dcd\": {\n        source: \"iana\"\n      },\n      \"application/dec-dx\": {\n        source: \"iana\"\n      },\n      \"application/dialog-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom\": {\n        source: \"iana\",\n        extensions: [\"dcm\"]\n      },\n      \"application/dicom+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dii\": {\n        source: \"iana\"\n      },\n      \"application/dit\": {\n        source: \"iana\"\n      },\n      \"application/dns\": {\n        source: \"iana\"\n      },\n      \"application/dns+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dns-message\": {\n        source: \"iana\"\n      },\n      \"application/docbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dbk\"]\n      },\n      \"application/dots+cbor\": {\n        source: \"iana\"\n      },\n      \"application/dpop+jwt\": {\n        source: \"iana\"\n      },\n      \"application/dskpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dssc+der\": {\n        source: \"iana\",\n        extensions: [\"dssc\"]\n      },\n      \"application/dssc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdssc\"]\n      },\n      \"application/dvcs\": {\n        source: \"iana\"\n      },\n      \"application/eat+cwt\": {\n        source: \"iana\"\n      },\n      \"application/eat+jwt\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/eat-ucs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-ucs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ecmascript\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ecma\"]\n      },\n      \"application/edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/edi-consent\": {\n        source: \"iana\"\n      },\n      \"application/edi-x12\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/edifact\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/efi\": {\n        source: \"iana\"\n      },\n      \"application/elm+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/elm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.cap+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/emergencycalldata.comment+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.deviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.ecall.msd\": {\n        source: \"iana\"\n      },\n      \"application/emergencycalldata.legacyesn+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.providerinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.serviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.subscriberinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.veds+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emma+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emma\"]\n      },\n      \"application/emotionml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emotionml\"]\n      },\n      \"application/encaprtp\": {\n        source: \"iana\"\n      },\n      \"application/entity-statement+jwt\": {\n        source: \"iana\"\n      },\n      \"application/epp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/epub+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"epub\"]\n      },\n      \"application/eshop\": {\n        source: \"iana\"\n      },\n      \"application/exi\": {\n        source: \"iana\",\n        extensions: [\"exi\"]\n      },\n      \"application/expect-ct-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/express\": {\n        source: \"iana\",\n        extensions: [\"exp\"]\n      },\n      \"application/fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/fastsoap\": {\n        source: \"iana\"\n      },\n      \"application/fdf\": {\n        source: \"iana\",\n        extensions: [\"fdf\"]\n      },\n      \"application/fdt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fdt\"]\n      },\n      \"application/fhir+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fhir+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fido.trusted-apps+json\": {\n        compressible: true\n      },\n      \"application/fits\": {\n        source: \"iana\"\n      },\n      \"application/flexfec\": {\n        source: \"iana\"\n      },\n      \"application/font-sfnt\": {\n        source: \"iana\"\n      },\n      \"application/font-tdpfr\": {\n        source: \"iana\",\n        extensions: [\"pfr\"]\n      },\n      \"application/font-woff\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/framework-attributes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geo+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"geojson\"]\n      },\n      \"application/geo+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/geopackage+sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/geopose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/gltf-buffer\": {\n        source: \"iana\"\n      },\n      \"application/gml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gml\"]\n      },\n      \"application/gnap-binding-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gpx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"gpx\"]\n      },\n      \"application/grib\": {\n        source: \"iana\"\n      },\n      \"application/gxf\": {\n        source: \"apache\",\n        extensions: [\"gxf\"]\n      },\n      \"application/gzip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gz\"]\n      },\n      \"application/h224\": {\n        source: \"iana\"\n      },\n      \"application/held+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/hjson\": {\n        extensions: [\"hjson\"]\n      },\n      \"application/hl7v2+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/http\": {\n        source: \"iana\"\n      },\n      \"application/hyperstudio\": {\n        source: \"iana\",\n        extensions: [\"stk\"]\n      },\n      \"application/ibe-key-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pkg-reply+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pp-data\": {\n        source: \"iana\"\n      },\n      \"application/iges\": {\n        source: \"iana\"\n      },\n      \"application/im-iscomposing+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/index\": {\n        source: \"iana\"\n      },\n      \"application/index.cmd\": {\n        source: \"iana\"\n      },\n      \"application/index.obj\": {\n        source: \"iana\"\n      },\n      \"application/index.response\": {\n        source: \"iana\"\n      },\n      \"application/index.vnd\": {\n        source: \"iana\"\n      },\n      \"application/inkml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ink\", \"inkml\"]\n      },\n      \"application/iotp\": {\n        source: \"iana\"\n      },\n      \"application/ipfix\": {\n        source: \"iana\",\n        extensions: [\"ipfix\"]\n      },\n      \"application/ipp\": {\n        source: \"iana\"\n      },\n      \"application/isup\": {\n        source: \"iana\"\n      },\n      \"application/its+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"its\"]\n      },\n      \"application/java-archive\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jar\", \"war\", \"ear\"]\n      },\n      \"application/java-serialized-object\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"ser\"]\n      },\n      \"application/java-vm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"class\"]\n      },\n      \"application/javascript\": {\n        source: \"apache\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\"]\n      },\n      \"application/jf2feed+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jose\": {\n        source: \"iana\"\n      },\n      \"application/jose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jrd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscalendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscontact+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"json\", \"map\"]\n      },\n      \"application/json-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json-seq\": {\n        source: \"iana\"\n      },\n      \"application/json5\": {\n        extensions: [\"json5\"]\n      },\n      \"application/jsonml+json\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"jsonml\"]\n      },\n      \"application/jsonpath\": {\n        source: \"iana\"\n      },\n      \"application/jwk+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+jwt\": {\n        source: \"iana\"\n      },\n      \"application/jwt\": {\n        source: \"iana\"\n      },\n      \"application/kpml-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/kpml-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ld+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"jsonld\"]\n      },\n      \"application/lgr+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lgr\"]\n      },\n      \"application/link-format\": {\n        source: \"iana\"\n      },\n      \"application/linkset\": {\n        source: \"iana\"\n      },\n      \"application/linkset+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/load-control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/logout+jwt\": {\n        source: \"iana\"\n      },\n      \"application/lost+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lostxml\"]\n      },\n      \"application/lostsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/lpf+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/lxf\": {\n        source: \"iana\"\n      },\n      \"application/mac-binhex40\": {\n        source: \"iana\",\n        extensions: [\"hqx\"]\n      },\n      \"application/mac-compactpro\": {\n        source: \"apache\",\n        extensions: [\"cpt\"]\n      },\n      \"application/macwriteii\": {\n        source: \"iana\"\n      },\n      \"application/mads+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mads\"]\n      },\n      \"application/manifest+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"webmanifest\"]\n      },\n      \"application/marc\": {\n        source: \"iana\",\n        extensions: [\"mrc\"]\n      },\n      \"application/marcxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mrcx\"]\n      },\n      \"application/mathematica\": {\n        source: \"iana\",\n        extensions: [\"ma\", \"nb\", \"mb\"]\n      },\n      \"application/mathml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mathml\"]\n      },\n      \"application/mathml-content+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mathml-presentation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-associated-procedure-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-deregister+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-envelope+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-protection-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-reception-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-user-service-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbox\": {\n        source: \"iana\",\n        extensions: [\"mbox\"]\n      },\n      \"application/media-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpf\"]\n      },\n      \"application/media_control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mediaservercontrol+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mscml\"]\n      },\n      \"application/merge-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/metalink+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"metalink\"]\n      },\n      \"application/metalink4+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"meta4\"]\n      },\n      \"application/mets+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mets\"]\n      },\n      \"application/mf4\": {\n        source: \"iana\"\n      },\n      \"application/mikey\": {\n        source: \"iana\"\n      },\n      \"application/mipc\": {\n        source: \"iana\"\n      },\n      \"application/missing-blocks+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/mmt-aei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"maei\"]\n      },\n      \"application/mmt-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musd\"]\n      },\n      \"application/mods+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mods\"]\n      },\n      \"application/moss-keys\": {\n        source: \"iana\"\n      },\n      \"application/moss-signature\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-data\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-request\": {\n        source: \"iana\"\n      },\n      \"application/mp21\": {\n        source: \"iana\",\n        extensions: [\"m21\", \"mp21\"]\n      },\n      \"application/mp4\": {\n        source: \"iana\",\n        extensions: [\"mp4\", \"mpg4\", \"mp4s\", \"m4p\"]\n      },\n      \"application/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod-xmt\": {\n        source: \"iana\"\n      },\n      \"application/mrb-consumer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mrb-publish+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/msc-ivr+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msc-mixer+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msix\": {\n        compressible: false,\n        extensions: [\"msix\"]\n      },\n      \"application/msixbundle\": {\n        compressible: false,\n        extensions: [\"msixbundle\"]\n      },\n      \"application/msword\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"doc\", \"dot\"]\n      },\n      \"application/mud+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/multipart-core\": {\n        source: \"iana\"\n      },\n      \"application/mxf\": {\n        source: \"iana\",\n        extensions: [\"mxf\"]\n      },\n      \"application/n-quads\": {\n        source: \"iana\",\n        extensions: [\"nq\"]\n      },\n      \"application/n-triples\": {\n        source: \"iana\",\n        extensions: [\"nt\"]\n      },\n      \"application/nasdata\": {\n        source: \"iana\"\n      },\n      \"application/news-checkgroups\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-groupinfo\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-transmission\": {\n        source: \"iana\"\n      },\n      \"application/nlsml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/node\": {\n        source: \"iana\",\n        extensions: [\"cjs\"]\n      },\n      \"application/nss\": {\n        source: \"iana\"\n      },\n      \"application/oauth-authz-req+jwt\": {\n        source: \"iana\"\n      },\n      \"application/oblivious-dns-message\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-request\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-response\": {\n        source: \"iana\"\n      },\n      \"application/octet-stream\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bin\", \"dms\", \"lrf\", \"mar\", \"so\", \"dist\", \"distz\", \"pkg\", \"bpk\", \"dump\", \"elc\", \"deploy\", \"exe\", \"dll\", \"deb\", \"dmg\", \"iso\", \"img\", \"msi\", \"msp\", \"msm\", \"buffer\"]\n      },\n      \"application/oda\": {\n        source: \"iana\",\n        extensions: [\"oda\"]\n      },\n      \"application/odm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/odx\": {\n        source: \"iana\"\n      },\n      \"application/oebps-package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"opf\"]\n      },\n      \"application/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogx\"]\n      },\n      \"application/ohttp-keys\": {\n        source: \"iana\"\n      },\n      \"application/omdoc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"omdoc\"]\n      },\n      \"application/onenote\": {\n        source: \"apache\",\n        extensions: [\"onetoc\", \"onetoc2\", \"onetmp\", \"onepkg\", \"one\", \"onea\"]\n      },\n      \"application/opc-nodeset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/oscore\": {\n        source: \"iana\"\n      },\n      \"application/oxps\": {\n        source: \"iana\",\n        extensions: [\"oxps\"]\n      },\n      \"application/p21\": {\n        source: \"iana\"\n      },\n      \"application/p21+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/p2p-overlay+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"relo\"]\n      },\n      \"application/parityfec\": {\n        source: \"iana\"\n      },\n      \"application/passport\": {\n        source: \"iana\"\n      },\n      \"application/patch-ops-error+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xer\"]\n      },\n      \"application/pdf\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pdf\"]\n      },\n      \"application/pdx\": {\n        source: \"iana\"\n      },\n      \"application/pem-certificate-chain\": {\n        source: \"iana\"\n      },\n      \"application/pgp-encrypted\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pgp\"]\n      },\n      \"application/pgp-keys\": {\n        source: \"iana\",\n        extensions: [\"asc\"]\n      },\n      \"application/pgp-signature\": {\n        source: \"iana\",\n        extensions: [\"sig\", \"asc\"]\n      },\n      \"application/pics-rules\": {\n        source: \"apache\",\n        extensions: [\"prf\"]\n      },\n      \"application/pidf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pidf-diff+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pkcs10\": {\n        source: \"iana\",\n        extensions: [\"p10\"]\n      },\n      \"application/pkcs12\": {\n        source: \"iana\"\n      },\n      \"application/pkcs7-mime\": {\n        source: \"iana\",\n        extensions: [\"p7m\", \"p7c\"]\n      },\n      \"application/pkcs7-signature\": {\n        source: \"iana\",\n        extensions: [\"p7s\"]\n      },\n      \"application/pkcs8\": {\n        source: \"iana\",\n        extensions: [\"p8\"]\n      },\n      \"application/pkcs8-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/pkix-attr-cert\": {\n        source: \"iana\",\n        extensions: [\"ac\"]\n      },\n      \"application/pkix-cert\": {\n        source: \"iana\",\n        extensions: [\"cer\"]\n      },\n      \"application/pkix-crl\": {\n        source: \"iana\",\n        extensions: [\"crl\"]\n      },\n      \"application/pkix-pkipath\": {\n        source: \"iana\",\n        extensions: [\"pkipath\"]\n      },\n      \"application/pkixcmp\": {\n        source: \"iana\",\n        extensions: [\"pki\"]\n      },\n      \"application/pls+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pls\"]\n      },\n      \"application/poc-settings+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/postscript\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ai\", \"eps\", \"ps\"]\n      },\n      \"application/ppsp-tracker+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/private-token-issuer-directory\": {\n        source: \"iana\"\n      },\n      \"application/private-token-request\": {\n        source: \"iana\"\n      },\n      \"application/private-token-response\": {\n        source: \"iana\"\n      },\n      \"application/problem+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/problem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/provenance+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"provx\"]\n      },\n      \"application/provided-claims+jwt\": {\n        source: \"iana\"\n      },\n      \"application/prs.alvestrand.titrax-sheet\": {\n        source: \"iana\"\n      },\n      \"application/prs.cww\": {\n        source: \"iana\",\n        extensions: [\"cww\"]\n      },\n      \"application/prs.cyn\": {\n        source: \"iana\",\n        charset: \"7-BIT\"\n      },\n      \"application/prs.hpub+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/prs.implied-document+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-executable\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-object+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+yaml\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-structure\": {\n        source: \"iana\"\n      },\n      \"application/prs.mayfile\": {\n        source: \"iana\"\n      },\n      \"application/prs.nprend\": {\n        source: \"iana\"\n      },\n      \"application/prs.plucker\": {\n        source: \"iana\"\n      },\n      \"application/prs.rdf-xml-crypt\": {\n        source: \"iana\"\n      },\n      \"application/prs.vcfbzip2\": {\n        source: \"iana\"\n      },\n      \"application/prs.xsf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsf\"]\n      },\n      \"application/pskc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pskcxml\"]\n      },\n      \"application/pvd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/qsig\": {\n        source: \"iana\"\n      },\n      \"application/raml+yaml\": {\n        compressible: true,\n        extensions: [\"raml\"]\n      },\n      \"application/raptorfec\": {\n        source: \"iana\"\n      },\n      \"application/rdap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rdf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rdf\", \"owl\"]\n      },\n      \"application/reginfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rif\"]\n      },\n      \"application/relax-ng-compact-syntax\": {\n        source: \"iana\",\n        extensions: [\"rnc\"]\n      },\n      \"application/remote-printing\": {\n        source: \"apache\"\n      },\n      \"application/reputon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/resolve-response+jwt\": {\n        source: \"iana\"\n      },\n      \"application/resource-lists+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rl\"]\n      },\n      \"application/resource-lists-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rld\"]\n      },\n      \"application/rfc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/riscos\": {\n        source: \"iana\"\n      },\n      \"application/rlmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rls-services+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rs\"]\n      },\n      \"application/route-apd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rapd\"]\n      },\n      \"application/route-s-tsid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sls\"]\n      },\n      \"application/route-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rusd\"]\n      },\n      \"application/rpki-checklist\": {\n        source: \"iana\"\n      },\n      \"application/rpki-ghostbusters\": {\n        source: \"iana\",\n        extensions: [\"gbr\"]\n      },\n      \"application/rpki-manifest\": {\n        source: \"iana\",\n        extensions: [\"mft\"]\n      },\n      \"application/rpki-publication\": {\n        source: \"iana\"\n      },\n      \"application/rpki-roa\": {\n        source: \"iana\",\n        extensions: [\"roa\"]\n      },\n      \"application/rpki-signed-tal\": {\n        source: \"iana\"\n      },\n      \"application/rpki-updown\": {\n        source: \"iana\"\n      },\n      \"application/rsd+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rsd\"]\n      },\n      \"application/rss+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rss\"]\n      },\n      \"application/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"application/rtploopback\": {\n        source: \"iana\"\n      },\n      \"application/rtx\": {\n        source: \"iana\"\n      },\n      \"application/samlassertion+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/samlmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif-external-properties+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sbe\": {\n        source: \"iana\"\n      },\n      \"application/sbml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sbml\"]\n      },\n      \"application/scaip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scim+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scvp-cv-request\": {\n        source: \"iana\",\n        extensions: [\"scq\"]\n      },\n      \"application/scvp-cv-response\": {\n        source: \"iana\",\n        extensions: [\"scs\"]\n      },\n      \"application/scvp-vp-request\": {\n        source: \"iana\",\n        extensions: [\"spq\"]\n      },\n      \"application/scvp-vp-response\": {\n        source: \"iana\",\n        extensions: [\"spp\"]\n      },\n      \"application/sdp\": {\n        source: \"iana\",\n        extensions: [\"sdp\"]\n      },\n      \"application/secevent+jwt\": {\n        source: \"iana\"\n      },\n      \"application/senml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"senmlx\"]\n      },\n      \"application/senml-etch+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml-etch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sensml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/sensml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sensml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sensmlx\"]\n      },\n      \"application/sensml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sep+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sep-exi\": {\n        source: \"iana\"\n      },\n      \"application/session-info\": {\n        source: \"iana\"\n      },\n      \"application/set-payment\": {\n        source: \"iana\"\n      },\n      \"application/set-payment-initiation\": {\n        source: \"iana\",\n        extensions: [\"setpay\"]\n      },\n      \"application/set-registration\": {\n        source: \"iana\"\n      },\n      \"application/set-registration-initiation\": {\n        source: \"iana\",\n        extensions: [\"setreg\"]\n      },\n      \"application/sgml\": {\n        source: \"iana\"\n      },\n      \"application/sgml-open-catalog\": {\n        source: \"iana\"\n      },\n      \"application/shf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"shf\"]\n      },\n      \"application/sieve\": {\n        source: \"iana\",\n        extensions: [\"siv\", \"sieve\"]\n      },\n      \"application/simple-filter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/simple-message-summary\": {\n        source: \"iana\"\n      },\n      \"application/simplesymbolcontainer\": {\n        source: \"iana\"\n      },\n      \"application/sipc\": {\n        source: \"iana\"\n      },\n      \"application/slate\": {\n        source: \"iana\"\n      },\n      \"application/smil\": {\n        source: \"apache\"\n      },\n      \"application/smil+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"smi\", \"smil\"]\n      },\n      \"application/smpte336m\": {\n        source: \"iana\"\n      },\n      \"application/soap+fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/soap+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sparql-query\": {\n        source: \"iana\",\n        extensions: [\"rq\"]\n      },\n      \"application/sparql-results+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"srx\"]\n      },\n      \"application/spdx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/spirits-event+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sql\": {\n        source: \"iana\",\n        extensions: [\"sql\"]\n      },\n      \"application/srgs\": {\n        source: \"iana\",\n        extensions: [\"gram\"]\n      },\n      \"application/srgs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"grxml\"]\n      },\n      \"application/sru+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sru\"]\n      },\n      \"application/ssdl+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ssdl\"]\n      },\n      \"application/sslkeylogfile\": {\n        source: \"iana\"\n      },\n      \"application/ssml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ssml\"]\n      },\n      \"application/st2110-41\": {\n        source: \"iana\"\n      },\n      \"application/stix+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/stratum\": {\n        source: \"iana\"\n      },\n      \"application/swid+cbor\": {\n        source: \"iana\"\n      },\n      \"application/swid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"swidtag\"]\n      },\n      \"application/tamp-apex-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-apex-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-error\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-query\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-response\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tar\": {\n        compressible: true\n      },\n      \"application/taxii+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/td+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tei\", \"teicorpus\"]\n      },\n      \"application/tetra_isi\": {\n        source: \"iana\"\n      },\n      \"application/thraud+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tfi\"]\n      },\n      \"application/timestamp-query\": {\n        source: \"iana\"\n      },\n      \"application/timestamp-reply\": {\n        source: \"iana\"\n      },\n      \"application/timestamped-data\": {\n        source: \"iana\",\n        extensions: [\"tsd\"]\n      },\n      \"application/tlsrpt+gzip\": {\n        source: \"iana\"\n      },\n      \"application/tlsrpt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tnauthlist\": {\n        source: \"iana\"\n      },\n      \"application/toc+cbor\": {\n        source: \"iana\"\n      },\n      \"application/token-introspection+jwt\": {\n        source: \"iana\"\n      },\n      \"application/toml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"toml\"]\n      },\n      \"application/trickle-ice-sdpfrag\": {\n        source: \"iana\"\n      },\n      \"application/trig\": {\n        source: \"iana\",\n        extensions: [\"trig\"]\n      },\n      \"application/trust-chain+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/trust-mark+jwt\": {\n        source: \"iana\"\n      },\n      \"application/trust-mark-delegation+jwt\": {\n        source: \"iana\"\n      },\n      \"application/ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttml\"]\n      },\n      \"application/tve-trigger\": {\n        source: \"iana\"\n      },\n      \"application/tzif\": {\n        source: \"iana\"\n      },\n      \"application/tzif-leap\": {\n        source: \"iana\"\n      },\n      \"application/ubjson\": {\n        compressible: false,\n        extensions: [\"ubj\"]\n      },\n      \"application/uccs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ujcs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ulpfec\": {\n        source: \"iana\"\n      },\n      \"application/urc-grpsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/urc-ressheet+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsheet\"]\n      },\n      \"application/urc-targetdesc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"td\"]\n      },\n      \"application/urc-uisocketdesc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vc\": {\n        source: \"iana\"\n      },\n      \"application/vc+cose\": {\n        source: \"iana\"\n      },\n      \"application/vc+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vcard+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vcard+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vemmi\": {\n        source: \"iana\"\n      },\n      \"application/vividence.scriptfile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.1000minds.decision-model+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"1km\"]\n      },\n      \"application/vnd.1ob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp-prose+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3a+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ach+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc8+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-v2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gnas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.access-transfer-events+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.bsf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.crs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.current-location-discovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gmop+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gtpc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.interworking-data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.lpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mc-signalling-ear\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-payload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-signalling\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-floor-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-signed+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-init-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-transmission-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mid-call+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ngap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pfcp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pic-bw-large\": {\n        source: \"iana\",\n        extensions: [\"plb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-small\": {\n        source: \"iana\",\n        extensions: [\"psb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-var\": {\n        source: \"iana\",\n        extensions: [\"pvb\"]\n      },\n      \"application/vnd.3gpp.pinapp-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.s1ap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.seal-group-doc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-network-qos-management-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-ue-config-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-unicast-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-user-profile-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.sms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-ext+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.state-and-event-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ussd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.v2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.vae-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.bcmcsinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp2.tcap\": {\n        source: \"iana\",\n        extensions: [\"tcap\"]\n      },\n      \"application/vnd.3lightssoftware.imagescal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3m.post-it-notes\": {\n        source: \"iana\",\n        extensions: [\"pwn\"]\n      },\n      \"application/vnd.accpac.simply.aso\": {\n        source: \"iana\",\n        extensions: [\"aso\"]\n      },\n      \"application/vnd.accpac.simply.imp\": {\n        source: \"iana\",\n        extensions: [\"imp\"]\n      },\n      \"application/vnd.acm.addressxfer+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acm.chatbot+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acucobol\": {\n        source: \"iana\",\n        extensions: [\"acu\"]\n      },\n      \"application/vnd.acucorp\": {\n        source: \"iana\",\n        extensions: [\"atc\", \"acutc\"]\n      },\n      \"application/vnd.adobe.air-application-installer-package+zip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"air\"]\n      },\n      \"application/vnd.adobe.flash.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.formscentral.fcdt\": {\n        source: \"iana\",\n        extensions: [\"fcdt\"]\n      },\n      \"application/vnd.adobe.fxp\": {\n        source: \"iana\",\n        extensions: [\"fxp\", \"fxpl\"]\n      },\n      \"application/vnd.adobe.partial-upload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.xdp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdp\"]\n      },\n      \"application/vnd.adobe.xfdf\": {\n        source: \"apache\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/vnd.aether.imp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata-pagedef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.cmoca-cmresource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-charset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codedfont\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codepage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-cmtable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-formdef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-mediummap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-objectcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-overlay\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-pagesegment\": {\n        source: \"iana\"\n      },\n      \"application/vnd.age\": {\n        source: \"iana\",\n        extensions: [\"age\"]\n      },\n      \"application/vnd.ah-barcode\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ahead.space\": {\n        source: \"iana\",\n        extensions: [\"ahead\"]\n      },\n      \"application/vnd.airzip.filesecure.azf\": {\n        source: \"iana\",\n        extensions: [\"azf\"]\n      },\n      \"application/vnd.airzip.filesecure.azs\": {\n        source: \"iana\",\n        extensions: [\"azs\"]\n      },\n      \"application/vnd.amadeus+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.amazon.ebook\": {\n        source: \"apache\",\n        extensions: [\"azw\"]\n      },\n      \"application/vnd.amazon.mobi8-ebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.americandynamics.acc\": {\n        source: \"iana\",\n        extensions: [\"acc\"]\n      },\n      \"application/vnd.amiga.ami\": {\n        source: \"iana\",\n        extensions: [\"ami\"]\n      },\n      \"application/vnd.amundsen.maze+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.android.ota\": {\n        source: \"iana\"\n      },\n      \"application/vnd.android.package-archive\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"apk\"]\n      },\n      \"application/vnd.anki\": {\n        source: \"iana\"\n      },\n      \"application/vnd.anser-web-certificate-issue-initiation\": {\n        source: \"iana\",\n        extensions: [\"cii\"]\n      },\n      \"application/vnd.anser-web-funds-transfer-initiation\": {\n        source: \"apache\",\n        extensions: [\"fti\"]\n      },\n      \"application/vnd.antix.game-component\": {\n        source: \"iana\",\n        extensions: [\"atx\"]\n      },\n      \"application/vnd.apache.arrow.file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.arrow.stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.parquet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.compact\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apexlang\": {\n        source: \"iana\"\n      },\n      \"application/vnd.api+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.aplextor.warrp+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apothekende.reservation+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apple.installer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpkg\"]\n      },\n      \"application/vnd.apple.keynote\": {\n        source: \"iana\",\n        extensions: [\"key\"]\n      },\n      \"application/vnd.apple.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"m3u8\"]\n      },\n      \"application/vnd.apple.numbers\": {\n        source: \"iana\",\n        extensions: [\"numbers\"]\n      },\n      \"application/vnd.apple.pages\": {\n        source: \"iana\",\n        extensions: [\"pages\"]\n      },\n      \"application/vnd.apple.pkpass\": {\n        compressible: false,\n        extensions: [\"pkpass\"]\n      },\n      \"application/vnd.arastra.swi\": {\n        source: \"apache\"\n      },\n      \"application/vnd.aristanetworks.swi\": {\n        source: \"iana\",\n        extensions: [\"swi\"]\n      },\n      \"application/vnd.artisan+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.artsquare\": {\n        source: \"iana\"\n      },\n      \"application/vnd.astraea-software.iota\": {\n        source: \"iana\",\n        extensions: [\"iota\"]\n      },\n      \"application/vnd.audiograph\": {\n        source: \"iana\",\n        extensions: [\"aep\"]\n      },\n      \"application/vnd.autodesk.fbx\": {\n        extensions: [\"fbx\"]\n      },\n      \"application/vnd.autopackage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.avalon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.avistar+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.balsamiq.bmml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmml\"]\n      },\n      \"application/vnd.balsamiq.bmpr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.banana-accounting\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.error\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bekitzur-stech+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.belightsoft.lhzd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.belightsoft.lhzl+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.bint.med-content\": {\n        source: \"iana\"\n      },\n      \"application/vnd.biopax.rdf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.blink-idb-value-wrapper\": {\n        source: \"iana\"\n      },\n      \"application/vnd.blueice.multipass\": {\n        source: \"iana\",\n        extensions: [\"mpm\"]\n      },\n      \"application/vnd.bluetooth.ep.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bluetooth.le.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bmi\": {\n        source: \"iana\",\n        extensions: [\"bmi\"]\n      },\n      \"application/vnd.bpf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bpf3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.businessobjects\": {\n        source: \"iana\",\n        extensions: [\"rep\"]\n      },\n      \"application/vnd.byu.uapi+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bzip3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.c3voc.schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cab-jscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-cpdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-lips\": {\n        source: \"iana\"\n      },\n      \"application/vnd.capasystems-pg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cendio.thinlinc.clientconf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.century-systems.tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chemdraw+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdxml\"]\n      },\n      \"application/vnd.chess-pgn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chipnuts.karaoke-mmd\": {\n        source: \"iana\",\n        extensions: [\"mmd\"]\n      },\n      \"application/vnd.ciedi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cinderella\": {\n        source: \"iana\",\n        extensions: [\"cdy\"]\n      },\n      \"application/vnd.cirpack.isdn-ext\": {\n        source: \"iana\"\n      },\n      \"application/vnd.citationstyles.style+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csl\"]\n      },\n      \"application/vnd.claymore\": {\n        source: \"iana\",\n        extensions: [\"cla\"]\n      },\n      \"application/vnd.cloanto.rp9\": {\n        source: \"iana\",\n        extensions: [\"rp9\"]\n      },\n      \"application/vnd.clonk.c4group\": {\n        source: \"iana\",\n        extensions: [\"c4g\", \"c4d\", \"c4f\", \"c4p\", \"c4u\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config\": {\n        source: \"iana\",\n        extensions: [\"c11amc\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config-pkg\": {\n        source: \"iana\",\n        extensions: [\"c11amz\"]\n      },\n      \"application/vnd.cncf.helm.chart.content.v1.tar+gzip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.chart.provenance.v1.prov\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.config.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.coffeescript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collection+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.doc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.next+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.comicbook+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.comicbook-rar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commerce-battelle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commonspace\": {\n        source: \"iana\",\n        extensions: [\"csp\"]\n      },\n      \"application/vnd.contact.cmsg\": {\n        source: \"iana\",\n        extensions: [\"cdbcmsg\"]\n      },\n      \"application/vnd.coreos.ignition+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cosmocaller\": {\n        source: \"iana\",\n        extensions: [\"cmc\"]\n      },\n      \"application/vnd.crick.clicker\": {\n        source: \"iana\",\n        extensions: [\"clkx\"]\n      },\n      \"application/vnd.crick.clicker.keyboard\": {\n        source: \"iana\",\n        extensions: [\"clkk\"]\n      },\n      \"application/vnd.crick.clicker.palette\": {\n        source: \"iana\",\n        extensions: [\"clkp\"]\n      },\n      \"application/vnd.crick.clicker.template\": {\n        source: \"iana\",\n        extensions: [\"clkt\"]\n      },\n      \"application/vnd.crick.clicker.wordbank\": {\n        source: \"iana\",\n        extensions: [\"clkw\"]\n      },\n      \"application/vnd.criticaltools.wbs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wbs\"]\n      },\n      \"application/vnd.cryptii.pipe+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.crypto-shade-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.vault\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ctc-posml\": {\n        source: \"iana\",\n        extensions: [\"pml\"]\n      },\n      \"application/vnd.ctct.ws+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cups-pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-postscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-ppd\": {\n        source: \"iana\",\n        extensions: [\"ppd\"]\n      },\n      \"application/vnd.cups-raster\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl.car\": {\n        source: \"apache\",\n        extensions: [\"car\"]\n      },\n      \"application/vnd.curl.pcurl\": {\n        source: \"apache\",\n        extensions: [\"pcurl\"]\n      },\n      \"application/vnd.cyan.dean.root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cybank\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cyclonedx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cyclonedx+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.d2l.coursepackage1p0+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.d3m-dataset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.d3m-problem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dart\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dart\"]\n      },\n      \"application/vnd.data-vision.rdz\": {\n        source: \"iana\",\n        extensions: [\"rdz\"]\n      },\n      \"application/vnd.datalog\": {\n        source: \"iana\"\n      },\n      \"application/vnd.datapackage+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dataresource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dbf\": {\n        source: \"iana\",\n        extensions: [\"dbf\"]\n      },\n      \"application/vnd.dcmp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dcmp\"]\n      },\n      \"application/vnd.debian.binary-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dece.data\": {\n        source: \"iana\",\n        extensions: [\"uvf\", \"uvvf\", \"uvd\", \"uvvd\"]\n      },\n      \"application/vnd.dece.ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uvt\", \"uvvt\"]\n      },\n      \"application/vnd.dece.unspecified\": {\n        source: \"iana\",\n        extensions: [\"uvx\", \"uvvx\"]\n      },\n      \"application/vnd.dece.zip\": {\n        source: \"iana\",\n        extensions: [\"uvz\", \"uvvz\"]\n      },\n      \"application/vnd.denovo.fcselayout-link\": {\n        source: \"iana\",\n        extensions: [\"fe_launch\"]\n      },\n      \"application/vnd.desmume.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dir-bi.plate-dl-nosuffix\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dm.delegation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dna\": {\n        source: \"iana\",\n        extensions: [\"dna\"]\n      },\n      \"application/vnd.document+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dolby.mlp\": {\n        source: \"apache\",\n        extensions: [\"mlp\"]\n      },\n      \"application/vnd.dolby.mobile.1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dolby.mobile.2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.doremir.scorecloud-binary-document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dpgraph\": {\n        source: \"iana\",\n        extensions: [\"dpg\"]\n      },\n      \"application/vnd.dreamfactory\": {\n        source: \"iana\",\n        extensions: [\"dfac\"]\n      },\n      \"application/vnd.drive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ds-keypoint\": {\n        source: \"apache\",\n        extensions: [\"kpxx\"]\n      },\n      \"application/vnd.dtg.local\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.flash\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ait\": {\n        source: \"iana\",\n        extensions: [\"ait\"]\n      },\n      \"application/vnd.dvb.dvbisl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.dvbj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.esgcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcdftnotifaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgpdd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcroaming\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-enhancement\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.notif-aggregate-root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-container+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-generic+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-msglist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-init+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.pfr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.service\": {\n        source: \"iana\",\n        extensions: [\"svc\"]\n      },\n      \"application/vnd.dxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dynageo\": {\n        source: \"iana\",\n        extensions: [\"geo\"]\n      },\n      \"application/vnd.dzr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.easykaraoke.cdgdownload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecdis-update\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecip.rlp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eclipse.ditto+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ecowin.chart\": {\n        source: \"iana\",\n        extensions: [\"mag\"]\n      },\n      \"application/vnd.ecowin.filerequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.fileupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.series\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesrequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.img\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.iso\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eln+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.emclient.accessrequest+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.enliven\": {\n        source: \"iana\",\n        extensions: [\"nml\"]\n      },\n      \"application/vnd.enphase.envoy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eprints.data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.epson.esf\": {\n        source: \"iana\",\n        extensions: [\"esf\"]\n      },\n      \"application/vnd.epson.msf\": {\n        source: \"iana\",\n        extensions: [\"msf\"]\n      },\n      \"application/vnd.epson.quickanime\": {\n        source: \"iana\",\n        extensions: [\"qam\"]\n      },\n      \"application/vnd.epson.salt\": {\n        source: \"iana\",\n        extensions: [\"slt\"]\n      },\n      \"application/vnd.epson.ssf\": {\n        source: \"iana\",\n        extensions: [\"ssf\"]\n      },\n      \"application/vnd.ericsson.quickcall\": {\n        source: \"iana\"\n      },\n      \"application/vnd.erofs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.espass-espass+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.eszigno3+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"es3\", \"et3\"]\n      },\n      \"application/vnd.etsi.aoc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.asic-e+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.asic-s+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.cug+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvcommand+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-bc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-cod+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-npvr+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvservice+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mcid+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mheg5\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.overload-control-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.pstn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.sci+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.simservs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.timestamp-token\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.tsl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.tsl.der\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eu.kasparian.car+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.eudora.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.profile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.settings\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.theme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.exstream-empower+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.exstream-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ezpix-album\": {\n        source: \"iana\",\n        extensions: [\"ez2\"]\n      },\n      \"application/vnd.ezpix-package\": {\n        source: \"iana\",\n        extensions: [\"ez3\"]\n      },\n      \"application/vnd.f-secure.mobile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.familysearch.gedcom+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.fastcopy-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fdf\": {\n        source: \"apache\",\n        extensions: [\"fdf\"]\n      },\n      \"application/vnd.fdsn.mseed\": {\n        source: \"iana\",\n        extensions: [\"mseed\"]\n      },\n      \"application/vnd.fdsn.seed\": {\n        source: \"iana\",\n        extensions: [\"seed\", \"dataless\"]\n      },\n      \"application/vnd.fdsn.stationxml+xml\": {\n        source: \"iana\",\n        charset: \"XML-BASED\",\n        compressible: true\n      },\n      \"application/vnd.ffsns\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ficlab.flb+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.filmit.zfc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fints\": {\n        source: \"iana\"\n      },\n      \"application/vnd.firemonkeys.cloudcell\": {\n        source: \"iana\"\n      },\n      \"application/vnd.flographit\": {\n        source: \"iana\",\n        extensions: [\"gph\"]\n      },\n      \"application/vnd.fluxtime.clip\": {\n        source: \"iana\",\n        extensions: [\"ftc\"]\n      },\n      \"application/vnd.font-fontforge-sfd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.framemaker\": {\n        source: \"iana\",\n        extensions: [\"fm\", \"frame\", \"maker\", \"book\"]\n      },\n      \"application/vnd.freelog.comic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.frogans.fnc\": {\n        source: \"apache\",\n        extensions: [\"fnc\"]\n      },\n      \"application/vnd.frogans.ltf\": {\n        source: \"apache\",\n        extensions: [\"ltf\"]\n      },\n      \"application/vnd.fsc.weblaunch\": {\n        source: \"iana\",\n        extensions: [\"fsc\"]\n      },\n      \"application/vnd.fujifilm.fb.docuworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.binder\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.jfi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fujitsu.oasys\": {\n        source: \"iana\",\n        extensions: [\"oas\"]\n      },\n      \"application/vnd.fujitsu.oasys2\": {\n        source: \"iana\",\n        extensions: [\"oa2\"]\n      },\n      \"application/vnd.fujitsu.oasys3\": {\n        source: \"iana\",\n        extensions: [\"oa3\"]\n      },\n      \"application/vnd.fujitsu.oasysgp\": {\n        source: \"iana\",\n        extensions: [\"fg5\"]\n      },\n      \"application/vnd.fujitsu.oasysprs\": {\n        source: \"iana\",\n        extensions: [\"bh2\"]\n      },\n      \"application/vnd.fujixerox.art-ex\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.art4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.ddd\": {\n        source: \"iana\",\n        extensions: [\"ddd\"]\n      },\n      \"application/vnd.fujixerox.docuworks\": {\n        source: \"iana\",\n        extensions: [\"xdw\"]\n      },\n      \"application/vnd.fujixerox.docuworks.binder\": {\n        source: \"iana\",\n        extensions: [\"xbd\"]\n      },\n      \"application/vnd.fujixerox.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.hbpl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fut-misnet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fuzzysheet\": {\n        source: \"iana\",\n        extensions: [\"fzs\"]\n      },\n      \"application/vnd.ga4gh.passport+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.genomatix.tuxedo\": {\n        source: \"iana\",\n        extensions: [\"txd\"]\n      },\n      \"application/vnd.genozip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentics.grd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.catmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.ebuild\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.eclass\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.gpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.manifest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.pkgmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.xpak\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geo+json\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geocube+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geogebra.file\": {\n        source: \"iana\",\n        extensions: [\"ggb\"]\n      },\n      \"application/vnd.geogebra.pinboard\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geogebra.slides\": {\n        source: \"iana\",\n        extensions: [\"ggs\"]\n      },\n      \"application/vnd.geogebra.tool\": {\n        source: \"iana\",\n        extensions: [\"ggt\"]\n      },\n      \"application/vnd.geometry-explorer\": {\n        source: \"iana\",\n        extensions: [\"gex\", \"gre\"]\n      },\n      \"application/vnd.geonext\": {\n        source: \"iana\",\n        extensions: [\"gxt\"]\n      },\n      \"application/vnd.geoplan\": {\n        source: \"iana\",\n        extensions: [\"g2w\"]\n      },\n      \"application/vnd.geospace\": {\n        source: \"iana\",\n        extensions: [\"g3w\"]\n      },\n      \"application/vnd.gerber\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gmx\": {\n        source: \"iana\",\n        extensions: [\"gmx\"]\n      },\n      \"application/vnd.gnu.taler.exchange+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gnu.taler.merchant+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.google-apps.audio\": {},\n      \"application/vnd.google-apps.document\": {\n        compressible: false,\n        extensions: [\"gdoc\"]\n      },\n      \"application/vnd.google-apps.drawing\": {\n        compressible: false,\n        extensions: [\"gdraw\"]\n      },\n      \"application/vnd.google-apps.drive-sdk\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.file\": {},\n      \"application/vnd.google-apps.folder\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.form\": {\n        compressible: false,\n        extensions: [\"gform\"]\n      },\n      \"application/vnd.google-apps.fusiontable\": {},\n      \"application/vnd.google-apps.jam\": {\n        compressible: false,\n        extensions: [\"gjam\"]\n      },\n      \"application/vnd.google-apps.mail-layout\": {},\n      \"application/vnd.google-apps.map\": {\n        compressible: false,\n        extensions: [\"gmap\"]\n      },\n      \"application/vnd.google-apps.photo\": {},\n      \"application/vnd.google-apps.presentation\": {\n        compressible: false,\n        extensions: [\"gslides\"]\n      },\n      \"application/vnd.google-apps.script\": {\n        compressible: false,\n        extensions: [\"gscript\"]\n      },\n      \"application/vnd.google-apps.shortcut\": {},\n      \"application/vnd.google-apps.site\": {\n        compressible: false,\n        extensions: [\"gsite\"]\n      },\n      \"application/vnd.google-apps.spreadsheet\": {\n        compressible: false,\n        extensions: [\"gsheet\"]\n      },\n      \"application/vnd.google-apps.unknown\": {},\n      \"application/vnd.google-apps.video\": {},\n      \"application/vnd.google-earth.kml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"kml\"]\n      },\n      \"application/vnd.google-earth.kmz\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"kmz\"]\n      },\n      \"application/vnd.gov.sk.e-form+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.gov.sk.e-form+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.gov.sk.xmldatacontainer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdcf\"]\n      },\n      \"application/vnd.gpxsee.map+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.grafeq\": {\n        source: \"iana\",\n        extensions: [\"gqf\", \"gqs\"]\n      },\n      \"application/vnd.gridmp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.groove-account\": {\n        source: \"iana\",\n        extensions: [\"gac\"]\n      },\n      \"application/vnd.groove-help\": {\n        source: \"iana\",\n        extensions: [\"ghf\"]\n      },\n      \"application/vnd.groove-identity-message\": {\n        source: \"iana\",\n        extensions: [\"gim\"]\n      },\n      \"application/vnd.groove-injector\": {\n        source: \"iana\",\n        extensions: [\"grv\"]\n      },\n      \"application/vnd.groove-tool-message\": {\n        source: \"iana\",\n        extensions: [\"gtm\"]\n      },\n      \"application/vnd.groove-tool-template\": {\n        source: \"iana\",\n        extensions: [\"tpl\"]\n      },\n      \"application/vnd.groove-vcard\": {\n        source: \"iana\",\n        extensions: [\"vcg\"]\n      },\n      \"application/vnd.hal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hal+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"hal\"]\n      },\n      \"application/vnd.handheld-entertainment+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zmm\"]\n      },\n      \"application/vnd.hbci\": {\n        source: \"iana\",\n        extensions: [\"hbci\"]\n      },\n      \"application/vnd.hc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hcl-bireports\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hdt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.heroku+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hhe.lesson-player\": {\n        source: \"iana\",\n        extensions: [\"les\"]\n      },\n      \"application/vnd.hp-hpgl\": {\n        source: \"iana\",\n        extensions: [\"hpgl\"]\n      },\n      \"application/vnd.hp-hpid\": {\n        source: \"iana\",\n        extensions: [\"hpid\"]\n      },\n      \"application/vnd.hp-hps\": {\n        source: \"iana\",\n        extensions: [\"hps\"]\n      },\n      \"application/vnd.hp-jlyt\": {\n        source: \"iana\",\n        extensions: [\"jlt\"]\n      },\n      \"application/vnd.hp-pcl\": {\n        source: \"iana\",\n        extensions: [\"pcl\"]\n      },\n      \"application/vnd.hp-pclxl\": {\n        source: \"iana\",\n        extensions: [\"pclxl\"]\n      },\n      \"application/vnd.hsl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.httphone\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hydrostatix.sof-data\": {\n        source: \"iana\",\n        extensions: [\"sfd-hdstx\"]\n      },\n      \"application/vnd.hyper+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyper-item+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyperdrive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hzn-3d-crossword\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.afplinedata\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ibm.electronic-media\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.minipay\": {\n        source: \"iana\",\n        extensions: [\"mpy\"]\n      },\n      \"application/vnd.ibm.modcap\": {\n        source: \"apache\",\n        extensions: [\"afp\", \"listafp\", \"list3820\"]\n      },\n      \"application/vnd.ibm.rights-management\": {\n        source: \"iana\",\n        extensions: [\"irm\"]\n      },\n      \"application/vnd.ibm.secure-container\": {\n        source: \"iana\",\n        extensions: [\"sc\"]\n      },\n      \"application/vnd.iccprofile\": {\n        source: \"iana\",\n        extensions: [\"icc\", \"icm\"]\n      },\n      \"application/vnd.ieee.1905\": {\n        source: \"iana\"\n      },\n      \"application/vnd.igloader\": {\n        source: \"iana\",\n        extensions: [\"igl\"]\n      },\n      \"application/vnd.imagemeter.folder+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.imagemeter.image+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.immervision-ivp\": {\n        source: \"iana\",\n        extensions: [\"ivp\"]\n      },\n      \"application/vnd.immervision-ivu\": {\n        source: \"iana\",\n        extensions: [\"ivu\"]\n      },\n      \"application/vnd.ims.imsccv1p1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.lis.v2.result+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolconsumerprofile+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy.id+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings.simple+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informedcontrol.rms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informix-visionary\": {\n        source: \"apache\"\n      },\n      \"application/vnd.infotech.project\": {\n        source: \"iana\"\n      },\n      \"application/vnd.infotech.project+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.innopath.wamp.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.insors.igm\": {\n        source: \"iana\",\n        extensions: [\"igm\"]\n      },\n      \"application/vnd.intercon.formnet\": {\n        source: \"iana\",\n        extensions: [\"xpw\", \"xpx\"]\n      },\n      \"application/vnd.intergeo\": {\n        source: \"iana\",\n        extensions: [\"i2g\"]\n      },\n      \"application/vnd.intertrust.digibox\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intertrust.nncp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intu.qbo\": {\n        source: \"iana\",\n        extensions: [\"qbo\"]\n      },\n      \"application/vnd.intu.qfx\": {\n        source: \"iana\",\n        extensions: [\"qfx\"]\n      },\n      \"application/vnd.ipfs.ipns-record\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.car\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.iptc.g2.catalogitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.conceptitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.knowledgeitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.packageitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.planningitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ipunplugged.rcprofile\": {\n        source: \"iana\",\n        extensions: [\"rcprofile\"]\n      },\n      \"application/vnd.irepository.package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"irp\"]\n      },\n      \"application/vnd.is-xpr\": {\n        source: \"iana\",\n        extensions: [\"xpr\"]\n      },\n      \"application/vnd.isac.fcs\": {\n        source: \"iana\",\n        extensions: [\"fcs\"]\n      },\n      \"application/vnd.iso11783-10+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.jam\": {\n        source: \"iana\",\n        extensions: [\"jam\"]\n      },\n      \"application/vnd.japannet-directory-service\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-jpnstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-payment-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-setstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.jcp.javame.midlet-rms\": {\n        source: \"iana\",\n        extensions: [\"rms\"]\n      },\n      \"application/vnd.jisp\": {\n        source: \"iana\",\n        extensions: [\"jisp\"]\n      },\n      \"application/vnd.joost.joda-archive\": {\n        source: \"iana\",\n        extensions: [\"joda\"]\n      },\n      \"application/vnd.jsk.isdn-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kahootz\": {\n        source: \"iana\",\n        extensions: [\"ktz\", \"ktr\"]\n      },\n      \"application/vnd.kde.karbon\": {\n        source: \"iana\",\n        extensions: [\"karbon\"]\n      },\n      \"application/vnd.kde.kchart\": {\n        source: \"iana\",\n        extensions: [\"chrt\"]\n      },\n      \"application/vnd.kde.kformula\": {\n        source: \"iana\",\n        extensions: [\"kfo\"]\n      },\n      \"application/vnd.kde.kivio\": {\n        source: \"iana\",\n        extensions: [\"flw\"]\n      },\n      \"application/vnd.kde.kontour\": {\n        source: \"iana\",\n        extensions: [\"kon\"]\n      },\n      \"application/vnd.kde.kpresenter\": {\n        source: \"iana\",\n        extensions: [\"kpr\", \"kpt\"]\n      },\n      \"application/vnd.kde.kspread\": {\n        source: \"iana\",\n        extensions: [\"ksp\"]\n      },\n      \"application/vnd.kde.kword\": {\n        source: \"iana\",\n        extensions: [\"kwd\", \"kwt\"]\n      },\n      \"application/vnd.kdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kenameaapp\": {\n        source: \"iana\",\n        extensions: [\"htke\"]\n      },\n      \"application/vnd.keyman.kmp+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.keyman.kmx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kidspiration\": {\n        source: \"iana\",\n        extensions: [\"kia\"]\n      },\n      \"application/vnd.kinar\": {\n        source: \"iana\",\n        extensions: [\"kne\", \"knp\"]\n      },\n      \"application/vnd.koan\": {\n        source: \"iana\",\n        extensions: [\"skp\", \"skd\", \"skt\", \"skm\"]\n      },\n      \"application/vnd.kodak-descriptor\": {\n        source: \"iana\",\n        extensions: [\"sse\"]\n      },\n      \"application/vnd.las\": {\n        source: \"iana\"\n      },\n      \"application/vnd.las.las+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.las.las+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lasxml\"]\n      },\n      \"application/vnd.laszip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ldev.productlicensing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.leap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.liberty-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.llamagraphics.life-balance.desktop\": {\n        source: \"iana\",\n        extensions: [\"lbd\"]\n      },\n      \"application/vnd.llamagraphics.life-balance.exchange+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lbe\"]\n      },\n      \"application/vnd.logipipe.circuit+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.loom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.lotus-1-2-3\": {\n        source: \"iana\",\n        extensions: [\"123\"]\n      },\n      \"application/vnd.lotus-approach\": {\n        source: \"iana\",\n        extensions: [\"apr\"]\n      },\n      \"application/vnd.lotus-freelance\": {\n        source: \"iana\",\n        extensions: [\"pre\"]\n      },\n      \"application/vnd.lotus-notes\": {\n        source: \"iana\",\n        extensions: [\"nsf\"]\n      },\n      \"application/vnd.lotus-organizer\": {\n        source: \"iana\",\n        extensions: [\"org\"]\n      },\n      \"application/vnd.lotus-screencam\": {\n        source: \"iana\",\n        extensions: [\"scm\"]\n      },\n      \"application/vnd.lotus-wordpro\": {\n        source: \"iana\",\n        extensions: [\"lwp\"]\n      },\n      \"application/vnd.macports.portpkg\": {\n        source: \"iana\",\n        extensions: [\"portpkg\"]\n      },\n      \"application/vnd.mapbox-vector-tile\": {\n        source: \"iana\",\n        extensions: [\"mvt\"]\n      },\n      \"application/vnd.marlin.drm.actiontoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.conftoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.license+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.mdcf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mason+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.maxar.archive.3tz+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.maxmind.maxmind-db\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mcd\": {\n        source: \"iana\",\n        extensions: [\"mcd\"]\n      },\n      \"application/vnd.mdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mdl-mbsdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.medcalcdata\": {\n        source: \"iana\",\n        extensions: [\"mc1\"]\n      },\n      \"application/vnd.mediastation.cdkey\": {\n        source: \"iana\",\n        extensions: [\"cdkey\"]\n      },\n      \"application/vnd.medicalholodeck.recordxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.meridian-slingshot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mermaid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mfer\": {\n        source: \"iana\",\n        extensions: [\"mwf\"]\n      },\n      \"application/vnd.mfmp\": {\n        source: \"iana\",\n        extensions: [\"mfm\"]\n      },\n      \"application/vnd.micro+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.micrografx.flo\": {\n        source: \"iana\",\n        extensions: [\"flo\"]\n      },\n      \"application/vnd.micrografx.igx\": {\n        source: \"iana\",\n        extensions: [\"igx\"]\n      },\n      \"application/vnd.microsoft.portable-executable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.microsoft.windows.thumbnail-cache\": {\n        source: \"iana\"\n      },\n      \"application/vnd.miele+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.mif\": {\n        source: \"iana\",\n        extensions: [\"mif\"]\n      },\n      \"application/vnd.minisoft-hp3000-save\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mitsubishi.misty-guard.trustweb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mobius.daf\": {\n        source: \"iana\",\n        extensions: [\"daf\"]\n      },\n      \"application/vnd.mobius.dis\": {\n        source: \"iana\",\n        extensions: [\"dis\"]\n      },\n      \"application/vnd.mobius.mbk\": {\n        source: \"iana\",\n        extensions: [\"mbk\"]\n      },\n      \"application/vnd.mobius.mqy\": {\n        source: \"iana\",\n        extensions: [\"mqy\"]\n      },\n      \"application/vnd.mobius.msl\": {\n        source: \"iana\",\n        extensions: [\"msl\"]\n      },\n      \"application/vnd.mobius.plc\": {\n        source: \"iana\",\n        extensions: [\"plc\"]\n      },\n      \"application/vnd.mobius.txf\": {\n        source: \"iana\",\n        extensions: [\"txf\"]\n      },\n      \"application/vnd.modl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mophun.application\": {\n        source: \"iana\",\n        extensions: [\"mpn\"]\n      },\n      \"application/vnd.mophun.certificate\": {\n        source: \"iana\",\n        extensions: [\"mpc\"]\n      },\n      \"application/vnd.motorola.flexsuite\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.adsi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.fis\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.gotap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.kmr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.ttc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.wem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.iprm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mozilla.xul+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xul\"]\n      },\n      \"application/vnd.ms-3mfdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-artgalry\": {\n        source: \"iana\",\n        extensions: [\"cil\"]\n      },\n      \"application/vnd.ms-asf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-cab-compressed\": {\n        source: \"iana\",\n        extensions: [\"cab\"]\n      },\n      \"application/vnd.ms-color.iccprofile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-excel\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xls\", \"xlm\", \"xla\", \"xlc\", \"xlt\", \"xlw\"]\n      },\n      \"application/vnd.ms-excel.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlam\"]\n      },\n      \"application/vnd.ms-excel.sheet.binary.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsb\"]\n      },\n      \"application/vnd.ms-excel.sheet.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsm\"]\n      },\n      \"application/vnd.ms-excel.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xltm\"]\n      },\n      \"application/vnd.ms-fontobject\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eot\"]\n      },\n      \"application/vnd.ms-htmlhelp\": {\n        source: \"iana\",\n        extensions: [\"chm\"]\n      },\n      \"application/vnd.ms-ims\": {\n        source: \"iana\",\n        extensions: [\"ims\"]\n      },\n      \"application/vnd.ms-lrm\": {\n        source: \"iana\",\n        extensions: [\"lrm\"]\n      },\n      \"application/vnd.ms-office.activex+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-officetheme\": {\n        source: \"iana\",\n        extensions: [\"thmx\"]\n      },\n      \"application/vnd.ms-opentype\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-outlook\": {\n        compressible: false,\n        extensions: [\"msg\"]\n      },\n      \"application/vnd.ms-package.obfuscated-opentype\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-pki.seccat\": {\n        source: \"apache\",\n        extensions: [\"cat\"]\n      },\n      \"application/vnd.ms-pki.stl\": {\n        source: \"apache\",\n        extensions: [\"stl\"]\n      },\n      \"application/vnd.ms-playready.initiator+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-powerpoint\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ppt\", \"pps\", \"pot\"]\n      },\n      \"application/vnd.ms-powerpoint.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppam\"]\n      },\n      \"application/vnd.ms-powerpoint.presentation.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"pptm\"]\n      },\n      \"application/vnd.ms-powerpoint.slide.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"sldm\"]\n      },\n      \"application/vnd.ms-powerpoint.slideshow.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppsm\"]\n      },\n      \"application/vnd.ms-powerpoint.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"potm\"]\n      },\n      \"application/vnd.ms-printdevicecapabilities+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-printing.printticket+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-printschematicket+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-project\": {\n        source: \"iana\",\n        extensions: [\"mpp\", \"mpt\"]\n      },\n      \"application/vnd.ms-tnef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-visio.viewer\": {\n        extensions: [\"vdx\"]\n      },\n      \"application/vnd.ms-windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.nwprinting.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.printerpairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.wsd.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-word.document.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"docm\"]\n      },\n      \"application/vnd.ms-word.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"dotm\"]\n      },\n      \"application/vnd.ms-works\": {\n        source: \"iana\",\n        extensions: [\"wps\", \"wks\", \"wcm\", \"wdb\"]\n      },\n      \"application/vnd.ms-wpl\": {\n        source: \"iana\",\n        extensions: [\"wpl\"]\n      },\n      \"application/vnd.ms-xpsdocument\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xps\"]\n      },\n      \"application/vnd.msa-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mseq\": {\n        source: \"iana\",\n        extensions: [\"mseq\"]\n      },\n      \"application/vnd.msgpack\": {\n        source: \"iana\"\n      },\n      \"application/vnd.msign\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator.cif\": {\n        source: \"iana\"\n      },\n      \"application/vnd.music-niff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.musician\": {\n        source: \"iana\",\n        extensions: [\"mus\"]\n      },\n      \"application/vnd.muvee.style\": {\n        source: \"iana\",\n        extensions: [\"msty\"]\n      },\n      \"application/vnd.mynfc\": {\n        source: \"iana\",\n        extensions: [\"taglet\"]\n      },\n      \"application/vnd.nacamar.ybrid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nato.bindingdataobject+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bdo\"]\n      },\n      \"application/vnd.nato.openxmlformats-package.iepd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.ncd.control\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ncd.reference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nearst.inv+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nebumind.line\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nervana\": {\n        source: \"iana\"\n      },\n      \"application/vnd.netfpx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.neurolanguage.nlu\": {\n        source: \"iana\",\n        extensions: [\"nlu\"]\n      },\n      \"application/vnd.nimn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.nitro.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.snes.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nitf\": {\n        source: \"iana\",\n        extensions: [\"ntf\", \"nitf\"]\n      },\n      \"application/vnd.noblenet-directory\": {\n        source: \"iana\",\n        extensions: [\"nnd\"]\n      },\n      \"application/vnd.noblenet-sealer\": {\n        source: \"iana\",\n        extensions: [\"nns\"]\n      },\n      \"application/vnd.noblenet-web\": {\n        source: \"iana\",\n        extensions: [\"nnw\"]\n      },\n      \"application/vnd.nokia.catalogs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.iptv.config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.isds-radio-presets\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.landmarkcollection+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.n-gage.ac+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ac\"]\n      },\n      \"application/vnd.nokia.n-gage.data\": {\n        source: \"iana\",\n        extensions: [\"ngdat\"]\n      },\n      \"application/vnd.nokia.n-gage.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"n-gage\"]\n      },\n      \"application/vnd.nokia.ncd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.radio-preset\": {\n        source: \"iana\",\n        extensions: [\"rpst\"]\n      },\n      \"application/vnd.nokia.radio-presets\": {\n        source: \"iana\",\n        extensions: [\"rpss\"]\n      },\n      \"application/vnd.novadigm.edm\": {\n        source: \"iana\",\n        extensions: [\"edm\"]\n      },\n      \"application/vnd.novadigm.edx\": {\n        source: \"iana\",\n        extensions: [\"edx\"]\n      },\n      \"application/vnd.novadigm.ext\": {\n        source: \"iana\",\n        extensions: [\"ext\"]\n      },\n      \"application/vnd.ntt-local.content-share\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.file-transfer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.ogw_remote-access\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_remote\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oai.workflows+yaml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.chart\": {\n        source: \"iana\",\n        extensions: [\"odc\"]\n      },\n      \"application/vnd.oasis.opendocument.chart-template\": {\n        source: \"iana\",\n        extensions: [\"otc\"]\n      },\n      \"application/vnd.oasis.opendocument.database\": {\n        source: \"apache\",\n        extensions: [\"odb\"]\n      },\n      \"application/vnd.oasis.opendocument.formula\": {\n        source: \"iana\",\n        extensions: [\"odf\"]\n      },\n      \"application/vnd.oasis.opendocument.formula-template\": {\n        source: \"iana\",\n        extensions: [\"odft\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odg\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics-template\": {\n        source: \"iana\",\n        extensions: [\"otg\"]\n      },\n      \"application/vnd.oasis.opendocument.image\": {\n        source: \"iana\",\n        extensions: [\"odi\"]\n      },\n      \"application/vnd.oasis.opendocument.image-template\": {\n        source: \"iana\",\n        extensions: [\"oti\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odp\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation-template\": {\n        source: \"iana\",\n        extensions: [\"otp\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ods\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet-template\": {\n        source: \"iana\",\n        extensions: [\"ots\"]\n      },\n      \"application/vnd.oasis.opendocument.text\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odt\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master\": {\n        source: \"iana\",\n        extensions: [\"odm\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.text-template\": {\n        source: \"iana\",\n        extensions: [\"ott\"]\n      },\n      \"application/vnd.oasis.opendocument.text-web\": {\n        source: \"iana\",\n        extensions: [\"oth\"]\n      },\n      \"application/vnd.obn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ocf+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oci.image.manifest.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oftn.l10n+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessdownload+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessstreaming+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.cspg-hexbinary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.dae.svg+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.dae.xhtml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.mippvcontrolmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.pae.gem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.spdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.spdlist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.ueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.userprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.olpc-sugar\": {\n        source: \"iana\",\n        extensions: [\"xo\"]\n      },\n      \"application/vnd.oma-scws-config\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-request\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.associated-procedure-parameter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.drm-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.imd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.ltkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.notification+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.provisioningtrigger\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgboot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgdd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sgdu\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.simple-symbol-container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.smartcard-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sprov+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.stkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.cab-address-book+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-feature-handler+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-pcc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-subs-invite+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-user-prefs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.dcd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dcdc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dd2+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dd2\"]\n      },\n      \"application/vnd.oma.drm.risd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.group-usage-list+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.lwm2m+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+tlv\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.pal+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.detailed-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.final-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.groups+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.invocation-descriptor+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.optimized-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.push\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.scidm.messages+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.xcap-directory+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.omads-email+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-file+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-folder+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omaloc-supl-init\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepager\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertat\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onvif.metadata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openblox.game+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"obgx\"]\n      },\n      \"application/vnd.openblox.game-binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openeye.oeb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openofficeorg.extension\": {\n        source: \"apache\",\n        extensions: [\"oxt\"]\n      },\n      \"application/vnd.openstreetmap.data+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osm\"]\n      },\n      \"application/vnd.opentimestamps.ots\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openvpi.dspx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.custom-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.customxmlproperties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawing+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chart+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.extended-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pptx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide\": {\n        source: \"iana\",\n        extensions: [\"sldx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow\": {\n        source: \"iana\",\n        extensions: [\"ppsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tags+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template\": {\n        source: \"iana\",\n        extensions: [\"potx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xlsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template\": {\n        source: \"iana\",\n        extensions: [\"xltx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.theme+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.themeoverride+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.vmldrawing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"docx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template\": {\n        source: \"iana\",\n        extensions: [\"dotx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.core-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.relationships+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oracle.resource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.orange.indata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osa.netdeploy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgeo.mapguide.package\": {\n        source: \"iana\",\n        extensions: [\"mgp\"]\n      },\n      \"application/vnd.osgi.bundle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgi.dp\": {\n        source: \"iana\",\n        extensions: [\"dp\"]\n      },\n      \"application/vnd.osgi.subsystem\": {\n        source: \"iana\",\n        extensions: [\"esa\"]\n      },\n      \"application/vnd.otps.ct-kip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oxli.countgraph\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pagerduty+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.palm\": {\n        source: \"iana\",\n        extensions: [\"pdb\", \"pqa\", \"oprc\"]\n      },\n      \"application/vnd.panoply\": {\n        source: \"iana\"\n      },\n      \"application/vnd.paos.xml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patentdive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patientecommsdoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pawaafile\": {\n        source: \"iana\",\n        extensions: [\"paw\"]\n      },\n      \"application/vnd.pcos\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pg.format\": {\n        source: \"iana\",\n        extensions: [\"str\"]\n      },\n      \"application/vnd.pg.osasli\": {\n        source: \"iana\",\n        extensions: [\"ei6\"]\n      },\n      \"application/vnd.piaccess.application-licence\": {\n        source: \"iana\"\n      },\n      \"application/vnd.picsel\": {\n        source: \"iana\",\n        extensions: [\"efif\"]\n      },\n      \"application/vnd.pmi.widget\": {\n        source: \"iana\",\n        extensions: [\"wg\"]\n      },\n      \"application/vnd.poc.group-advertisement+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.pocketlearn\": {\n        source: \"iana\",\n        extensions: [\"plf\"]\n      },\n      \"application/vnd.powerbuilder6\": {\n        source: \"iana\",\n        extensions: [\"pbd\"]\n      },\n      \"application/vnd.powerbuilder6-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.preminet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.previewsystems.box\": {\n        source: \"iana\",\n        extensions: [\"box\"]\n      },\n      \"application/vnd.procrate.brushset\": {\n        extensions: [\"brushset\"]\n      },\n      \"application/vnd.procreate.brush\": {\n        extensions: [\"brush\"]\n      },\n      \"application/vnd.procreate.dream\": {\n        extensions: [\"drm\"]\n      },\n      \"application/vnd.proteus.magazine\": {\n        source: \"iana\",\n        extensions: [\"mgz\"]\n      },\n      \"application/vnd.psfs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pt.mundusmundi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.publishare-delta-tree\": {\n        source: \"iana\",\n        extensions: [\"qps\"]\n      },\n      \"application/vnd.pvi.ptid1\": {\n        source: \"iana\",\n        extensions: [\"ptid\"]\n      },\n      \"application/vnd.pwg-multiplexed\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pwg-xhtml-print+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtm\"]\n      },\n      \"application/vnd.qualcomm.brew-app-res\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quarantainenet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quark.quarkxpress\": {\n        source: \"iana\",\n        extensions: [\"qxd\", \"qxt\", \"qwd\", \"qwt\", \"qxl\", \"qxb\"]\n      },\n      \"application/vnd.quobject-quoxdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.radisys.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-stream+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-base+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-detect+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-sendrecv+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-group+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-speech+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-transform+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rainstor.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rapid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rar\": {\n        source: \"iana\",\n        extensions: [\"rar\"]\n      },\n      \"application/vnd.realvnc.bed\": {\n        source: \"iana\",\n        extensions: [\"bed\"]\n      },\n      \"application/vnd.recordare.musicxml\": {\n        source: \"iana\",\n        extensions: [\"mxl\"]\n      },\n      \"application/vnd.recordare.musicxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musicxml\"]\n      },\n      \"application/vnd.relpipe\": {\n        source: \"iana\"\n      },\n      \"application/vnd.renlearn.rlprint\": {\n        source: \"iana\"\n      },\n      \"application/vnd.resilient.logic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.restful+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rig.cryptonote\": {\n        source: \"iana\",\n        extensions: [\"cryptonote\"]\n      },\n      \"application/vnd.rim.cod\": {\n        source: \"apache\",\n        extensions: [\"cod\"]\n      },\n      \"application/vnd.rn-realmedia\": {\n        source: \"apache\",\n        extensions: [\"rm\"]\n      },\n      \"application/vnd.rn-realmedia-vbr\": {\n        source: \"apache\",\n        extensions: [\"rmvb\"]\n      },\n      \"application/vnd.route66.link66+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"link66\"]\n      },\n      \"application/vnd.rs-274x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ruckus.download\": {\n        source: \"iana\"\n      },\n      \"application/vnd.s3sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sailingtracker.track\": {\n        source: \"iana\",\n        extensions: [\"st\"]\n      },\n      \"application/vnd.sar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.cid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.mid2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.scribus\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.3df\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.csf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.doc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.eml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.mht\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.net\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.ppt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.tiff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.xls\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.seemail\": {\n        source: \"iana\",\n        extensions: [\"see\"]\n      },\n      \"application/vnd.seis+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sema\": {\n        source: \"iana\",\n        extensions: [\"sema\"]\n      },\n      \"application/vnd.semd\": {\n        source: \"iana\",\n        extensions: [\"semd\"]\n      },\n      \"application/vnd.semf\": {\n        source: \"iana\",\n        extensions: [\"semf\"]\n      },\n      \"application/vnd.shade-save-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shana.informed.formdata\": {\n        source: \"iana\",\n        extensions: [\"ifm\"]\n      },\n      \"application/vnd.shana.informed.formtemplate\": {\n        source: \"iana\",\n        extensions: [\"itp\"]\n      },\n      \"application/vnd.shana.informed.interchange\": {\n        source: \"iana\",\n        extensions: [\"iif\"]\n      },\n      \"application/vnd.shana.informed.package\": {\n        source: \"iana\",\n        extensions: [\"ipk\"]\n      },\n      \"application/vnd.shootproof+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shopkick+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sigrok.session\": {\n        source: \"iana\"\n      },\n      \"application/vnd.simtech-mindmapper\": {\n        source: \"iana\",\n        extensions: [\"twd\", \"twds\"]\n      },\n      \"application/vnd.siren+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sketchometry\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smaf\": {\n        source: \"iana\",\n        extensions: [\"mmf\"]\n      },\n      \"application/vnd.smart.notebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smart.teacher\": {\n        source: \"iana\",\n        extensions: [\"teacher\"]\n      },\n      \"application/vnd.smintio.portals.archive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.snesdev-page-table\": {\n        source: \"iana\"\n      },\n      \"application/vnd.software602.filler.form+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fo\"]\n      },\n      \"application/vnd.software602.filler.form-xml-zip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.solent.sdkm+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sdkm\", \"sdkd\"]\n      },\n      \"application/vnd.spotfire.dxp\": {\n        source: \"iana\",\n        extensions: [\"dxp\"]\n      },\n      \"application/vnd.spotfire.sfs\": {\n        source: \"iana\",\n        extensions: [\"sfs\"]\n      },\n      \"application/vnd.sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-cod\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-dtf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-ntf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.stardivision.calc\": {\n        source: \"apache\",\n        extensions: [\"sdc\"]\n      },\n      \"application/vnd.stardivision.draw\": {\n        source: \"apache\",\n        extensions: [\"sda\"]\n      },\n      \"application/vnd.stardivision.impress\": {\n        source: \"apache\",\n        extensions: [\"sdd\"]\n      },\n      \"application/vnd.stardivision.math\": {\n        source: \"apache\",\n        extensions: [\"smf\"]\n      },\n      \"application/vnd.stardivision.writer\": {\n        source: \"apache\",\n        extensions: [\"sdw\", \"vor\"]\n      },\n      \"application/vnd.stardivision.writer-global\": {\n        source: \"apache\",\n        extensions: [\"sgl\"]\n      },\n      \"application/vnd.stepmania.package\": {\n        source: \"iana\",\n        extensions: [\"smzip\"]\n      },\n      \"application/vnd.stepmania.stepchart\": {\n        source: \"iana\",\n        extensions: [\"sm\"]\n      },\n      \"application/vnd.street-stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sun.wadl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wadl\"]\n      },\n      \"application/vnd.sun.xml.calc\": {\n        source: \"apache\",\n        extensions: [\"sxc\"]\n      },\n      \"application/vnd.sun.xml.calc.template\": {\n        source: \"apache\",\n        extensions: [\"stc\"]\n      },\n      \"application/vnd.sun.xml.draw\": {\n        source: \"apache\",\n        extensions: [\"sxd\"]\n      },\n      \"application/vnd.sun.xml.draw.template\": {\n        source: \"apache\",\n        extensions: [\"std\"]\n      },\n      \"application/vnd.sun.xml.impress\": {\n        source: \"apache\",\n        extensions: [\"sxi\"]\n      },\n      \"application/vnd.sun.xml.impress.template\": {\n        source: \"apache\",\n        extensions: [\"sti\"]\n      },\n      \"application/vnd.sun.xml.math\": {\n        source: \"apache\",\n        extensions: [\"sxm\"]\n      },\n      \"application/vnd.sun.xml.writer\": {\n        source: \"apache\",\n        extensions: [\"sxw\"]\n      },\n      \"application/vnd.sun.xml.writer.global\": {\n        source: \"apache\",\n        extensions: [\"sxg\"]\n      },\n      \"application/vnd.sun.xml.writer.template\": {\n        source: \"apache\",\n        extensions: [\"stw\"]\n      },\n      \"application/vnd.sus-calendar\": {\n        source: \"iana\",\n        extensions: [\"sus\", \"susp\"]\n      },\n      \"application/vnd.svd\": {\n        source: \"iana\",\n        extensions: [\"svd\"]\n      },\n      \"application/vnd.swiftview-ics\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sybyl.mol2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sycle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.syft+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"sis\", \"sisx\"]\n      },\n      \"application/vnd.syncml+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xsm\"]\n      },\n      \"application/vnd.syncml.dm+wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"bdm\"]\n      },\n      \"application/vnd.syncml.dm+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xdm\"]\n      },\n      \"application/vnd.syncml.dm.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"ddf\"]\n      },\n      \"application/vnd.syncml.dmtnds+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmtnds+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.syncml.ds.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tableschema+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tao.intent-module-archive\": {\n        source: \"iana\",\n        extensions: [\"tao\"]\n      },\n      \"application/vnd.tcpdump.pcap\": {\n        source: \"iana\",\n        extensions: [\"pcap\", \"cap\", \"dmp\"]\n      },\n      \"application/vnd.think-cell.ppttc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tmd.mediaflex.api+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tmobile-livetv\": {\n        source: \"iana\",\n        extensions: [\"tmo\"]\n      },\n      \"application/vnd.tri.onesource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.trid.tpt\": {\n        source: \"iana\",\n        extensions: [\"tpt\"]\n      },\n      \"application/vnd.triscape.mxs\": {\n        source: \"iana\",\n        extensions: [\"mxs\"]\n      },\n      \"application/vnd.trueapp\": {\n        source: \"iana\",\n        extensions: [\"tra\"]\n      },\n      \"application/vnd.truedoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ubisoft.webplayer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ufdl\": {\n        source: \"iana\",\n        extensions: [\"ufd\", \"ufdl\"]\n      },\n      \"application/vnd.uic.osdm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.uiq.theme\": {\n        source: \"iana\",\n        extensions: [\"utz\"]\n      },\n      \"application/vnd.umajin\": {\n        source: \"iana\",\n        extensions: [\"umj\"]\n      },\n      \"application/vnd.unity\": {\n        source: \"iana\",\n        extensions: [\"unityweb\"]\n      },\n      \"application/vnd.uoml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uoml\", \"uo\"]\n      },\n      \"application/vnd.uplanet.alert\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.alert-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.signal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uri-map\": {\n        source: \"iana\"\n      },\n      \"application/vnd.valve.source.material\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vcx\": {\n        source: \"iana\",\n        extensions: [\"vcx\"]\n      },\n      \"application/vnd.vd-study\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vectorworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vel+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veraison.tsm-report+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veraison.tsm-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.verimatrix.vcas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veritone.aion+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veryant.thin\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ves.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vidsoft.vidconference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.visio\": {\n        source: \"iana\",\n        extensions: [\"vsd\", \"vst\", \"vss\", \"vsw\", \"vsdx\", \"vtx\"]\n      },\n      \"application/vnd.visionary\": {\n        source: \"iana\",\n        extensions: [\"vis\"]\n      },\n      \"application/vnd.vividence.scriptfile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vocalshaper.vsp4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vsf\": {\n        source: \"iana\",\n        extensions: [\"vsf\"]\n      },\n      \"application/vnd.wap.sic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.slc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"wbxml\"]\n      },\n      \"application/vnd.wap.wmlc\": {\n        source: \"iana\",\n        extensions: [\"wmlc\"]\n      },\n      \"application/vnd.wap.wmlscriptc\": {\n        source: \"iana\",\n        extensions: [\"wmlsc\"]\n      },\n      \"application/vnd.wasmflow.wafl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.webturbo\": {\n        source: \"iana\",\n        extensions: [\"wtb\"]\n      },\n      \"application/vnd.wfa.dpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.p2p\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.wsc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmf.bootstrap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica.package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.player\": {\n        source: \"iana\",\n        extensions: [\"nbp\"]\n      },\n      \"application/vnd.wordlift\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wordperfect\": {\n        source: \"iana\",\n        extensions: [\"wpd\"]\n      },\n      \"application/vnd.wqd\": {\n        source: \"iana\",\n        extensions: [\"wqd\"]\n      },\n      \"application/vnd.wrq-hp3000-labelled\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wt.stf\": {\n        source: \"iana\",\n        extensions: [\"stf\"]\n      },\n      \"application/vnd.wv.csp+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wv.csp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.wv.ssp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xara\": {\n        source: \"iana\",\n        extensions: [\"xar\"]\n      },\n      \"application/vnd.xarin.cpj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xecrets-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xfdl\": {\n        source: \"iana\",\n        extensions: [\"xfdl\"]\n      },\n      \"application/vnd.xfdl.webform\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xmpie.cpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.dpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.plan\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.ppkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.xlim\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.hv-dic\": {\n        source: \"iana\",\n        extensions: [\"hvd\"]\n      },\n      \"application/vnd.yamaha.hv-script\": {\n        source: \"iana\",\n        extensions: [\"hvs\"]\n      },\n      \"application/vnd.yamaha.hv-voice\": {\n        source: \"iana\",\n        extensions: [\"hvp\"]\n      },\n      \"application/vnd.yamaha.openscoreformat\": {\n        source: \"iana\",\n        extensions: [\"osf\"]\n      },\n      \"application/vnd.yamaha.openscoreformat.osfpvg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osfpvg\"]\n      },\n      \"application/vnd.yamaha.remote-setup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.smaf-audio\": {\n        source: \"iana\",\n        extensions: [\"saf\"]\n      },\n      \"application/vnd.yamaha.smaf-phrase\": {\n        source: \"iana\",\n        extensions: [\"spf\"]\n      },\n      \"application/vnd.yamaha.through-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.tunnel-udpencap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yaoweme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yellowriver-custom-menu\": {\n        source: \"iana\",\n        extensions: [\"cmp\"]\n      },\n      \"application/vnd.zul\": {\n        source: \"iana\",\n        extensions: [\"zir\", \"zirz\"]\n      },\n      \"application/vnd.zzazz.deck+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zaz\"]\n      },\n      \"application/voicexml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vxml\"]\n      },\n      \"application/voucher-cms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/voucher-jws+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vp\": {\n        source: \"iana\"\n      },\n      \"application/vp+cose\": {\n        source: \"iana\"\n      },\n      \"application/vp+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vq-rtcpxr\": {\n        source: \"iana\"\n      },\n      \"application/wasm\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wasm\"]\n      },\n      \"application/watcherinfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wif\"]\n      },\n      \"application/webpush-options+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/whoispp-query\": {\n        source: \"iana\"\n      },\n      \"application/whoispp-response\": {\n        source: \"iana\"\n      },\n      \"application/widget\": {\n        source: \"iana\",\n        extensions: [\"wgt\"]\n      },\n      \"application/winhlp\": {\n        source: \"apache\",\n        extensions: [\"hlp\"]\n      },\n      \"application/wita\": {\n        source: \"iana\"\n      },\n      \"application/wordperfect5.1\": {\n        source: \"iana\"\n      },\n      \"application/wsdl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wsdl\"]\n      },\n      \"application/wspolicy+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wspolicy\"]\n      },\n      \"application/x-7z-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"7z\"]\n      },\n      \"application/x-abiword\": {\n        source: \"apache\",\n        extensions: [\"abw\"]\n      },\n      \"application/x-ace-compressed\": {\n        source: \"apache\",\n        extensions: [\"ace\"]\n      },\n      \"application/x-amf\": {\n        source: \"apache\"\n      },\n      \"application/x-apple-diskimage\": {\n        source: \"apache\",\n        extensions: [\"dmg\"]\n      },\n      \"application/x-arj\": {\n        compressible: false,\n        extensions: [\"arj\"]\n      },\n      \"application/x-authorware-bin\": {\n        source: \"apache\",\n        extensions: [\"aab\", \"x32\", \"u32\", \"vox\"]\n      },\n      \"application/x-authorware-map\": {\n        source: \"apache\",\n        extensions: [\"aam\"]\n      },\n      \"application/x-authorware-seg\": {\n        source: \"apache\",\n        extensions: [\"aas\"]\n      },\n      \"application/x-bcpio\": {\n        source: \"apache\",\n        extensions: [\"bcpio\"]\n      },\n      \"application/x-bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/x-bittorrent\": {\n        source: \"apache\",\n        extensions: [\"torrent\"]\n      },\n      \"application/x-blender\": {\n        extensions: [\"blend\"]\n      },\n      \"application/x-blorb\": {\n        source: \"apache\",\n        extensions: [\"blb\", \"blorb\"]\n      },\n      \"application/x-bzip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz\"]\n      },\n      \"application/x-bzip2\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz2\", \"boz\"]\n      },\n      \"application/x-cbr\": {\n        source: \"apache\",\n        extensions: [\"cbr\", \"cba\", \"cbt\", \"cbz\", \"cb7\"]\n      },\n      \"application/x-cdlink\": {\n        source: \"apache\",\n        extensions: [\"vcd\"]\n      },\n      \"application/x-cfs-compressed\": {\n        source: \"apache\",\n        extensions: [\"cfs\"]\n      },\n      \"application/x-chat\": {\n        source: \"apache\",\n        extensions: [\"chat\"]\n      },\n      \"application/x-chess-pgn\": {\n        source: \"apache\",\n        extensions: [\"pgn\"]\n      },\n      \"application/x-chrome-extension\": {\n        extensions: [\"crx\"]\n      },\n      \"application/x-cocoa\": {\n        source: \"nginx\",\n        extensions: [\"cco\"]\n      },\n      \"application/x-compress\": {\n        source: \"apache\"\n      },\n      \"application/x-compressed\": {\n        extensions: [\"rar\"]\n      },\n      \"application/x-conference\": {\n        source: \"apache\",\n        extensions: [\"nsc\"]\n      },\n      \"application/x-cpio\": {\n        source: \"apache\",\n        extensions: [\"cpio\"]\n      },\n      \"application/x-csh\": {\n        source: \"apache\",\n        extensions: [\"csh\"]\n      },\n      \"application/x-deb\": {\n        compressible: false\n      },\n      \"application/x-debian-package\": {\n        source: \"apache\",\n        extensions: [\"deb\", \"udeb\"]\n      },\n      \"application/x-dgc-compressed\": {\n        source: \"apache\",\n        extensions: [\"dgc\"]\n      },\n      \"application/x-director\": {\n        source: \"apache\",\n        extensions: [\"dir\", \"dcr\", \"dxr\", \"cst\", \"cct\", \"cxt\", \"w3d\", \"fgd\", \"swa\"]\n      },\n      \"application/x-doom\": {\n        source: \"apache\",\n        extensions: [\"wad\"]\n      },\n      \"application/x-dtbncx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ncx\"]\n      },\n      \"application/x-dtbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dtb\"]\n      },\n      \"application/x-dtbresource+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"res\"]\n      },\n      \"application/x-dvi\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"dvi\"]\n      },\n      \"application/x-envoy\": {\n        source: \"apache\",\n        extensions: [\"evy\"]\n      },\n      \"application/x-eva\": {\n        source: \"apache\",\n        extensions: [\"eva\"]\n      },\n      \"application/x-font-bdf\": {\n        source: \"apache\",\n        extensions: [\"bdf\"]\n      },\n      \"application/x-font-dos\": {\n        source: \"apache\"\n      },\n      \"application/x-font-framemaker\": {\n        source: \"apache\"\n      },\n      \"application/x-font-ghostscript\": {\n        source: \"apache\",\n        extensions: [\"gsf\"]\n      },\n      \"application/x-font-libgrx\": {\n        source: \"apache\"\n      },\n      \"application/x-font-linux-psf\": {\n        source: \"apache\",\n        extensions: [\"psf\"]\n      },\n      \"application/x-font-pcf\": {\n        source: \"apache\",\n        extensions: [\"pcf\"]\n      },\n      \"application/x-font-snf\": {\n        source: \"apache\",\n        extensions: [\"snf\"]\n      },\n      \"application/x-font-speedo\": {\n        source: \"apache\"\n      },\n      \"application/x-font-sunos-news\": {\n        source: \"apache\"\n      },\n      \"application/x-font-type1\": {\n        source: \"apache\",\n        extensions: [\"pfa\", \"pfb\", \"pfm\", \"afm\"]\n      },\n      \"application/x-font-vfont\": {\n        source: \"apache\"\n      },\n      \"application/x-freearc\": {\n        source: \"apache\",\n        extensions: [\"arc\"]\n      },\n      \"application/x-futuresplash\": {\n        source: \"apache\",\n        extensions: [\"spl\"]\n      },\n      \"application/x-gca-compressed\": {\n        source: \"apache\",\n        extensions: [\"gca\"]\n      },\n      \"application/x-glulx\": {\n        source: \"apache\",\n        extensions: [\"ulx\"]\n      },\n      \"application/x-gnumeric\": {\n        source: \"apache\",\n        extensions: [\"gnumeric\"]\n      },\n      \"application/x-gramps-xml\": {\n        source: \"apache\",\n        extensions: [\"gramps\"]\n      },\n      \"application/x-gtar\": {\n        source: \"apache\",\n        extensions: [\"gtar\"]\n      },\n      \"application/x-gzip\": {\n        source: \"apache\"\n      },\n      \"application/x-hdf\": {\n        source: \"apache\",\n        extensions: [\"hdf\"]\n      },\n      \"application/x-httpd-php\": {\n        compressible: true,\n        extensions: [\"php\"]\n      },\n      \"application/x-install-instructions\": {\n        source: \"apache\",\n        extensions: [\"install\"]\n      },\n      \"application/x-ipynb+json\": {\n        compressible: true,\n        extensions: [\"ipynb\"]\n      },\n      \"application/x-iso9660-image\": {\n        source: \"apache\",\n        extensions: [\"iso\"]\n      },\n      \"application/x-iwork-keynote-sffkey\": {\n        extensions: [\"key\"]\n      },\n      \"application/x-iwork-numbers-sffnumbers\": {\n        extensions: [\"numbers\"]\n      },\n      \"application/x-iwork-pages-sffpages\": {\n        extensions: [\"pages\"]\n      },\n      \"application/x-java-archive-diff\": {\n        source: \"nginx\",\n        extensions: [\"jardiff\"]\n      },\n      \"application/x-java-jnlp-file\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"jnlp\"]\n      },\n      \"application/x-javascript\": {\n        compressible: true\n      },\n      \"application/x-keepass2\": {\n        extensions: [\"kdbx\"]\n      },\n      \"application/x-latex\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"latex\"]\n      },\n      \"application/x-lua-bytecode\": {\n        extensions: [\"luac\"]\n      },\n      \"application/x-lzh-compressed\": {\n        source: \"apache\",\n        extensions: [\"lzh\", \"lha\"]\n      },\n      \"application/x-makeself\": {\n        source: \"nginx\",\n        extensions: [\"run\"]\n      },\n      \"application/x-mie\": {\n        source: \"apache\",\n        extensions: [\"mie\"]\n      },\n      \"application/x-mobipocket-ebook\": {\n        source: \"apache\",\n        extensions: [\"prc\", \"mobi\"]\n      },\n      \"application/x-mpegurl\": {\n        compressible: false\n      },\n      \"application/x-ms-application\": {\n        source: \"apache\",\n        extensions: [\"application\"]\n      },\n      \"application/x-ms-shortcut\": {\n        source: \"apache\",\n        extensions: [\"lnk\"]\n      },\n      \"application/x-ms-wmd\": {\n        source: \"apache\",\n        extensions: [\"wmd\"]\n      },\n      \"application/x-ms-wmz\": {\n        source: \"apache\",\n        extensions: [\"wmz\"]\n      },\n      \"application/x-ms-xbap\": {\n        source: \"apache\",\n        extensions: [\"xbap\"]\n      },\n      \"application/x-msaccess\": {\n        source: \"apache\",\n        extensions: [\"mdb\"]\n      },\n      \"application/x-msbinder\": {\n        source: \"apache\",\n        extensions: [\"obd\"]\n      },\n      \"application/x-mscardfile\": {\n        source: \"apache\",\n        extensions: [\"crd\"]\n      },\n      \"application/x-msclip\": {\n        source: \"apache\",\n        extensions: [\"clp\"]\n      },\n      \"application/x-msdos-program\": {\n        extensions: [\"exe\"]\n      },\n      \"application/x-msdownload\": {\n        source: \"apache\",\n        extensions: [\"exe\", \"dll\", \"com\", \"bat\", \"msi\"]\n      },\n      \"application/x-msmediaview\": {\n        source: \"apache\",\n        extensions: [\"mvb\", \"m13\", \"m14\"]\n      },\n      \"application/x-msmetafile\": {\n        source: \"apache\",\n        extensions: [\"wmf\", \"wmz\", \"emf\", \"emz\"]\n      },\n      \"application/x-msmoney\": {\n        source: \"apache\",\n        extensions: [\"mny\"]\n      },\n      \"application/x-mspublisher\": {\n        source: \"apache\",\n        extensions: [\"pub\"]\n      },\n      \"application/x-msschedule\": {\n        source: \"apache\",\n        extensions: [\"scd\"]\n      },\n      \"application/x-msterminal\": {\n        source: \"apache\",\n        extensions: [\"trm\"]\n      },\n      \"application/x-mswrite\": {\n        source: \"apache\",\n        extensions: [\"wri\"]\n      },\n      \"application/x-netcdf\": {\n        source: \"apache\",\n        extensions: [\"nc\", \"cdf\"]\n      },\n      \"application/x-ns-proxy-autoconfig\": {\n        compressible: true,\n        extensions: [\"pac\"]\n      },\n      \"application/x-nzb\": {\n        source: \"apache\",\n        extensions: [\"nzb\"]\n      },\n      \"application/x-perl\": {\n        source: \"nginx\",\n        extensions: [\"pl\", \"pm\"]\n      },\n      \"application/x-pilot\": {\n        source: \"nginx\",\n        extensions: [\"prc\", \"pdb\"]\n      },\n      \"application/x-pkcs12\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"p12\", \"pfx\"]\n      },\n      \"application/x-pkcs7-certificates\": {\n        source: \"apache\",\n        extensions: [\"p7b\", \"spc\"]\n      },\n      \"application/x-pkcs7-certreqresp\": {\n        source: \"apache\",\n        extensions: [\"p7r\"]\n      },\n      \"application/x-pki-message\": {\n        source: \"iana\"\n      },\n      \"application/x-rar-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"rar\"]\n      },\n      \"application/x-redhat-package-manager\": {\n        source: \"nginx\",\n        extensions: [\"rpm\"]\n      },\n      \"application/x-research-info-systems\": {\n        source: \"apache\",\n        extensions: [\"ris\"]\n      },\n      \"application/x-sea\": {\n        source: \"nginx\",\n        extensions: [\"sea\"]\n      },\n      \"application/x-sh\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"sh\"]\n      },\n      \"application/x-shar\": {\n        source: \"apache\",\n        extensions: [\"shar\"]\n      },\n      \"application/x-shockwave-flash\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"swf\"]\n      },\n      \"application/x-silverlight-app\": {\n        source: \"apache\",\n        extensions: [\"xap\"]\n      },\n      \"application/x-sql\": {\n        source: \"apache\",\n        extensions: [\"sql\"]\n      },\n      \"application/x-stuffit\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"sit\"]\n      },\n      \"application/x-stuffitx\": {\n        source: \"apache\",\n        extensions: [\"sitx\"]\n      },\n      \"application/x-subrip\": {\n        source: \"apache\",\n        extensions: [\"srt\"]\n      },\n      \"application/x-sv4cpio\": {\n        source: \"apache\",\n        extensions: [\"sv4cpio\"]\n      },\n      \"application/x-sv4crc\": {\n        source: \"apache\",\n        extensions: [\"sv4crc\"]\n      },\n      \"application/x-t3vm-image\": {\n        source: \"apache\",\n        extensions: [\"t3\"]\n      },\n      \"application/x-tads\": {\n        source: \"apache\",\n        extensions: [\"gam\"]\n      },\n      \"application/x-tar\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"tar\"]\n      },\n      \"application/x-tcl\": {\n        source: \"apache\",\n        extensions: [\"tcl\", \"tk\"]\n      },\n      \"application/x-tex\": {\n        source: \"apache\",\n        extensions: [\"tex\"]\n      },\n      \"application/x-tex-tfm\": {\n        source: \"apache\",\n        extensions: [\"tfm\"]\n      },\n      \"application/x-texinfo\": {\n        source: \"apache\",\n        extensions: [\"texinfo\", \"texi\"]\n      },\n      \"application/x-tgif\": {\n        source: \"apache\",\n        extensions: [\"obj\"]\n      },\n      \"application/x-ustar\": {\n        source: \"apache\",\n        extensions: [\"ustar\"]\n      },\n      \"application/x-virtualbox-hdd\": {\n        compressible: true,\n        extensions: [\"hdd\"]\n      },\n      \"application/x-virtualbox-ova\": {\n        compressible: true,\n        extensions: [\"ova\"]\n      },\n      \"application/x-virtualbox-ovf\": {\n        compressible: true,\n        extensions: [\"ovf\"]\n      },\n      \"application/x-virtualbox-vbox\": {\n        compressible: true,\n        extensions: [\"vbox\"]\n      },\n      \"application/x-virtualbox-vbox-extpack\": {\n        compressible: false,\n        extensions: [\"vbox-extpack\"]\n      },\n      \"application/x-virtualbox-vdi\": {\n        compressible: true,\n        extensions: [\"vdi\"]\n      },\n      \"application/x-virtualbox-vhd\": {\n        compressible: true,\n        extensions: [\"vhd\"]\n      },\n      \"application/x-virtualbox-vmdk\": {\n        compressible: true,\n        extensions: [\"vmdk\"]\n      },\n      \"application/x-wais-source\": {\n        source: \"apache\",\n        extensions: [\"src\"]\n      },\n      \"application/x-web-app-manifest+json\": {\n        compressible: true,\n        extensions: [\"webapp\"]\n      },\n      \"application/x-www-form-urlencoded\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/x-x509-ca-cert\": {\n        source: \"iana\",\n        extensions: [\"der\", \"crt\", \"pem\"]\n      },\n      \"application/x-x509-ca-ra-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-x509-next-ca-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-xfig\": {\n        source: \"apache\",\n        extensions: [\"fig\"]\n      },\n      \"application/x-xliff+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/x-xpinstall\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"xpi\"]\n      },\n      \"application/x-xz\": {\n        source: \"apache\",\n        extensions: [\"xz\"]\n      },\n      \"application/x-zip-compressed\": {\n        extensions: [\"zip\"]\n      },\n      \"application/x-zmachine\": {\n        source: \"apache\",\n        extensions: [\"z1\", \"z2\", \"z3\", \"z4\", \"z5\", \"z6\", \"z7\", \"z8\"]\n      },\n      \"application/x400-bp\": {\n        source: \"iana\"\n      },\n      \"application/xacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xaml+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xaml\"]\n      },\n      \"application/xcap-att+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xav\"]\n      },\n      \"application/xcap-caps+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xca\"]\n      },\n      \"application/xcap-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdf\"]\n      },\n      \"application/xcap-el+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xel\"]\n      },\n      \"application/xcap-error+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcap-ns+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xns\"]\n      },\n      \"application/xcon-conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcon-conference-info-diff+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xenc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xenc\"]\n      },\n      \"application/xfdf\": {\n        source: \"iana\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/xhtml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtml\", \"xht\"]\n      },\n      \"application/xhtml-voice+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/xliff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\", \"xsl\", \"xsd\", \"rng\"]\n      },\n      \"application/xml-dtd\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dtd\"]\n      },\n      \"application/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"application/xml-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xmpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xop+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xop\"]\n      },\n      \"application/xproc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xpl\"]\n      },\n      \"application/xslt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsl\", \"xslt\"]\n      },\n      \"application/xspf+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xspf\"]\n      },\n      \"application/xv+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mxml\", \"xhvml\", \"xvml\", \"xvm\"]\n      },\n      \"application/yaml\": {\n        source: \"iana\"\n      },\n      \"application/yang\": {\n        source: \"iana\",\n        extensions: [\"yang\"]\n      },\n      \"application/yang-data+cbor\": {\n        source: \"iana\"\n      },\n      \"application/yang-data+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-sid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yin+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"yin\"]\n      },\n      \"application/zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"zip\"]\n      },\n      \"application/zip+dotlottie\": {\n        extensions: [\"lottie\"]\n      },\n      \"application/zlib\": {\n        source: \"iana\"\n      },\n      \"application/zstd\": {\n        source: \"iana\"\n      },\n      \"audio/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/3gpp\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"3gpp\"]\n      },\n      \"audio/3gpp2\": {\n        source: \"iana\"\n      },\n      \"audio/aac\": {\n        source: \"iana\",\n        extensions: [\"adts\", \"aac\"]\n      },\n      \"audio/ac3\": {\n        source: \"iana\"\n      },\n      \"audio/adpcm\": {\n        source: \"apache\",\n        extensions: [\"adp\"]\n      },\n      \"audio/amr\": {\n        source: \"iana\",\n        extensions: [\"amr\"]\n      },\n      \"audio/amr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/amr-wb+\": {\n        source: \"iana\"\n      },\n      \"audio/aptx\": {\n        source: \"iana\"\n      },\n      \"audio/asc\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-advanced-lossless\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-x\": {\n        source: \"iana\"\n      },\n      \"audio/atrac3\": {\n        source: \"iana\"\n      },\n      \"audio/basic\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"au\", \"snd\"]\n      },\n      \"audio/bv16\": {\n        source: \"iana\"\n      },\n      \"audio/bv32\": {\n        source: \"iana\"\n      },\n      \"audio/clearmode\": {\n        source: \"iana\"\n      },\n      \"audio/cn\": {\n        source: \"iana\"\n      },\n      \"audio/dat12\": {\n        source: \"iana\"\n      },\n      \"audio/dls\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es201108\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202050\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202211\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202212\": {\n        source: \"iana\"\n      },\n      \"audio/dv\": {\n        source: \"iana\"\n      },\n      \"audio/dvi4\": {\n        source: \"iana\"\n      },\n      \"audio/eac3\": {\n        source: \"iana\"\n      },\n      \"audio/encaprtp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc\": {\n        source: \"iana\"\n      },\n      \"audio/evrc-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc0\": {\n        source: \"iana\"\n      },\n      \"audio/evrc1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb1\": {\n        source: \"iana\"\n      },\n      \"audio/evs\": {\n        source: \"iana\"\n      },\n      \"audio/flac\": {\n        source: \"iana\"\n      },\n      \"audio/flexfec\": {\n        source: \"iana\"\n      },\n      \"audio/fwdred\": {\n        source: \"iana\"\n      },\n      \"audio/g711-0\": {\n        source: \"iana\"\n      },\n      \"audio/g719\": {\n        source: \"iana\"\n      },\n      \"audio/g722\": {\n        source: \"iana\"\n      },\n      \"audio/g7221\": {\n        source: \"iana\"\n      },\n      \"audio/g723\": {\n        source: \"iana\"\n      },\n      \"audio/g726-16\": {\n        source: \"iana\"\n      },\n      \"audio/g726-24\": {\n        source: \"iana\"\n      },\n      \"audio/g726-32\": {\n        source: \"iana\"\n      },\n      \"audio/g726-40\": {\n        source: \"iana\"\n      },\n      \"audio/g728\": {\n        source: \"iana\"\n      },\n      \"audio/g729\": {\n        source: \"iana\"\n      },\n      \"audio/g7291\": {\n        source: \"iana\"\n      },\n      \"audio/g729d\": {\n        source: \"iana\"\n      },\n      \"audio/g729e\": {\n        source: \"iana\"\n      },\n      \"audio/gsm\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-efr\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-hr-08\": {\n        source: \"iana\"\n      },\n      \"audio/ilbc\": {\n        source: \"iana\"\n      },\n      \"audio/ip-mr_v2.5\": {\n        source: \"iana\"\n      },\n      \"audio/isac\": {\n        source: \"apache\"\n      },\n      \"audio/l16\": {\n        source: \"iana\"\n      },\n      \"audio/l20\": {\n        source: \"iana\"\n      },\n      \"audio/l24\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/l8\": {\n        source: \"iana\"\n      },\n      \"audio/lpc\": {\n        source: \"iana\"\n      },\n      \"audio/matroska\": {\n        source: \"iana\"\n      },\n      \"audio/melp\": {\n        source: \"iana\"\n      },\n      \"audio/melp1200\": {\n        source: \"iana\"\n      },\n      \"audio/melp2400\": {\n        source: \"iana\"\n      },\n      \"audio/melp600\": {\n        source: \"iana\"\n      },\n      \"audio/mhas\": {\n        source: \"iana\"\n      },\n      \"audio/midi\": {\n        source: \"apache\",\n        extensions: [\"mid\", \"midi\", \"kar\", \"rmi\"]\n      },\n      \"audio/midi-clip\": {\n        source: \"iana\"\n      },\n      \"audio/mobile-xmf\": {\n        source: \"iana\",\n        extensions: [\"mxmf\"]\n      },\n      \"audio/mp3\": {\n        compressible: false,\n        extensions: [\"mp3\"]\n      },\n      \"audio/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"m4a\", \"mp4a\", \"m4b\"]\n      },\n      \"audio/mp4a-latm\": {\n        source: \"iana\"\n      },\n      \"audio/mpa\": {\n        source: \"iana\"\n      },\n      \"audio/mpa-robust\": {\n        source: \"iana\"\n      },\n      \"audio/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpga\", \"mp2\", \"mp2a\", \"mp3\", \"m2a\", \"m3a\"]\n      },\n      \"audio/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"audio/musepack\": {\n        source: \"apache\"\n      },\n      \"audio/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"oga\", \"ogg\", \"spx\", \"opus\"]\n      },\n      \"audio/opus\": {\n        source: \"iana\"\n      },\n      \"audio/parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/pcma\": {\n        source: \"iana\"\n      },\n      \"audio/pcma-wb\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu-wb\": {\n        source: \"iana\"\n      },\n      \"audio/prs.sid\": {\n        source: \"iana\"\n      },\n      \"audio/qcelp\": {\n        source: \"iana\"\n      },\n      \"audio/raptorfec\": {\n        source: \"iana\"\n      },\n      \"audio/red\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/rtploopback\": {\n        source: \"iana\"\n      },\n      \"audio/rtx\": {\n        source: \"iana\"\n      },\n      \"audio/s3m\": {\n        source: \"apache\",\n        extensions: [\"s3m\"]\n      },\n      \"audio/scip\": {\n        source: \"iana\"\n      },\n      \"audio/silk\": {\n        source: \"apache\",\n        extensions: [\"sil\"]\n      },\n      \"audio/smv\": {\n        source: \"iana\"\n      },\n      \"audio/smv-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/smv0\": {\n        source: \"iana\"\n      },\n      \"audio/sofa\": {\n        source: \"iana\"\n      },\n      \"audio/sp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/speex\": {\n        source: \"iana\"\n      },\n      \"audio/t140c\": {\n        source: \"iana\"\n      },\n      \"audio/t38\": {\n        source: \"iana\"\n      },\n      \"audio/telephone-event\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp_bb\": {\n        source: \"iana\"\n      },\n      \"audio/tone\": {\n        source: \"iana\"\n      },\n      \"audio/tsvcis\": {\n        source: \"iana\"\n      },\n      \"audio/uemclip\": {\n        source: \"iana\"\n      },\n      \"audio/ulpfec\": {\n        source: \"iana\"\n      },\n      \"audio/usac\": {\n        source: \"iana\"\n      },\n      \"audio/vdvi\": {\n        source: \"iana\"\n      },\n      \"audio/vmr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.3gpp.iufp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.4sb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.audiokoz\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.celp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cisco.nse\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cmles.radio-events\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.anp1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.inf1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dece.audio\": {\n        source: \"iana\",\n        extensions: [\"uva\", \"uvva\"]\n      },\n      \"audio/vnd.digital-winds\": {\n        source: \"iana\",\n        extensions: [\"eol\"]\n      },\n      \"audio/vnd.dlna.adts\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mlp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mps\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2x\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2z\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pulse.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dra\": {\n        source: \"iana\",\n        extensions: [\"dra\"]\n      },\n      \"audio/vnd.dts\": {\n        source: \"iana\",\n        extensions: [\"dts\"]\n      },\n      \"audio/vnd.dts.hd\": {\n        source: \"iana\",\n        extensions: [\"dtshd\"]\n      },\n      \"audio/vnd.dts.uhd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dvb.file\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.everad.plj\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.hns.audio\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.lucent.voice\": {\n        source: \"iana\",\n        extensions: [\"lvp\"]\n      },\n      \"audio/vnd.ms-playready.media.pya\": {\n        source: \"iana\",\n        extensions: [\"pya\"]\n      },\n      \"audio/vnd.nokia.mobile-xmf\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nortel.vbk\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nuera.ecelp4800\": {\n        source: \"iana\",\n        extensions: [\"ecelp4800\"]\n      },\n      \"audio/vnd.nuera.ecelp7470\": {\n        source: \"iana\",\n        extensions: [\"ecelp7470\"]\n      },\n      \"audio/vnd.nuera.ecelp9600\": {\n        source: \"iana\",\n        extensions: [\"ecelp9600\"]\n      },\n      \"audio/vnd.octel.sbc\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.presonus.multitrack\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.qcelp\": {\n        source: \"apache\"\n      },\n      \"audio/vnd.rhetorex.32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.rip\": {\n        source: \"iana\",\n        extensions: [\"rip\"]\n      },\n      \"audio/vnd.rn-realaudio\": {\n        compressible: false\n      },\n      \"audio/vnd.sealedmedia.softseal.mpeg\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.vmx.cvsd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.wave\": {\n        compressible: false\n      },\n      \"audio/vorbis\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/vorbis-config\": {\n        source: \"iana\"\n      },\n      \"audio/wav\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/wave\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"weba\"]\n      },\n      \"audio/x-aac\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"aac\"]\n      },\n      \"audio/x-aiff\": {\n        source: \"apache\",\n        extensions: [\"aif\", \"aiff\", \"aifc\"]\n      },\n      \"audio/x-caf\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"caf\"]\n      },\n      \"audio/x-flac\": {\n        source: \"apache\",\n        extensions: [\"flac\"]\n      },\n      \"audio/x-m4a\": {\n        source: \"nginx\",\n        extensions: [\"m4a\"]\n      },\n      \"audio/x-matroska\": {\n        source: \"apache\",\n        extensions: [\"mka\"]\n      },\n      \"audio/x-mpegurl\": {\n        source: \"apache\",\n        extensions: [\"m3u\"]\n      },\n      \"audio/x-ms-wax\": {\n        source: \"apache\",\n        extensions: [\"wax\"]\n      },\n      \"audio/x-ms-wma\": {\n        source: \"apache\",\n        extensions: [\"wma\"]\n      },\n      \"audio/x-pn-realaudio\": {\n        source: \"apache\",\n        extensions: [\"ram\", \"ra\"]\n      },\n      \"audio/x-pn-realaudio-plugin\": {\n        source: \"apache\",\n        extensions: [\"rmp\"]\n      },\n      \"audio/x-realaudio\": {\n        source: \"nginx\",\n        extensions: [\"ra\"]\n      },\n      \"audio/x-tta\": {\n        source: \"apache\"\n      },\n      \"audio/x-wav\": {\n        source: \"apache\",\n        extensions: [\"wav\"]\n      },\n      \"audio/xm\": {\n        source: \"apache\",\n        extensions: [\"xm\"]\n      },\n      \"chemical/x-cdx\": {\n        source: \"apache\",\n        extensions: [\"cdx\"]\n      },\n      \"chemical/x-cif\": {\n        source: \"apache\",\n        extensions: [\"cif\"]\n      },\n      \"chemical/x-cmdf\": {\n        source: \"apache\",\n        extensions: [\"cmdf\"]\n      },\n      \"chemical/x-cml\": {\n        source: \"apache\",\n        extensions: [\"cml\"]\n      },\n      \"chemical/x-csml\": {\n        source: \"apache\",\n        extensions: [\"csml\"]\n      },\n      \"chemical/x-pdb\": {\n        source: \"apache\"\n      },\n      \"chemical/x-xyz\": {\n        source: \"apache\",\n        extensions: [\"xyz\"]\n      },\n      \"font/collection\": {\n        source: \"iana\",\n        extensions: [\"ttc\"]\n      },\n      \"font/otf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"otf\"]\n      },\n      \"font/sfnt\": {\n        source: \"iana\"\n      },\n      \"font/ttf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttf\"]\n      },\n      \"font/woff\": {\n        source: \"iana\",\n        extensions: [\"woff\"]\n      },\n      \"font/woff2\": {\n        source: \"iana\",\n        extensions: [\"woff2\"]\n      },\n      \"image/aces\": {\n        source: \"iana\",\n        extensions: [\"exr\"]\n      },\n      \"image/apng\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"apng\"]\n      },\n      \"image/avci\": {\n        source: \"iana\",\n        extensions: [\"avci\"]\n      },\n      \"image/avcs\": {\n        source: \"iana\",\n        extensions: [\"avcs\"]\n      },\n      \"image/avif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"avif\"]\n      },\n      \"image/bmp\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmp\", \"dib\"]\n      },\n      \"image/cgm\": {\n        source: \"iana\",\n        extensions: [\"cgm\"]\n      },\n      \"image/dicom-rle\": {\n        source: \"iana\",\n        extensions: [\"drle\"]\n      },\n      \"image/dpx\": {\n        source: \"iana\",\n        extensions: [\"dpx\"]\n      },\n      \"image/emf\": {\n        source: \"iana\",\n        extensions: [\"emf\"]\n      },\n      \"image/fits\": {\n        source: \"iana\",\n        extensions: [\"fits\"]\n      },\n      \"image/g3fax\": {\n        source: \"iana\",\n        extensions: [\"g3\"]\n      },\n      \"image/gif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gif\"]\n      },\n      \"image/heic\": {\n        source: \"iana\",\n        extensions: [\"heic\"]\n      },\n      \"image/heic-sequence\": {\n        source: \"iana\",\n        extensions: [\"heics\"]\n      },\n      \"image/heif\": {\n        source: \"iana\",\n        extensions: [\"heif\"]\n      },\n      \"image/heif-sequence\": {\n        source: \"iana\",\n        extensions: [\"heifs\"]\n      },\n      \"image/hej2k\": {\n        source: \"iana\",\n        extensions: [\"hej2\"]\n      },\n      \"image/ief\": {\n        source: \"iana\",\n        extensions: [\"ief\"]\n      },\n      \"image/j2c\": {\n        source: \"iana\"\n      },\n      \"image/jaii\": {\n        source: \"iana\",\n        extensions: [\"jaii\"]\n      },\n      \"image/jais\": {\n        source: \"iana\",\n        extensions: [\"jais\"]\n      },\n      \"image/jls\": {\n        source: \"iana\",\n        extensions: [\"jls\"]\n      },\n      \"image/jp2\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jp2\", \"jpg2\"]\n      },\n      \"image/jpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpg\", \"jpeg\", \"jpe\"]\n      },\n      \"image/jph\": {\n        source: \"iana\",\n        extensions: [\"jph\"]\n      },\n      \"image/jphc\": {\n        source: \"iana\",\n        extensions: [\"jhc\"]\n      },\n      \"image/jpm\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"image/jpx\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpx\", \"jpf\"]\n      },\n      \"image/jxl\": {\n        source: \"iana\",\n        extensions: [\"jxl\"]\n      },\n      \"image/jxr\": {\n        source: \"iana\",\n        extensions: [\"jxr\"]\n      },\n      \"image/jxra\": {\n        source: \"iana\",\n        extensions: [\"jxra\"]\n      },\n      \"image/jxrs\": {\n        source: \"iana\",\n        extensions: [\"jxrs\"]\n      },\n      \"image/jxs\": {\n        source: \"iana\",\n        extensions: [\"jxs\"]\n      },\n      \"image/jxsc\": {\n        source: \"iana\",\n        extensions: [\"jxsc\"]\n      },\n      \"image/jxsi\": {\n        source: \"iana\",\n        extensions: [\"jxsi\"]\n      },\n      \"image/jxss\": {\n        source: \"iana\",\n        extensions: [\"jxss\"]\n      },\n      \"image/ktx\": {\n        source: \"iana\",\n        extensions: [\"ktx\"]\n      },\n      \"image/ktx2\": {\n        source: \"iana\",\n        extensions: [\"ktx2\"]\n      },\n      \"image/naplps\": {\n        source: \"iana\"\n      },\n      \"image/pjpeg\": {\n        compressible: false,\n        extensions: [\"jfif\"]\n      },\n      \"image/png\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"png\"]\n      },\n      \"image/prs.btif\": {\n        source: \"iana\",\n        extensions: [\"btif\", \"btf\"]\n      },\n      \"image/prs.pti\": {\n        source: \"iana\",\n        extensions: [\"pti\"]\n      },\n      \"image/pwg-raster\": {\n        source: \"iana\"\n      },\n      \"image/sgi\": {\n        source: \"apache\",\n        extensions: [\"sgi\"]\n      },\n      \"image/svg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"svg\", \"svgz\"]\n      },\n      \"image/t38\": {\n        source: \"iana\",\n        extensions: [\"t38\"]\n      },\n      \"image/tiff\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"tif\", \"tiff\"]\n      },\n      \"image/tiff-fx\": {\n        source: \"iana\",\n        extensions: [\"tfx\"]\n      },\n      \"image/vnd.adobe.photoshop\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"psd\"]\n      },\n      \"image/vnd.airzip.accelerator.azv\": {\n        source: \"iana\",\n        extensions: [\"azv\"]\n      },\n      \"image/vnd.clip\": {\n        source: \"iana\"\n      },\n      \"image/vnd.cns.inf2\": {\n        source: \"iana\"\n      },\n      \"image/vnd.dece.graphic\": {\n        source: \"iana\",\n        extensions: [\"uvi\", \"uvvi\", \"uvg\", \"uvvg\"]\n      },\n      \"image/vnd.djvu\": {\n        source: \"iana\",\n        extensions: [\"djvu\", \"djv\"]\n      },\n      \"image/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"image/vnd.dwg\": {\n        source: \"iana\",\n        extensions: [\"dwg\"]\n      },\n      \"image/vnd.dxf\": {\n        source: \"iana\",\n        extensions: [\"dxf\"]\n      },\n      \"image/vnd.fastbidsheet\": {\n        source: \"iana\",\n        extensions: [\"fbs\"]\n      },\n      \"image/vnd.fpx\": {\n        source: \"iana\",\n        extensions: [\"fpx\"]\n      },\n      \"image/vnd.fst\": {\n        source: \"iana\",\n        extensions: [\"fst\"]\n      },\n      \"image/vnd.fujixerox.edmics-mmr\": {\n        source: \"iana\",\n        extensions: [\"mmr\"]\n      },\n      \"image/vnd.fujixerox.edmics-rlc\": {\n        source: \"iana\",\n        extensions: [\"rlc\"]\n      },\n      \"image/vnd.globalgraphics.pgb\": {\n        source: \"iana\"\n      },\n      \"image/vnd.microsoft.icon\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/vnd.mix\": {\n        source: \"iana\"\n      },\n      \"image/vnd.mozilla.apng\": {\n        source: \"iana\"\n      },\n      \"image/vnd.ms-dds\": {\n        compressible: true,\n        extensions: [\"dds\"]\n      },\n      \"image/vnd.ms-modi\": {\n        source: \"iana\",\n        extensions: [\"mdi\"]\n      },\n      \"image/vnd.ms-photo\": {\n        source: \"apache\",\n        extensions: [\"wdp\"]\n      },\n      \"image/vnd.net-fpx\": {\n        source: \"iana\",\n        extensions: [\"npx\"]\n      },\n      \"image/vnd.pco.b16\": {\n        source: \"iana\",\n        extensions: [\"b16\"]\n      },\n      \"image/vnd.radiance\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealed.png\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.gif\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.jpg\": {\n        source: \"iana\"\n      },\n      \"image/vnd.svf\": {\n        source: \"iana\"\n      },\n      \"image/vnd.tencent.tap\": {\n        source: \"iana\",\n        extensions: [\"tap\"]\n      },\n      \"image/vnd.valve.source.texture\": {\n        source: \"iana\",\n        extensions: [\"vtf\"]\n      },\n      \"image/vnd.wap.wbmp\": {\n        source: \"iana\",\n        extensions: [\"wbmp\"]\n      },\n      \"image/vnd.xiff\": {\n        source: \"iana\",\n        extensions: [\"xif\"]\n      },\n      \"image/vnd.zbrush.pcx\": {\n        source: \"iana\",\n        extensions: [\"pcx\"]\n      },\n      \"image/webp\": {\n        source: \"iana\",\n        extensions: [\"webp\"]\n      },\n      \"image/wmf\": {\n        source: \"iana\",\n        extensions: [\"wmf\"]\n      },\n      \"image/x-3ds\": {\n        source: \"apache\",\n        extensions: [\"3ds\"]\n      },\n      \"image/x-adobe-dng\": {\n        extensions: [\"dng\"]\n      },\n      \"image/x-cmu-raster\": {\n        source: \"apache\",\n        extensions: [\"ras\"]\n      },\n      \"image/x-cmx\": {\n        source: \"apache\",\n        extensions: [\"cmx\"]\n      },\n      \"image/x-emf\": {\n        source: \"iana\"\n      },\n      \"image/x-freehand\": {\n        source: \"apache\",\n        extensions: [\"fh\", \"fhc\", \"fh4\", \"fh5\", \"fh7\"]\n      },\n      \"image/x-icon\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/x-jng\": {\n        source: \"nginx\",\n        extensions: [\"jng\"]\n      },\n      \"image/x-mrsid-image\": {\n        source: \"apache\",\n        extensions: [\"sid\"]\n      },\n      \"image/x-ms-bmp\": {\n        source: \"nginx\",\n        compressible: true,\n        extensions: [\"bmp\"]\n      },\n      \"image/x-pcx\": {\n        source: \"apache\",\n        extensions: [\"pcx\"]\n      },\n      \"image/x-pict\": {\n        source: \"apache\",\n        extensions: [\"pic\", \"pct\"]\n      },\n      \"image/x-portable-anymap\": {\n        source: \"apache\",\n        extensions: [\"pnm\"]\n      },\n      \"image/x-portable-bitmap\": {\n        source: \"apache\",\n        extensions: [\"pbm\"]\n      },\n      \"image/x-portable-graymap\": {\n        source: \"apache\",\n        extensions: [\"pgm\"]\n      },\n      \"image/x-portable-pixmap\": {\n        source: \"apache\",\n        extensions: [\"ppm\"]\n      },\n      \"image/x-rgb\": {\n        source: \"apache\",\n        extensions: [\"rgb\"]\n      },\n      \"image/x-tga\": {\n        source: \"apache\",\n        extensions: [\"tga\"]\n      },\n      \"image/x-wmf\": {\n        source: \"iana\"\n      },\n      \"image/x-xbitmap\": {\n        source: \"apache\",\n        extensions: [\"xbm\"]\n      },\n      \"image/x-xcf\": {\n        compressible: false\n      },\n      \"image/x-xpixmap\": {\n        source: \"apache\",\n        extensions: [\"xpm\"]\n      },\n      \"image/x-xwindowdump\": {\n        source: \"apache\",\n        extensions: [\"xwd\"]\n      },\n      \"message/bhttp\": {\n        source: \"iana\"\n      },\n      \"message/cpim\": {\n        source: \"iana\"\n      },\n      \"message/delivery-status\": {\n        source: \"iana\"\n      },\n      \"message/disposition-notification\": {\n        source: \"iana\",\n        extensions: [\n          \"disposition-notification\"\n        ]\n      },\n      \"message/external-body\": {\n        source: \"iana\"\n      },\n      \"message/feedback-report\": {\n        source: \"iana\"\n      },\n      \"message/global\": {\n        source: \"iana\",\n        extensions: [\"u8msg\"]\n      },\n      \"message/global-delivery-status\": {\n        source: \"iana\",\n        extensions: [\"u8dsn\"]\n      },\n      \"message/global-disposition-notification\": {\n        source: \"iana\",\n        extensions: [\"u8mdn\"]\n      },\n      \"message/global-headers\": {\n        source: \"iana\",\n        extensions: [\"u8hdr\"]\n      },\n      \"message/http\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/imdn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"message/mls\": {\n        source: \"iana\"\n      },\n      \"message/news\": {\n        source: \"apache\"\n      },\n      \"message/ohttp-req\": {\n        source: \"iana\"\n      },\n      \"message/ohttp-res\": {\n        source: \"iana\"\n      },\n      \"message/partial\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/rfc822\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eml\", \"mime\", \"mht\", \"mhtml\"]\n      },\n      \"message/s-http\": {\n        source: \"apache\"\n      },\n      \"message/sip\": {\n        source: \"iana\"\n      },\n      \"message/sipfrag\": {\n        source: \"iana\"\n      },\n      \"message/tracking-status\": {\n        source: \"iana\"\n      },\n      \"message/vnd.si.simp\": {\n        source: \"apache\"\n      },\n      \"message/vnd.wfa.wsc\": {\n        source: \"iana\",\n        extensions: [\"wsc\"]\n      },\n      \"model/3mf\": {\n        source: \"iana\",\n        extensions: [\"3mf\"]\n      },\n      \"model/e57\": {\n        source: \"iana\"\n      },\n      \"model/gltf+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gltf\"]\n      },\n      \"model/gltf-binary\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"glb\"]\n      },\n      \"model/iges\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"igs\", \"iges\"]\n      },\n      \"model/jt\": {\n        source: \"iana\",\n        extensions: [\"jt\"]\n      },\n      \"model/mesh\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"msh\", \"mesh\", \"silo\"]\n      },\n      \"model/mtl\": {\n        source: \"iana\",\n        extensions: [\"mtl\"]\n      },\n      \"model/obj\": {\n        source: \"iana\",\n        extensions: [\"obj\"]\n      },\n      \"model/prc\": {\n        source: \"iana\",\n        extensions: [\"prc\"]\n      },\n      \"model/step\": {\n        source: \"iana\",\n        extensions: [\"step\", \"stp\", \"stpnc\", \"p21\", \"210\"]\n      },\n      \"model/step+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"stpx\"]\n      },\n      \"model/step+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpz\"]\n      },\n      \"model/step-xml+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpxz\"]\n      },\n      \"model/stl\": {\n        source: \"iana\",\n        extensions: [\"stl\"]\n      },\n      \"model/u3d\": {\n        source: \"iana\",\n        extensions: [\"u3d\"]\n      },\n      \"model/vnd.bary\": {\n        source: \"iana\",\n        extensions: [\"bary\"]\n      },\n      \"model/vnd.cld\": {\n        source: \"iana\",\n        extensions: [\"cld\"]\n      },\n      \"model/vnd.collada+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dae\"]\n      },\n      \"model/vnd.dwf\": {\n        source: \"iana\",\n        extensions: [\"dwf\"]\n      },\n      \"model/vnd.flatland.3dml\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gdl\": {\n        source: \"iana\",\n        extensions: [\"gdl\"]\n      },\n      \"model/vnd.gs-gdl\": {\n        source: \"apache\"\n      },\n      \"model/vnd.gs.gdl\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gtw\": {\n        source: \"iana\",\n        extensions: [\"gtw\"]\n      },\n      \"model/vnd.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"model/vnd.mts\": {\n        source: \"iana\",\n        extensions: [\"mts\"]\n      },\n      \"model/vnd.opengex\": {\n        source: \"iana\",\n        extensions: [\"ogex\"]\n      },\n      \"model/vnd.parasolid.transmit.binary\": {\n        source: \"iana\",\n        extensions: [\"x_b\"]\n      },\n      \"model/vnd.parasolid.transmit.text\": {\n        source: \"iana\",\n        extensions: [\"x_t\"]\n      },\n      \"model/vnd.pytha.pyox\": {\n        source: \"iana\",\n        extensions: [\"pyo\", \"pyox\"]\n      },\n      \"model/vnd.rosette.annotated-data-model\": {\n        source: \"iana\"\n      },\n      \"model/vnd.sap.vds\": {\n        source: \"iana\",\n        extensions: [\"vds\"]\n      },\n      \"model/vnd.usda\": {\n        source: \"iana\",\n        extensions: [\"usda\"]\n      },\n      \"model/vnd.usdz+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"usdz\"]\n      },\n      \"model/vnd.valve.source.compiled-map\": {\n        source: \"iana\",\n        extensions: [\"bsp\"]\n      },\n      \"model/vnd.vtu\": {\n        source: \"iana\",\n        extensions: [\"vtu\"]\n      },\n      \"model/vrml\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"wrl\", \"vrml\"]\n      },\n      \"model/x3d+binary\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3db\", \"x3dbz\"]\n      },\n      \"model/x3d+fastinfoset\": {\n        source: \"iana\",\n        extensions: [\"x3db\"]\n      },\n      \"model/x3d+vrml\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3dv\", \"x3dvz\"]\n      },\n      \"model/x3d+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"x3d\", \"x3dz\"]\n      },\n      \"model/x3d-vrml\": {\n        source: \"iana\",\n        extensions: [\"x3dv\"]\n      },\n      \"multipart/alternative\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/appledouble\": {\n        source: \"iana\"\n      },\n      \"multipart/byteranges\": {\n        source: \"iana\"\n      },\n      \"multipart/digest\": {\n        source: \"iana\"\n      },\n      \"multipart/encrypted\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/form-data\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/header-set\": {\n        source: \"iana\"\n      },\n      \"multipart/mixed\": {\n        source: \"iana\"\n      },\n      \"multipart/multilingual\": {\n        source: \"iana\"\n      },\n      \"multipart/parallel\": {\n        source: \"iana\"\n      },\n      \"multipart/related\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/report\": {\n        source: \"iana\"\n      },\n      \"multipart/signed\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/vnd.bint.med-plus\": {\n        source: \"iana\"\n      },\n      \"multipart/voice-message\": {\n        source: \"iana\"\n      },\n      \"multipart/x-mixed-replace\": {\n        source: \"iana\"\n      },\n      \"text/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"text/cache-manifest\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"appcache\", \"manifest\"]\n      },\n      \"text/calendar\": {\n        source: \"iana\",\n        extensions: [\"ics\", \"ifb\"]\n      },\n      \"text/calender\": {\n        compressible: true\n      },\n      \"text/cmd\": {\n        compressible: true\n      },\n      \"text/coffeescript\": {\n        extensions: [\"coffee\", \"litcoffee\"]\n      },\n      \"text/cql\": {\n        source: \"iana\"\n      },\n      \"text/cql-expression\": {\n        source: \"iana\"\n      },\n      \"text/cql-identifier\": {\n        source: \"iana\"\n      },\n      \"text/css\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"css\"]\n      },\n      \"text/csv\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csv\"]\n      },\n      \"text/csv-schema\": {\n        source: \"iana\"\n      },\n      \"text/directory\": {\n        source: \"iana\"\n      },\n      \"text/dns\": {\n        source: \"iana\"\n      },\n      \"text/ecmascript\": {\n        source: \"apache\"\n      },\n      \"text/encaprtp\": {\n        source: \"iana\"\n      },\n      \"text/enriched\": {\n        source: \"iana\"\n      },\n      \"text/fhirpath\": {\n        source: \"iana\"\n      },\n      \"text/flexfec\": {\n        source: \"iana\"\n      },\n      \"text/fwdred\": {\n        source: \"iana\"\n      },\n      \"text/gff3\": {\n        source: \"iana\"\n      },\n      \"text/grammar-ref-list\": {\n        source: \"iana\"\n      },\n      \"text/hl7v2\": {\n        source: \"iana\"\n      },\n      \"text/html\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"html\", \"htm\", \"shtml\"]\n      },\n      \"text/jade\": {\n        extensions: [\"jade\"]\n      },\n      \"text/javascript\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\", \"mjs\"]\n      },\n      \"text/jcr-cnd\": {\n        source: \"iana\"\n      },\n      \"text/jsx\": {\n        compressible: true,\n        extensions: [\"jsx\"]\n      },\n      \"text/less\": {\n        compressible: true,\n        extensions: [\"less\"]\n      },\n      \"text/markdown\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"md\", \"markdown\"]\n      },\n      \"text/mathml\": {\n        source: \"nginx\",\n        extensions: [\"mml\"]\n      },\n      \"text/mdx\": {\n        compressible: true,\n        extensions: [\"mdx\"]\n      },\n      \"text/mizar\": {\n        source: \"iana\"\n      },\n      \"text/n3\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"n3\"]\n      },\n      \"text/parameters\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/parityfec\": {\n        source: \"iana\"\n      },\n      \"text/plain\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"txt\", \"text\", \"conf\", \"def\", \"list\", \"log\", \"in\", \"ini\"]\n      },\n      \"text/provenance-notation\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/prs.fallenstein.rst\": {\n        source: \"iana\"\n      },\n      \"text/prs.lines.tag\": {\n        source: \"iana\",\n        extensions: [\"dsc\"]\n      },\n      \"text/prs.prop.logic\": {\n        source: \"iana\"\n      },\n      \"text/prs.texi\": {\n        source: \"iana\"\n      },\n      \"text/raptorfec\": {\n        source: \"iana\"\n      },\n      \"text/red\": {\n        source: \"iana\"\n      },\n      \"text/rfc822-headers\": {\n        source: \"iana\"\n      },\n      \"text/richtext\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtx\"]\n      },\n      \"text/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"text/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"text/rtploopback\": {\n        source: \"iana\"\n      },\n      \"text/rtx\": {\n        source: \"iana\"\n      },\n      \"text/sgml\": {\n        source: \"iana\",\n        extensions: [\"sgml\", \"sgm\"]\n      },\n      \"text/shaclc\": {\n        source: \"iana\"\n      },\n      \"text/shex\": {\n        source: \"iana\",\n        extensions: [\"shex\"]\n      },\n      \"text/slim\": {\n        extensions: [\"slim\", \"slm\"]\n      },\n      \"text/spdx\": {\n        source: \"iana\",\n        extensions: [\"spdx\"]\n      },\n      \"text/strings\": {\n        source: \"iana\"\n      },\n      \"text/stylus\": {\n        extensions: [\"stylus\", \"styl\"]\n      },\n      \"text/t140\": {\n        source: \"iana\"\n      },\n      \"text/tab-separated-values\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tsv\"]\n      },\n      \"text/troff\": {\n        source: \"iana\",\n        extensions: [\"t\", \"tr\", \"roff\", \"man\", \"me\", \"ms\"]\n      },\n      \"text/turtle\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"ttl\"]\n      },\n      \"text/ulpfec\": {\n        source: \"iana\"\n      },\n      \"text/uri-list\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uri\", \"uris\", \"urls\"]\n      },\n      \"text/vcard\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vcard\"]\n      },\n      \"text/vnd.a\": {\n        source: \"iana\"\n      },\n      \"text/vnd.abc\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ascii-art\": {\n        source: \"iana\"\n      },\n      \"text/vnd.curl\": {\n        source: \"iana\",\n        extensions: [\"curl\"]\n      },\n      \"text/vnd.curl.dcurl\": {\n        source: \"apache\",\n        extensions: [\"dcurl\"]\n      },\n      \"text/vnd.curl.mcurl\": {\n        source: \"apache\",\n        extensions: [\"mcurl\"]\n      },\n      \"text/vnd.curl.scurl\": {\n        source: \"apache\",\n        extensions: [\"scurl\"]\n      },\n      \"text/vnd.debian.copyright\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.dmclientscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"text/vnd.esmertec.theme-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.exchangeable\": {\n        source: \"iana\"\n      },\n      \"text/vnd.familysearch.gedcom\": {\n        source: \"iana\",\n        extensions: [\"ged\"]\n      },\n      \"text/vnd.ficlab.flt\": {\n        source: \"iana\"\n      },\n      \"text/vnd.fly\": {\n        source: \"iana\",\n        extensions: [\"fly\"]\n      },\n      \"text/vnd.fmi.flexstor\": {\n        source: \"iana\",\n        extensions: [\"flx\"]\n      },\n      \"text/vnd.gml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.graphviz\": {\n        source: \"iana\",\n        extensions: [\"gv\"]\n      },\n      \"text/vnd.hans\": {\n        source: \"iana\"\n      },\n      \"text/vnd.hgl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.in3d.3dml\": {\n        source: \"iana\",\n        extensions: [\"3dml\"]\n      },\n      \"text/vnd.in3d.spot\": {\n        source: \"iana\",\n        extensions: [\"spot\"]\n      },\n      \"text/vnd.iptc.newsml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.iptc.nitf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.latex-z\": {\n        source: \"iana\"\n      },\n      \"text/vnd.motorola.reflex\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ms-mediapackage\": {\n        source: \"iana\"\n      },\n      \"text/vnd.net2phone.commcenter.command\": {\n        source: \"iana\"\n      },\n      \"text/vnd.radisys.msml-basic-layout\": {\n        source: \"iana\"\n      },\n      \"text/vnd.senx.warpscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.si.uricatalogue\": {\n        source: \"apache\"\n      },\n      \"text/vnd.sosi\": {\n        source: \"iana\"\n      },\n      \"text/vnd.sun.j2me.app-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"jad\"]\n      },\n      \"text/vnd.trolltech.linguist\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.vcf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.si\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.sl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.wml\": {\n        source: \"iana\",\n        extensions: [\"wml\"]\n      },\n      \"text/vnd.wap.wmlscript\": {\n        source: \"iana\",\n        extensions: [\"wmls\"]\n      },\n      \"text/vnd.zoo.kcl\": {\n        source: \"iana\"\n      },\n      \"text/vtt\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"vtt\"]\n      },\n      \"text/wgsl\": {\n        source: \"iana\",\n        extensions: [\"wgsl\"]\n      },\n      \"text/x-asm\": {\n        source: \"apache\",\n        extensions: [\"s\", \"asm\"]\n      },\n      \"text/x-c\": {\n        source: \"apache\",\n        extensions: [\"c\", \"cc\", \"cxx\", \"cpp\", \"h\", \"hh\", \"dic\"]\n      },\n      \"text/x-component\": {\n        source: \"nginx\",\n        extensions: [\"htc\"]\n      },\n      \"text/x-fortran\": {\n        source: \"apache\",\n        extensions: [\"f\", \"for\", \"f77\", \"f90\"]\n      },\n      \"text/x-gwt-rpc\": {\n        compressible: true\n      },\n      \"text/x-handlebars-template\": {\n        extensions: [\"hbs\"]\n      },\n      \"text/x-java-source\": {\n        source: \"apache\",\n        extensions: [\"java\"]\n      },\n      \"text/x-jquery-tmpl\": {\n        compressible: true\n      },\n      \"text/x-lua\": {\n        extensions: [\"lua\"]\n      },\n      \"text/x-markdown\": {\n        compressible: true,\n        extensions: [\"mkd\"]\n      },\n      \"text/x-nfo\": {\n        source: \"apache\",\n        extensions: [\"nfo\"]\n      },\n      \"text/x-opml\": {\n        source: \"apache\",\n        extensions: [\"opml\"]\n      },\n      \"text/x-org\": {\n        compressible: true,\n        extensions: [\"org\"]\n      },\n      \"text/x-pascal\": {\n        source: \"apache\",\n        extensions: [\"p\", \"pas\"]\n      },\n      \"text/x-processing\": {\n        compressible: true,\n        extensions: [\"pde\"]\n      },\n      \"text/x-sass\": {\n        extensions: [\"sass\"]\n      },\n      \"text/x-scss\": {\n        extensions: [\"scss\"]\n      },\n      \"text/x-setext\": {\n        source: \"apache\",\n        extensions: [\"etx\"]\n      },\n      \"text/x-sfv\": {\n        source: \"apache\",\n        extensions: [\"sfv\"]\n      },\n      \"text/x-suse-ymp\": {\n        compressible: true,\n        extensions: [\"ymp\"]\n      },\n      \"text/x-uuencode\": {\n        source: \"apache\",\n        extensions: [\"uu\"]\n      },\n      \"text/x-vcalendar\": {\n        source: \"apache\",\n        extensions: [\"vcs\"]\n      },\n      \"text/x-vcard\": {\n        source: \"apache\",\n        extensions: [\"vcf\"]\n      },\n      \"text/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\"]\n      },\n      \"text/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"text/yaml\": {\n        compressible: true,\n        extensions: [\"yaml\", \"yml\"]\n      },\n      \"video/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"video/3gpp\": {\n        source: \"iana\",\n        extensions: [\"3gp\", \"3gpp\"]\n      },\n      \"video/3gpp-tt\": {\n        source: \"iana\"\n      },\n      \"video/3gpp2\": {\n        source: \"iana\",\n        extensions: [\"3g2\"]\n      },\n      \"video/av1\": {\n        source: \"iana\"\n      },\n      \"video/bmpeg\": {\n        source: \"iana\"\n      },\n      \"video/bt656\": {\n        source: \"iana\"\n      },\n      \"video/celb\": {\n        source: \"iana\"\n      },\n      \"video/dv\": {\n        source: \"iana\"\n      },\n      \"video/encaprtp\": {\n        source: \"iana\"\n      },\n      \"video/evc\": {\n        source: \"iana\"\n      },\n      \"video/ffv1\": {\n        source: \"iana\"\n      },\n      \"video/flexfec\": {\n        source: \"iana\"\n      },\n      \"video/h261\": {\n        source: \"iana\",\n        extensions: [\"h261\"]\n      },\n      \"video/h263\": {\n        source: \"iana\",\n        extensions: [\"h263\"]\n      },\n      \"video/h263-1998\": {\n        source: \"iana\"\n      },\n      \"video/h263-2000\": {\n        source: \"iana\"\n      },\n      \"video/h264\": {\n        source: \"iana\",\n        extensions: [\"h264\"]\n      },\n      \"video/h264-rcdo\": {\n        source: \"iana\"\n      },\n      \"video/h264-svc\": {\n        source: \"iana\"\n      },\n      \"video/h265\": {\n        source: \"iana\"\n      },\n      \"video/h266\": {\n        source: \"iana\"\n      },\n      \"video/iso.segment\": {\n        source: \"iana\",\n        extensions: [\"m4s\"]\n      },\n      \"video/jpeg\": {\n        source: \"iana\",\n        extensions: [\"jpgv\"]\n      },\n      \"video/jpeg2000\": {\n        source: \"iana\"\n      },\n      \"video/jpm\": {\n        source: \"apache\",\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"video/jxsv\": {\n        source: \"iana\"\n      },\n      \"video/lottie+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"video/matroska\": {\n        source: \"iana\"\n      },\n      \"video/matroska-3d\": {\n        source: \"iana\"\n      },\n      \"video/mj2\": {\n        source: \"iana\",\n        extensions: [\"mj2\", \"mjp2\"]\n      },\n      \"video/mp1s\": {\n        source: \"iana\"\n      },\n      \"video/mp2p\": {\n        source: \"iana\"\n      },\n      \"video/mp2t\": {\n        source: \"iana\",\n        extensions: [\"ts\", \"m2t\", \"m2ts\", \"mts\"]\n      },\n      \"video/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mp4\", \"mp4v\", \"mpg4\"]\n      },\n      \"video/mp4v-es\": {\n        source: \"iana\"\n      },\n      \"video/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpeg\", \"mpg\", \"mpe\", \"m1v\", \"m2v\"]\n      },\n      \"video/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"video/mpv\": {\n        source: \"iana\"\n      },\n      \"video/nv\": {\n        source: \"iana\"\n      },\n      \"video/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogv\"]\n      },\n      \"video/parityfec\": {\n        source: \"iana\"\n      },\n      \"video/pointer\": {\n        source: \"iana\"\n      },\n      \"video/quicktime\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"qt\", \"mov\"]\n      },\n      \"video/raptorfec\": {\n        source: \"iana\"\n      },\n      \"video/raw\": {\n        source: \"iana\"\n      },\n      \"video/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"video/rtploopback\": {\n        source: \"iana\"\n      },\n      \"video/rtx\": {\n        source: \"iana\"\n      },\n      \"video/scip\": {\n        source: \"iana\"\n      },\n      \"video/smpte291\": {\n        source: \"iana\"\n      },\n      \"video/smpte292m\": {\n        source: \"iana\"\n      },\n      \"video/ulpfec\": {\n        source: \"iana\"\n      },\n      \"video/vc1\": {\n        source: \"iana\"\n      },\n      \"video/vc2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.cctv\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.hd\": {\n        source: \"iana\",\n        extensions: [\"uvh\", \"uvvh\"]\n      },\n      \"video/vnd.dece.mobile\": {\n        source: \"iana\",\n        extensions: [\"uvm\", \"uvvm\"]\n      },\n      \"video/vnd.dece.mp4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.pd\": {\n        source: \"iana\",\n        extensions: [\"uvp\", \"uvvp\"]\n      },\n      \"video/vnd.dece.sd\": {\n        source: \"iana\",\n        extensions: [\"uvs\", \"uvvs\"]\n      },\n      \"video/vnd.dece.video\": {\n        source: \"iana\",\n        extensions: [\"uvv\", \"uvvv\"]\n      },\n      \"video/vnd.directv.mpeg\": {\n        source: \"iana\"\n      },\n      \"video/vnd.directv.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dlna.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dvb.file\": {\n        source: \"iana\",\n        extensions: [\"dvb\"]\n      },\n      \"video/vnd.fvt\": {\n        source: \"iana\",\n        extensions: [\"fvt\"]\n      },\n      \"video/vnd.hns.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsavc\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsmpeg2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.videop\": {\n        source: \"iana\"\n      },\n      \"video/vnd.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"mxu\", \"m4u\"]\n      },\n      \"video/vnd.ms-playready.media.pyv\": {\n        source: \"iana\",\n        extensions: [\"pyv\"]\n      },\n      \"video/vnd.nokia.interleaved-multimedia\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.mp4vr\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.videovoip\": {\n        source: \"iana\"\n      },\n      \"video/vnd.objectvideo\": {\n        source: \"iana\"\n      },\n      \"video/vnd.planar\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.bink\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.smacker\": {\n        source: \"apache\"\n      },\n      \"video/vnd.sealed.mpeg1\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.mpeg4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.swf\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealedmedia.softseal.mov\": {\n        source: \"iana\"\n      },\n      \"video/vnd.uvvu.mp4\": {\n        source: \"iana\",\n        extensions: [\"uvu\", \"uvvu\"]\n      },\n      \"video/vnd.vivo\": {\n        source: \"iana\",\n        extensions: [\"viv\"]\n      },\n      \"video/vnd.youtube.yt\": {\n        source: \"iana\"\n      },\n      \"video/vp8\": {\n        source: \"iana\"\n      },\n      \"video/vp9\": {\n        source: \"iana\"\n      },\n      \"video/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"webm\"]\n      },\n      \"video/x-f4v\": {\n        source: \"apache\",\n        extensions: [\"f4v\"]\n      },\n      \"video/x-fli\": {\n        source: \"apache\",\n        extensions: [\"fli\"]\n      },\n      \"video/x-flv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"flv\"]\n      },\n      \"video/x-m4v\": {\n        source: \"apache\",\n        extensions: [\"m4v\"]\n      },\n      \"video/x-matroska\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"mkv\", \"mk3d\", \"mks\"]\n      },\n      \"video/x-mng\": {\n        source: \"apache\",\n        extensions: [\"mng\"]\n      },\n      \"video/x-ms-asf\": {\n        source: \"apache\",\n        extensions: [\"asf\", \"asx\"]\n      },\n      \"video/x-ms-vob\": {\n        source: \"apache\",\n        extensions: [\"vob\"]\n      },\n      \"video/x-ms-wm\": {\n        source: \"apache\",\n        extensions: [\"wm\"]\n      },\n      \"video/x-ms-wmv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"wmv\"]\n      },\n      \"video/x-ms-wmx\": {\n        source: \"apache\",\n        extensions: [\"wmx\"]\n      },\n      \"video/x-ms-wvx\": {\n        source: \"apache\",\n        extensions: [\"wvx\"]\n      },\n      \"video/x-msvideo\": {\n        source: \"apache\",\n        extensions: [\"avi\"]\n      },\n      \"video/x-sgi-movie\": {\n        source: \"apache\",\n        extensions: [\"movie\"]\n      },\n      \"video/x-smv\": {\n        source: \"apache\",\n        extensions: [\"smv\"]\n      },\n      \"x-conference/x-cooltalk\": {\n        source: \"apache\",\n        extensions: [\"ice\"]\n      },\n      \"x-shader/x-fragment\": {\n        compressible: true\n      },\n      \"x-shader/x-vertex\": {\n        compressible: true\n      }\n    };\n  }\n});\n\n// node_modules/accepts/node_modules/mime-db/index.js\nvar require_mime_db3 = __commonJS({\n  \"node_modules/accepts/node_modules/mime-db/index.js\"(exports2, module2) {\n    module2.exports = require_db3();\n  }\n});\n\n// node_modules/accepts/node_modules/mime-types/mimeScore.js\nvar require_mimeScore3 = __commonJS({\n  \"node_modules/accepts/node_modules/mime-types/mimeScore.js\"(exports2, module2) {\n    var FACET_SCORES = {\n      \"prs.\": 100,\n      \"x-\": 200,\n      \"x.\": 300,\n      \"vnd.\": 400,\n      default: 900\n    };\n    var SOURCE_SCORES = {\n      nginx: 10,\n      apache: 20,\n      iana: 40,\n      default: 30\n      // definitions added by `jshttp/mime-db` project?\n    };\n    var TYPE_SCORES = {\n      // prefer application/xml over text/xml\n      // prefer application/rtf over text/rtf\n      application: 1,\n      // prefer font/woff over application/font-woff\n      font: 2,\n      default: 0\n    };\n    module2.exports = function mimeScore(mimeType, source = \"default\") {\n      if (mimeType === \"application/octet-stream\") {\n        return 0;\n      }\n      const [type, subtype] = mimeType.split(\"/\");\n      const facet = subtype.replace(/(\\.|x-).*/, \"$1\");\n      const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;\n      const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;\n      const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;\n      const lengthScore = 1 - mimeType.length / 100;\n      return facetScore + sourceScore + typeScore + lengthScore;\n    };\n  }\n});\n\n// node_modules/accepts/node_modules/mime-types/index.js\nvar require_mime_types3 = __commonJS({\n  \"node_modules/accepts/node_modules/mime-types/index.js\"(exports2) {\n    \"use strict\";\n    var db = require_mime_db3();\n    var extname = require(\"path\").extname;\n    var mimeScore = require_mimeScore3();\n    var EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/;\n    var TEXT_TYPE_REGEXP = /^text\\//i;\n    exports2.charset = charset;\n    exports2.charsets = { lookup: charset };\n    exports2.contentType = contentType2;\n    exports2.extension = extension;\n    exports2.extensions = /* @__PURE__ */ Object.create(null);\n    exports2.lookup = lookup;\n    exports2.types = /* @__PURE__ */ Object.create(null);\n    exports2._extensionConflicts = [];\n    populateMaps(exports2.extensions, exports2.types);\n    function charset(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var mime = match && db[match[1].toLowerCase()];\n      if (mime && mime.charset) {\n        return mime.charset;\n      }\n      if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n        return \"UTF-8\";\n      }\n      return false;\n    }\n    function contentType2(str) {\n      if (!str || typeof str !== \"string\") {\n        return false;\n      }\n      var mime = str.indexOf(\"/\") === -1 ? exports2.lookup(str) : str;\n      if (!mime) {\n        return false;\n      }\n      if (mime.indexOf(\"charset\") === -1) {\n        var charset2 = exports2.charset(mime);\n        if (charset2) mime += \"; charset=\" + charset2.toLowerCase();\n      }\n      return mime;\n    }\n    function extension(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var exts = match && exports2.extensions[match[1].toLowerCase()];\n      if (!exts || !exts.length) {\n        return false;\n      }\n      return exts[0];\n    }\n    function lookup(path) {\n      if (!path || typeof path !== \"string\") {\n        return false;\n      }\n      var extension2 = extname(\"x.\" + path).toLowerCase().slice(1);\n      if (!extension2) {\n        return false;\n      }\n      return exports2.types[extension2] || false;\n    }\n    function populateMaps(extensions, types) {\n      Object.keys(db).forEach(function forEachMimeType(type) {\n        var mime = db[type];\n        var exts = mime.extensions;\n        if (!exts || !exts.length) {\n          return;\n        }\n        extensions[type] = exts;\n        for (var i = 0; i < exts.length; i++) {\n          var extension2 = exts[i];\n          types[extension2] = _preferredType(extension2, types[extension2], type);\n          const legacyType = _preferredTypeLegacy(\n            extension2,\n            types[extension2],\n            type\n          );\n          if (legacyType !== types[extension2]) {\n            exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]);\n          }\n        }\n      });\n    }\n    function _preferredType(ext, type0, type1) {\n      var score0 = type0 ? mimeScore(type0, db[type0].source) : 0;\n      var score1 = type1 ? mimeScore(type1, db[type1].source) : 0;\n      return score0 > score1 ? type0 : type1;\n    }\n    function _preferredTypeLegacy(ext, type0, type1) {\n      var SOURCE_RANK = [\"nginx\", \"apache\", void 0, \"iana\"];\n      var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0;\n      var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0;\n      if (exports2.types[extension] !== \"application/octet-stream\" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === \"application/\")) {\n        return type0;\n      }\n      return score0 > score1 ? type0 : type1;\n    }\n  }\n});\n\n// node_modules/accepts/index.js\nvar require_accepts = __commonJS({\n  \"node_modules/accepts/index.js\"(exports2, module2) {\n    \"use strict\";\n    var Negotiator = require_negotiator();\n    var mime = require_mime_types3();\n    module2.exports = Accepts;\n    function Accepts(req) {\n      if (!(this instanceof Accepts)) {\n        return new Accepts(req);\n      }\n      this.headers = req.headers;\n      this.negotiator = new Negotiator(req);\n    }\n    Accepts.prototype.type = Accepts.prototype.types = function(types_) {\n      var types = types_;\n      if (types && !Array.isArray(types)) {\n        types = new Array(arguments.length);\n        for (var i = 0; i < types.length; i++) {\n          types[i] = arguments[i];\n        }\n      }\n      if (!types || types.length === 0) {\n        return this.negotiator.mediaTypes();\n      }\n      if (!this.headers.accept) {\n        return types[0];\n      }\n      var mimes = types.map(extToMime);\n      var accepts = this.negotiator.mediaTypes(mimes.filter(validMime));\n      var first = accepts[0];\n      return first ? types[mimes.indexOf(first)] : false;\n    };\n    Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) {\n      var encodings = encodings_;\n      if (encodings && !Array.isArray(encodings)) {\n        encodings = new Array(arguments.length);\n        for (var i = 0; i < encodings.length; i++) {\n          encodings[i] = arguments[i];\n        }\n      }\n      if (!encodings || encodings.length === 0) {\n        return this.negotiator.encodings();\n      }\n      return this.negotiator.encodings(encodings)[0] || false;\n    };\n    Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) {\n      var charsets = charsets_;\n      if (charsets && !Array.isArray(charsets)) {\n        charsets = new Array(arguments.length);\n        for (var i = 0; i < charsets.length; i++) {\n          charsets[i] = arguments[i];\n        }\n      }\n      if (!charsets || charsets.length === 0) {\n        return this.negotiator.charsets();\n      }\n      return this.negotiator.charsets(charsets)[0] || false;\n    };\n    Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) {\n      var languages = languages_;\n      if (languages && !Array.isArray(languages)) {\n        languages = new Array(arguments.length);\n        for (var i = 0; i < languages.length; i++) {\n          languages[i] = arguments[i];\n        }\n      }\n      if (!languages || languages.length === 0) {\n        return this.negotiator.languages();\n      }\n      return this.negotiator.languages(languages)[0] || false;\n    };\n    function extToMime(type) {\n      return type.indexOf(\"/\") === -1 ? mime.lookup(type) : type;\n    }\n    function validMime(type) {\n      return typeof type === \"string\";\n    }\n  }\n});\n\n// node_modules/fresh/index.js\nvar require_fresh = __commonJS({\n  \"node_modules/fresh/index.js\"(exports2, module2) {\n    \"use strict\";\n    var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\\s*?no-cache\\s*?(?:,|$)/;\n    module2.exports = fresh;\n    function fresh(reqHeaders, resHeaders) {\n      var modifiedSince = reqHeaders[\"if-modified-since\"];\n      var noneMatch = reqHeaders[\"if-none-match\"];\n      if (!modifiedSince && !noneMatch) {\n        return false;\n      }\n      var cacheControl = reqHeaders[\"cache-control\"];\n      if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) {\n        return false;\n      }\n      if (noneMatch) {\n        if (noneMatch === \"*\") {\n          return true;\n        }\n        var etag = resHeaders.etag;\n        if (!etag) {\n          return false;\n        }\n        var matches = parseTokenList(noneMatch);\n        for (var i = 0; i < matches.length; i++) {\n          var match = matches[i];\n          if (match === etag || match === \"W/\" + etag || \"W/\" + match === etag) {\n            return true;\n          }\n        }\n        return false;\n      }\n      if (modifiedSince) {\n        var lastModified = resHeaders[\"last-modified\"];\n        var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince));\n        if (modifiedStale) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function parseHttpDate(date) {\n      var timestamp = date && Date.parse(date);\n      return typeof timestamp === \"number\" ? timestamp : NaN;\n    }\n    function parseTokenList(str) {\n      var end = 0;\n      var list = [];\n      var start = 0;\n      for (var i = 0, len = str.length; i < len; i++) {\n        switch (str.charCodeAt(i)) {\n          case 32:\n            if (start === end) {\n              start = end = i + 1;\n            }\n            break;\n          case 44:\n            list.push(str.substring(start, end));\n            start = end = i + 1;\n            break;\n          default:\n            end = i + 1;\n            break;\n        }\n      }\n      list.push(str.substring(start, end));\n      return list;\n    }\n  }\n});\n\n// node_modules/range-parser/index.js\nvar require_range_parser = __commonJS({\n  \"node_modules/range-parser/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = rangeParser;\n    function rangeParser(size, str, options) {\n      if (typeof str !== \"string\") {\n        throw new TypeError(\"argument str must be a string\");\n      }\n      var index = str.indexOf(\"=\");\n      if (index === -1) {\n        return -2;\n      }\n      var arr = str.slice(index + 1).split(\",\");\n      var ranges = [];\n      ranges.type = str.slice(0, index);\n      for (var i = 0; i < arr.length; i++) {\n        var range = arr[i].split(\"-\");\n        var start = parseInt(range[0], 10);\n        var end = parseInt(range[1], 10);\n        if (isNaN(start)) {\n          start = size - end;\n          end = size - 1;\n        } else if (isNaN(end)) {\n          end = size - 1;\n        }\n        if (end > size - 1) {\n          end = size - 1;\n        }\n        if (isNaN(start) || isNaN(end) || start > end || start < 0) {\n          continue;\n        }\n        ranges.push({\n          start,\n          end\n        });\n      }\n      if (ranges.length < 1) {\n        return -1;\n      }\n      return options && options.combine ? combineRanges(ranges) : ranges;\n    }\n    function combineRanges(ranges) {\n      var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);\n      for (var j = 0, i = 1; i < ordered.length; i++) {\n        var range = ordered[i];\n        var current = ordered[j];\n        if (range.start > current.end + 1) {\n          ordered[++j] = range;\n        } else if (range.end > current.end) {\n          current.end = range.end;\n          current.index = Math.min(current.index, range.index);\n        }\n      }\n      ordered.length = j + 1;\n      var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);\n      combined.type = ranges.type;\n      return combined;\n    }\n    function mapWithIndex(range, index) {\n      return {\n        start: range.start,\n        end: range.end,\n        index\n      };\n    }\n    function mapWithoutIndex(range) {\n      return {\n        start: range.start,\n        end: range.end\n      };\n    }\n    function sortByRangeIndex(a, b) {\n      return a.index - b.index;\n    }\n    function sortByRangeStart(a, b) {\n      return a.start - b.start;\n    }\n  }\n});\n\n// node_modules/express/lib/request.js\nvar require_request = __commonJS({\n  \"node_modules/express/lib/request.js\"(exports2, module2) {\n    \"use strict\";\n    var accepts = require_accepts();\n    var isIP = require(\"node:net\").isIP;\n    var typeis = require_type_is();\n    var http = require(\"node:http\");\n    var fresh = require_fresh();\n    var parseRange = require_range_parser();\n    var parse = require_parseurl();\n    var proxyaddr = require_proxy_addr();\n    var req = Object.create(http.IncomingMessage.prototype);\n    module2.exports = req;\n    req.get = req.header = function header(name) {\n      if (!name) {\n        throw new TypeError(\"name argument is required to req.get\");\n      }\n      if (typeof name !== \"string\") {\n        throw new TypeError(\"name must be a string to req.get\");\n      }\n      var lc = name.toLowerCase();\n      switch (lc) {\n        case \"referer\":\n        case \"referrer\":\n          return this.headers.referrer || this.headers.referer;\n        default:\n          return this.headers[lc];\n      }\n    };\n    req.accepts = function() {\n      var accept = accepts(this);\n      return accept.types.apply(accept, arguments);\n    };\n    req.acceptsEncodings = function() {\n      var accept = accepts(this);\n      return accept.encodings.apply(accept, arguments);\n    };\n    req.acceptsCharsets = function() {\n      var accept = accepts(this);\n      return accept.charsets.apply(accept, arguments);\n    };\n    req.acceptsLanguages = function() {\n      var accept = accepts(this);\n      return accept.languages.apply(accept, arguments);\n    };\n    req.range = function range(size, options) {\n      var range2 = this.get(\"Range\");\n      if (!range2) return;\n      return parseRange(size, range2, options);\n    };\n    defineGetter(req, \"query\", function query() {\n      var queryparse = this.app.get(\"query parser fn\");\n      if (!queryparse) {\n        return /* @__PURE__ */ Object.create(null);\n      }\n      var querystring = parse(this).query;\n      return queryparse(querystring);\n    });\n    req.is = function is(types) {\n      var arr = types;\n      if (!Array.isArray(types)) {\n        arr = new Array(arguments.length);\n        for (var i = 0; i < arr.length; i++) {\n          arr[i] = arguments[i];\n        }\n      }\n      return typeis(this, arr);\n    };\n    defineGetter(req, \"protocol\", function protocol() {\n      var proto = this.connection.encrypted ? \"https\" : \"http\";\n      var trust = this.app.get(\"trust proxy fn\");\n      if (!trust(this.connection.remoteAddress, 0)) {\n        return proto;\n      }\n      var header = this.get(\"X-Forwarded-Proto\") || proto;\n      var index = header.indexOf(\",\");\n      return index !== -1 ? header.substring(0, index).trim() : header.trim();\n    });\n    defineGetter(req, \"secure\", function secure() {\n      return this.protocol === \"https\";\n    });\n    defineGetter(req, \"ip\", function ip() {\n      var trust = this.app.get(\"trust proxy fn\");\n      return proxyaddr(this, trust);\n    });\n    defineGetter(req, \"ips\", function ips() {\n      var trust = this.app.get(\"trust proxy fn\");\n      var addrs = proxyaddr.all(this, trust);\n      addrs.reverse().pop();\n      return addrs;\n    });\n    defineGetter(req, \"subdomains\", function subdomains() {\n      var hostname = this.hostname;\n      if (!hostname) return [];\n      var offset = this.app.get(\"subdomain offset\");\n      var subdomains2 = !isIP(hostname) ? hostname.split(\".\").reverse() : [hostname];\n      return subdomains2.slice(offset);\n    });\n    defineGetter(req, \"path\", function path() {\n      return parse(this).pathname;\n    });\n    defineGetter(req, \"host\", function host() {\n      var trust = this.app.get(\"trust proxy fn\");\n      var val = this.get(\"X-Forwarded-Host\");\n      if (!val || !trust(this.connection.remoteAddress, 0)) {\n        val = this.get(\"Host\");\n      } else if (val.indexOf(\",\") !== -1) {\n        val = val.substring(0, val.indexOf(\",\")).trimRight();\n      }\n      return val || void 0;\n    });\n    defineGetter(req, \"hostname\", function hostname() {\n      var host = this.host;\n      if (!host) return;\n      var offset = host[0] === \"[\" ? host.indexOf(\"]\") + 1 : 0;\n      var index = host.indexOf(\":\", offset);\n      return index !== -1 ? host.substring(0, index) : host;\n    });\n    defineGetter(req, \"fresh\", function() {\n      var method = this.method;\n      var res = this.res;\n      var status = res.statusCode;\n      if (\"GET\" !== method && \"HEAD\" !== method) return false;\n      if (status >= 200 && status < 300 || 304 === status) {\n        return fresh(this.headers, {\n          \"etag\": res.get(\"ETag\"),\n          \"last-modified\": res.get(\"Last-Modified\")\n        });\n      }\n      return false;\n    });\n    defineGetter(req, \"stale\", function stale() {\n      return !this.fresh;\n    });\n    defineGetter(req, \"xhr\", function xhr() {\n      var val = this.get(\"X-Requested-With\") || \"\";\n      return val.toLowerCase() === \"xmlhttprequest\";\n    });\n    function defineGetter(obj, name, getter) {\n      Object.defineProperty(obj, name, {\n        configurable: true,\n        enumerable: true,\n        get: getter\n      });\n    }\n  }\n});\n\n// node_modules/safe-buffer/index.js\nvar require_safe_buffer = __commonJS({\n  \"node_modules/safe-buffer/index.js\"(exports2, module2) {\n    var buffer = require(\"buffer\");\n    var Buffer2 = buffer.Buffer;\n    function copyProps(src, dst) {\n      for (var key in src) {\n        dst[key] = src[key];\n      }\n    }\n    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {\n      module2.exports = buffer;\n    } else {\n      copyProps(buffer, exports2);\n      exports2.Buffer = SafeBuffer;\n    }\n    function SafeBuffer(arg, encodingOrOffset, length) {\n      return Buffer2(arg, encodingOrOffset, length);\n    }\n    SafeBuffer.prototype = Object.create(Buffer2.prototype);\n    copyProps(Buffer2, SafeBuffer);\n    SafeBuffer.from = function(arg, encodingOrOffset, length) {\n      if (typeof arg === \"number\") {\n        throw new TypeError(\"Argument must not be a number\");\n      }\n      return Buffer2(arg, encodingOrOffset, length);\n    };\n    SafeBuffer.alloc = function(size, fill, encoding) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      var buf = Buffer2(size);\n      if (fill !== void 0) {\n        if (typeof encoding === \"string\") {\n          buf.fill(fill, encoding);\n        } else {\n          buf.fill(fill);\n        }\n      } else {\n        buf.fill(0);\n      }\n      return buf;\n    };\n    SafeBuffer.allocUnsafe = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return Buffer2(size);\n    };\n    SafeBuffer.allocUnsafeSlow = function(size) {\n      if (typeof size !== \"number\") {\n        throw new TypeError(\"Argument must be a number\");\n      }\n      return buffer.SlowBuffer(size);\n    };\n  }\n});\n\n// node_modules/content-disposition/index.js\nvar require_content_disposition = __commonJS({\n  \"node_modules/content-disposition/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = contentDisposition;\n    module2.exports.parse = parse;\n    var basename = require(\"path\").basename;\n    var Buffer2 = require_safe_buffer().Buffer;\n    var ENCODE_URL_ATTR_CHAR_REGEXP = /[\\x00-\\x20\"'()*,/:;<=>?@[\\\\\\]{}\\x7f]/g;\n    var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;\n    var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;\n    var NON_LATIN1_REGEXP = /[^\\x20-\\x7e\\xa0-\\xff]/g;\n    var QESC_REGEXP = /\\\\([\\u0000-\\u007f])/g;\n    var QUOTE_REGEXP = /([\\\\\"])/g;\n    var PARAM_REGEXP = /;[\\x09\\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\\x09\\x20]*=[\\x09\\x20]*(\"(?:[\\x20!\\x23-\\x5b\\x5d-\\x7e\\x80-\\xff]|\\\\[\\x20-\\x7e])*\"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\\x09\\x20]*/g;\n    var TEXT_REGEXP = /^[\\x20-\\x7e\\x80-\\xff]+$/;\n    var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/;\n    var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/;\n    var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\\x09\\x20]*(?:$|;)/;\n    function contentDisposition(filename, options) {\n      var opts = options || {};\n      var type = opts.type || \"attachment\";\n      var params = createparams(filename, opts.fallback);\n      return format(new ContentDisposition(type, params));\n    }\n    function createparams(filename, fallback) {\n      if (filename === void 0) {\n        return;\n      }\n      var params = {};\n      if (typeof filename !== \"string\") {\n        throw new TypeError(\"filename must be a string\");\n      }\n      if (fallback === void 0) {\n        fallback = true;\n      }\n      if (typeof fallback !== \"string\" && typeof fallback !== \"boolean\") {\n        throw new TypeError(\"fallback must be a string or boolean\");\n      }\n      if (typeof fallback === \"string\" && NON_LATIN1_REGEXP.test(fallback)) {\n        throw new TypeError(\"fallback must be ISO-8859-1 string\");\n      }\n      var name = basename(filename);\n      var isQuotedString = TEXT_REGEXP.test(name);\n      var fallbackName = typeof fallback !== \"string\" ? fallback && getlatin1(name) : basename(fallback);\n      var hasFallback = typeof fallbackName === \"string\" && fallbackName !== name;\n      if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) {\n        params[\"filename*\"] = name;\n      }\n      if (isQuotedString || hasFallback) {\n        params.filename = hasFallback ? fallbackName : name;\n      }\n      return params;\n    }\n    function format(obj) {\n      var parameters = obj.parameters;\n      var type = obj.type;\n      if (!type || typeof type !== \"string\" || !TOKEN_REGEXP.test(type)) {\n        throw new TypeError(\"invalid type\");\n      }\n      var string = String(type).toLowerCase();\n      if (parameters && typeof parameters === \"object\") {\n        var param;\n        var params = Object.keys(parameters).sort();\n        for (var i = 0; i < params.length; i++) {\n          param = params[i];\n          var val = param.slice(-1) === \"*\" ? ustring(parameters[param]) : qstring(parameters[param]);\n          string += \"; \" + param + \"=\" + val;\n        }\n      }\n      return string;\n    }\n    function decodefield(str) {\n      var match = EXT_VALUE_REGEXP.exec(str);\n      if (!match) {\n        throw new TypeError(\"invalid extended field value\");\n      }\n      var charset = match[1].toLowerCase();\n      var encoded = match[2];\n      var value;\n      var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode);\n      switch (charset) {\n        case \"iso-8859-1\":\n          value = getlatin1(binary);\n          break;\n        case \"utf-8\":\n        case \"utf8\":\n          value = Buffer2.from(binary, \"binary\").toString(\"utf8\");\n          break;\n        default:\n          throw new TypeError(\"unsupported charset in extended field\");\n      }\n      return value;\n    }\n    function getlatin1(val) {\n      return String(val).replace(NON_LATIN1_REGEXP, \"?\");\n    }\n    function parse(string) {\n      if (!string || typeof string !== \"string\") {\n        throw new TypeError(\"argument string is required\");\n      }\n      var match = DISPOSITION_TYPE_REGEXP.exec(string);\n      if (!match) {\n        throw new TypeError(\"invalid type format\");\n      }\n      var index = match[0].length;\n      var type = match[1].toLowerCase();\n      var key;\n      var names = [];\n      var params = {};\n      var value;\n      index = PARAM_REGEXP.lastIndex = match[0].slice(-1) === \";\" ? index - 1 : index;\n      while (match = PARAM_REGEXP.exec(string)) {\n        if (match.index !== index) {\n          throw new TypeError(\"invalid parameter format\");\n        }\n        index += match[0].length;\n        key = match[1].toLowerCase();\n        value = match[2];\n        if (names.indexOf(key) !== -1) {\n          throw new TypeError(\"invalid duplicate parameter\");\n        }\n        names.push(key);\n        if (key.indexOf(\"*\") + 1 === key.length) {\n          key = key.slice(0, -1);\n          value = decodefield(value);\n          params[key] = value;\n          continue;\n        }\n        if (typeof params[key] === \"string\") {\n          continue;\n        }\n        if (value[0] === '\"') {\n          value = value.slice(1, -1).replace(QESC_REGEXP, \"$1\");\n        }\n        params[key] = value;\n      }\n      if (index !== -1 && index !== string.length) {\n        throw new TypeError(\"invalid parameter format\");\n      }\n      return new ContentDisposition(type, params);\n    }\n    function pdecode(str, hex) {\n      return String.fromCharCode(parseInt(hex, 16));\n    }\n    function pencode(char) {\n      return \"%\" + String(char).charCodeAt(0).toString(16).toUpperCase();\n    }\n    function qstring(val) {\n      var str = String(val);\n      return '\"' + str.replace(QUOTE_REGEXP, \"\\\\$1\") + '\"';\n    }\n    function ustring(val) {\n      var str = String(val);\n      var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);\n      return \"UTF-8''\" + encoded;\n    }\n    function ContentDisposition(type, parameters) {\n      this.type = type;\n      this.parameters = parameters;\n    }\n  }\n});\n\n// node_modules/cookie-signature/index.js\nvar require_cookie_signature = __commonJS({\n  \"node_modules/cookie-signature/index.js\"(exports2) {\n    var crypto = require(\"crypto\");\n    exports2.sign = function(val, secret) {\n      if (\"string\" != typeof val) throw new TypeError(\"Cookie value must be provided as a string.\");\n      if (null == secret) throw new TypeError(\"Secret key must be provided.\");\n      return val + \".\" + crypto.createHmac(\"sha256\", secret).update(val).digest(\"base64\").replace(/\\=+$/, \"\");\n    };\n    exports2.unsign = function(input, secret) {\n      if (\"string\" != typeof input) throw new TypeError(\"Signed cookie string must be provided.\");\n      if (null == secret) throw new TypeError(\"Secret key must be provided.\");\n      var tentativeValue = input.slice(0, input.lastIndexOf(\".\")), expectedInput = exports2.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);\n      return expectedBuffer.length === inputBuffer.length && crypto.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;\n    };\n  }\n});\n\n// node_modules/cookie/index.js\nvar require_cookie = __commonJS({\n  \"node_modules/cookie/index.js\"(exports2) {\n    \"use strict\";\n    exports2.parse = parse;\n    exports2.serialize = serialize;\n    var __toString = Object.prototype.toString;\n    var cookieNameRegExp = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;\n    var cookieValueRegExp = /^(\"?)[\\u0021\\u0023-\\u002B\\u002D-\\u003A\\u003C-\\u005B\\u005D-\\u007E]*\\1$/;\n    var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;\n    var pathValueRegExp = /^[\\u0020-\\u003A\\u003D-\\u007E]*$/;\n    function parse(str, opt) {\n      if (typeof str !== \"string\") {\n        throw new TypeError(\"argument str must be a string\");\n      }\n      var obj = {};\n      var len = str.length;\n      if (len < 2) return obj;\n      var dec = opt && opt.decode || decode;\n      var index = 0;\n      var eqIdx = 0;\n      var endIdx = 0;\n      do {\n        eqIdx = str.indexOf(\"=\", index);\n        if (eqIdx === -1) break;\n        endIdx = str.indexOf(\";\", index);\n        if (endIdx === -1) {\n          endIdx = len;\n        } else if (eqIdx > endIdx) {\n          index = str.lastIndexOf(\";\", eqIdx - 1) + 1;\n          continue;\n        }\n        var keyStartIdx = startIndex(str, index, eqIdx);\n        var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);\n        var key = str.slice(keyStartIdx, keyEndIdx);\n        if (!obj.hasOwnProperty(key)) {\n          var valStartIdx = startIndex(str, eqIdx + 1, endIdx);\n          var valEndIdx = endIndex(str, endIdx, valStartIdx);\n          if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) {\n            valStartIdx++;\n            valEndIdx--;\n          }\n          var val = str.slice(valStartIdx, valEndIdx);\n          obj[key] = tryDecode(val, dec);\n        }\n        index = endIdx + 1;\n      } while (index < len);\n      return obj;\n    }\n    function startIndex(str, index, max) {\n      do {\n        var code = str.charCodeAt(index);\n        if (code !== 32 && code !== 9) return index;\n      } while (++index < max);\n      return max;\n    }\n    function endIndex(str, index, min) {\n      while (index > min) {\n        var code = str.charCodeAt(--index);\n        if (code !== 32 && code !== 9) return index + 1;\n      }\n      return min;\n    }\n    function serialize(name, val, opt) {\n      var enc = opt && opt.encode || encodeURIComponent;\n      if (typeof enc !== \"function\") {\n        throw new TypeError(\"option encode is invalid\");\n      }\n      if (!cookieNameRegExp.test(name)) {\n        throw new TypeError(\"argument name is invalid\");\n      }\n      var value = enc(val);\n      if (!cookieValueRegExp.test(value)) {\n        throw new TypeError(\"argument val is invalid\");\n      }\n      var str = name + \"=\" + value;\n      if (!opt) return str;\n      if (null != opt.maxAge) {\n        var maxAge = Math.floor(opt.maxAge);\n        if (!isFinite(maxAge)) {\n          throw new TypeError(\"option maxAge is invalid\");\n        }\n        str += \"; Max-Age=\" + maxAge;\n      }\n      if (opt.domain) {\n        if (!domainValueRegExp.test(opt.domain)) {\n          throw new TypeError(\"option domain is invalid\");\n        }\n        str += \"; Domain=\" + opt.domain;\n      }\n      if (opt.path) {\n        if (!pathValueRegExp.test(opt.path)) {\n          throw new TypeError(\"option path is invalid\");\n        }\n        str += \"; Path=\" + opt.path;\n      }\n      if (opt.expires) {\n        var expires = opt.expires;\n        if (!isDate(expires) || isNaN(expires.valueOf())) {\n          throw new TypeError(\"option expires is invalid\");\n        }\n        str += \"; Expires=\" + expires.toUTCString();\n      }\n      if (opt.httpOnly) {\n        str += \"; HttpOnly\";\n      }\n      if (opt.secure) {\n        str += \"; Secure\";\n      }\n      if (opt.partitioned) {\n        str += \"; Partitioned\";\n      }\n      if (opt.priority) {\n        var priority = typeof opt.priority === \"string\" ? opt.priority.toLowerCase() : opt.priority;\n        switch (priority) {\n          case \"low\":\n            str += \"; Priority=Low\";\n            break;\n          case \"medium\":\n            str += \"; Priority=Medium\";\n            break;\n          case \"high\":\n            str += \"; Priority=High\";\n            break;\n          default:\n            throw new TypeError(\"option priority is invalid\");\n        }\n      }\n      if (opt.sameSite) {\n        var sameSite = typeof opt.sameSite === \"string\" ? opt.sameSite.toLowerCase() : opt.sameSite;\n        switch (sameSite) {\n          case true:\n            str += \"; SameSite=Strict\";\n            break;\n          case \"lax\":\n            str += \"; SameSite=Lax\";\n            break;\n          case \"strict\":\n            str += \"; SameSite=Strict\";\n            break;\n          case \"none\":\n            str += \"; SameSite=None\";\n            break;\n          default:\n            throw new TypeError(\"option sameSite is invalid\");\n        }\n      }\n      return str;\n    }\n    function decode(str) {\n      return str.indexOf(\"%\") !== -1 ? decodeURIComponent(str) : str;\n    }\n    function isDate(val) {\n      return __toString.call(val) === \"[object Date]\";\n    }\n    function tryDecode(str, decode2) {\n      try {\n        return decode2(str);\n      } catch (e) {\n        return str;\n      }\n    }\n  }\n});\n\n// node_modules/send/node_modules/mime-db/db.json\nvar require_db4 = __commonJS({\n  \"node_modules/send/node_modules/mime-db/db.json\"(exports2, module2) {\n    module2.exports = {\n      \"application/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"application/3gpdash-qoe-report+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/3gpp-ims+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/3gpphalforms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/a2l\": {\n        source: \"iana\"\n      },\n      \"application/ace+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ace-groupcomm+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ace-trl+cbor\": {\n        source: \"iana\"\n      },\n      \"application/activemessage\": {\n        source: \"iana\"\n      },\n      \"application/activity+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aif+cbor\": {\n        source: \"iana\"\n      },\n      \"application/aif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdni+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-cdnifilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-costmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-directory+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcost+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointcostparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointprop+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-endpointpropparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-error+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-networkmapfilter+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-propmapparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tips+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-tipsparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamcontrol+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/alto-updatestreamparams+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/aml\": {\n        source: \"iana\"\n      },\n      \"application/andrew-inset\": {\n        source: \"iana\",\n        extensions: [\"ez\"]\n      },\n      \"application/appinstaller\": {\n        compressible: false,\n        extensions: [\"appinstaller\"]\n      },\n      \"application/applefile\": {\n        source: \"iana\"\n      },\n      \"application/applixware\": {\n        source: \"apache\",\n        extensions: [\"aw\"]\n      },\n      \"application/appx\": {\n        compressible: false,\n        extensions: [\"appx\"]\n      },\n      \"application/appxbundle\": {\n        compressible: false,\n        extensions: [\"appxbundle\"]\n      },\n      \"application/at+jwt\": {\n        source: \"iana\"\n      },\n      \"application/atf\": {\n        source: \"iana\"\n      },\n      \"application/atfx\": {\n        source: \"iana\"\n      },\n      \"application/atom+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atom\"]\n      },\n      \"application/atomcat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomcat\"]\n      },\n      \"application/atomdeleted+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomdeleted\"]\n      },\n      \"application/atomicmail\": {\n        source: \"iana\"\n      },\n      \"application/atomsvc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"atomsvc\"]\n      },\n      \"application/atsc-dwd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dwd\"]\n      },\n      \"application/atsc-dynamic-event-message\": {\n        source: \"iana\"\n      },\n      \"application/atsc-held+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"held\"]\n      },\n      \"application/atsc-rdt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/atsc-rsat+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsat\"]\n      },\n      \"application/atxml\": {\n        source: \"iana\"\n      },\n      \"application/auth-policy+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/automationml-aml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"aml\"]\n      },\n      \"application/automationml-amlx+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"amlx\"]\n      },\n      \"application/bacnet-xdd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/batch-smtp\": {\n        source: \"iana\"\n      },\n      \"application/bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/beep+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/bufr\": {\n        source: \"iana\"\n      },\n      \"application/c2pa\": {\n        source: \"iana\"\n      },\n      \"application/calendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/calendar+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xcs\"]\n      },\n      \"application/call-completion\": {\n        source: \"iana\"\n      },\n      \"application/cals-1840\": {\n        source: \"iana\"\n      },\n      \"application/captive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cbor\": {\n        source: \"iana\"\n      },\n      \"application/cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/cccex\": {\n        source: \"iana\"\n      },\n      \"application/ccmp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ccxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ccxml\"]\n      },\n      \"application/cda+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/cdfx+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdfx\"]\n      },\n      \"application/cdmi-capability\": {\n        source: \"iana\",\n        extensions: [\"cdmia\"]\n      },\n      \"application/cdmi-container\": {\n        source: \"iana\",\n        extensions: [\"cdmic\"]\n      },\n      \"application/cdmi-domain\": {\n        source: \"iana\",\n        extensions: [\"cdmid\"]\n      },\n      \"application/cdmi-object\": {\n        source: \"iana\",\n        extensions: [\"cdmio\"]\n      },\n      \"application/cdmi-queue\": {\n        source: \"iana\",\n        extensions: [\"cdmiq\"]\n      },\n      \"application/cdni\": {\n        source: \"iana\"\n      },\n      \"application/ce+cbor\": {\n        source: \"iana\"\n      },\n      \"application/cea\": {\n        source: \"iana\"\n      },\n      \"application/cea-2018+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cellml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cfw\": {\n        source: \"iana\"\n      },\n      \"application/cid-edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/city+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/city+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/clr\": {\n        source: \"iana\"\n      },\n      \"application/clue+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/clue_info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cms\": {\n        source: \"iana\"\n      },\n      \"application/cnrp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-eap\": {\n        source: \"iana\"\n      },\n      \"application/coap-group+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/coap-payload\": {\n        source: \"iana\"\n      },\n      \"application/commonground\": {\n        source: \"iana\"\n      },\n      \"application/concise-problem-details+cbor\": {\n        source: \"iana\"\n      },\n      \"application/conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cose\": {\n        source: \"iana\"\n      },\n      \"application/cose-key\": {\n        source: \"iana\"\n      },\n      \"application/cose-key-set\": {\n        source: \"iana\"\n      },\n      \"application/cose-x509\": {\n        source: \"iana\"\n      },\n      \"application/cpl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cpl\"]\n      },\n      \"application/csrattrs\": {\n        source: \"iana\"\n      },\n      \"application/csta+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cstadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/csvm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cu-seeme\": {\n        source: \"apache\",\n        extensions: [\"cu\"]\n      },\n      \"application/cwl\": {\n        source: \"iana\",\n        extensions: [\"cwl\"]\n      },\n      \"application/cwl+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/cwl+yaml\": {\n        source: \"iana\"\n      },\n      \"application/cwt\": {\n        source: \"iana\"\n      },\n      \"application/cybercash\": {\n        source: \"iana\"\n      },\n      \"application/dart\": {\n        compressible: true\n      },\n      \"application/dash+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpd\"]\n      },\n      \"application/dash-patch+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpp\"]\n      },\n      \"application/dashdelta\": {\n        source: \"iana\"\n      },\n      \"application/davmount+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"davmount\"]\n      },\n      \"application/dca-rft\": {\n        source: \"iana\"\n      },\n      \"application/dcd\": {\n        source: \"iana\"\n      },\n      \"application/dec-dx\": {\n        source: \"iana\"\n      },\n      \"application/dialog-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom\": {\n        source: \"iana\",\n        extensions: [\"dcm\"]\n      },\n      \"application/dicom+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dicom+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dii\": {\n        source: \"iana\"\n      },\n      \"application/dit\": {\n        source: \"iana\"\n      },\n      \"application/dns\": {\n        source: \"iana\"\n      },\n      \"application/dns+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dns-message\": {\n        source: \"iana\"\n      },\n      \"application/docbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dbk\"]\n      },\n      \"application/dots+cbor\": {\n        source: \"iana\"\n      },\n      \"application/dpop+jwt\": {\n        source: \"iana\"\n      },\n      \"application/dskpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/dssc+der\": {\n        source: \"iana\",\n        extensions: [\"dssc\"]\n      },\n      \"application/dssc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdssc\"]\n      },\n      \"application/dvcs\": {\n        source: \"iana\"\n      },\n      \"application/eat+cwt\": {\n        source: \"iana\"\n      },\n      \"application/eat+jwt\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-bun+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/eat-ucs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/eat-ucs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ecmascript\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ecma\"]\n      },\n      \"application/edhoc+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/edi-consent\": {\n        source: \"iana\"\n      },\n      \"application/edi-x12\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/edifact\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/efi\": {\n        source: \"iana\"\n      },\n      \"application/elm+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/elm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.cap+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/emergencycalldata.comment+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.deviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.ecall.msd\": {\n        source: \"iana\"\n      },\n      \"application/emergencycalldata.legacyesn+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.providerinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.serviceinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.subscriberinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emergencycalldata.veds+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/emma+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emma\"]\n      },\n      \"application/emotionml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"emotionml\"]\n      },\n      \"application/encaprtp\": {\n        source: \"iana\"\n      },\n      \"application/entity-statement+jwt\": {\n        source: \"iana\"\n      },\n      \"application/epp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/epub+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"epub\"]\n      },\n      \"application/eshop\": {\n        source: \"iana\"\n      },\n      \"application/exi\": {\n        source: \"iana\",\n        extensions: [\"exi\"]\n      },\n      \"application/expect-ct-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/express\": {\n        source: \"iana\",\n        extensions: [\"exp\"]\n      },\n      \"application/fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/fastsoap\": {\n        source: \"iana\"\n      },\n      \"application/fdf\": {\n        source: \"iana\",\n        extensions: [\"fdf\"]\n      },\n      \"application/fdt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fdt\"]\n      },\n      \"application/fhir+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fhir+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/fido.trusted-apps+json\": {\n        compressible: true\n      },\n      \"application/fits\": {\n        source: \"iana\"\n      },\n      \"application/flexfec\": {\n        source: \"iana\"\n      },\n      \"application/font-sfnt\": {\n        source: \"iana\"\n      },\n      \"application/font-tdpfr\": {\n        source: \"iana\",\n        extensions: [\"pfr\"]\n      },\n      \"application/font-woff\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/framework-attributes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geo+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"geojson\"]\n      },\n      \"application/geo+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/geopackage+sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/geopose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/geoxacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/gltf-buffer\": {\n        source: \"iana\"\n      },\n      \"application/gml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gml\"]\n      },\n      \"application/gnap-binding-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jws\": {\n        source: \"iana\"\n      },\n      \"application/gnap-binding-rotation-jwsd\": {\n        source: \"iana\"\n      },\n      \"application/gpx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"gpx\"]\n      },\n      \"application/grib\": {\n        source: \"iana\"\n      },\n      \"application/gxf\": {\n        source: \"apache\",\n        extensions: [\"gxf\"]\n      },\n      \"application/gzip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gz\"]\n      },\n      \"application/h224\": {\n        source: \"iana\"\n      },\n      \"application/held+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/hjson\": {\n        extensions: [\"hjson\"]\n      },\n      \"application/hl7v2+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/http\": {\n        source: \"iana\"\n      },\n      \"application/hyperstudio\": {\n        source: \"iana\",\n        extensions: [\"stk\"]\n      },\n      \"application/ibe-key-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pkg-reply+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ibe-pp-data\": {\n        source: \"iana\"\n      },\n      \"application/iges\": {\n        source: \"iana\"\n      },\n      \"application/im-iscomposing+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/index\": {\n        source: \"iana\"\n      },\n      \"application/index.cmd\": {\n        source: \"iana\"\n      },\n      \"application/index.obj\": {\n        source: \"iana\"\n      },\n      \"application/index.response\": {\n        source: \"iana\"\n      },\n      \"application/index.vnd\": {\n        source: \"iana\"\n      },\n      \"application/inkml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ink\", \"inkml\"]\n      },\n      \"application/iotp\": {\n        source: \"iana\"\n      },\n      \"application/ipfix\": {\n        source: \"iana\",\n        extensions: [\"ipfix\"]\n      },\n      \"application/ipp\": {\n        source: \"iana\"\n      },\n      \"application/isup\": {\n        source: \"iana\"\n      },\n      \"application/its+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"its\"]\n      },\n      \"application/java-archive\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jar\", \"war\", \"ear\"]\n      },\n      \"application/java-serialized-object\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"ser\"]\n      },\n      \"application/java-vm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"class\"]\n      },\n      \"application/javascript\": {\n        source: \"apache\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\"]\n      },\n      \"application/jf2feed+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jose\": {\n        source: \"iana\"\n      },\n      \"application/jose+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jrd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscalendar+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jscontact+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"json\", \"map\"]\n      },\n      \"application/json-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/json-seq\": {\n        source: \"iana\"\n      },\n      \"application/json5\": {\n        extensions: [\"json5\"]\n      },\n      \"application/jsonml+json\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"jsonml\"]\n      },\n      \"application/jsonpath\": {\n        source: \"iana\"\n      },\n      \"application/jwk+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/jwk-set+jwt\": {\n        source: \"iana\"\n      },\n      \"application/jwt\": {\n        source: \"iana\"\n      },\n      \"application/kpml-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/kpml-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ld+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"jsonld\"]\n      },\n      \"application/lgr+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lgr\"]\n      },\n      \"application/link-format\": {\n        source: \"iana\"\n      },\n      \"application/linkset\": {\n        source: \"iana\"\n      },\n      \"application/linkset+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/load-control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/logout+jwt\": {\n        source: \"iana\"\n      },\n      \"application/lost+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lostxml\"]\n      },\n      \"application/lostsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/lpf+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/lxf\": {\n        source: \"iana\"\n      },\n      \"application/mac-binhex40\": {\n        source: \"iana\",\n        extensions: [\"hqx\"]\n      },\n      \"application/mac-compactpro\": {\n        source: \"apache\",\n        extensions: [\"cpt\"]\n      },\n      \"application/macwriteii\": {\n        source: \"iana\"\n      },\n      \"application/mads+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mads\"]\n      },\n      \"application/manifest+json\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"webmanifest\"]\n      },\n      \"application/marc\": {\n        source: \"iana\",\n        extensions: [\"mrc\"]\n      },\n      \"application/marcxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mrcx\"]\n      },\n      \"application/mathematica\": {\n        source: \"iana\",\n        extensions: [\"ma\", \"nb\", \"mb\"]\n      },\n      \"application/mathml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mathml\"]\n      },\n      \"application/mathml-content+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mathml-presentation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-associated-procedure-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-deregister+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-envelope+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-msk-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-protection-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-reception-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-register-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbms-user-service-description+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mbox\": {\n        source: \"iana\",\n        extensions: [\"mbox\"]\n      },\n      \"application/media-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpf\"]\n      },\n      \"application/media_control+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mediaservercontrol+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mscml\"]\n      },\n      \"application/merge-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/metalink+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"metalink\"]\n      },\n      \"application/metalink4+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"meta4\"]\n      },\n      \"application/mets+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mets\"]\n      },\n      \"application/mf4\": {\n        source: \"iana\"\n      },\n      \"application/mikey\": {\n        source: \"iana\"\n      },\n      \"application/mipc\": {\n        source: \"iana\"\n      },\n      \"application/missing-blocks+cbor-seq\": {\n        source: \"iana\"\n      },\n      \"application/mmt-aei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"maei\"]\n      },\n      \"application/mmt-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musd\"]\n      },\n      \"application/mods+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mods\"]\n      },\n      \"application/moss-keys\": {\n        source: \"iana\"\n      },\n      \"application/moss-signature\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-data\": {\n        source: \"iana\"\n      },\n      \"application/mosskey-request\": {\n        source: \"iana\"\n      },\n      \"application/mp21\": {\n        source: \"iana\",\n        extensions: [\"m21\", \"mp21\"]\n      },\n      \"application/mp4\": {\n        source: \"iana\",\n        extensions: [\"mp4\", \"mpg4\", \"mp4s\", \"m4p\"]\n      },\n      \"application/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod\": {\n        source: \"iana\"\n      },\n      \"application/mpeg4-iod-xmt\": {\n        source: \"iana\"\n      },\n      \"application/mrb-consumer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/mrb-publish+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/msc-ivr+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msc-mixer+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/msix\": {\n        compressible: false,\n        extensions: [\"msix\"]\n      },\n      \"application/msixbundle\": {\n        compressible: false,\n        extensions: [\"msixbundle\"]\n      },\n      \"application/msword\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"doc\", \"dot\"]\n      },\n      \"application/mud+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/multipart-core\": {\n        source: \"iana\"\n      },\n      \"application/mxf\": {\n        source: \"iana\",\n        extensions: [\"mxf\"]\n      },\n      \"application/n-quads\": {\n        source: \"iana\",\n        extensions: [\"nq\"]\n      },\n      \"application/n-triples\": {\n        source: \"iana\",\n        extensions: [\"nt\"]\n      },\n      \"application/nasdata\": {\n        source: \"iana\"\n      },\n      \"application/news-checkgroups\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-groupinfo\": {\n        source: \"iana\",\n        charset: \"US-ASCII\"\n      },\n      \"application/news-transmission\": {\n        source: \"iana\"\n      },\n      \"application/nlsml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/node\": {\n        source: \"iana\",\n        extensions: [\"cjs\"]\n      },\n      \"application/nss\": {\n        source: \"iana\"\n      },\n      \"application/oauth-authz-req+jwt\": {\n        source: \"iana\"\n      },\n      \"application/oblivious-dns-message\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-request\": {\n        source: \"iana\"\n      },\n      \"application/ocsp-response\": {\n        source: \"iana\"\n      },\n      \"application/octet-stream\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bin\", \"dms\", \"lrf\", \"mar\", \"so\", \"dist\", \"distz\", \"pkg\", \"bpk\", \"dump\", \"elc\", \"deploy\", \"exe\", \"dll\", \"deb\", \"dmg\", \"iso\", \"img\", \"msi\", \"msp\", \"msm\", \"buffer\"]\n      },\n      \"application/oda\": {\n        source: \"iana\",\n        extensions: [\"oda\"]\n      },\n      \"application/odm+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/odx\": {\n        source: \"iana\"\n      },\n      \"application/oebps-package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"opf\"]\n      },\n      \"application/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogx\"]\n      },\n      \"application/ohttp-keys\": {\n        source: \"iana\"\n      },\n      \"application/omdoc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"omdoc\"]\n      },\n      \"application/onenote\": {\n        source: \"apache\",\n        extensions: [\"onetoc\", \"onetoc2\", \"onetmp\", \"onepkg\", \"one\", \"onea\"]\n      },\n      \"application/opc-nodeset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/oscore\": {\n        source: \"iana\"\n      },\n      \"application/oxps\": {\n        source: \"iana\",\n        extensions: [\"oxps\"]\n      },\n      \"application/p21\": {\n        source: \"iana\"\n      },\n      \"application/p21+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/p2p-overlay+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"relo\"]\n      },\n      \"application/parityfec\": {\n        source: \"iana\"\n      },\n      \"application/passport\": {\n        source: \"iana\"\n      },\n      \"application/patch-ops-error+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xer\"]\n      },\n      \"application/pdf\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pdf\"]\n      },\n      \"application/pdx\": {\n        source: \"iana\"\n      },\n      \"application/pem-certificate-chain\": {\n        source: \"iana\"\n      },\n      \"application/pgp-encrypted\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pgp\"]\n      },\n      \"application/pgp-keys\": {\n        source: \"iana\",\n        extensions: [\"asc\"]\n      },\n      \"application/pgp-signature\": {\n        source: \"iana\",\n        extensions: [\"sig\", \"asc\"]\n      },\n      \"application/pics-rules\": {\n        source: \"apache\",\n        extensions: [\"prf\"]\n      },\n      \"application/pidf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pidf-diff+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/pkcs10\": {\n        source: \"iana\",\n        extensions: [\"p10\"]\n      },\n      \"application/pkcs12\": {\n        source: \"iana\"\n      },\n      \"application/pkcs7-mime\": {\n        source: \"iana\",\n        extensions: [\"p7m\", \"p7c\"]\n      },\n      \"application/pkcs7-signature\": {\n        source: \"iana\",\n        extensions: [\"p7s\"]\n      },\n      \"application/pkcs8\": {\n        source: \"iana\",\n        extensions: [\"p8\"]\n      },\n      \"application/pkcs8-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/pkix-attr-cert\": {\n        source: \"iana\",\n        extensions: [\"ac\"]\n      },\n      \"application/pkix-cert\": {\n        source: \"iana\",\n        extensions: [\"cer\"]\n      },\n      \"application/pkix-crl\": {\n        source: \"iana\",\n        extensions: [\"crl\"]\n      },\n      \"application/pkix-pkipath\": {\n        source: \"iana\",\n        extensions: [\"pkipath\"]\n      },\n      \"application/pkixcmp\": {\n        source: \"iana\",\n        extensions: [\"pki\"]\n      },\n      \"application/pls+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pls\"]\n      },\n      \"application/poc-settings+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/postscript\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ai\", \"eps\", \"ps\"]\n      },\n      \"application/ppsp-tracker+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/private-token-issuer-directory\": {\n        source: \"iana\"\n      },\n      \"application/private-token-request\": {\n        source: \"iana\"\n      },\n      \"application/private-token-response\": {\n        source: \"iana\"\n      },\n      \"application/problem+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/problem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/provenance+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"provx\"]\n      },\n      \"application/provided-claims+jwt\": {\n        source: \"iana\"\n      },\n      \"application/prs.alvestrand.titrax-sheet\": {\n        source: \"iana\"\n      },\n      \"application/prs.cww\": {\n        source: \"iana\",\n        extensions: [\"cww\"]\n      },\n      \"application/prs.cyn\": {\n        source: \"iana\",\n        charset: \"7-BIT\"\n      },\n      \"application/prs.hpub+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/prs.implied-document+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-executable\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/prs.implied-object+json-seq\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-object+yaml\": {\n        source: \"iana\"\n      },\n      \"application/prs.implied-structure\": {\n        source: \"iana\"\n      },\n      \"application/prs.mayfile\": {\n        source: \"iana\"\n      },\n      \"application/prs.nprend\": {\n        source: \"iana\"\n      },\n      \"application/prs.plucker\": {\n        source: \"iana\"\n      },\n      \"application/prs.rdf-xml-crypt\": {\n        source: \"iana\"\n      },\n      \"application/prs.vcfbzip2\": {\n        source: \"iana\"\n      },\n      \"application/prs.xsf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsf\"]\n      },\n      \"application/pskc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"pskcxml\"]\n      },\n      \"application/pvd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/qsig\": {\n        source: \"iana\"\n      },\n      \"application/raml+yaml\": {\n        compressible: true,\n        extensions: [\"raml\"]\n      },\n      \"application/raptorfec\": {\n        source: \"iana\"\n      },\n      \"application/rdap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rdf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rdf\", \"owl\"]\n      },\n      \"application/reginfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rif\"]\n      },\n      \"application/relax-ng-compact-syntax\": {\n        source: \"iana\",\n        extensions: [\"rnc\"]\n      },\n      \"application/remote-printing\": {\n        source: \"apache\"\n      },\n      \"application/reputon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/resolve-response+jwt\": {\n        source: \"iana\"\n      },\n      \"application/resource-lists+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rl\"]\n      },\n      \"application/resource-lists-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rld\"]\n      },\n      \"application/rfc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/riscos\": {\n        source: \"iana\"\n      },\n      \"application/rlmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/rls-services+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rs\"]\n      },\n      \"application/route-apd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rapd\"]\n      },\n      \"application/route-s-tsid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sls\"]\n      },\n      \"application/route-usd+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rusd\"]\n      },\n      \"application/rpki-checklist\": {\n        source: \"iana\"\n      },\n      \"application/rpki-ghostbusters\": {\n        source: \"iana\",\n        extensions: [\"gbr\"]\n      },\n      \"application/rpki-manifest\": {\n        source: \"iana\",\n        extensions: [\"mft\"]\n      },\n      \"application/rpki-publication\": {\n        source: \"iana\"\n      },\n      \"application/rpki-roa\": {\n        source: \"iana\",\n        extensions: [\"roa\"]\n      },\n      \"application/rpki-signed-tal\": {\n        source: \"iana\"\n      },\n      \"application/rpki-updown\": {\n        source: \"iana\"\n      },\n      \"application/rsd+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rsd\"]\n      },\n      \"application/rss+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"rss\"]\n      },\n      \"application/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"application/rtploopback\": {\n        source: \"iana\"\n      },\n      \"application/rtx\": {\n        source: \"iana\"\n      },\n      \"application/samlassertion+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/samlmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sarif-external-properties+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sbe\": {\n        source: \"iana\"\n      },\n      \"application/sbml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sbml\"]\n      },\n      \"application/scaip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scim+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/scvp-cv-request\": {\n        source: \"iana\",\n        extensions: [\"scq\"]\n      },\n      \"application/scvp-cv-response\": {\n        source: \"iana\",\n        extensions: [\"scs\"]\n      },\n      \"application/scvp-vp-request\": {\n        source: \"iana\",\n        extensions: [\"spq\"]\n      },\n      \"application/scvp-vp-response\": {\n        source: \"iana\",\n        extensions: [\"spp\"]\n      },\n      \"application/sdp\": {\n        source: \"iana\",\n        extensions: [\"sdp\"]\n      },\n      \"application/secevent+jwt\": {\n        source: \"iana\"\n      },\n      \"application/senml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"senmlx\"]\n      },\n      \"application/senml-etch+cbor\": {\n        source: \"iana\"\n      },\n      \"application/senml-etch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/senml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sensml+cbor\": {\n        source: \"iana\"\n      },\n      \"application/sensml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sensml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sensmlx\"]\n      },\n      \"application/sensml-exi\": {\n        source: \"iana\"\n      },\n      \"application/sep+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sep-exi\": {\n        source: \"iana\"\n      },\n      \"application/session-info\": {\n        source: \"iana\"\n      },\n      \"application/set-payment\": {\n        source: \"iana\"\n      },\n      \"application/set-payment-initiation\": {\n        source: \"iana\",\n        extensions: [\"setpay\"]\n      },\n      \"application/set-registration\": {\n        source: \"iana\"\n      },\n      \"application/set-registration-initiation\": {\n        source: \"iana\",\n        extensions: [\"setreg\"]\n      },\n      \"application/sgml\": {\n        source: \"iana\"\n      },\n      \"application/sgml-open-catalog\": {\n        source: \"iana\"\n      },\n      \"application/shf+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"shf\"]\n      },\n      \"application/sieve\": {\n        source: \"iana\",\n        extensions: [\"siv\", \"sieve\"]\n      },\n      \"application/simple-filter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/simple-message-summary\": {\n        source: \"iana\"\n      },\n      \"application/simplesymbolcontainer\": {\n        source: \"iana\"\n      },\n      \"application/sipc\": {\n        source: \"iana\"\n      },\n      \"application/slate\": {\n        source: \"iana\"\n      },\n      \"application/smil\": {\n        source: \"apache\"\n      },\n      \"application/smil+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"smi\", \"smil\"]\n      },\n      \"application/smpte336m\": {\n        source: \"iana\"\n      },\n      \"application/soap+fastinfoset\": {\n        source: \"iana\"\n      },\n      \"application/soap+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sparql-query\": {\n        source: \"iana\",\n        extensions: [\"rq\"]\n      },\n      \"application/sparql-results+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"srx\"]\n      },\n      \"application/spdx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/spirits-event+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/sql\": {\n        source: \"iana\",\n        extensions: [\"sql\"]\n      },\n      \"application/srgs\": {\n        source: \"iana\",\n        extensions: [\"gram\"]\n      },\n      \"application/srgs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"grxml\"]\n      },\n      \"application/sru+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sru\"]\n      },\n      \"application/ssdl+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ssdl\"]\n      },\n      \"application/sslkeylogfile\": {\n        source: \"iana\"\n      },\n      \"application/ssml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ssml\"]\n      },\n      \"application/st2110-41\": {\n        source: \"iana\"\n      },\n      \"application/stix+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/stratum\": {\n        source: \"iana\"\n      },\n      \"application/swid+cbor\": {\n        source: \"iana\"\n      },\n      \"application/swid+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"swidtag\"]\n      },\n      \"application/tamp-apex-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-apex-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-community-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-error\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust\": {\n        source: \"iana\"\n      },\n      \"application/tamp-sequence-adjust-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-query\": {\n        source: \"iana\"\n      },\n      \"application/tamp-status-response\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update\": {\n        source: \"iana\"\n      },\n      \"application/tamp-update-confirm\": {\n        source: \"iana\"\n      },\n      \"application/tar\": {\n        compressible: true\n      },\n      \"application/taxii+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/td+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tei+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tei\", \"teicorpus\"]\n      },\n      \"application/tetra_isi\": {\n        source: \"iana\"\n      },\n      \"application/thraud+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tfi\"]\n      },\n      \"application/timestamp-query\": {\n        source: \"iana\"\n      },\n      \"application/timestamp-reply\": {\n        source: \"iana\"\n      },\n      \"application/timestamped-data\": {\n        source: \"iana\",\n        extensions: [\"tsd\"]\n      },\n      \"application/tlsrpt+gzip\": {\n        source: \"iana\"\n      },\n      \"application/tlsrpt+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/tnauthlist\": {\n        source: \"iana\"\n      },\n      \"application/toc+cbor\": {\n        source: \"iana\"\n      },\n      \"application/token-introspection+jwt\": {\n        source: \"iana\"\n      },\n      \"application/toml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"toml\"]\n      },\n      \"application/trickle-ice-sdpfrag\": {\n        source: \"iana\"\n      },\n      \"application/trig\": {\n        source: \"iana\",\n        extensions: [\"trig\"]\n      },\n      \"application/trust-chain+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/trust-mark+jwt\": {\n        source: \"iana\"\n      },\n      \"application/trust-mark-delegation+jwt\": {\n        source: \"iana\"\n      },\n      \"application/ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttml\"]\n      },\n      \"application/tve-trigger\": {\n        source: \"iana\"\n      },\n      \"application/tzif\": {\n        source: \"iana\"\n      },\n      \"application/tzif-leap\": {\n        source: \"iana\"\n      },\n      \"application/ubjson\": {\n        compressible: false,\n        extensions: [\"ubj\"]\n      },\n      \"application/uccs+cbor\": {\n        source: \"iana\"\n      },\n      \"application/ujcs+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/ulpfec\": {\n        source: \"iana\"\n      },\n      \"application/urc-grpsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/urc-ressheet+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rsheet\"]\n      },\n      \"application/urc-targetdesc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"td\"]\n      },\n      \"application/urc-uisocketdesc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vc\": {\n        source: \"iana\"\n      },\n      \"application/vc+cose\": {\n        source: \"iana\"\n      },\n      \"application/vc+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vcard+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vcard+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vemmi\": {\n        source: \"iana\"\n      },\n      \"application/vividence.scriptfile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.1000minds.decision-model+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"1km\"]\n      },\n      \"application/vnd.1ob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp-prose+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3a+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ach+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc3ch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-prose-pc8+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp-v2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gnas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsa2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.5gsv2x-local-service-information\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.access-transfer-events+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.bsf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.crs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.current-location-discovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gmop+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.gtpc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.interworking-data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.lpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mc-signalling-ear\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-payload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-signalling\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.mcdata-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcdata-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-floor-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-signed+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-ue-init-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcptt-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-affiliation-command+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-regroup+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-service-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-transmission-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-ue-config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mcvideo-user-profile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.mid-call+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ngap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pfcp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.pic-bw-large\": {\n        source: \"iana\",\n        extensions: [\"plb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-small\": {\n        source: \"iana\",\n        extensions: [\"psb\"]\n      },\n      \"application/vnd.3gpp.pic-bw-var\": {\n        source: \"iana\",\n        extensions: [\"pvb\"]\n      },\n      \"application/vnd.3gpp.pinapp-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.s1ap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.seal-group-doc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-location-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-mbms-usage-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-network-qos-management-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-ue-config-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-unicast-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.seal-user-profile-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.sms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-ext+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.srvcc-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.state-and-event-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.ussd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp.v2x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp.vae-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.bcmcsinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.3gpp2.sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3gpp2.tcap\": {\n        source: \"iana\",\n        extensions: [\"tcap\"]\n      },\n      \"application/vnd.3lightssoftware.imagescal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.3m.post-it-notes\": {\n        source: \"iana\",\n        extensions: [\"pwn\"]\n      },\n      \"application/vnd.accpac.simply.aso\": {\n        source: \"iana\",\n        extensions: [\"aso\"]\n      },\n      \"application/vnd.accpac.simply.imp\": {\n        source: \"iana\",\n        extensions: [\"imp\"]\n      },\n      \"application/vnd.acm.addressxfer+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acm.chatbot+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.acucobol\": {\n        source: \"iana\",\n        extensions: [\"acu\"]\n      },\n      \"application/vnd.acucorp\": {\n        source: \"iana\",\n        extensions: [\"atc\", \"acutc\"]\n      },\n      \"application/vnd.adobe.air-application-installer-package+zip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"air\"]\n      },\n      \"application/vnd.adobe.flash.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.formscentral.fcdt\": {\n        source: \"iana\",\n        extensions: [\"fcdt\"]\n      },\n      \"application/vnd.adobe.fxp\": {\n        source: \"iana\",\n        extensions: [\"fxp\", \"fxpl\"]\n      },\n      \"application/vnd.adobe.partial-upload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.adobe.xdp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdp\"]\n      },\n      \"application/vnd.adobe.xfdf\": {\n        source: \"apache\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/vnd.aether.imp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.afplinedata-pagedef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.cmoca-cmresource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-charset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codedfont\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.foca-codepage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-cmtable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-formdef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-mediummap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-objectcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-overlay\": {\n        source: \"iana\"\n      },\n      \"application/vnd.afpc.modca-pagesegment\": {\n        source: \"iana\"\n      },\n      \"application/vnd.age\": {\n        source: \"iana\",\n        extensions: [\"age\"]\n      },\n      \"application/vnd.ah-barcode\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ahead.space\": {\n        source: \"iana\",\n        extensions: [\"ahead\"]\n      },\n      \"application/vnd.airzip.filesecure.azf\": {\n        source: \"iana\",\n        extensions: [\"azf\"]\n      },\n      \"application/vnd.airzip.filesecure.azs\": {\n        source: \"iana\",\n        extensions: [\"azs\"]\n      },\n      \"application/vnd.amadeus+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.amazon.ebook\": {\n        source: \"apache\",\n        extensions: [\"azw\"]\n      },\n      \"application/vnd.amazon.mobi8-ebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.americandynamics.acc\": {\n        source: \"iana\",\n        extensions: [\"acc\"]\n      },\n      \"application/vnd.amiga.ami\": {\n        source: \"iana\",\n        extensions: [\"ami\"]\n      },\n      \"application/vnd.amundsen.maze+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.android.ota\": {\n        source: \"iana\"\n      },\n      \"application/vnd.android.package-archive\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"apk\"]\n      },\n      \"application/vnd.anki\": {\n        source: \"iana\"\n      },\n      \"application/vnd.anser-web-certificate-issue-initiation\": {\n        source: \"iana\",\n        extensions: [\"cii\"]\n      },\n      \"application/vnd.anser-web-funds-transfer-initiation\": {\n        source: \"apache\",\n        extensions: [\"fti\"]\n      },\n      \"application/vnd.antix.game-component\": {\n        source: \"iana\",\n        extensions: [\"atx\"]\n      },\n      \"application/vnd.apache.arrow.file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.arrow.stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.parquet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.compact\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apache.thrift.json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.apexlang\": {\n        source: \"iana\"\n      },\n      \"application/vnd.api+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.aplextor.warrp+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apothekende.reservation+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.apple.installer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mpkg\"]\n      },\n      \"application/vnd.apple.keynote\": {\n        source: \"iana\",\n        extensions: [\"key\"]\n      },\n      \"application/vnd.apple.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"m3u8\"]\n      },\n      \"application/vnd.apple.numbers\": {\n        source: \"iana\",\n        extensions: [\"numbers\"]\n      },\n      \"application/vnd.apple.pages\": {\n        source: \"iana\",\n        extensions: [\"pages\"]\n      },\n      \"application/vnd.apple.pkpass\": {\n        compressible: false,\n        extensions: [\"pkpass\"]\n      },\n      \"application/vnd.arastra.swi\": {\n        source: \"apache\"\n      },\n      \"application/vnd.aristanetworks.swi\": {\n        source: \"iana\",\n        extensions: [\"swi\"]\n      },\n      \"application/vnd.artisan+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.artsquare\": {\n        source: \"iana\"\n      },\n      \"application/vnd.astraea-software.iota\": {\n        source: \"iana\",\n        extensions: [\"iota\"]\n      },\n      \"application/vnd.audiograph\": {\n        source: \"iana\",\n        extensions: [\"aep\"]\n      },\n      \"application/vnd.autodesk.fbx\": {\n        extensions: [\"fbx\"]\n      },\n      \"application/vnd.autopackage\": {\n        source: \"iana\"\n      },\n      \"application/vnd.avalon+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.avistar+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.balsamiq.bmml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmml\"]\n      },\n      \"application/vnd.balsamiq.bmpr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.banana-accounting\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.error\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bbf.usp.msg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bekitzur-stech+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.belightsoft.lhzd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.belightsoft.lhzl+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.bint.med-content\": {\n        source: \"iana\"\n      },\n      \"application/vnd.biopax.rdf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.blink-idb-value-wrapper\": {\n        source: \"iana\"\n      },\n      \"application/vnd.blueice.multipass\": {\n        source: \"iana\",\n        extensions: [\"mpm\"]\n      },\n      \"application/vnd.bluetooth.ep.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bluetooth.le.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bmi\": {\n        source: \"iana\",\n        extensions: [\"bmi\"]\n      },\n      \"application/vnd.bpf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.bpf3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.businessobjects\": {\n        source: \"iana\",\n        extensions: [\"rep\"]\n      },\n      \"application/vnd.byu.uapi+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.bzip3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.c3voc.schedule+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cab-jscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-cpdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.canon-lips\": {\n        source: \"iana\"\n      },\n      \"application/vnd.capasystems-pg+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cendio.thinlinc.clientconf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.century-systems.tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chemdraw+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"cdxml\"]\n      },\n      \"application/vnd.chess-pgn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.chipnuts.karaoke-mmd\": {\n        source: \"iana\",\n        extensions: [\"mmd\"]\n      },\n      \"application/vnd.ciedi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cinderella\": {\n        source: \"iana\",\n        extensions: [\"cdy\"]\n      },\n      \"application/vnd.cirpack.isdn-ext\": {\n        source: \"iana\"\n      },\n      \"application/vnd.citationstyles.style+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csl\"]\n      },\n      \"application/vnd.claymore\": {\n        source: \"iana\",\n        extensions: [\"cla\"]\n      },\n      \"application/vnd.cloanto.rp9\": {\n        source: \"iana\",\n        extensions: [\"rp9\"]\n      },\n      \"application/vnd.clonk.c4group\": {\n        source: \"iana\",\n        extensions: [\"c4g\", \"c4d\", \"c4f\", \"c4p\", \"c4u\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config\": {\n        source: \"iana\",\n        extensions: [\"c11amc\"]\n      },\n      \"application/vnd.cluetrust.cartomobile-config-pkg\": {\n        source: \"iana\",\n        extensions: [\"c11amz\"]\n      },\n      \"application/vnd.cncf.helm.chart.content.v1.tar+gzip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.chart.provenance.v1.prov\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cncf.helm.config.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.coffeescript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.document-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.presentation-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collabio.xodocuments.spreadsheet-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.collection+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.doc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.collection.next+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.comicbook+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.comicbook-rar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commerce-battelle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.commonspace\": {\n        source: \"iana\",\n        extensions: [\"csp\"]\n      },\n      \"application/vnd.contact.cmsg\": {\n        source: \"iana\",\n        extensions: [\"cdbcmsg\"]\n      },\n      \"application/vnd.coreos.ignition+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cosmocaller\": {\n        source: \"iana\",\n        extensions: [\"cmc\"]\n      },\n      \"application/vnd.crick.clicker\": {\n        source: \"iana\",\n        extensions: [\"clkx\"]\n      },\n      \"application/vnd.crick.clicker.keyboard\": {\n        source: \"iana\",\n        extensions: [\"clkk\"]\n      },\n      \"application/vnd.crick.clicker.palette\": {\n        source: \"iana\",\n        extensions: [\"clkp\"]\n      },\n      \"application/vnd.crick.clicker.template\": {\n        source: \"iana\",\n        extensions: [\"clkt\"]\n      },\n      \"application/vnd.crick.clicker.wordbank\": {\n        source: \"iana\",\n        extensions: [\"clkw\"]\n      },\n      \"application/vnd.criticaltools.wbs+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wbs\"]\n      },\n      \"application/vnd.cryptii.pipe+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.crypto-shade-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cryptomator.vault\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ctc-posml\": {\n        source: \"iana\",\n        extensions: [\"pml\"]\n      },\n      \"application/vnd.ctct.ws+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cups-pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-postscript\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-ppd\": {\n        source: \"iana\",\n        extensions: [\"ppd\"]\n      },\n      \"application/vnd.cups-raster\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cups-raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.curl.car\": {\n        source: \"apache\",\n        extensions: [\"car\"]\n      },\n      \"application/vnd.curl.pcurl\": {\n        source: \"apache\",\n        extensions: [\"pcurl\"]\n      },\n      \"application/vnd.cyan.dean.root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cybank\": {\n        source: \"iana\"\n      },\n      \"application/vnd.cyclonedx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.cyclonedx+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.d2l.coursepackage1p0+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.d3m-dataset\": {\n        source: \"iana\"\n      },\n      \"application/vnd.d3m-problem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dart\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dart\"]\n      },\n      \"application/vnd.data-vision.rdz\": {\n        source: \"iana\",\n        extensions: [\"rdz\"]\n      },\n      \"application/vnd.datalog\": {\n        source: \"iana\"\n      },\n      \"application/vnd.datapackage+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dataresource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dbf\": {\n        source: \"iana\",\n        extensions: [\"dbf\"]\n      },\n      \"application/vnd.dcmp+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dcmp\"]\n      },\n      \"application/vnd.debian.binary-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dece.data\": {\n        source: \"iana\",\n        extensions: [\"uvf\", \"uvvf\", \"uvd\", \"uvvd\"]\n      },\n      \"application/vnd.dece.ttml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uvt\", \"uvvt\"]\n      },\n      \"application/vnd.dece.unspecified\": {\n        source: \"iana\",\n        extensions: [\"uvx\", \"uvvx\"]\n      },\n      \"application/vnd.dece.zip\": {\n        source: \"iana\",\n        extensions: [\"uvz\", \"uvvz\"]\n      },\n      \"application/vnd.denovo.fcselayout-link\": {\n        source: \"iana\",\n        extensions: [\"fe_launch\"]\n      },\n      \"application/vnd.desmume.movie\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dir-bi.plate-dl-nosuffix\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dm.delegation+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dna\": {\n        source: \"iana\",\n        extensions: [\"dna\"]\n      },\n      \"application/vnd.document+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dolby.mlp\": {\n        source: \"apache\",\n        extensions: [\"mlp\"]\n      },\n      \"application/vnd.dolby.mobile.1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dolby.mobile.2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.doremir.scorecloud-binary-document\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dpgraph\": {\n        source: \"iana\",\n        extensions: [\"dpg\"]\n      },\n      \"application/vnd.dreamfactory\": {\n        source: \"iana\",\n        extensions: [\"dfac\"]\n      },\n      \"application/vnd.drive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ds-keypoint\": {\n        source: \"apache\",\n        extensions: [\"kpxx\"]\n      },\n      \"application/vnd.dtg.local\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.flash\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dtg.local.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ait\": {\n        source: \"iana\",\n        extensions: [\"ait\"]\n      },\n      \"application/vnd.dvb.dvbisl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.dvbj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.esgcontainer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcdftnotifaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgaccess2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcesgpdd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.ipdcroaming\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.iptv.alfec-enhancement\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.notif-aggregate-root+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-container+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-generic+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-msglist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-ia-registration-response+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.notif-init+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.dvb.pfr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dvb.service\": {\n        source: \"iana\",\n        extensions: [\"svc\"]\n      },\n      \"application/vnd.dxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.dynageo\": {\n        source: \"iana\",\n        extensions: [\"geo\"]\n      },\n      \"application/vnd.dzr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.easykaraoke.cdgdownload\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecdis-update\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecip.rlp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eclipse.ditto+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ecowin.chart\": {\n        source: \"iana\",\n        extensions: [\"mag\"]\n      },\n      \"application/vnd.ecowin.filerequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.fileupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.series\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesrequest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ecowin.seriesupdate\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.img\": {\n        source: \"iana\"\n      },\n      \"application/vnd.efi.iso\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eln+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.emclient.accessrequest+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.enliven\": {\n        source: \"iana\",\n        extensions: [\"nml\"]\n      },\n      \"application/vnd.enphase.envoy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eprints.data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.epson.esf\": {\n        source: \"iana\",\n        extensions: [\"esf\"]\n      },\n      \"application/vnd.epson.msf\": {\n        source: \"iana\",\n        extensions: [\"msf\"]\n      },\n      \"application/vnd.epson.quickanime\": {\n        source: \"iana\",\n        extensions: [\"qam\"]\n      },\n      \"application/vnd.epson.salt\": {\n        source: \"iana\",\n        extensions: [\"slt\"]\n      },\n      \"application/vnd.epson.ssf\": {\n        source: \"iana\",\n        extensions: [\"ssf\"]\n      },\n      \"application/vnd.ericsson.quickcall\": {\n        source: \"iana\"\n      },\n      \"application/vnd.erofs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.espass-espass+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.eszigno3+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"es3\", \"et3\"]\n      },\n      \"application/vnd.etsi.aoc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.asic-e+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.asic-s+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.etsi.cug+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvcommand+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-bc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-cod+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsad-npvr+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvservice+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvsync+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.iptvueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mcid+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.mheg5\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.overload-control-policy-dataset+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.pstn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.sci+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.simservs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.timestamp-token\": {\n        source: \"iana\"\n      },\n      \"application/vnd.etsi.tsl+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.etsi.tsl.der\": {\n        source: \"iana\"\n      },\n      \"application/vnd.eu.kasparian.car+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.eudora.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.profile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.settings\": {\n        source: \"iana\"\n      },\n      \"application/vnd.evolv.ecig.theme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.exstream-empower+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.exstream-package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ezpix-album\": {\n        source: \"iana\",\n        extensions: [\"ez2\"]\n      },\n      \"application/vnd.ezpix-package\": {\n        source: \"iana\",\n        extensions: [\"ez3\"]\n      },\n      \"application/vnd.f-secure.mobile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.familysearch.gedcom+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.fastcopy-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fdf\": {\n        source: \"apache\",\n        extensions: [\"fdf\"]\n      },\n      \"application/vnd.fdsn.mseed\": {\n        source: \"iana\",\n        extensions: [\"mseed\"]\n      },\n      \"application/vnd.fdsn.seed\": {\n        source: \"iana\",\n        extensions: [\"seed\", \"dataless\"]\n      },\n      \"application/vnd.fdsn.stationxml+xml\": {\n        source: \"iana\",\n        charset: \"XML-BASED\",\n        compressible: true\n      },\n      \"application/vnd.ffsns\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ficlab.flb+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.filmit.zfc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fints\": {\n        source: \"iana\"\n      },\n      \"application/vnd.firemonkeys.cloudcell\": {\n        source: \"iana\"\n      },\n      \"application/vnd.flographit\": {\n        source: \"iana\",\n        extensions: [\"gph\"]\n      },\n      \"application/vnd.fluxtime.clip\": {\n        source: \"iana\",\n        extensions: [\"ftc\"]\n      },\n      \"application/vnd.font-fontforge-sfd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.framemaker\": {\n        source: \"iana\",\n        extensions: [\"fm\", \"frame\", \"maker\", \"book\"]\n      },\n      \"application/vnd.freelog.comic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.frogans.fnc\": {\n        source: \"apache\",\n        extensions: [\"fnc\"]\n      },\n      \"application/vnd.frogans.ltf\": {\n        source: \"apache\",\n        extensions: [\"ltf\"]\n      },\n      \"application/vnd.fsc.weblaunch\": {\n        source: \"iana\",\n        extensions: [\"fsc\"]\n      },\n      \"application/vnd.fujifilm.fb.docuworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.binder\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujifilm.fb.jfi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fujitsu.oasys\": {\n        source: \"iana\",\n        extensions: [\"oas\"]\n      },\n      \"application/vnd.fujitsu.oasys2\": {\n        source: \"iana\",\n        extensions: [\"oa2\"]\n      },\n      \"application/vnd.fujitsu.oasys3\": {\n        source: \"iana\",\n        extensions: [\"oa3\"]\n      },\n      \"application/vnd.fujitsu.oasysgp\": {\n        source: \"iana\",\n        extensions: [\"fg5\"]\n      },\n      \"application/vnd.fujitsu.oasysprs\": {\n        source: \"iana\",\n        extensions: [\"bh2\"]\n      },\n      \"application/vnd.fujixerox.art-ex\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.art4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.ddd\": {\n        source: \"iana\",\n        extensions: [\"ddd\"]\n      },\n      \"application/vnd.fujixerox.docuworks\": {\n        source: \"iana\",\n        extensions: [\"xdw\"]\n      },\n      \"application/vnd.fujixerox.docuworks.binder\": {\n        source: \"iana\",\n        extensions: [\"xbd\"]\n      },\n      \"application/vnd.fujixerox.docuworks.container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fujixerox.hbpl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.fut-misnet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.futoin+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.fuzzysheet\": {\n        source: \"iana\",\n        extensions: [\"fzs\"]\n      },\n      \"application/vnd.ga4gh.passport+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.genomatix.tuxedo\": {\n        source: \"iana\",\n        extensions: [\"txd\"]\n      },\n      \"application/vnd.genozip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentics.grd+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.catmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.ebuild\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.eclass\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.gpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.manifest\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gentoo.pkgmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gentoo.xpak\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geo+json\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geocube+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.geogebra.file\": {\n        source: \"iana\",\n        extensions: [\"ggb\"]\n      },\n      \"application/vnd.geogebra.pinboard\": {\n        source: \"iana\"\n      },\n      \"application/vnd.geogebra.slides\": {\n        source: \"iana\",\n        extensions: [\"ggs\"]\n      },\n      \"application/vnd.geogebra.tool\": {\n        source: \"iana\",\n        extensions: [\"ggt\"]\n      },\n      \"application/vnd.geometry-explorer\": {\n        source: \"iana\",\n        extensions: [\"gex\", \"gre\"]\n      },\n      \"application/vnd.geonext\": {\n        source: \"iana\",\n        extensions: [\"gxt\"]\n      },\n      \"application/vnd.geoplan\": {\n        source: \"iana\",\n        extensions: [\"g2w\"]\n      },\n      \"application/vnd.geospace\": {\n        source: \"iana\",\n        extensions: [\"g3w\"]\n      },\n      \"application/vnd.gerber\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.globalplatform.card-content-mgt-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.gmx\": {\n        source: \"iana\",\n        extensions: [\"gmx\"]\n      },\n      \"application/vnd.gnu.taler.exchange+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.gnu.taler.merchant+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.google-apps.audio\": {},\n      \"application/vnd.google-apps.document\": {\n        compressible: false,\n        extensions: [\"gdoc\"]\n      },\n      \"application/vnd.google-apps.drawing\": {\n        compressible: false,\n        extensions: [\"gdraw\"]\n      },\n      \"application/vnd.google-apps.drive-sdk\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.file\": {},\n      \"application/vnd.google-apps.folder\": {\n        compressible: false\n      },\n      \"application/vnd.google-apps.form\": {\n        compressible: false,\n        extensions: [\"gform\"]\n      },\n      \"application/vnd.google-apps.fusiontable\": {},\n      \"application/vnd.google-apps.jam\": {\n        compressible: false,\n        extensions: [\"gjam\"]\n      },\n      \"application/vnd.google-apps.mail-layout\": {},\n      \"application/vnd.google-apps.map\": {\n        compressible: false,\n        extensions: [\"gmap\"]\n      },\n      \"application/vnd.google-apps.photo\": {},\n      \"application/vnd.google-apps.presentation\": {\n        compressible: false,\n        extensions: [\"gslides\"]\n      },\n      \"application/vnd.google-apps.script\": {\n        compressible: false,\n        extensions: [\"gscript\"]\n      },\n      \"application/vnd.google-apps.shortcut\": {},\n      \"application/vnd.google-apps.site\": {\n        compressible: false,\n        extensions: [\"gsite\"]\n      },\n      \"application/vnd.google-apps.spreadsheet\": {\n        compressible: false,\n        extensions: [\"gsheet\"]\n      },\n      \"application/vnd.google-apps.unknown\": {},\n      \"application/vnd.google-apps.video\": {},\n      \"application/vnd.google-earth.kml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"kml\"]\n      },\n      \"application/vnd.google-earth.kmz\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"kmz\"]\n      },\n      \"application/vnd.gov.sk.e-form+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.gov.sk.e-form+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.gov.sk.xmldatacontainer+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdcf\"]\n      },\n      \"application/vnd.gpxsee.map+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.grafeq\": {\n        source: \"iana\",\n        extensions: [\"gqf\", \"gqs\"]\n      },\n      \"application/vnd.gridmp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.groove-account\": {\n        source: \"iana\",\n        extensions: [\"gac\"]\n      },\n      \"application/vnd.groove-help\": {\n        source: \"iana\",\n        extensions: [\"ghf\"]\n      },\n      \"application/vnd.groove-identity-message\": {\n        source: \"iana\",\n        extensions: [\"gim\"]\n      },\n      \"application/vnd.groove-injector\": {\n        source: \"iana\",\n        extensions: [\"grv\"]\n      },\n      \"application/vnd.groove-tool-message\": {\n        source: \"iana\",\n        extensions: [\"gtm\"]\n      },\n      \"application/vnd.groove-tool-template\": {\n        source: \"iana\",\n        extensions: [\"tpl\"]\n      },\n      \"application/vnd.groove-vcard\": {\n        source: \"iana\",\n        extensions: [\"vcg\"]\n      },\n      \"application/vnd.hal+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hal+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"hal\"]\n      },\n      \"application/vnd.handheld-entertainment+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zmm\"]\n      },\n      \"application/vnd.hbci\": {\n        source: \"iana\",\n        extensions: [\"hbci\"]\n      },\n      \"application/vnd.hc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hcl-bireports\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hdt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.heroku+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hhe.lesson-player\": {\n        source: \"iana\",\n        extensions: [\"les\"]\n      },\n      \"application/vnd.hp-hpgl\": {\n        source: \"iana\",\n        extensions: [\"hpgl\"]\n      },\n      \"application/vnd.hp-hpid\": {\n        source: \"iana\",\n        extensions: [\"hpid\"]\n      },\n      \"application/vnd.hp-hps\": {\n        source: \"iana\",\n        extensions: [\"hps\"]\n      },\n      \"application/vnd.hp-jlyt\": {\n        source: \"iana\",\n        extensions: [\"jlt\"]\n      },\n      \"application/vnd.hp-pcl\": {\n        source: \"iana\",\n        extensions: [\"pcl\"]\n      },\n      \"application/vnd.hp-pclxl\": {\n        source: \"iana\",\n        extensions: [\"pclxl\"]\n      },\n      \"application/vnd.hsl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.httphone\": {\n        source: \"iana\"\n      },\n      \"application/vnd.hydrostatix.sof-data\": {\n        source: \"iana\",\n        extensions: [\"sfd-hdstx\"]\n      },\n      \"application/vnd.hyper+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyper-item+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hyperdrive+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.hzn-3d-crossword\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.afplinedata\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ibm.electronic-media\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ibm.minipay\": {\n        source: \"iana\",\n        extensions: [\"mpy\"]\n      },\n      \"application/vnd.ibm.modcap\": {\n        source: \"apache\",\n        extensions: [\"afp\", \"listafp\", \"list3820\"]\n      },\n      \"application/vnd.ibm.rights-management\": {\n        source: \"iana\",\n        extensions: [\"irm\"]\n      },\n      \"application/vnd.ibm.secure-container\": {\n        source: \"iana\",\n        extensions: [\"sc\"]\n      },\n      \"application/vnd.iccprofile\": {\n        source: \"iana\",\n        extensions: [\"icc\", \"icm\"]\n      },\n      \"application/vnd.ieee.1905\": {\n        source: \"iana\"\n      },\n      \"application/vnd.igloader\": {\n        source: \"iana\",\n        extensions: [\"igl\"]\n      },\n      \"application/vnd.imagemeter.folder+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.imagemeter.image+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.immervision-ivp\": {\n        source: \"iana\",\n        extensions: [\"ivp\"]\n      },\n      \"application/vnd.immervision-ivu\": {\n        source: \"iana\",\n        extensions: [\"ivu\"]\n      },\n      \"application/vnd.ims.imsccv1p1\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.imsccv1p3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ims.lis.v2.result+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolconsumerprofile+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolproxy.id+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ims.lti.v2.toolsettings.simple+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informedcontrol.rms+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.informix-visionary\": {\n        source: \"apache\"\n      },\n      \"application/vnd.infotech.project\": {\n        source: \"iana\"\n      },\n      \"application/vnd.infotech.project+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.innopath.wamp.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.insors.igm\": {\n        source: \"iana\",\n        extensions: [\"igm\"]\n      },\n      \"application/vnd.intercon.formnet\": {\n        source: \"iana\",\n        extensions: [\"xpw\", \"xpx\"]\n      },\n      \"application/vnd.intergeo\": {\n        source: \"iana\",\n        extensions: [\"i2g\"]\n      },\n      \"application/vnd.intertrust.digibox\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intertrust.nncp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.intu.qbo\": {\n        source: \"iana\",\n        extensions: [\"qbo\"]\n      },\n      \"application/vnd.intu.qfx\": {\n        source: \"iana\",\n        extensions: [\"qfx\"]\n      },\n      \"application/vnd.ipfs.ipns-record\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.car\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.dag-json\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ipld.raw\": {\n        source: \"iana\"\n      },\n      \"application/vnd.iptc.g2.catalogitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.conceptitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.knowledgeitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.newsmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.packageitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.iptc.g2.planningitem+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ipunplugged.rcprofile\": {\n        source: \"iana\",\n        extensions: [\"rcprofile\"]\n      },\n      \"application/vnd.irepository.package+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"irp\"]\n      },\n      \"application/vnd.is-xpr\": {\n        source: \"iana\",\n        extensions: [\"xpr\"]\n      },\n      \"application/vnd.isac.fcs\": {\n        source: \"iana\",\n        extensions: [\"fcs\"]\n      },\n      \"application/vnd.iso11783-10+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.jam\": {\n        source: \"iana\",\n        extensions: [\"jam\"]\n      },\n      \"application/vnd.japannet-directory-service\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-jpnstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-payment-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-registration-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-setstore-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.japannet-verification-wakeup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.jcp.javame.midlet-rms\": {\n        source: \"iana\",\n        extensions: [\"rms\"]\n      },\n      \"application/vnd.jisp\": {\n        source: \"iana\",\n        extensions: [\"jisp\"]\n      },\n      \"application/vnd.joost.joda-archive\": {\n        source: \"iana\",\n        extensions: [\"joda\"]\n      },\n      \"application/vnd.jsk.isdn-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kahootz\": {\n        source: \"iana\",\n        extensions: [\"ktz\", \"ktr\"]\n      },\n      \"application/vnd.kde.karbon\": {\n        source: \"iana\",\n        extensions: [\"karbon\"]\n      },\n      \"application/vnd.kde.kchart\": {\n        source: \"iana\",\n        extensions: [\"chrt\"]\n      },\n      \"application/vnd.kde.kformula\": {\n        source: \"iana\",\n        extensions: [\"kfo\"]\n      },\n      \"application/vnd.kde.kivio\": {\n        source: \"iana\",\n        extensions: [\"flw\"]\n      },\n      \"application/vnd.kde.kontour\": {\n        source: \"iana\",\n        extensions: [\"kon\"]\n      },\n      \"application/vnd.kde.kpresenter\": {\n        source: \"iana\",\n        extensions: [\"kpr\", \"kpt\"]\n      },\n      \"application/vnd.kde.kspread\": {\n        source: \"iana\",\n        extensions: [\"ksp\"]\n      },\n      \"application/vnd.kde.kword\": {\n        source: \"iana\",\n        extensions: [\"kwd\", \"kwt\"]\n      },\n      \"application/vnd.kdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kenameaapp\": {\n        source: \"iana\",\n        extensions: [\"htke\"]\n      },\n      \"application/vnd.keyman.kmp+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.keyman.kmx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.kidspiration\": {\n        source: \"iana\",\n        extensions: [\"kia\"]\n      },\n      \"application/vnd.kinar\": {\n        source: \"iana\",\n        extensions: [\"kne\", \"knp\"]\n      },\n      \"application/vnd.koan\": {\n        source: \"iana\",\n        extensions: [\"skp\", \"skd\", \"skt\", \"skm\"]\n      },\n      \"application/vnd.kodak-descriptor\": {\n        source: \"iana\",\n        extensions: [\"sse\"]\n      },\n      \"application/vnd.las\": {\n        source: \"iana\"\n      },\n      \"application/vnd.las.las+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.las.las+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lasxml\"]\n      },\n      \"application/vnd.laszip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ldev.productlicensing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.leap+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.liberty-request+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.llamagraphics.life-balance.desktop\": {\n        source: \"iana\",\n        extensions: [\"lbd\"]\n      },\n      \"application/vnd.llamagraphics.life-balance.exchange+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"lbe\"]\n      },\n      \"application/vnd.logipipe.circuit+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.loom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.lotus-1-2-3\": {\n        source: \"iana\",\n        extensions: [\"123\"]\n      },\n      \"application/vnd.lotus-approach\": {\n        source: \"iana\",\n        extensions: [\"apr\"]\n      },\n      \"application/vnd.lotus-freelance\": {\n        source: \"iana\",\n        extensions: [\"pre\"]\n      },\n      \"application/vnd.lotus-notes\": {\n        source: \"iana\",\n        extensions: [\"nsf\"]\n      },\n      \"application/vnd.lotus-organizer\": {\n        source: \"iana\",\n        extensions: [\"org\"]\n      },\n      \"application/vnd.lotus-screencam\": {\n        source: \"iana\",\n        extensions: [\"scm\"]\n      },\n      \"application/vnd.lotus-wordpro\": {\n        source: \"iana\",\n        extensions: [\"lwp\"]\n      },\n      \"application/vnd.macports.portpkg\": {\n        source: \"iana\",\n        extensions: [\"portpkg\"]\n      },\n      \"application/vnd.mapbox-vector-tile\": {\n        source: \"iana\",\n        extensions: [\"mvt\"]\n      },\n      \"application/vnd.marlin.drm.actiontoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.conftoken+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.license+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.marlin.drm.mdcf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mason+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.maxar.archive.3tz+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.maxmind.maxmind-db\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mcd\": {\n        source: \"iana\",\n        extensions: [\"mcd\"]\n      },\n      \"application/vnd.mdl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mdl-mbsdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.medcalcdata\": {\n        source: \"iana\",\n        extensions: [\"mc1\"]\n      },\n      \"application/vnd.mediastation.cdkey\": {\n        source: \"iana\",\n        extensions: [\"cdkey\"]\n      },\n      \"application/vnd.medicalholodeck.recordxr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.meridian-slingshot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mermaid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mfer\": {\n        source: \"iana\",\n        extensions: [\"mwf\"]\n      },\n      \"application/vnd.mfmp\": {\n        source: \"iana\",\n        extensions: [\"mfm\"]\n      },\n      \"application/vnd.micro+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.micrografx.flo\": {\n        source: \"iana\",\n        extensions: [\"flo\"]\n      },\n      \"application/vnd.micrografx.igx\": {\n        source: \"iana\",\n        extensions: [\"igx\"]\n      },\n      \"application/vnd.microsoft.portable-executable\": {\n        source: \"iana\"\n      },\n      \"application/vnd.microsoft.windows.thumbnail-cache\": {\n        source: \"iana\"\n      },\n      \"application/vnd.miele+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.mif\": {\n        source: \"iana\",\n        extensions: [\"mif\"]\n      },\n      \"application/vnd.minisoft-hp3000-save\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mitsubishi.misty-guard.trustweb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mobius.daf\": {\n        source: \"iana\",\n        extensions: [\"daf\"]\n      },\n      \"application/vnd.mobius.dis\": {\n        source: \"iana\",\n        extensions: [\"dis\"]\n      },\n      \"application/vnd.mobius.mbk\": {\n        source: \"iana\",\n        extensions: [\"mbk\"]\n      },\n      \"application/vnd.mobius.mqy\": {\n        source: \"iana\",\n        extensions: [\"mqy\"]\n      },\n      \"application/vnd.mobius.msl\": {\n        source: \"iana\",\n        extensions: [\"msl\"]\n      },\n      \"application/vnd.mobius.plc\": {\n        source: \"iana\",\n        extensions: [\"plc\"]\n      },\n      \"application/vnd.mobius.txf\": {\n        source: \"iana\",\n        extensions: [\"txf\"]\n      },\n      \"application/vnd.modl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mophun.application\": {\n        source: \"iana\",\n        extensions: [\"mpn\"]\n      },\n      \"application/vnd.mophun.certificate\": {\n        source: \"iana\",\n        extensions: [\"mpc\"]\n      },\n      \"application/vnd.motorola.flexsuite\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.adsi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.fis\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.gotap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.kmr\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.ttc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.flexsuite.wem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.motorola.iprm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mozilla.xul+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xul\"]\n      },\n      \"application/vnd.ms-3mfdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-artgalry\": {\n        source: \"iana\",\n        extensions: [\"cil\"]\n      },\n      \"application/vnd.ms-asf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-cab-compressed\": {\n        source: \"iana\",\n        extensions: [\"cab\"]\n      },\n      \"application/vnd.ms-color.iccprofile\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-excel\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xls\", \"xlm\", \"xla\", \"xlc\", \"xlt\", \"xlw\"]\n      },\n      \"application/vnd.ms-excel.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlam\"]\n      },\n      \"application/vnd.ms-excel.sheet.binary.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsb\"]\n      },\n      \"application/vnd.ms-excel.sheet.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xlsm\"]\n      },\n      \"application/vnd.ms-excel.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"xltm\"]\n      },\n      \"application/vnd.ms-fontobject\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eot\"]\n      },\n      \"application/vnd.ms-htmlhelp\": {\n        source: \"iana\",\n        extensions: [\"chm\"]\n      },\n      \"application/vnd.ms-ims\": {\n        source: \"iana\",\n        extensions: [\"ims\"]\n      },\n      \"application/vnd.ms-lrm\": {\n        source: \"iana\",\n        extensions: [\"lrm\"]\n      },\n      \"application/vnd.ms-office.activex+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-officetheme\": {\n        source: \"iana\",\n        extensions: [\"thmx\"]\n      },\n      \"application/vnd.ms-opentype\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-outlook\": {\n        compressible: false,\n        extensions: [\"msg\"]\n      },\n      \"application/vnd.ms-package.obfuscated-opentype\": {\n        source: \"apache\"\n      },\n      \"application/vnd.ms-pki.seccat\": {\n        source: \"apache\",\n        extensions: [\"cat\"]\n      },\n      \"application/vnd.ms-pki.stl\": {\n        source: \"apache\",\n        extensions: [\"stl\"]\n      },\n      \"application/vnd.ms-playready.initiator+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-powerpoint\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ppt\", \"pps\", \"pot\"]\n      },\n      \"application/vnd.ms-powerpoint.addin.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppam\"]\n      },\n      \"application/vnd.ms-powerpoint.presentation.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"pptm\"]\n      },\n      \"application/vnd.ms-powerpoint.slide.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"sldm\"]\n      },\n      \"application/vnd.ms-powerpoint.slideshow.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"ppsm\"]\n      },\n      \"application/vnd.ms-powerpoint.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"potm\"]\n      },\n      \"application/vnd.ms-printdevicecapabilities+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-printing.printticket+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.ms-printschematicket+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.ms-project\": {\n        source: \"iana\",\n        extensions: [\"mpp\", \"mpt\"]\n      },\n      \"application/vnd.ms-tnef\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-visio.viewer\": {\n        extensions: [\"vdx\"]\n      },\n      \"application/vnd.ms-windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.nwprinting.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.printerpairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-windows.wsd.oob\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.lic-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-chlg-req\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-wmdrm.meter-resp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ms-word.document.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"docm\"]\n      },\n      \"application/vnd.ms-word.template.macroenabled.12\": {\n        source: \"iana\",\n        extensions: [\"dotm\"]\n      },\n      \"application/vnd.ms-works\": {\n        source: \"iana\",\n        extensions: [\"wps\", \"wks\", \"wcm\", \"wdb\"]\n      },\n      \"application/vnd.ms-wpl\": {\n        source: \"iana\",\n        extensions: [\"wpl\"]\n      },\n      \"application/vnd.ms-xpsdocument\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xps\"]\n      },\n      \"application/vnd.msa-disk-image\": {\n        source: \"iana\"\n      },\n      \"application/vnd.mseq\": {\n        source: \"iana\",\n        extensions: [\"mseq\"]\n      },\n      \"application/vnd.msgpack\": {\n        source: \"iana\"\n      },\n      \"application/vnd.msign\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator\": {\n        source: \"iana\"\n      },\n      \"application/vnd.multiad.creator.cif\": {\n        source: \"iana\"\n      },\n      \"application/vnd.music-niff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.musician\": {\n        source: \"iana\",\n        extensions: [\"mus\"]\n      },\n      \"application/vnd.muvee.style\": {\n        source: \"iana\",\n        extensions: [\"msty\"]\n      },\n      \"application/vnd.mynfc\": {\n        source: \"iana\",\n        extensions: [\"taglet\"]\n      },\n      \"application/vnd.nacamar.ybrid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nato.bindingdataobject+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nato.bindingdataobject+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bdo\"]\n      },\n      \"application/vnd.nato.openxmlformats-package.iepd+zip\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"application/vnd.ncd.control\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ncd.reference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nearst.inv+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nebumind.line\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nervana\": {\n        source: \"iana\"\n      },\n      \"application/vnd.netfpx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.neurolanguage.nlu\": {\n        source: \"iana\",\n        extensions: [\"nlu\"]\n      },\n      \"application/vnd.nimn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.nitro.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nintendo.snes.rom\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nitf\": {\n        source: \"iana\",\n        extensions: [\"ntf\", \"nitf\"]\n      },\n      \"application/vnd.noblenet-directory\": {\n        source: \"iana\",\n        extensions: [\"nnd\"]\n      },\n      \"application/vnd.noblenet-sealer\": {\n        source: \"iana\",\n        extensions: [\"nns\"]\n      },\n      \"application/vnd.noblenet-web\": {\n        source: \"iana\",\n        extensions: [\"nnw\"]\n      },\n      \"application/vnd.nokia.catalogs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.conml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.iptv.config+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.isds-radio-presets\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.landmark+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.landmarkcollection+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.n-gage.ac+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ac\"]\n      },\n      \"application/vnd.nokia.n-gage.data\": {\n        source: \"iana\",\n        extensions: [\"ngdat\"]\n      },\n      \"application/vnd.nokia.n-gage.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"n-gage\"]\n      },\n      \"application/vnd.nokia.ncd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.nokia.pcd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.nokia.radio-preset\": {\n        source: \"iana\",\n        extensions: [\"rpst\"]\n      },\n      \"application/vnd.nokia.radio-presets\": {\n        source: \"iana\",\n        extensions: [\"rpss\"]\n      },\n      \"application/vnd.novadigm.edm\": {\n        source: \"iana\",\n        extensions: [\"edm\"]\n      },\n      \"application/vnd.novadigm.edx\": {\n        source: \"iana\",\n        extensions: [\"edx\"]\n      },\n      \"application/vnd.novadigm.ext\": {\n        source: \"iana\",\n        extensions: [\"ext\"]\n      },\n      \"application/vnd.ntt-local.content-share\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.file-transfer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.ogw_remote-access\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_remote\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ntt-local.sip-ta_tcp_stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oai.workflows+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oai.workflows+yaml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.base\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.chart\": {\n        source: \"iana\",\n        extensions: [\"odc\"]\n      },\n      \"application/vnd.oasis.opendocument.chart-template\": {\n        source: \"iana\",\n        extensions: [\"otc\"]\n      },\n      \"application/vnd.oasis.opendocument.database\": {\n        source: \"apache\",\n        extensions: [\"odb\"]\n      },\n      \"application/vnd.oasis.opendocument.formula\": {\n        source: \"iana\",\n        extensions: [\"odf\"]\n      },\n      \"application/vnd.oasis.opendocument.formula-template\": {\n        source: \"iana\",\n        extensions: [\"odft\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odg\"]\n      },\n      \"application/vnd.oasis.opendocument.graphics-template\": {\n        source: \"iana\",\n        extensions: [\"otg\"]\n      },\n      \"application/vnd.oasis.opendocument.image\": {\n        source: \"iana\",\n        extensions: [\"odi\"]\n      },\n      \"application/vnd.oasis.opendocument.image-template\": {\n        source: \"iana\",\n        extensions: [\"oti\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odp\"]\n      },\n      \"application/vnd.oasis.opendocument.presentation-template\": {\n        source: \"iana\",\n        extensions: [\"otp\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ods\"]\n      },\n      \"application/vnd.oasis.opendocument.spreadsheet-template\": {\n        source: \"iana\",\n        extensions: [\"ots\"]\n      },\n      \"application/vnd.oasis.opendocument.text\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"odt\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master\": {\n        source: \"iana\",\n        extensions: [\"odm\"]\n      },\n      \"application/vnd.oasis.opendocument.text-master-template\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oasis.opendocument.text-template\": {\n        source: \"iana\",\n        extensions: [\"ott\"]\n      },\n      \"application/vnd.oasis.opendocument.text-web\": {\n        source: \"iana\",\n        extensions: [\"oth\"]\n      },\n      \"application/vnd.obn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ocf+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oci.image.manifest.v1+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oftn.l10n+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessdownload+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.contentaccessstreaming+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.cspg-hexbinary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.dae.svg+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.dae.xhtml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.mippvcontrolmessage+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.pae.gem\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oipf.spdiscovery+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.spdlist+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.ueprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oipf.userprofile+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.olpc-sugar\": {\n        source: \"iana\",\n        extensions: [\"xo\"]\n      },\n      \"application/vnd.oma-scws-config\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-request\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma-scws-http-response\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.associated-procedure-parameter+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.drm-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.imd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.ltkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.notification+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.provisioningtrigger\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgboot\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.sgdd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sgdu\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.simple-symbol-container\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.bcast.smartcard-trigger+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.sprov+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.bcast.stkm\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.cab-address-book+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-feature-handler+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-pcc+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-subs-invite+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.cab-user-prefs+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.dcd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dcdc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.dd2+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dd2\"]\n      },\n      \"application/vnd.oma.drm.risd+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.group-usage-list+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.lwm2m+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.lwm2m+tlv\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.pal+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.detailed-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.final-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.groups+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.invocation-descriptor+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.poc.optimized-progress-report+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.push\": {\n        source: \"iana\"\n      },\n      \"application/vnd.oma.scidm.messages+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oma.xcap-directory+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.omads-email+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-file+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omads-folder+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.omaloc-supl-init\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepager\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertamx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertat\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onepagertatx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.onvif.metadata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openblox.game+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"obgx\"]\n      },\n      \"application/vnd.openblox.game-binary\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openeye.oeb\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openofficeorg.extension\": {\n        source: \"apache\",\n        extensions: [\"oxt\"]\n      },\n      \"application/vnd.openstreetmap.data+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osm\"]\n      },\n      \"application/vnd.opentimestamps.ots\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openvpi.dspx+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.custom-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.customxmlproperties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawing+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chart+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.extended-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"pptx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide\": {\n        source: \"iana\",\n        extensions: [\"sldx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow\": {\n        source: \"iana\",\n        extensions: [\"ppsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.tags+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template\": {\n        source: \"iana\",\n        extensions: [\"potx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"xlsx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template\": {\n        source: \"iana\",\n        extensions: [\"xltx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.theme+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.themeoverride+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.vmldrawing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"docx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template\": {\n        source: \"iana\",\n        extensions: [\"dotx\"]\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.core-properties+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.openxmlformats-package.relationships+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oracle.resource+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.orange.indata\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osa.netdeploy\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgeo.mapguide.package\": {\n        source: \"iana\",\n        extensions: [\"mgp\"]\n      },\n      \"application/vnd.osgi.bundle\": {\n        source: \"iana\"\n      },\n      \"application/vnd.osgi.dp\": {\n        source: \"iana\",\n        extensions: [\"dp\"]\n      },\n      \"application/vnd.osgi.subsystem\": {\n        source: \"iana\",\n        extensions: [\"esa\"]\n      },\n      \"application/vnd.otps.ct-kip+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.oxli.countgraph\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pagerduty+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.palm\": {\n        source: \"iana\",\n        extensions: [\"pdb\", \"pqa\", \"oprc\"]\n      },\n      \"application/vnd.panoply\": {\n        source: \"iana\"\n      },\n      \"application/vnd.paos.xml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patentdive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.patientecommsdoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pawaafile\": {\n        source: \"iana\",\n        extensions: [\"paw\"]\n      },\n      \"application/vnd.pcos\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pg.format\": {\n        source: \"iana\",\n        extensions: [\"str\"]\n      },\n      \"application/vnd.pg.osasli\": {\n        source: \"iana\",\n        extensions: [\"ei6\"]\n      },\n      \"application/vnd.piaccess.application-licence\": {\n        source: \"iana\"\n      },\n      \"application/vnd.picsel\": {\n        source: \"iana\",\n        extensions: [\"efif\"]\n      },\n      \"application/vnd.pmi.widget\": {\n        source: \"iana\",\n        extensions: [\"wg\"]\n      },\n      \"application/vnd.poc.group-advertisement+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.pocketlearn\": {\n        source: \"iana\",\n        extensions: [\"plf\"]\n      },\n      \"application/vnd.powerbuilder6\": {\n        source: \"iana\",\n        extensions: [\"pbd\"]\n      },\n      \"application/vnd.powerbuilder6-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder7-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75\": {\n        source: \"iana\"\n      },\n      \"application/vnd.powerbuilder75-s\": {\n        source: \"iana\"\n      },\n      \"application/vnd.preminet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.previewsystems.box\": {\n        source: \"iana\",\n        extensions: [\"box\"]\n      },\n      \"application/vnd.procrate.brushset\": {\n        extensions: [\"brushset\"]\n      },\n      \"application/vnd.procreate.brush\": {\n        extensions: [\"brush\"]\n      },\n      \"application/vnd.procreate.dream\": {\n        extensions: [\"drm\"]\n      },\n      \"application/vnd.proteus.magazine\": {\n        source: \"iana\",\n        extensions: [\"mgz\"]\n      },\n      \"application/vnd.psfs\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pt.mundusmundi\": {\n        source: \"iana\"\n      },\n      \"application/vnd.publishare-delta-tree\": {\n        source: \"iana\",\n        extensions: [\"qps\"]\n      },\n      \"application/vnd.pvi.ptid1\": {\n        source: \"iana\",\n        extensions: [\"ptid\"]\n      },\n      \"application/vnd.pwg-multiplexed\": {\n        source: \"iana\"\n      },\n      \"application/vnd.pwg-xhtml-print+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtm\"]\n      },\n      \"application/vnd.qualcomm.brew-app-res\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quarantainenet\": {\n        source: \"iana\"\n      },\n      \"application/vnd.quark.quarkxpress\": {\n        source: \"iana\",\n        extensions: [\"qxd\", \"qxt\", \"qwd\", \"qwt\", \"qxl\", \"qxb\"]\n      },\n      \"application/vnd.quobject-quoxdocument\": {\n        source: \"iana\"\n      },\n      \"application/vnd.radisys.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-conn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-audit-stream+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-conf+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-base+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-detect+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-fax-sendrecv+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-group+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-speech+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.radisys.msml-dialog-transform+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rainstor.data\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rapid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.rar\": {\n        source: \"iana\",\n        extensions: [\"rar\"]\n      },\n      \"application/vnd.realvnc.bed\": {\n        source: \"iana\",\n        extensions: [\"bed\"]\n      },\n      \"application/vnd.recordare.musicxml\": {\n        source: \"iana\",\n        extensions: [\"mxl\"]\n      },\n      \"application/vnd.recordare.musicxml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"musicxml\"]\n      },\n      \"application/vnd.relpipe\": {\n        source: \"iana\"\n      },\n      \"application/vnd.renlearn.rlprint\": {\n        source: \"iana\"\n      },\n      \"application/vnd.resilient.logic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.restful+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.rig.cryptonote\": {\n        source: \"iana\",\n        extensions: [\"cryptonote\"]\n      },\n      \"application/vnd.rim.cod\": {\n        source: \"apache\",\n        extensions: [\"cod\"]\n      },\n      \"application/vnd.rn-realmedia\": {\n        source: \"apache\",\n        extensions: [\"rm\"]\n      },\n      \"application/vnd.rn-realmedia-vbr\": {\n        source: \"apache\",\n        extensions: [\"rmvb\"]\n      },\n      \"application/vnd.route66.link66+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"link66\"]\n      },\n      \"application/vnd.rs-274x\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ruckus.download\": {\n        source: \"iana\"\n      },\n      \"application/vnd.s3sms\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sailingtracker.track\": {\n        source: \"iana\",\n        extensions: [\"st\"]\n      },\n      \"application/vnd.sar\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.cid\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sbm.mid2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.scribus\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.3df\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.csf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.doc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.eml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.mht\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.net\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.ppt\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.tiff\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealed.xls\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.html\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sealedmedia.softseal.pdf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.seemail\": {\n        source: \"iana\",\n        extensions: [\"see\"]\n      },\n      \"application/vnd.seis+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sema\": {\n        source: \"iana\",\n        extensions: [\"sema\"]\n      },\n      \"application/vnd.semd\": {\n        source: \"iana\",\n        extensions: [\"semd\"]\n      },\n      \"application/vnd.semf\": {\n        source: \"iana\",\n        extensions: [\"semf\"]\n      },\n      \"application/vnd.shade-save-file\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shana.informed.formdata\": {\n        source: \"iana\",\n        extensions: [\"ifm\"]\n      },\n      \"application/vnd.shana.informed.formtemplate\": {\n        source: \"iana\",\n        extensions: [\"itp\"]\n      },\n      \"application/vnd.shana.informed.interchange\": {\n        source: \"iana\",\n        extensions: [\"iif\"]\n      },\n      \"application/vnd.shana.informed.package\": {\n        source: \"iana\",\n        extensions: [\"ipk\"]\n      },\n      \"application/vnd.shootproof+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shopkick+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.shp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.shx\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sigrok.session\": {\n        source: \"iana\"\n      },\n      \"application/vnd.simtech-mindmapper\": {\n        source: \"iana\",\n        extensions: [\"twd\", \"twds\"]\n      },\n      \"application/vnd.siren+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.sketchometry\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smaf\": {\n        source: \"iana\",\n        extensions: [\"mmf\"]\n      },\n      \"application/vnd.smart.notebook\": {\n        source: \"iana\"\n      },\n      \"application/vnd.smart.teacher\": {\n        source: \"iana\",\n        extensions: [\"teacher\"]\n      },\n      \"application/vnd.smintio.portals.archive\": {\n        source: \"iana\"\n      },\n      \"application/vnd.snesdev-page-table\": {\n        source: \"iana\"\n      },\n      \"application/vnd.software602.filler.form+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"fo\"]\n      },\n      \"application/vnd.software602.filler.form-xml-zip\": {\n        source: \"iana\"\n      },\n      \"application/vnd.solent.sdkm+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"sdkm\", \"sdkd\"]\n      },\n      \"application/vnd.spotfire.dxp\": {\n        source: \"iana\",\n        extensions: [\"dxp\"]\n      },\n      \"application/vnd.spotfire.sfs\": {\n        source: \"iana\",\n        extensions: [\"sfs\"]\n      },\n      \"application/vnd.sqlite3\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-cod\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-dtf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sss-ntf\": {\n        source: \"iana\"\n      },\n      \"application/vnd.stardivision.calc\": {\n        source: \"apache\",\n        extensions: [\"sdc\"]\n      },\n      \"application/vnd.stardivision.draw\": {\n        source: \"apache\",\n        extensions: [\"sda\"]\n      },\n      \"application/vnd.stardivision.impress\": {\n        source: \"apache\",\n        extensions: [\"sdd\"]\n      },\n      \"application/vnd.stardivision.math\": {\n        source: \"apache\",\n        extensions: [\"smf\"]\n      },\n      \"application/vnd.stardivision.writer\": {\n        source: \"apache\",\n        extensions: [\"sdw\", \"vor\"]\n      },\n      \"application/vnd.stardivision.writer-global\": {\n        source: \"apache\",\n        extensions: [\"sgl\"]\n      },\n      \"application/vnd.stepmania.package\": {\n        source: \"iana\",\n        extensions: [\"smzip\"]\n      },\n      \"application/vnd.stepmania.stepchart\": {\n        source: \"iana\",\n        extensions: [\"sm\"]\n      },\n      \"application/vnd.street-stream\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sun.wadl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wadl\"]\n      },\n      \"application/vnd.sun.xml.calc\": {\n        source: \"apache\",\n        extensions: [\"sxc\"]\n      },\n      \"application/vnd.sun.xml.calc.template\": {\n        source: \"apache\",\n        extensions: [\"stc\"]\n      },\n      \"application/vnd.sun.xml.draw\": {\n        source: \"apache\",\n        extensions: [\"sxd\"]\n      },\n      \"application/vnd.sun.xml.draw.template\": {\n        source: \"apache\",\n        extensions: [\"std\"]\n      },\n      \"application/vnd.sun.xml.impress\": {\n        source: \"apache\",\n        extensions: [\"sxi\"]\n      },\n      \"application/vnd.sun.xml.impress.template\": {\n        source: \"apache\",\n        extensions: [\"sti\"]\n      },\n      \"application/vnd.sun.xml.math\": {\n        source: \"apache\",\n        extensions: [\"sxm\"]\n      },\n      \"application/vnd.sun.xml.writer\": {\n        source: \"apache\",\n        extensions: [\"sxw\"]\n      },\n      \"application/vnd.sun.xml.writer.global\": {\n        source: \"apache\",\n        extensions: [\"sxg\"]\n      },\n      \"application/vnd.sun.xml.writer.template\": {\n        source: \"apache\",\n        extensions: [\"stw\"]\n      },\n      \"application/vnd.sus-calendar\": {\n        source: \"iana\",\n        extensions: [\"sus\", \"susp\"]\n      },\n      \"application/vnd.svd\": {\n        source: \"iana\",\n        extensions: [\"svd\"]\n      },\n      \"application/vnd.swiftview-ics\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sybyl.mol2\": {\n        source: \"iana\"\n      },\n      \"application/vnd.sycle+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.syft+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.symbian.install\": {\n        source: \"apache\",\n        extensions: [\"sis\", \"sisx\"]\n      },\n      \"application/vnd.syncml+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xsm\"]\n      },\n      \"application/vnd.syncml.dm+wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"bdm\"]\n      },\n      \"application/vnd.syncml.dm+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"xdm\"]\n      },\n      \"application/vnd.syncml.dm.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmddf+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"ddf\"]\n      },\n      \"application/vnd.syncml.dmtnds+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.syncml.dmtnds+xml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true\n      },\n      \"application/vnd.syncml.ds.notification\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tableschema+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tao.intent-module-archive\": {\n        source: \"iana\",\n        extensions: [\"tao\"]\n      },\n      \"application/vnd.tcpdump.pcap\": {\n        source: \"iana\",\n        extensions: [\"pcap\", \"cap\", \"dmp\"]\n      },\n      \"application/vnd.think-cell.ppttc+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tmd.mediaflex.api+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.tml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.tmobile-livetv\": {\n        source: \"iana\",\n        extensions: [\"tmo\"]\n      },\n      \"application/vnd.tri.onesource\": {\n        source: \"iana\"\n      },\n      \"application/vnd.trid.tpt\": {\n        source: \"iana\",\n        extensions: [\"tpt\"]\n      },\n      \"application/vnd.triscape.mxs\": {\n        source: \"iana\",\n        extensions: [\"mxs\"]\n      },\n      \"application/vnd.trueapp\": {\n        source: \"iana\",\n        extensions: [\"tra\"]\n      },\n      \"application/vnd.truedoc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ubisoft.webplayer\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ufdl\": {\n        source: \"iana\",\n        extensions: [\"ufd\", \"ufdl\"]\n      },\n      \"application/vnd.uic.osdm+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.uiq.theme\": {\n        source: \"iana\",\n        extensions: [\"utz\"]\n      },\n      \"application/vnd.umajin\": {\n        source: \"iana\",\n        extensions: [\"umj\"]\n      },\n      \"application/vnd.unity\": {\n        source: \"iana\",\n        extensions: [\"unityweb\"]\n      },\n      \"application/vnd.uoml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uoml\", \"uo\"]\n      },\n      \"application/vnd.uplanet.alert\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.alert-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.bearer-choice-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.cacheop-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.channel-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.list-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.listcmd-wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uplanet.signal\": {\n        source: \"iana\"\n      },\n      \"application/vnd.uri-map\": {\n        source: \"iana\"\n      },\n      \"application/vnd.valve.source.material\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vcx\": {\n        source: \"iana\",\n        extensions: [\"vcx\"]\n      },\n      \"application/vnd.vd-study\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vectorworks\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vel+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veraison.tsm-report+cbor\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veraison.tsm-report+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.verimatrix.vcas\": {\n        source: \"iana\"\n      },\n      \"application/vnd.veritone.aion+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.veryant.thin\": {\n        source: \"iana\"\n      },\n      \"application/vnd.ves.encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vidsoft.vidconference\": {\n        source: \"iana\"\n      },\n      \"application/vnd.visio\": {\n        source: \"iana\",\n        extensions: [\"vsd\", \"vst\", \"vss\", \"vsw\", \"vsdx\", \"vtx\"]\n      },\n      \"application/vnd.visionary\": {\n        source: \"iana\",\n        extensions: [\"vis\"]\n      },\n      \"application/vnd.vividence.scriptfile\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vocalshaper.vsp4\": {\n        source: \"iana\"\n      },\n      \"application/vnd.vsf\": {\n        source: \"iana\",\n        extensions: [\"vsf\"]\n      },\n      \"application/vnd.wap.sic\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.slc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wap.wbxml\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"wbxml\"]\n      },\n      \"application/vnd.wap.wmlc\": {\n        source: \"iana\",\n        extensions: [\"wmlc\"]\n      },\n      \"application/vnd.wap.wmlscriptc\": {\n        source: \"iana\",\n        extensions: [\"wmlsc\"]\n      },\n      \"application/vnd.wasmflow.wafl\": {\n        source: \"iana\"\n      },\n      \"application/vnd.webturbo\": {\n        source: \"iana\",\n        extensions: [\"wtb\"]\n      },\n      \"application/vnd.wfa.dpp\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.p2p\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wfa.wsc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.windows.devicepairing\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmc\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wmf.bootstrap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.mathematica.package\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wolfram.player\": {\n        source: \"iana\",\n        extensions: [\"nbp\"]\n      },\n      \"application/vnd.wordlift\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wordperfect\": {\n        source: \"iana\",\n        extensions: [\"wpd\"]\n      },\n      \"application/vnd.wqd\": {\n        source: \"iana\",\n        extensions: [\"wqd\"]\n      },\n      \"application/vnd.wrq-hp3000-labelled\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wt.stf\": {\n        source: \"iana\",\n        extensions: [\"stf\"]\n      },\n      \"application/vnd.wv.csp+wbxml\": {\n        source: \"iana\"\n      },\n      \"application/vnd.wv.csp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.wv.ssp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xacml+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xara\": {\n        source: \"iana\",\n        extensions: [\"xar\"]\n      },\n      \"application/vnd.xarin.cpj\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xecrets-encrypted\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xfdl\": {\n        source: \"iana\",\n        extensions: [\"xfdl\"]\n      },\n      \"application/vnd.xfdl.webform\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmi+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vnd.xmpie.cpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.dpkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.plan\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.ppkg\": {\n        source: \"iana\"\n      },\n      \"application/vnd.xmpie.xlim\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.hv-dic\": {\n        source: \"iana\",\n        extensions: [\"hvd\"]\n      },\n      \"application/vnd.yamaha.hv-script\": {\n        source: \"iana\",\n        extensions: [\"hvs\"]\n      },\n      \"application/vnd.yamaha.hv-voice\": {\n        source: \"iana\",\n        extensions: [\"hvp\"]\n      },\n      \"application/vnd.yamaha.openscoreformat\": {\n        source: \"iana\",\n        extensions: [\"osf\"]\n      },\n      \"application/vnd.yamaha.openscoreformat.osfpvg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"osfpvg\"]\n      },\n      \"application/vnd.yamaha.remote-setup\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.smaf-audio\": {\n        source: \"iana\",\n        extensions: [\"saf\"]\n      },\n      \"application/vnd.yamaha.smaf-phrase\": {\n        source: \"iana\",\n        extensions: [\"spf\"]\n      },\n      \"application/vnd.yamaha.through-ngn\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yamaha.tunnel-udpencap\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yaoweme\": {\n        source: \"iana\"\n      },\n      \"application/vnd.yellowriver-custom-menu\": {\n        source: \"iana\",\n        extensions: [\"cmp\"]\n      },\n      \"application/vnd.zul\": {\n        source: \"iana\",\n        extensions: [\"zir\", \"zirz\"]\n      },\n      \"application/vnd.zzazz.deck+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"zaz\"]\n      },\n      \"application/voicexml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vxml\"]\n      },\n      \"application/voucher-cms+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/voucher-jws+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/vp\": {\n        source: \"iana\"\n      },\n      \"application/vp+cose\": {\n        source: \"iana\"\n      },\n      \"application/vp+jwt\": {\n        source: \"iana\"\n      },\n      \"application/vq-rtcpxr\": {\n        source: \"iana\"\n      },\n      \"application/wasm\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wasm\"]\n      },\n      \"application/watcherinfo+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wif\"]\n      },\n      \"application/webpush-options+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/whoispp-query\": {\n        source: \"iana\"\n      },\n      \"application/whoispp-response\": {\n        source: \"iana\"\n      },\n      \"application/widget\": {\n        source: \"iana\",\n        extensions: [\"wgt\"]\n      },\n      \"application/winhlp\": {\n        source: \"apache\",\n        extensions: [\"hlp\"]\n      },\n      \"application/wita\": {\n        source: \"iana\"\n      },\n      \"application/wordperfect5.1\": {\n        source: \"iana\"\n      },\n      \"application/wsdl+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wsdl\"]\n      },\n      \"application/wspolicy+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"wspolicy\"]\n      },\n      \"application/x-7z-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"7z\"]\n      },\n      \"application/x-abiword\": {\n        source: \"apache\",\n        extensions: [\"abw\"]\n      },\n      \"application/x-ace-compressed\": {\n        source: \"apache\",\n        extensions: [\"ace\"]\n      },\n      \"application/x-amf\": {\n        source: \"apache\"\n      },\n      \"application/x-apple-diskimage\": {\n        source: \"apache\",\n        extensions: [\"dmg\"]\n      },\n      \"application/x-arj\": {\n        compressible: false,\n        extensions: [\"arj\"]\n      },\n      \"application/x-authorware-bin\": {\n        source: \"apache\",\n        extensions: [\"aab\", \"x32\", \"u32\", \"vox\"]\n      },\n      \"application/x-authorware-map\": {\n        source: \"apache\",\n        extensions: [\"aam\"]\n      },\n      \"application/x-authorware-seg\": {\n        source: \"apache\",\n        extensions: [\"aas\"]\n      },\n      \"application/x-bcpio\": {\n        source: \"apache\",\n        extensions: [\"bcpio\"]\n      },\n      \"application/x-bdoc\": {\n        compressible: false,\n        extensions: [\"bdoc\"]\n      },\n      \"application/x-bittorrent\": {\n        source: \"apache\",\n        extensions: [\"torrent\"]\n      },\n      \"application/x-blender\": {\n        extensions: [\"blend\"]\n      },\n      \"application/x-blorb\": {\n        source: \"apache\",\n        extensions: [\"blb\", \"blorb\"]\n      },\n      \"application/x-bzip\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz\"]\n      },\n      \"application/x-bzip2\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"bz2\", \"boz\"]\n      },\n      \"application/x-cbr\": {\n        source: \"apache\",\n        extensions: [\"cbr\", \"cba\", \"cbt\", \"cbz\", \"cb7\"]\n      },\n      \"application/x-cdlink\": {\n        source: \"apache\",\n        extensions: [\"vcd\"]\n      },\n      \"application/x-cfs-compressed\": {\n        source: \"apache\",\n        extensions: [\"cfs\"]\n      },\n      \"application/x-chat\": {\n        source: \"apache\",\n        extensions: [\"chat\"]\n      },\n      \"application/x-chess-pgn\": {\n        source: \"apache\",\n        extensions: [\"pgn\"]\n      },\n      \"application/x-chrome-extension\": {\n        extensions: [\"crx\"]\n      },\n      \"application/x-cocoa\": {\n        source: \"nginx\",\n        extensions: [\"cco\"]\n      },\n      \"application/x-compress\": {\n        source: \"apache\"\n      },\n      \"application/x-compressed\": {\n        extensions: [\"rar\"]\n      },\n      \"application/x-conference\": {\n        source: \"apache\",\n        extensions: [\"nsc\"]\n      },\n      \"application/x-cpio\": {\n        source: \"apache\",\n        extensions: [\"cpio\"]\n      },\n      \"application/x-csh\": {\n        source: \"apache\",\n        extensions: [\"csh\"]\n      },\n      \"application/x-deb\": {\n        compressible: false\n      },\n      \"application/x-debian-package\": {\n        source: \"apache\",\n        extensions: [\"deb\", \"udeb\"]\n      },\n      \"application/x-dgc-compressed\": {\n        source: \"apache\",\n        extensions: [\"dgc\"]\n      },\n      \"application/x-director\": {\n        source: \"apache\",\n        extensions: [\"dir\", \"dcr\", \"dxr\", \"cst\", \"cct\", \"cxt\", \"w3d\", \"fgd\", \"swa\"]\n      },\n      \"application/x-doom\": {\n        source: \"apache\",\n        extensions: [\"wad\"]\n      },\n      \"application/x-dtbncx+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ncx\"]\n      },\n      \"application/x-dtbook+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"dtb\"]\n      },\n      \"application/x-dtbresource+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"res\"]\n      },\n      \"application/x-dvi\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"dvi\"]\n      },\n      \"application/x-envoy\": {\n        source: \"apache\",\n        extensions: [\"evy\"]\n      },\n      \"application/x-eva\": {\n        source: \"apache\",\n        extensions: [\"eva\"]\n      },\n      \"application/x-font-bdf\": {\n        source: \"apache\",\n        extensions: [\"bdf\"]\n      },\n      \"application/x-font-dos\": {\n        source: \"apache\"\n      },\n      \"application/x-font-framemaker\": {\n        source: \"apache\"\n      },\n      \"application/x-font-ghostscript\": {\n        source: \"apache\",\n        extensions: [\"gsf\"]\n      },\n      \"application/x-font-libgrx\": {\n        source: \"apache\"\n      },\n      \"application/x-font-linux-psf\": {\n        source: \"apache\",\n        extensions: [\"psf\"]\n      },\n      \"application/x-font-pcf\": {\n        source: \"apache\",\n        extensions: [\"pcf\"]\n      },\n      \"application/x-font-snf\": {\n        source: \"apache\",\n        extensions: [\"snf\"]\n      },\n      \"application/x-font-speedo\": {\n        source: \"apache\"\n      },\n      \"application/x-font-sunos-news\": {\n        source: \"apache\"\n      },\n      \"application/x-font-type1\": {\n        source: \"apache\",\n        extensions: [\"pfa\", \"pfb\", \"pfm\", \"afm\"]\n      },\n      \"application/x-font-vfont\": {\n        source: \"apache\"\n      },\n      \"application/x-freearc\": {\n        source: \"apache\",\n        extensions: [\"arc\"]\n      },\n      \"application/x-futuresplash\": {\n        source: \"apache\",\n        extensions: [\"spl\"]\n      },\n      \"application/x-gca-compressed\": {\n        source: \"apache\",\n        extensions: [\"gca\"]\n      },\n      \"application/x-glulx\": {\n        source: \"apache\",\n        extensions: [\"ulx\"]\n      },\n      \"application/x-gnumeric\": {\n        source: \"apache\",\n        extensions: [\"gnumeric\"]\n      },\n      \"application/x-gramps-xml\": {\n        source: \"apache\",\n        extensions: [\"gramps\"]\n      },\n      \"application/x-gtar\": {\n        source: \"apache\",\n        extensions: [\"gtar\"]\n      },\n      \"application/x-gzip\": {\n        source: \"apache\"\n      },\n      \"application/x-hdf\": {\n        source: \"apache\",\n        extensions: [\"hdf\"]\n      },\n      \"application/x-httpd-php\": {\n        compressible: true,\n        extensions: [\"php\"]\n      },\n      \"application/x-install-instructions\": {\n        source: \"apache\",\n        extensions: [\"install\"]\n      },\n      \"application/x-ipynb+json\": {\n        compressible: true,\n        extensions: [\"ipynb\"]\n      },\n      \"application/x-iso9660-image\": {\n        source: \"apache\",\n        extensions: [\"iso\"]\n      },\n      \"application/x-iwork-keynote-sffkey\": {\n        extensions: [\"key\"]\n      },\n      \"application/x-iwork-numbers-sffnumbers\": {\n        extensions: [\"numbers\"]\n      },\n      \"application/x-iwork-pages-sffpages\": {\n        extensions: [\"pages\"]\n      },\n      \"application/x-java-archive-diff\": {\n        source: \"nginx\",\n        extensions: [\"jardiff\"]\n      },\n      \"application/x-java-jnlp-file\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"jnlp\"]\n      },\n      \"application/x-javascript\": {\n        compressible: true\n      },\n      \"application/x-keepass2\": {\n        extensions: [\"kdbx\"]\n      },\n      \"application/x-latex\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"latex\"]\n      },\n      \"application/x-lua-bytecode\": {\n        extensions: [\"luac\"]\n      },\n      \"application/x-lzh-compressed\": {\n        source: \"apache\",\n        extensions: [\"lzh\", \"lha\"]\n      },\n      \"application/x-makeself\": {\n        source: \"nginx\",\n        extensions: [\"run\"]\n      },\n      \"application/x-mie\": {\n        source: \"apache\",\n        extensions: [\"mie\"]\n      },\n      \"application/x-mobipocket-ebook\": {\n        source: \"apache\",\n        extensions: [\"prc\", \"mobi\"]\n      },\n      \"application/x-mpegurl\": {\n        compressible: false\n      },\n      \"application/x-ms-application\": {\n        source: \"apache\",\n        extensions: [\"application\"]\n      },\n      \"application/x-ms-shortcut\": {\n        source: \"apache\",\n        extensions: [\"lnk\"]\n      },\n      \"application/x-ms-wmd\": {\n        source: \"apache\",\n        extensions: [\"wmd\"]\n      },\n      \"application/x-ms-wmz\": {\n        source: \"apache\",\n        extensions: [\"wmz\"]\n      },\n      \"application/x-ms-xbap\": {\n        source: \"apache\",\n        extensions: [\"xbap\"]\n      },\n      \"application/x-msaccess\": {\n        source: \"apache\",\n        extensions: [\"mdb\"]\n      },\n      \"application/x-msbinder\": {\n        source: \"apache\",\n        extensions: [\"obd\"]\n      },\n      \"application/x-mscardfile\": {\n        source: \"apache\",\n        extensions: [\"crd\"]\n      },\n      \"application/x-msclip\": {\n        source: \"apache\",\n        extensions: [\"clp\"]\n      },\n      \"application/x-msdos-program\": {\n        extensions: [\"exe\"]\n      },\n      \"application/x-msdownload\": {\n        source: \"apache\",\n        extensions: [\"exe\", \"dll\", \"com\", \"bat\", \"msi\"]\n      },\n      \"application/x-msmediaview\": {\n        source: \"apache\",\n        extensions: [\"mvb\", \"m13\", \"m14\"]\n      },\n      \"application/x-msmetafile\": {\n        source: \"apache\",\n        extensions: [\"wmf\", \"wmz\", \"emf\", \"emz\"]\n      },\n      \"application/x-msmoney\": {\n        source: \"apache\",\n        extensions: [\"mny\"]\n      },\n      \"application/x-mspublisher\": {\n        source: \"apache\",\n        extensions: [\"pub\"]\n      },\n      \"application/x-msschedule\": {\n        source: \"apache\",\n        extensions: [\"scd\"]\n      },\n      \"application/x-msterminal\": {\n        source: \"apache\",\n        extensions: [\"trm\"]\n      },\n      \"application/x-mswrite\": {\n        source: \"apache\",\n        extensions: [\"wri\"]\n      },\n      \"application/x-netcdf\": {\n        source: \"apache\",\n        extensions: [\"nc\", \"cdf\"]\n      },\n      \"application/x-ns-proxy-autoconfig\": {\n        compressible: true,\n        extensions: [\"pac\"]\n      },\n      \"application/x-nzb\": {\n        source: \"apache\",\n        extensions: [\"nzb\"]\n      },\n      \"application/x-perl\": {\n        source: \"nginx\",\n        extensions: [\"pl\", \"pm\"]\n      },\n      \"application/x-pilot\": {\n        source: \"nginx\",\n        extensions: [\"prc\", \"pdb\"]\n      },\n      \"application/x-pkcs12\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"p12\", \"pfx\"]\n      },\n      \"application/x-pkcs7-certificates\": {\n        source: \"apache\",\n        extensions: [\"p7b\", \"spc\"]\n      },\n      \"application/x-pkcs7-certreqresp\": {\n        source: \"apache\",\n        extensions: [\"p7r\"]\n      },\n      \"application/x-pki-message\": {\n        source: \"iana\"\n      },\n      \"application/x-rar-compressed\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"rar\"]\n      },\n      \"application/x-redhat-package-manager\": {\n        source: \"nginx\",\n        extensions: [\"rpm\"]\n      },\n      \"application/x-research-info-systems\": {\n        source: \"apache\",\n        extensions: [\"ris\"]\n      },\n      \"application/x-sea\": {\n        source: \"nginx\",\n        extensions: [\"sea\"]\n      },\n      \"application/x-sh\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"sh\"]\n      },\n      \"application/x-shar\": {\n        source: \"apache\",\n        extensions: [\"shar\"]\n      },\n      \"application/x-shockwave-flash\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"swf\"]\n      },\n      \"application/x-silverlight-app\": {\n        source: \"apache\",\n        extensions: [\"xap\"]\n      },\n      \"application/x-sql\": {\n        source: \"apache\",\n        extensions: [\"sql\"]\n      },\n      \"application/x-stuffit\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"sit\"]\n      },\n      \"application/x-stuffitx\": {\n        source: \"apache\",\n        extensions: [\"sitx\"]\n      },\n      \"application/x-subrip\": {\n        source: \"apache\",\n        extensions: [\"srt\"]\n      },\n      \"application/x-sv4cpio\": {\n        source: \"apache\",\n        extensions: [\"sv4cpio\"]\n      },\n      \"application/x-sv4crc\": {\n        source: \"apache\",\n        extensions: [\"sv4crc\"]\n      },\n      \"application/x-t3vm-image\": {\n        source: \"apache\",\n        extensions: [\"t3\"]\n      },\n      \"application/x-tads\": {\n        source: \"apache\",\n        extensions: [\"gam\"]\n      },\n      \"application/x-tar\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"tar\"]\n      },\n      \"application/x-tcl\": {\n        source: \"apache\",\n        extensions: [\"tcl\", \"tk\"]\n      },\n      \"application/x-tex\": {\n        source: \"apache\",\n        extensions: [\"tex\"]\n      },\n      \"application/x-tex-tfm\": {\n        source: \"apache\",\n        extensions: [\"tfm\"]\n      },\n      \"application/x-texinfo\": {\n        source: \"apache\",\n        extensions: [\"texinfo\", \"texi\"]\n      },\n      \"application/x-tgif\": {\n        source: \"apache\",\n        extensions: [\"obj\"]\n      },\n      \"application/x-ustar\": {\n        source: \"apache\",\n        extensions: [\"ustar\"]\n      },\n      \"application/x-virtualbox-hdd\": {\n        compressible: true,\n        extensions: [\"hdd\"]\n      },\n      \"application/x-virtualbox-ova\": {\n        compressible: true,\n        extensions: [\"ova\"]\n      },\n      \"application/x-virtualbox-ovf\": {\n        compressible: true,\n        extensions: [\"ovf\"]\n      },\n      \"application/x-virtualbox-vbox\": {\n        compressible: true,\n        extensions: [\"vbox\"]\n      },\n      \"application/x-virtualbox-vbox-extpack\": {\n        compressible: false,\n        extensions: [\"vbox-extpack\"]\n      },\n      \"application/x-virtualbox-vdi\": {\n        compressible: true,\n        extensions: [\"vdi\"]\n      },\n      \"application/x-virtualbox-vhd\": {\n        compressible: true,\n        extensions: [\"vhd\"]\n      },\n      \"application/x-virtualbox-vmdk\": {\n        compressible: true,\n        extensions: [\"vmdk\"]\n      },\n      \"application/x-wais-source\": {\n        source: \"apache\",\n        extensions: [\"src\"]\n      },\n      \"application/x-web-app-manifest+json\": {\n        compressible: true,\n        extensions: [\"webapp\"]\n      },\n      \"application/x-www-form-urlencoded\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/x-x509-ca-cert\": {\n        source: \"iana\",\n        extensions: [\"der\", \"crt\", \"pem\"]\n      },\n      \"application/x-x509-ca-ra-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-x509-next-ca-cert\": {\n        source: \"iana\"\n      },\n      \"application/x-xfig\": {\n        source: \"apache\",\n        extensions: [\"fig\"]\n      },\n      \"application/x-xliff+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/x-xpinstall\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"xpi\"]\n      },\n      \"application/x-xz\": {\n        source: \"apache\",\n        extensions: [\"xz\"]\n      },\n      \"application/x-zip-compressed\": {\n        extensions: [\"zip\"]\n      },\n      \"application/x-zmachine\": {\n        source: \"apache\",\n        extensions: [\"z1\", \"z2\", \"z3\", \"z4\", \"z5\", \"z6\", \"z7\", \"z8\"]\n      },\n      \"application/x400-bp\": {\n        source: \"iana\"\n      },\n      \"application/xacml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xaml+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xaml\"]\n      },\n      \"application/xcap-att+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xav\"]\n      },\n      \"application/xcap-caps+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xca\"]\n      },\n      \"application/xcap-diff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xdf\"]\n      },\n      \"application/xcap-el+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xel\"]\n      },\n      \"application/xcap-error+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcap-ns+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xns\"]\n      },\n      \"application/xcon-conference-info+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xcon-conference-info-diff+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xenc+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xenc\"]\n      },\n      \"application/xfdf\": {\n        source: \"iana\",\n        extensions: [\"xfdf\"]\n      },\n      \"application/xhtml+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xhtml\", \"xht\"]\n      },\n      \"application/xhtml-voice+xml\": {\n        source: \"apache\",\n        compressible: true\n      },\n      \"application/xliff+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xlf\"]\n      },\n      \"application/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\", \"xsl\", \"xsd\", \"rng\"]\n      },\n      \"application/xml-dtd\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dtd\"]\n      },\n      \"application/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"application/xml-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xmpp+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/xop+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xop\"]\n      },\n      \"application/xproc+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xpl\"]\n      },\n      \"application/xslt+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xsl\", \"xslt\"]\n      },\n      \"application/xspf+xml\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"xspf\"]\n      },\n      \"application/xv+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"mxml\", \"xhvml\", \"xvml\", \"xvm\"]\n      },\n      \"application/yaml\": {\n        source: \"iana\"\n      },\n      \"application/yang\": {\n        source: \"iana\",\n        extensions: [\"yang\"]\n      },\n      \"application/yang-data+cbor\": {\n        source: \"iana\"\n      },\n      \"application/yang-data+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-data+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-patch+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yang-sid+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"application/yin+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"yin\"]\n      },\n      \"application/zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"zip\"]\n      },\n      \"application/zip+dotlottie\": {\n        extensions: [\"lottie\"]\n      },\n      \"application/zlib\": {\n        source: \"iana\"\n      },\n      \"application/zstd\": {\n        source: \"iana\"\n      },\n      \"audio/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/3gpp\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"3gpp\"]\n      },\n      \"audio/3gpp2\": {\n        source: \"iana\"\n      },\n      \"audio/aac\": {\n        source: \"iana\",\n        extensions: [\"adts\", \"aac\"]\n      },\n      \"audio/ac3\": {\n        source: \"iana\"\n      },\n      \"audio/adpcm\": {\n        source: \"apache\",\n        extensions: [\"adp\"]\n      },\n      \"audio/amr\": {\n        source: \"iana\",\n        extensions: [\"amr\"]\n      },\n      \"audio/amr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/amr-wb+\": {\n        source: \"iana\"\n      },\n      \"audio/aptx\": {\n        source: \"iana\"\n      },\n      \"audio/asc\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-advanced-lossless\": {\n        source: \"iana\"\n      },\n      \"audio/atrac-x\": {\n        source: \"iana\"\n      },\n      \"audio/atrac3\": {\n        source: \"iana\"\n      },\n      \"audio/basic\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"au\", \"snd\"]\n      },\n      \"audio/bv16\": {\n        source: \"iana\"\n      },\n      \"audio/bv32\": {\n        source: \"iana\"\n      },\n      \"audio/clearmode\": {\n        source: \"iana\"\n      },\n      \"audio/cn\": {\n        source: \"iana\"\n      },\n      \"audio/dat12\": {\n        source: \"iana\"\n      },\n      \"audio/dls\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es201108\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202050\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202211\": {\n        source: \"iana\"\n      },\n      \"audio/dsr-es202212\": {\n        source: \"iana\"\n      },\n      \"audio/dv\": {\n        source: \"iana\"\n      },\n      \"audio/dvi4\": {\n        source: \"iana\"\n      },\n      \"audio/eac3\": {\n        source: \"iana\"\n      },\n      \"audio/encaprtp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc\": {\n        source: \"iana\"\n      },\n      \"audio/evrc-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/evrc0\": {\n        source: \"iana\"\n      },\n      \"audio/evrc1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcb1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcnw1\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb0\": {\n        source: \"iana\"\n      },\n      \"audio/evrcwb1\": {\n        source: \"iana\"\n      },\n      \"audio/evs\": {\n        source: \"iana\"\n      },\n      \"audio/flac\": {\n        source: \"iana\"\n      },\n      \"audio/flexfec\": {\n        source: \"iana\"\n      },\n      \"audio/fwdred\": {\n        source: \"iana\"\n      },\n      \"audio/g711-0\": {\n        source: \"iana\"\n      },\n      \"audio/g719\": {\n        source: \"iana\"\n      },\n      \"audio/g722\": {\n        source: \"iana\"\n      },\n      \"audio/g7221\": {\n        source: \"iana\"\n      },\n      \"audio/g723\": {\n        source: \"iana\"\n      },\n      \"audio/g726-16\": {\n        source: \"iana\"\n      },\n      \"audio/g726-24\": {\n        source: \"iana\"\n      },\n      \"audio/g726-32\": {\n        source: \"iana\"\n      },\n      \"audio/g726-40\": {\n        source: \"iana\"\n      },\n      \"audio/g728\": {\n        source: \"iana\"\n      },\n      \"audio/g729\": {\n        source: \"iana\"\n      },\n      \"audio/g7291\": {\n        source: \"iana\"\n      },\n      \"audio/g729d\": {\n        source: \"iana\"\n      },\n      \"audio/g729e\": {\n        source: \"iana\"\n      },\n      \"audio/gsm\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-efr\": {\n        source: \"iana\"\n      },\n      \"audio/gsm-hr-08\": {\n        source: \"iana\"\n      },\n      \"audio/ilbc\": {\n        source: \"iana\"\n      },\n      \"audio/ip-mr_v2.5\": {\n        source: \"iana\"\n      },\n      \"audio/isac\": {\n        source: \"apache\"\n      },\n      \"audio/l16\": {\n        source: \"iana\"\n      },\n      \"audio/l20\": {\n        source: \"iana\"\n      },\n      \"audio/l24\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/l8\": {\n        source: \"iana\"\n      },\n      \"audio/lpc\": {\n        source: \"iana\"\n      },\n      \"audio/matroska\": {\n        source: \"iana\"\n      },\n      \"audio/melp\": {\n        source: \"iana\"\n      },\n      \"audio/melp1200\": {\n        source: \"iana\"\n      },\n      \"audio/melp2400\": {\n        source: \"iana\"\n      },\n      \"audio/melp600\": {\n        source: \"iana\"\n      },\n      \"audio/mhas\": {\n        source: \"iana\"\n      },\n      \"audio/midi\": {\n        source: \"apache\",\n        extensions: [\"mid\", \"midi\", \"kar\", \"rmi\"]\n      },\n      \"audio/midi-clip\": {\n        source: \"iana\"\n      },\n      \"audio/mobile-xmf\": {\n        source: \"iana\",\n        extensions: [\"mxmf\"]\n      },\n      \"audio/mp3\": {\n        compressible: false,\n        extensions: [\"mp3\"]\n      },\n      \"audio/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"m4a\", \"mp4a\", \"m4b\"]\n      },\n      \"audio/mp4a-latm\": {\n        source: \"iana\"\n      },\n      \"audio/mpa\": {\n        source: \"iana\"\n      },\n      \"audio/mpa-robust\": {\n        source: \"iana\"\n      },\n      \"audio/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpga\", \"mp2\", \"mp2a\", \"mp3\", \"m2a\", \"m3a\"]\n      },\n      \"audio/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"audio/musepack\": {\n        source: \"apache\"\n      },\n      \"audio/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"oga\", \"ogg\", \"spx\", \"opus\"]\n      },\n      \"audio/opus\": {\n        source: \"iana\"\n      },\n      \"audio/parityfec\": {\n        source: \"iana\"\n      },\n      \"audio/pcma\": {\n        source: \"iana\"\n      },\n      \"audio/pcma-wb\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu\": {\n        source: \"iana\"\n      },\n      \"audio/pcmu-wb\": {\n        source: \"iana\"\n      },\n      \"audio/prs.sid\": {\n        source: \"iana\"\n      },\n      \"audio/qcelp\": {\n        source: \"iana\"\n      },\n      \"audio/raptorfec\": {\n        source: \"iana\"\n      },\n      \"audio/red\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"audio/rtp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/rtploopback\": {\n        source: \"iana\"\n      },\n      \"audio/rtx\": {\n        source: \"iana\"\n      },\n      \"audio/s3m\": {\n        source: \"apache\",\n        extensions: [\"s3m\"]\n      },\n      \"audio/scip\": {\n        source: \"iana\"\n      },\n      \"audio/silk\": {\n        source: \"apache\",\n        extensions: [\"sil\"]\n      },\n      \"audio/smv\": {\n        source: \"iana\"\n      },\n      \"audio/smv-qcp\": {\n        source: \"iana\"\n      },\n      \"audio/smv0\": {\n        source: \"iana\"\n      },\n      \"audio/sofa\": {\n        source: \"iana\"\n      },\n      \"audio/sp-midi\": {\n        source: \"iana\"\n      },\n      \"audio/speex\": {\n        source: \"iana\"\n      },\n      \"audio/t140c\": {\n        source: \"iana\"\n      },\n      \"audio/t38\": {\n        source: \"iana\"\n      },\n      \"audio/telephone-event\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp\": {\n        source: \"iana\"\n      },\n      \"audio/tetra_acelp_bb\": {\n        source: \"iana\"\n      },\n      \"audio/tone\": {\n        source: \"iana\"\n      },\n      \"audio/tsvcis\": {\n        source: \"iana\"\n      },\n      \"audio/uemclip\": {\n        source: \"iana\"\n      },\n      \"audio/ulpfec\": {\n        source: \"iana\"\n      },\n      \"audio/usac\": {\n        source: \"iana\"\n      },\n      \"audio/vdvi\": {\n        source: \"iana\"\n      },\n      \"audio/vmr-wb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.3gpp.iufp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.4sb\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.audiokoz\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.celp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cisco.nse\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cmles.radio-events\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.anp1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.cns.inf1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dece.audio\": {\n        source: \"iana\",\n        extensions: [\"uva\", \"uvva\"]\n      },\n      \"audio/vnd.digital-winds\": {\n        source: \"iana\",\n        extensions: [\"eol\"]\n      },\n      \"audio/vnd.dlna.adts\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.heaac.2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mlp\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.mps\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2x\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pl2z\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dolby.pulse.1\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dra\": {\n        source: \"iana\",\n        extensions: [\"dra\"]\n      },\n      \"audio/vnd.dts\": {\n        source: \"iana\",\n        extensions: [\"dts\"]\n      },\n      \"audio/vnd.dts.hd\": {\n        source: \"iana\",\n        extensions: [\"dtshd\"]\n      },\n      \"audio/vnd.dts.uhd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.dvb.file\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.everad.plj\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.hns.audio\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.lucent.voice\": {\n        source: \"iana\",\n        extensions: [\"lvp\"]\n      },\n      \"audio/vnd.ms-playready.media.pya\": {\n        source: \"iana\",\n        extensions: [\"pya\"]\n      },\n      \"audio/vnd.nokia.mobile-xmf\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nortel.vbk\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.nuera.ecelp4800\": {\n        source: \"iana\",\n        extensions: [\"ecelp4800\"]\n      },\n      \"audio/vnd.nuera.ecelp7470\": {\n        source: \"iana\",\n        extensions: [\"ecelp7470\"]\n      },\n      \"audio/vnd.nuera.ecelp9600\": {\n        source: \"iana\",\n        extensions: [\"ecelp9600\"]\n      },\n      \"audio/vnd.octel.sbc\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.presonus.multitrack\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.qcelp\": {\n        source: \"apache\"\n      },\n      \"audio/vnd.rhetorex.32kadpcm\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.rip\": {\n        source: \"iana\",\n        extensions: [\"rip\"]\n      },\n      \"audio/vnd.rn-realaudio\": {\n        compressible: false\n      },\n      \"audio/vnd.sealedmedia.softseal.mpeg\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.vmx.cvsd\": {\n        source: \"iana\"\n      },\n      \"audio/vnd.wave\": {\n        compressible: false\n      },\n      \"audio/vorbis\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"audio/vorbis-config\": {\n        source: \"iana\"\n      },\n      \"audio/wav\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/wave\": {\n        compressible: false,\n        extensions: [\"wav\"]\n      },\n      \"audio/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"weba\"]\n      },\n      \"audio/x-aac\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"aac\"]\n      },\n      \"audio/x-aiff\": {\n        source: \"apache\",\n        extensions: [\"aif\", \"aiff\", \"aifc\"]\n      },\n      \"audio/x-caf\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"caf\"]\n      },\n      \"audio/x-flac\": {\n        source: \"apache\",\n        extensions: [\"flac\"]\n      },\n      \"audio/x-m4a\": {\n        source: \"nginx\",\n        extensions: [\"m4a\"]\n      },\n      \"audio/x-matroska\": {\n        source: \"apache\",\n        extensions: [\"mka\"]\n      },\n      \"audio/x-mpegurl\": {\n        source: \"apache\",\n        extensions: [\"m3u\"]\n      },\n      \"audio/x-ms-wax\": {\n        source: \"apache\",\n        extensions: [\"wax\"]\n      },\n      \"audio/x-ms-wma\": {\n        source: \"apache\",\n        extensions: [\"wma\"]\n      },\n      \"audio/x-pn-realaudio\": {\n        source: \"apache\",\n        extensions: [\"ram\", \"ra\"]\n      },\n      \"audio/x-pn-realaudio-plugin\": {\n        source: \"apache\",\n        extensions: [\"rmp\"]\n      },\n      \"audio/x-realaudio\": {\n        source: \"nginx\",\n        extensions: [\"ra\"]\n      },\n      \"audio/x-tta\": {\n        source: \"apache\"\n      },\n      \"audio/x-wav\": {\n        source: \"apache\",\n        extensions: [\"wav\"]\n      },\n      \"audio/xm\": {\n        source: \"apache\",\n        extensions: [\"xm\"]\n      },\n      \"chemical/x-cdx\": {\n        source: \"apache\",\n        extensions: [\"cdx\"]\n      },\n      \"chemical/x-cif\": {\n        source: \"apache\",\n        extensions: [\"cif\"]\n      },\n      \"chemical/x-cmdf\": {\n        source: \"apache\",\n        extensions: [\"cmdf\"]\n      },\n      \"chemical/x-cml\": {\n        source: \"apache\",\n        extensions: [\"cml\"]\n      },\n      \"chemical/x-csml\": {\n        source: \"apache\",\n        extensions: [\"csml\"]\n      },\n      \"chemical/x-pdb\": {\n        source: \"apache\"\n      },\n      \"chemical/x-xyz\": {\n        source: \"apache\",\n        extensions: [\"xyz\"]\n      },\n      \"font/collection\": {\n        source: \"iana\",\n        extensions: [\"ttc\"]\n      },\n      \"font/otf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"otf\"]\n      },\n      \"font/sfnt\": {\n        source: \"iana\"\n      },\n      \"font/ttf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ttf\"]\n      },\n      \"font/woff\": {\n        source: \"iana\",\n        extensions: [\"woff\"]\n      },\n      \"font/woff2\": {\n        source: \"iana\",\n        extensions: [\"woff2\"]\n      },\n      \"image/aces\": {\n        source: \"iana\",\n        extensions: [\"exr\"]\n      },\n      \"image/apng\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"apng\"]\n      },\n      \"image/avci\": {\n        source: \"iana\",\n        extensions: [\"avci\"]\n      },\n      \"image/avcs\": {\n        source: \"iana\",\n        extensions: [\"avcs\"]\n      },\n      \"image/avif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"avif\"]\n      },\n      \"image/bmp\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"bmp\", \"dib\"]\n      },\n      \"image/cgm\": {\n        source: \"iana\",\n        extensions: [\"cgm\"]\n      },\n      \"image/dicom-rle\": {\n        source: \"iana\",\n        extensions: [\"drle\"]\n      },\n      \"image/dpx\": {\n        source: \"iana\",\n        extensions: [\"dpx\"]\n      },\n      \"image/emf\": {\n        source: \"iana\",\n        extensions: [\"emf\"]\n      },\n      \"image/fits\": {\n        source: \"iana\",\n        extensions: [\"fits\"]\n      },\n      \"image/g3fax\": {\n        source: \"iana\",\n        extensions: [\"g3\"]\n      },\n      \"image/gif\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"gif\"]\n      },\n      \"image/heic\": {\n        source: \"iana\",\n        extensions: [\"heic\"]\n      },\n      \"image/heic-sequence\": {\n        source: \"iana\",\n        extensions: [\"heics\"]\n      },\n      \"image/heif\": {\n        source: \"iana\",\n        extensions: [\"heif\"]\n      },\n      \"image/heif-sequence\": {\n        source: \"iana\",\n        extensions: [\"heifs\"]\n      },\n      \"image/hej2k\": {\n        source: \"iana\",\n        extensions: [\"hej2\"]\n      },\n      \"image/ief\": {\n        source: \"iana\",\n        extensions: [\"ief\"]\n      },\n      \"image/j2c\": {\n        source: \"iana\"\n      },\n      \"image/jaii\": {\n        source: \"iana\",\n        extensions: [\"jaii\"]\n      },\n      \"image/jais\": {\n        source: \"iana\",\n        extensions: [\"jais\"]\n      },\n      \"image/jls\": {\n        source: \"iana\",\n        extensions: [\"jls\"]\n      },\n      \"image/jp2\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jp2\", \"jpg2\"]\n      },\n      \"image/jpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpg\", \"jpeg\", \"jpe\"]\n      },\n      \"image/jph\": {\n        source: \"iana\",\n        extensions: [\"jph\"]\n      },\n      \"image/jphc\": {\n        source: \"iana\",\n        extensions: [\"jhc\"]\n      },\n      \"image/jpm\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"image/jpx\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"jpx\", \"jpf\"]\n      },\n      \"image/jxl\": {\n        source: \"iana\",\n        extensions: [\"jxl\"]\n      },\n      \"image/jxr\": {\n        source: \"iana\",\n        extensions: [\"jxr\"]\n      },\n      \"image/jxra\": {\n        source: \"iana\",\n        extensions: [\"jxra\"]\n      },\n      \"image/jxrs\": {\n        source: \"iana\",\n        extensions: [\"jxrs\"]\n      },\n      \"image/jxs\": {\n        source: \"iana\",\n        extensions: [\"jxs\"]\n      },\n      \"image/jxsc\": {\n        source: \"iana\",\n        extensions: [\"jxsc\"]\n      },\n      \"image/jxsi\": {\n        source: \"iana\",\n        extensions: [\"jxsi\"]\n      },\n      \"image/jxss\": {\n        source: \"iana\",\n        extensions: [\"jxss\"]\n      },\n      \"image/ktx\": {\n        source: \"iana\",\n        extensions: [\"ktx\"]\n      },\n      \"image/ktx2\": {\n        source: \"iana\",\n        extensions: [\"ktx2\"]\n      },\n      \"image/naplps\": {\n        source: \"iana\"\n      },\n      \"image/pjpeg\": {\n        compressible: false,\n        extensions: [\"jfif\"]\n      },\n      \"image/png\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"png\"]\n      },\n      \"image/prs.btif\": {\n        source: \"iana\",\n        extensions: [\"btif\", \"btf\"]\n      },\n      \"image/prs.pti\": {\n        source: \"iana\",\n        extensions: [\"pti\"]\n      },\n      \"image/pwg-raster\": {\n        source: \"iana\"\n      },\n      \"image/sgi\": {\n        source: \"apache\",\n        extensions: [\"sgi\"]\n      },\n      \"image/svg+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"svg\", \"svgz\"]\n      },\n      \"image/t38\": {\n        source: \"iana\",\n        extensions: [\"t38\"]\n      },\n      \"image/tiff\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"tif\", \"tiff\"]\n      },\n      \"image/tiff-fx\": {\n        source: \"iana\",\n        extensions: [\"tfx\"]\n      },\n      \"image/vnd.adobe.photoshop\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"psd\"]\n      },\n      \"image/vnd.airzip.accelerator.azv\": {\n        source: \"iana\",\n        extensions: [\"azv\"]\n      },\n      \"image/vnd.clip\": {\n        source: \"iana\"\n      },\n      \"image/vnd.cns.inf2\": {\n        source: \"iana\"\n      },\n      \"image/vnd.dece.graphic\": {\n        source: \"iana\",\n        extensions: [\"uvi\", \"uvvi\", \"uvg\", \"uvvg\"]\n      },\n      \"image/vnd.djvu\": {\n        source: \"iana\",\n        extensions: [\"djvu\", \"djv\"]\n      },\n      \"image/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"image/vnd.dwg\": {\n        source: \"iana\",\n        extensions: [\"dwg\"]\n      },\n      \"image/vnd.dxf\": {\n        source: \"iana\",\n        extensions: [\"dxf\"]\n      },\n      \"image/vnd.fastbidsheet\": {\n        source: \"iana\",\n        extensions: [\"fbs\"]\n      },\n      \"image/vnd.fpx\": {\n        source: \"iana\",\n        extensions: [\"fpx\"]\n      },\n      \"image/vnd.fst\": {\n        source: \"iana\",\n        extensions: [\"fst\"]\n      },\n      \"image/vnd.fujixerox.edmics-mmr\": {\n        source: \"iana\",\n        extensions: [\"mmr\"]\n      },\n      \"image/vnd.fujixerox.edmics-rlc\": {\n        source: \"iana\",\n        extensions: [\"rlc\"]\n      },\n      \"image/vnd.globalgraphics.pgb\": {\n        source: \"iana\"\n      },\n      \"image/vnd.microsoft.icon\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/vnd.mix\": {\n        source: \"iana\"\n      },\n      \"image/vnd.mozilla.apng\": {\n        source: \"iana\"\n      },\n      \"image/vnd.ms-dds\": {\n        compressible: true,\n        extensions: [\"dds\"]\n      },\n      \"image/vnd.ms-modi\": {\n        source: \"iana\",\n        extensions: [\"mdi\"]\n      },\n      \"image/vnd.ms-photo\": {\n        source: \"apache\",\n        extensions: [\"wdp\"]\n      },\n      \"image/vnd.net-fpx\": {\n        source: \"iana\",\n        extensions: [\"npx\"]\n      },\n      \"image/vnd.pco.b16\": {\n        source: \"iana\",\n        extensions: [\"b16\"]\n      },\n      \"image/vnd.radiance\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealed.png\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.gif\": {\n        source: \"iana\"\n      },\n      \"image/vnd.sealedmedia.softseal.jpg\": {\n        source: \"iana\"\n      },\n      \"image/vnd.svf\": {\n        source: \"iana\"\n      },\n      \"image/vnd.tencent.tap\": {\n        source: \"iana\",\n        extensions: [\"tap\"]\n      },\n      \"image/vnd.valve.source.texture\": {\n        source: \"iana\",\n        extensions: [\"vtf\"]\n      },\n      \"image/vnd.wap.wbmp\": {\n        source: \"iana\",\n        extensions: [\"wbmp\"]\n      },\n      \"image/vnd.xiff\": {\n        source: \"iana\",\n        extensions: [\"xif\"]\n      },\n      \"image/vnd.zbrush.pcx\": {\n        source: \"iana\",\n        extensions: [\"pcx\"]\n      },\n      \"image/webp\": {\n        source: \"iana\",\n        extensions: [\"webp\"]\n      },\n      \"image/wmf\": {\n        source: \"iana\",\n        extensions: [\"wmf\"]\n      },\n      \"image/x-3ds\": {\n        source: \"apache\",\n        extensions: [\"3ds\"]\n      },\n      \"image/x-adobe-dng\": {\n        extensions: [\"dng\"]\n      },\n      \"image/x-cmu-raster\": {\n        source: \"apache\",\n        extensions: [\"ras\"]\n      },\n      \"image/x-cmx\": {\n        source: \"apache\",\n        extensions: [\"cmx\"]\n      },\n      \"image/x-emf\": {\n        source: \"iana\"\n      },\n      \"image/x-freehand\": {\n        source: \"apache\",\n        extensions: [\"fh\", \"fhc\", \"fh4\", \"fh5\", \"fh7\"]\n      },\n      \"image/x-icon\": {\n        source: \"apache\",\n        compressible: true,\n        extensions: [\"ico\"]\n      },\n      \"image/x-jng\": {\n        source: \"nginx\",\n        extensions: [\"jng\"]\n      },\n      \"image/x-mrsid-image\": {\n        source: \"apache\",\n        extensions: [\"sid\"]\n      },\n      \"image/x-ms-bmp\": {\n        source: \"nginx\",\n        compressible: true,\n        extensions: [\"bmp\"]\n      },\n      \"image/x-pcx\": {\n        source: \"apache\",\n        extensions: [\"pcx\"]\n      },\n      \"image/x-pict\": {\n        source: \"apache\",\n        extensions: [\"pic\", \"pct\"]\n      },\n      \"image/x-portable-anymap\": {\n        source: \"apache\",\n        extensions: [\"pnm\"]\n      },\n      \"image/x-portable-bitmap\": {\n        source: \"apache\",\n        extensions: [\"pbm\"]\n      },\n      \"image/x-portable-graymap\": {\n        source: \"apache\",\n        extensions: [\"pgm\"]\n      },\n      \"image/x-portable-pixmap\": {\n        source: \"apache\",\n        extensions: [\"ppm\"]\n      },\n      \"image/x-rgb\": {\n        source: \"apache\",\n        extensions: [\"rgb\"]\n      },\n      \"image/x-tga\": {\n        source: \"apache\",\n        extensions: [\"tga\"]\n      },\n      \"image/x-wmf\": {\n        source: \"iana\"\n      },\n      \"image/x-xbitmap\": {\n        source: \"apache\",\n        extensions: [\"xbm\"]\n      },\n      \"image/x-xcf\": {\n        compressible: false\n      },\n      \"image/x-xpixmap\": {\n        source: \"apache\",\n        extensions: [\"xpm\"]\n      },\n      \"image/x-xwindowdump\": {\n        source: \"apache\",\n        extensions: [\"xwd\"]\n      },\n      \"message/bhttp\": {\n        source: \"iana\"\n      },\n      \"message/cpim\": {\n        source: \"iana\"\n      },\n      \"message/delivery-status\": {\n        source: \"iana\"\n      },\n      \"message/disposition-notification\": {\n        source: \"iana\",\n        extensions: [\n          \"disposition-notification\"\n        ]\n      },\n      \"message/external-body\": {\n        source: \"iana\"\n      },\n      \"message/feedback-report\": {\n        source: \"iana\"\n      },\n      \"message/global\": {\n        source: \"iana\",\n        extensions: [\"u8msg\"]\n      },\n      \"message/global-delivery-status\": {\n        source: \"iana\",\n        extensions: [\"u8dsn\"]\n      },\n      \"message/global-disposition-notification\": {\n        source: \"iana\",\n        extensions: [\"u8mdn\"]\n      },\n      \"message/global-headers\": {\n        source: \"iana\",\n        extensions: [\"u8hdr\"]\n      },\n      \"message/http\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/imdn+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"message/mls\": {\n        source: \"iana\"\n      },\n      \"message/news\": {\n        source: \"apache\"\n      },\n      \"message/ohttp-req\": {\n        source: \"iana\"\n      },\n      \"message/ohttp-res\": {\n        source: \"iana\"\n      },\n      \"message/partial\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"message/rfc822\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"eml\", \"mime\", \"mht\", \"mhtml\"]\n      },\n      \"message/s-http\": {\n        source: \"apache\"\n      },\n      \"message/sip\": {\n        source: \"iana\"\n      },\n      \"message/sipfrag\": {\n        source: \"iana\"\n      },\n      \"message/tracking-status\": {\n        source: \"iana\"\n      },\n      \"message/vnd.si.simp\": {\n        source: \"apache\"\n      },\n      \"message/vnd.wfa.wsc\": {\n        source: \"iana\",\n        extensions: [\"wsc\"]\n      },\n      \"model/3mf\": {\n        source: \"iana\",\n        extensions: [\"3mf\"]\n      },\n      \"model/e57\": {\n        source: \"iana\"\n      },\n      \"model/gltf+json\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"gltf\"]\n      },\n      \"model/gltf-binary\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"glb\"]\n      },\n      \"model/iges\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"igs\", \"iges\"]\n      },\n      \"model/jt\": {\n        source: \"iana\",\n        extensions: [\"jt\"]\n      },\n      \"model/mesh\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"msh\", \"mesh\", \"silo\"]\n      },\n      \"model/mtl\": {\n        source: \"iana\",\n        extensions: [\"mtl\"]\n      },\n      \"model/obj\": {\n        source: \"iana\",\n        extensions: [\"obj\"]\n      },\n      \"model/prc\": {\n        source: \"iana\",\n        extensions: [\"prc\"]\n      },\n      \"model/step\": {\n        source: \"iana\",\n        extensions: [\"step\", \"stp\", \"stpnc\", \"p21\", \"210\"]\n      },\n      \"model/step+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"stpx\"]\n      },\n      \"model/step+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpz\"]\n      },\n      \"model/step-xml+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"stpxz\"]\n      },\n      \"model/stl\": {\n        source: \"iana\",\n        extensions: [\"stl\"]\n      },\n      \"model/u3d\": {\n        source: \"iana\",\n        extensions: [\"u3d\"]\n      },\n      \"model/vnd.bary\": {\n        source: \"iana\",\n        extensions: [\"bary\"]\n      },\n      \"model/vnd.cld\": {\n        source: \"iana\",\n        extensions: [\"cld\"]\n      },\n      \"model/vnd.collada+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"dae\"]\n      },\n      \"model/vnd.dwf\": {\n        source: \"iana\",\n        extensions: [\"dwf\"]\n      },\n      \"model/vnd.flatland.3dml\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gdl\": {\n        source: \"iana\",\n        extensions: [\"gdl\"]\n      },\n      \"model/vnd.gs-gdl\": {\n        source: \"apache\"\n      },\n      \"model/vnd.gs.gdl\": {\n        source: \"iana\"\n      },\n      \"model/vnd.gtw\": {\n        source: \"iana\",\n        extensions: [\"gtw\"]\n      },\n      \"model/vnd.moml+xml\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"model/vnd.mts\": {\n        source: \"iana\",\n        extensions: [\"mts\"]\n      },\n      \"model/vnd.opengex\": {\n        source: \"iana\",\n        extensions: [\"ogex\"]\n      },\n      \"model/vnd.parasolid.transmit.binary\": {\n        source: \"iana\",\n        extensions: [\"x_b\"]\n      },\n      \"model/vnd.parasolid.transmit.text\": {\n        source: \"iana\",\n        extensions: [\"x_t\"]\n      },\n      \"model/vnd.pytha.pyox\": {\n        source: \"iana\",\n        extensions: [\"pyo\", \"pyox\"]\n      },\n      \"model/vnd.rosette.annotated-data-model\": {\n        source: \"iana\"\n      },\n      \"model/vnd.sap.vds\": {\n        source: \"iana\",\n        extensions: [\"vds\"]\n      },\n      \"model/vnd.usda\": {\n        source: \"iana\",\n        extensions: [\"usda\"]\n      },\n      \"model/vnd.usdz+zip\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"usdz\"]\n      },\n      \"model/vnd.valve.source.compiled-map\": {\n        source: \"iana\",\n        extensions: [\"bsp\"]\n      },\n      \"model/vnd.vtu\": {\n        source: \"iana\",\n        extensions: [\"vtu\"]\n      },\n      \"model/vrml\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"wrl\", \"vrml\"]\n      },\n      \"model/x3d+binary\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3db\", \"x3dbz\"]\n      },\n      \"model/x3d+fastinfoset\": {\n        source: \"iana\",\n        extensions: [\"x3db\"]\n      },\n      \"model/x3d+vrml\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"x3dv\", \"x3dvz\"]\n      },\n      \"model/x3d+xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"x3d\", \"x3dz\"]\n      },\n      \"model/x3d-vrml\": {\n        source: \"iana\",\n        extensions: [\"x3dv\"]\n      },\n      \"multipart/alternative\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/appledouble\": {\n        source: \"iana\"\n      },\n      \"multipart/byteranges\": {\n        source: \"iana\"\n      },\n      \"multipart/digest\": {\n        source: \"iana\"\n      },\n      \"multipart/encrypted\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/form-data\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/header-set\": {\n        source: \"iana\"\n      },\n      \"multipart/mixed\": {\n        source: \"iana\"\n      },\n      \"multipart/multilingual\": {\n        source: \"iana\"\n      },\n      \"multipart/parallel\": {\n        source: \"iana\"\n      },\n      \"multipart/related\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/report\": {\n        source: \"iana\"\n      },\n      \"multipart/signed\": {\n        source: \"iana\",\n        compressible: false\n      },\n      \"multipart/vnd.bint.med-plus\": {\n        source: \"iana\"\n      },\n      \"multipart/voice-message\": {\n        source: \"iana\"\n      },\n      \"multipart/x-mixed-replace\": {\n        source: \"iana\"\n      },\n      \"text/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"text/cache-manifest\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"appcache\", \"manifest\"]\n      },\n      \"text/calendar\": {\n        source: \"iana\",\n        extensions: [\"ics\", \"ifb\"]\n      },\n      \"text/calender\": {\n        compressible: true\n      },\n      \"text/cmd\": {\n        compressible: true\n      },\n      \"text/coffeescript\": {\n        extensions: [\"coffee\", \"litcoffee\"]\n      },\n      \"text/cql\": {\n        source: \"iana\"\n      },\n      \"text/cql-expression\": {\n        source: \"iana\"\n      },\n      \"text/cql-identifier\": {\n        source: \"iana\"\n      },\n      \"text/css\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"css\"]\n      },\n      \"text/csv\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"csv\"]\n      },\n      \"text/csv-schema\": {\n        source: \"iana\"\n      },\n      \"text/directory\": {\n        source: \"iana\"\n      },\n      \"text/dns\": {\n        source: \"iana\"\n      },\n      \"text/ecmascript\": {\n        source: \"apache\"\n      },\n      \"text/encaprtp\": {\n        source: \"iana\"\n      },\n      \"text/enriched\": {\n        source: \"iana\"\n      },\n      \"text/fhirpath\": {\n        source: \"iana\"\n      },\n      \"text/flexfec\": {\n        source: \"iana\"\n      },\n      \"text/fwdred\": {\n        source: \"iana\"\n      },\n      \"text/gff3\": {\n        source: \"iana\"\n      },\n      \"text/grammar-ref-list\": {\n        source: \"iana\"\n      },\n      \"text/hl7v2\": {\n        source: \"iana\"\n      },\n      \"text/html\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"html\", \"htm\", \"shtml\"]\n      },\n      \"text/jade\": {\n        extensions: [\"jade\"]\n      },\n      \"text/javascript\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"js\", \"mjs\"]\n      },\n      \"text/jcr-cnd\": {\n        source: \"iana\"\n      },\n      \"text/jsx\": {\n        compressible: true,\n        extensions: [\"jsx\"]\n      },\n      \"text/less\": {\n        compressible: true,\n        extensions: [\"less\"]\n      },\n      \"text/markdown\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"md\", \"markdown\"]\n      },\n      \"text/mathml\": {\n        source: \"nginx\",\n        extensions: [\"mml\"]\n      },\n      \"text/mdx\": {\n        compressible: true,\n        extensions: [\"mdx\"]\n      },\n      \"text/mizar\": {\n        source: \"iana\"\n      },\n      \"text/n3\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"n3\"]\n      },\n      \"text/parameters\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/parityfec\": {\n        source: \"iana\"\n      },\n      \"text/plain\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"txt\", \"text\", \"conf\", \"def\", \"list\", \"log\", \"in\", \"ini\"]\n      },\n      \"text/provenance-notation\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/prs.fallenstein.rst\": {\n        source: \"iana\"\n      },\n      \"text/prs.lines.tag\": {\n        source: \"iana\",\n        extensions: [\"dsc\"]\n      },\n      \"text/prs.prop.logic\": {\n        source: \"iana\"\n      },\n      \"text/prs.texi\": {\n        source: \"iana\"\n      },\n      \"text/raptorfec\": {\n        source: \"iana\"\n      },\n      \"text/red\": {\n        source: \"iana\"\n      },\n      \"text/rfc822-headers\": {\n        source: \"iana\"\n      },\n      \"text/richtext\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtx\"]\n      },\n      \"text/rtf\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"rtf\"]\n      },\n      \"text/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"text/rtploopback\": {\n        source: \"iana\"\n      },\n      \"text/rtx\": {\n        source: \"iana\"\n      },\n      \"text/sgml\": {\n        source: \"iana\",\n        extensions: [\"sgml\", \"sgm\"]\n      },\n      \"text/shaclc\": {\n        source: \"iana\"\n      },\n      \"text/shex\": {\n        source: \"iana\",\n        extensions: [\"shex\"]\n      },\n      \"text/slim\": {\n        extensions: [\"slim\", \"slm\"]\n      },\n      \"text/spdx\": {\n        source: \"iana\",\n        extensions: [\"spdx\"]\n      },\n      \"text/strings\": {\n        source: \"iana\"\n      },\n      \"text/stylus\": {\n        extensions: [\"stylus\", \"styl\"]\n      },\n      \"text/t140\": {\n        source: \"iana\"\n      },\n      \"text/tab-separated-values\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"tsv\"]\n      },\n      \"text/troff\": {\n        source: \"iana\",\n        extensions: [\"t\", \"tr\", \"roff\", \"man\", \"me\", \"ms\"]\n      },\n      \"text/turtle\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"ttl\"]\n      },\n      \"text/ulpfec\": {\n        source: \"iana\"\n      },\n      \"text/uri-list\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"uri\", \"uris\", \"urls\"]\n      },\n      \"text/vcard\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"vcard\"]\n      },\n      \"text/vnd.a\": {\n        source: \"iana\"\n      },\n      \"text/vnd.abc\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ascii-art\": {\n        source: \"iana\"\n      },\n      \"text/vnd.curl\": {\n        source: \"iana\",\n        extensions: [\"curl\"]\n      },\n      \"text/vnd.curl.dcurl\": {\n        source: \"apache\",\n        extensions: [\"dcurl\"]\n      },\n      \"text/vnd.curl.mcurl\": {\n        source: \"apache\",\n        extensions: [\"mcurl\"]\n      },\n      \"text/vnd.curl.scurl\": {\n        source: \"apache\",\n        extensions: [\"scurl\"]\n      },\n      \"text/vnd.debian.copyright\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.dmclientscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.dvb.subtitle\": {\n        source: \"iana\",\n        extensions: [\"sub\"]\n      },\n      \"text/vnd.esmertec.theme-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.exchangeable\": {\n        source: \"iana\"\n      },\n      \"text/vnd.familysearch.gedcom\": {\n        source: \"iana\",\n        extensions: [\"ged\"]\n      },\n      \"text/vnd.ficlab.flt\": {\n        source: \"iana\"\n      },\n      \"text/vnd.fly\": {\n        source: \"iana\",\n        extensions: [\"fly\"]\n      },\n      \"text/vnd.fmi.flexstor\": {\n        source: \"iana\",\n        extensions: [\"flx\"]\n      },\n      \"text/vnd.gml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.graphviz\": {\n        source: \"iana\",\n        extensions: [\"gv\"]\n      },\n      \"text/vnd.hans\": {\n        source: \"iana\"\n      },\n      \"text/vnd.hgl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.in3d.3dml\": {\n        source: \"iana\",\n        extensions: [\"3dml\"]\n      },\n      \"text/vnd.in3d.spot\": {\n        source: \"iana\",\n        extensions: [\"spot\"]\n      },\n      \"text/vnd.iptc.newsml\": {\n        source: \"iana\"\n      },\n      \"text/vnd.iptc.nitf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.latex-z\": {\n        source: \"iana\"\n      },\n      \"text/vnd.motorola.reflex\": {\n        source: \"iana\"\n      },\n      \"text/vnd.ms-mediapackage\": {\n        source: \"iana\"\n      },\n      \"text/vnd.net2phone.commcenter.command\": {\n        source: \"iana\"\n      },\n      \"text/vnd.radisys.msml-basic-layout\": {\n        source: \"iana\"\n      },\n      \"text/vnd.senx.warpscript\": {\n        source: \"iana\"\n      },\n      \"text/vnd.si.uricatalogue\": {\n        source: \"apache\"\n      },\n      \"text/vnd.sosi\": {\n        source: \"iana\"\n      },\n      \"text/vnd.sun.j2me.app-descriptor\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        extensions: [\"jad\"]\n      },\n      \"text/vnd.trolltech.linguist\": {\n        source: \"iana\",\n        charset: \"UTF-8\"\n      },\n      \"text/vnd.vcf\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.si\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.sl\": {\n        source: \"iana\"\n      },\n      \"text/vnd.wap.wml\": {\n        source: \"iana\",\n        extensions: [\"wml\"]\n      },\n      \"text/vnd.wap.wmlscript\": {\n        source: \"iana\",\n        extensions: [\"wmls\"]\n      },\n      \"text/vnd.zoo.kcl\": {\n        source: \"iana\"\n      },\n      \"text/vtt\": {\n        source: \"iana\",\n        charset: \"UTF-8\",\n        compressible: true,\n        extensions: [\"vtt\"]\n      },\n      \"text/wgsl\": {\n        source: \"iana\",\n        extensions: [\"wgsl\"]\n      },\n      \"text/x-asm\": {\n        source: \"apache\",\n        extensions: [\"s\", \"asm\"]\n      },\n      \"text/x-c\": {\n        source: \"apache\",\n        extensions: [\"c\", \"cc\", \"cxx\", \"cpp\", \"h\", \"hh\", \"dic\"]\n      },\n      \"text/x-component\": {\n        source: \"nginx\",\n        extensions: [\"htc\"]\n      },\n      \"text/x-fortran\": {\n        source: \"apache\",\n        extensions: [\"f\", \"for\", \"f77\", \"f90\"]\n      },\n      \"text/x-gwt-rpc\": {\n        compressible: true\n      },\n      \"text/x-handlebars-template\": {\n        extensions: [\"hbs\"]\n      },\n      \"text/x-java-source\": {\n        source: \"apache\",\n        extensions: [\"java\"]\n      },\n      \"text/x-jquery-tmpl\": {\n        compressible: true\n      },\n      \"text/x-lua\": {\n        extensions: [\"lua\"]\n      },\n      \"text/x-markdown\": {\n        compressible: true,\n        extensions: [\"mkd\"]\n      },\n      \"text/x-nfo\": {\n        source: \"apache\",\n        extensions: [\"nfo\"]\n      },\n      \"text/x-opml\": {\n        source: \"apache\",\n        extensions: [\"opml\"]\n      },\n      \"text/x-org\": {\n        compressible: true,\n        extensions: [\"org\"]\n      },\n      \"text/x-pascal\": {\n        source: \"apache\",\n        extensions: [\"p\", \"pas\"]\n      },\n      \"text/x-processing\": {\n        compressible: true,\n        extensions: [\"pde\"]\n      },\n      \"text/x-sass\": {\n        extensions: [\"sass\"]\n      },\n      \"text/x-scss\": {\n        extensions: [\"scss\"]\n      },\n      \"text/x-setext\": {\n        source: \"apache\",\n        extensions: [\"etx\"]\n      },\n      \"text/x-sfv\": {\n        source: \"apache\",\n        extensions: [\"sfv\"]\n      },\n      \"text/x-suse-ymp\": {\n        compressible: true,\n        extensions: [\"ymp\"]\n      },\n      \"text/x-uuencode\": {\n        source: \"apache\",\n        extensions: [\"uu\"]\n      },\n      \"text/x-vcalendar\": {\n        source: \"apache\",\n        extensions: [\"vcs\"]\n      },\n      \"text/x-vcard\": {\n        source: \"apache\",\n        extensions: [\"vcf\"]\n      },\n      \"text/xml\": {\n        source: \"iana\",\n        compressible: true,\n        extensions: [\"xml\"]\n      },\n      \"text/xml-external-parsed-entity\": {\n        source: \"iana\"\n      },\n      \"text/yaml\": {\n        compressible: true,\n        extensions: [\"yaml\", \"yml\"]\n      },\n      \"video/1d-interleaved-parityfec\": {\n        source: \"iana\"\n      },\n      \"video/3gpp\": {\n        source: \"iana\",\n        extensions: [\"3gp\", \"3gpp\"]\n      },\n      \"video/3gpp-tt\": {\n        source: \"iana\"\n      },\n      \"video/3gpp2\": {\n        source: \"iana\",\n        extensions: [\"3g2\"]\n      },\n      \"video/av1\": {\n        source: \"iana\"\n      },\n      \"video/bmpeg\": {\n        source: \"iana\"\n      },\n      \"video/bt656\": {\n        source: \"iana\"\n      },\n      \"video/celb\": {\n        source: \"iana\"\n      },\n      \"video/dv\": {\n        source: \"iana\"\n      },\n      \"video/encaprtp\": {\n        source: \"iana\"\n      },\n      \"video/evc\": {\n        source: \"iana\"\n      },\n      \"video/ffv1\": {\n        source: \"iana\"\n      },\n      \"video/flexfec\": {\n        source: \"iana\"\n      },\n      \"video/h261\": {\n        source: \"iana\",\n        extensions: [\"h261\"]\n      },\n      \"video/h263\": {\n        source: \"iana\",\n        extensions: [\"h263\"]\n      },\n      \"video/h263-1998\": {\n        source: \"iana\"\n      },\n      \"video/h263-2000\": {\n        source: \"iana\"\n      },\n      \"video/h264\": {\n        source: \"iana\",\n        extensions: [\"h264\"]\n      },\n      \"video/h264-rcdo\": {\n        source: \"iana\"\n      },\n      \"video/h264-svc\": {\n        source: \"iana\"\n      },\n      \"video/h265\": {\n        source: \"iana\"\n      },\n      \"video/h266\": {\n        source: \"iana\"\n      },\n      \"video/iso.segment\": {\n        source: \"iana\",\n        extensions: [\"m4s\"]\n      },\n      \"video/jpeg\": {\n        source: \"iana\",\n        extensions: [\"jpgv\"]\n      },\n      \"video/jpeg2000\": {\n        source: \"iana\"\n      },\n      \"video/jpm\": {\n        source: \"apache\",\n        extensions: [\"jpm\", \"jpgm\"]\n      },\n      \"video/jxsv\": {\n        source: \"iana\"\n      },\n      \"video/lottie+json\": {\n        source: \"iana\",\n        compressible: true\n      },\n      \"video/matroska\": {\n        source: \"iana\"\n      },\n      \"video/matroska-3d\": {\n        source: \"iana\"\n      },\n      \"video/mj2\": {\n        source: \"iana\",\n        extensions: [\"mj2\", \"mjp2\"]\n      },\n      \"video/mp1s\": {\n        source: \"iana\"\n      },\n      \"video/mp2p\": {\n        source: \"iana\"\n      },\n      \"video/mp2t\": {\n        source: \"iana\",\n        extensions: [\"ts\", \"m2t\", \"m2ts\", \"mts\"]\n      },\n      \"video/mp4\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mp4\", \"mp4v\", \"mpg4\"]\n      },\n      \"video/mp4v-es\": {\n        source: \"iana\"\n      },\n      \"video/mpeg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"mpeg\", \"mpg\", \"mpe\", \"m1v\", \"m2v\"]\n      },\n      \"video/mpeg4-generic\": {\n        source: \"iana\"\n      },\n      \"video/mpv\": {\n        source: \"iana\"\n      },\n      \"video/nv\": {\n        source: \"iana\"\n      },\n      \"video/ogg\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"ogv\"]\n      },\n      \"video/parityfec\": {\n        source: \"iana\"\n      },\n      \"video/pointer\": {\n        source: \"iana\"\n      },\n      \"video/quicktime\": {\n        source: \"iana\",\n        compressible: false,\n        extensions: [\"qt\", \"mov\"]\n      },\n      \"video/raptorfec\": {\n        source: \"iana\"\n      },\n      \"video/raw\": {\n        source: \"iana\"\n      },\n      \"video/rtp-enc-aescm128\": {\n        source: \"iana\"\n      },\n      \"video/rtploopback\": {\n        source: \"iana\"\n      },\n      \"video/rtx\": {\n        source: \"iana\"\n      },\n      \"video/scip\": {\n        source: \"iana\"\n      },\n      \"video/smpte291\": {\n        source: \"iana\"\n      },\n      \"video/smpte292m\": {\n        source: \"iana\"\n      },\n      \"video/ulpfec\": {\n        source: \"iana\"\n      },\n      \"video/vc1\": {\n        source: \"iana\"\n      },\n      \"video/vc2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.cctv\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.hd\": {\n        source: \"iana\",\n        extensions: [\"uvh\", \"uvvh\"]\n      },\n      \"video/vnd.dece.mobile\": {\n        source: \"iana\",\n        extensions: [\"uvm\", \"uvvm\"]\n      },\n      \"video/vnd.dece.mp4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dece.pd\": {\n        source: \"iana\",\n        extensions: [\"uvp\", \"uvvp\"]\n      },\n      \"video/vnd.dece.sd\": {\n        source: \"iana\",\n        extensions: [\"uvs\", \"uvvs\"]\n      },\n      \"video/vnd.dece.video\": {\n        source: \"iana\",\n        extensions: [\"uvv\", \"uvvv\"]\n      },\n      \"video/vnd.directv.mpeg\": {\n        source: \"iana\"\n      },\n      \"video/vnd.directv.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dlna.mpeg-tts\": {\n        source: \"iana\"\n      },\n      \"video/vnd.dvb.file\": {\n        source: \"iana\",\n        extensions: [\"dvb\"]\n      },\n      \"video/vnd.fvt\": {\n        source: \"iana\",\n        extensions: [\"fvt\"]\n      },\n      \"video/vnd.hns.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.1dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-1010\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.2dparityfec-2005\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsavc\": {\n        source: \"iana\"\n      },\n      \"video/vnd.iptvforum.ttsmpeg2\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.video\": {\n        source: \"iana\"\n      },\n      \"video/vnd.motorola.videop\": {\n        source: \"iana\"\n      },\n      \"video/vnd.mpegurl\": {\n        source: \"iana\",\n        extensions: [\"mxu\", \"m4u\"]\n      },\n      \"video/vnd.ms-playready.media.pyv\": {\n        source: \"iana\",\n        extensions: [\"pyv\"]\n      },\n      \"video/vnd.nokia.interleaved-multimedia\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.mp4vr\": {\n        source: \"iana\"\n      },\n      \"video/vnd.nokia.videovoip\": {\n        source: \"iana\"\n      },\n      \"video/vnd.objectvideo\": {\n        source: \"iana\"\n      },\n      \"video/vnd.planar\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.bink\": {\n        source: \"iana\"\n      },\n      \"video/vnd.radgamettools.smacker\": {\n        source: \"apache\"\n      },\n      \"video/vnd.sealed.mpeg1\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.mpeg4\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealed.swf\": {\n        source: \"iana\"\n      },\n      \"video/vnd.sealedmedia.softseal.mov\": {\n        source: \"iana\"\n      },\n      \"video/vnd.uvvu.mp4\": {\n        source: \"iana\",\n        extensions: [\"uvu\", \"uvvu\"]\n      },\n      \"video/vnd.vivo\": {\n        source: \"iana\",\n        extensions: [\"viv\"]\n      },\n      \"video/vnd.youtube.yt\": {\n        source: \"iana\"\n      },\n      \"video/vp8\": {\n        source: \"iana\"\n      },\n      \"video/vp9\": {\n        source: \"iana\"\n      },\n      \"video/webm\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"webm\"]\n      },\n      \"video/x-f4v\": {\n        source: \"apache\",\n        extensions: [\"f4v\"]\n      },\n      \"video/x-fli\": {\n        source: \"apache\",\n        extensions: [\"fli\"]\n      },\n      \"video/x-flv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"flv\"]\n      },\n      \"video/x-m4v\": {\n        source: \"apache\",\n        extensions: [\"m4v\"]\n      },\n      \"video/x-matroska\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"mkv\", \"mk3d\", \"mks\"]\n      },\n      \"video/x-mng\": {\n        source: \"apache\",\n        extensions: [\"mng\"]\n      },\n      \"video/x-ms-asf\": {\n        source: \"apache\",\n        extensions: [\"asf\", \"asx\"]\n      },\n      \"video/x-ms-vob\": {\n        source: \"apache\",\n        extensions: [\"vob\"]\n      },\n      \"video/x-ms-wm\": {\n        source: \"apache\",\n        extensions: [\"wm\"]\n      },\n      \"video/x-ms-wmv\": {\n        source: \"apache\",\n        compressible: false,\n        extensions: [\"wmv\"]\n      },\n      \"video/x-ms-wmx\": {\n        source: \"apache\",\n        extensions: [\"wmx\"]\n      },\n      \"video/x-ms-wvx\": {\n        source: \"apache\",\n        extensions: [\"wvx\"]\n      },\n      \"video/x-msvideo\": {\n        source: \"apache\",\n        extensions: [\"avi\"]\n      },\n      \"video/x-sgi-movie\": {\n        source: \"apache\",\n        extensions: [\"movie\"]\n      },\n      \"video/x-smv\": {\n        source: \"apache\",\n        extensions: [\"smv\"]\n      },\n      \"x-conference/x-cooltalk\": {\n        source: \"apache\",\n        extensions: [\"ice\"]\n      },\n      \"x-shader/x-fragment\": {\n        compressible: true\n      },\n      \"x-shader/x-vertex\": {\n        compressible: true\n      }\n    };\n  }\n});\n\n// node_modules/send/node_modules/mime-db/index.js\nvar require_mime_db4 = __commonJS({\n  \"node_modules/send/node_modules/mime-db/index.js\"(exports2, module2) {\n    module2.exports = require_db4();\n  }\n});\n\n// node_modules/send/node_modules/mime-types/mimeScore.js\nvar require_mimeScore4 = __commonJS({\n  \"node_modules/send/node_modules/mime-types/mimeScore.js\"(exports2, module2) {\n    var FACET_SCORES = {\n      \"prs.\": 100,\n      \"x-\": 200,\n      \"x.\": 300,\n      \"vnd.\": 400,\n      default: 900\n    };\n    var SOURCE_SCORES = {\n      nginx: 10,\n      apache: 20,\n      iana: 40,\n      default: 30\n      // definitions added by `jshttp/mime-db` project?\n    };\n    var TYPE_SCORES = {\n      // prefer application/xml over text/xml\n      // prefer application/rtf over text/rtf\n      application: 1,\n      // prefer font/woff over application/font-woff\n      font: 2,\n      default: 0\n    };\n    module2.exports = function mimeScore(mimeType, source = \"default\") {\n      if (mimeType === \"application/octet-stream\") {\n        return 0;\n      }\n      const [type, subtype] = mimeType.split(\"/\");\n      const facet = subtype.replace(/(\\.|x-).*/, \"$1\");\n      const facetScore = FACET_SCORES[facet] || FACET_SCORES.default;\n      const sourceScore = SOURCE_SCORES[source] || SOURCE_SCORES.default;\n      const typeScore = TYPE_SCORES[type] || TYPE_SCORES.default;\n      const lengthScore = 1 - mimeType.length / 100;\n      return facetScore + sourceScore + typeScore + lengthScore;\n    };\n  }\n});\n\n// node_modules/send/node_modules/mime-types/index.js\nvar require_mime_types4 = __commonJS({\n  \"node_modules/send/node_modules/mime-types/index.js\"(exports2) {\n    \"use strict\";\n    var db = require_mime_db4();\n    var extname = require(\"path\").extname;\n    var mimeScore = require_mimeScore4();\n    var EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/;\n    var TEXT_TYPE_REGEXP = /^text\\//i;\n    exports2.charset = charset;\n    exports2.charsets = { lookup: charset };\n    exports2.contentType = contentType2;\n    exports2.extension = extension;\n    exports2.extensions = /* @__PURE__ */ Object.create(null);\n    exports2.lookup = lookup;\n    exports2.types = /* @__PURE__ */ Object.create(null);\n    exports2._extensionConflicts = [];\n    populateMaps(exports2.extensions, exports2.types);\n    function charset(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var mime = match && db[match[1].toLowerCase()];\n      if (mime && mime.charset) {\n        return mime.charset;\n      }\n      if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n        return \"UTF-8\";\n      }\n      return false;\n    }\n    function contentType2(str) {\n      if (!str || typeof str !== \"string\") {\n        return false;\n      }\n      var mime = str.indexOf(\"/\") === -1 ? exports2.lookup(str) : str;\n      if (!mime) {\n        return false;\n      }\n      if (mime.indexOf(\"charset\") === -1) {\n        var charset2 = exports2.charset(mime);\n        if (charset2) mime += \"; charset=\" + charset2.toLowerCase();\n      }\n      return mime;\n    }\n    function extension(type) {\n      if (!type || typeof type !== \"string\") {\n        return false;\n      }\n      var match = EXTRACT_TYPE_REGEXP.exec(type);\n      var exts = match && exports2.extensions[match[1].toLowerCase()];\n      if (!exts || !exts.length) {\n        return false;\n      }\n      return exts[0];\n    }\n    function lookup(path) {\n      if (!path || typeof path !== \"string\") {\n        return false;\n      }\n      var extension2 = extname(\"x.\" + path).toLowerCase().slice(1);\n      if (!extension2) {\n        return false;\n      }\n      return exports2.types[extension2] || false;\n    }\n    function populateMaps(extensions, types) {\n      Object.keys(db).forEach(function forEachMimeType(type) {\n        var mime = db[type];\n        var exts = mime.extensions;\n        if (!exts || !exts.length) {\n          return;\n        }\n        extensions[type] = exts;\n        for (var i = 0; i < exts.length; i++) {\n          var extension2 = exts[i];\n          types[extension2] = _preferredType(extension2, types[extension2], type);\n          const legacyType = _preferredTypeLegacy(\n            extension2,\n            types[extension2],\n            type\n          );\n          if (legacyType !== types[extension2]) {\n            exports2._extensionConflicts.push([extension2, legacyType, types[extension2]]);\n          }\n        }\n      });\n    }\n    function _preferredType(ext, type0, type1) {\n      var score0 = type0 ? mimeScore(type0, db[type0].source) : 0;\n      var score1 = type1 ? mimeScore(type1, db[type1].source) : 0;\n      return score0 > score1 ? type0 : type1;\n    }\n    function _preferredTypeLegacy(ext, type0, type1) {\n      var SOURCE_RANK = [\"nginx\", \"apache\", void 0, \"iana\"];\n      var score0 = type0 ? SOURCE_RANK.indexOf(db[type0].source) : 0;\n      var score1 = type1 ? SOURCE_RANK.indexOf(db[type1].source) : 0;\n      if (exports2.types[extension] !== \"application/octet-stream\" && (score0 > score1 || score0 === score1 && exports2.types[extension]?.slice(0, 12) === \"application/\")) {\n        return type0;\n      }\n      return score0 > score1 ? type0 : type1;\n    }\n  }\n});\n\n// node_modules/send/index.js\nvar require_send = __commonJS({\n  \"node_modules/send/index.js\"(exports2, module2) {\n    \"use strict\";\n    var createError = require_http_errors();\n    var debug = require_src()(\"send\");\n    var encodeUrl = require_encodeurl();\n    var escapeHtml = require_escape_html();\n    var etag = require_etag();\n    var fresh = require_fresh();\n    var fs = require(\"fs\");\n    var mime = require_mime_types4();\n    var ms = require_ms();\n    var onFinished = require_on_finished();\n    var parseRange = require_range_parser();\n    var path = require(\"path\");\n    var statuses = require_statuses();\n    var Stream = require(\"stream\");\n    var util2 = require(\"util\");\n    var extname = path.extname;\n    var join = path.join;\n    var normalize = path.normalize;\n    var resolve = path.resolve;\n    var sep = path.sep;\n    var BYTES_RANGE_REGEXP = /^ *bytes=/;\n    var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;\n    var UP_PATH_REGEXP = /(?:^|[\\\\/])\\.\\.(?:[\\\\/]|$)/;\n    module2.exports = send;\n    function send(req, path2, options) {\n      return new SendStream(req, path2, options);\n    }\n    function SendStream(req, path2, options) {\n      Stream.call(this);\n      var opts = options || {};\n      this.options = opts;\n      this.path = path2;\n      this.req = req;\n      this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;\n      this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;\n      this._etag = opts.etag !== void 0 ? Boolean(opts.etag) : true;\n      this._dotfiles = opts.dotfiles !== void 0 ? opts.dotfiles : \"ignore\";\n      if (this._dotfiles !== \"ignore\" && this._dotfiles !== \"allow\" && this._dotfiles !== \"deny\") {\n        throw new TypeError('dotfiles option must be \"allow\", \"deny\", or \"ignore\"');\n      }\n      this._extensions = opts.extensions !== void 0 ? normalizeList(opts.extensions, \"extensions option\") : [];\n      this._immutable = opts.immutable !== void 0 ? Boolean(opts.immutable) : false;\n      this._index = opts.index !== void 0 ? normalizeList(opts.index, \"index option\") : [\"index.html\"];\n      this._lastModified = opts.lastModified !== void 0 ? Boolean(opts.lastModified) : true;\n      this._maxage = opts.maxAge || opts.maxage;\n      this._maxage = typeof this._maxage === \"string\" ? ms(this._maxage) : Number(this._maxage);\n      this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;\n      this._root = opts.root ? resolve(opts.root) : null;\n    }\n    util2.inherits(SendStream, Stream);\n    SendStream.prototype.error = function error(status, err2) {\n      if (hasListeners(this, \"error\")) {\n        return this.emit(\"error\", createHttpError(status, err2));\n      }\n      var res = this.res;\n      var msg = statuses.message[status] || String(status);\n      var doc = createHtmlDocument(\"Error\", escapeHtml(msg));\n      clearHeaders(res);\n      if (err2 && err2.headers) {\n        setHeaders(res, err2.headers);\n      }\n      res.statusCode = status;\n      res.setHeader(\"Content-Type\", \"text/html; charset=UTF-8\");\n      res.setHeader(\"Content-Length\", Buffer.byteLength(doc));\n      res.setHeader(\"Content-Security-Policy\", \"default-src 'none'\");\n      res.setHeader(\"X-Content-Type-Options\", \"nosniff\");\n      res.end(doc);\n    };\n    SendStream.prototype.hasTrailingSlash = function hasTrailingSlash() {\n      return this.path[this.path.length - 1] === \"/\";\n    };\n    SendStream.prototype.isConditionalGET = function isConditionalGET() {\n      return this.req.headers[\"if-match\"] || this.req.headers[\"if-unmodified-since\"] || this.req.headers[\"if-none-match\"] || this.req.headers[\"if-modified-since\"];\n    };\n    SendStream.prototype.isPreconditionFailure = function isPreconditionFailure() {\n      var req = this.req;\n      var res = this.res;\n      var match = req.headers[\"if-match\"];\n      if (match) {\n        var etag2 = res.getHeader(\"ETag\");\n        return !etag2 || match !== \"*\" && parseTokenList(match).every(function(match2) {\n          return match2 !== etag2 && match2 !== \"W/\" + etag2 && \"W/\" + match2 !== etag2;\n        });\n      }\n      var unmodifiedSince = parseHttpDate(req.headers[\"if-unmodified-since\"]);\n      if (!isNaN(unmodifiedSince)) {\n        var lastModified = parseHttpDate(res.getHeader(\"Last-Modified\"));\n        return isNaN(lastModified) || lastModified > unmodifiedSince;\n      }\n      return false;\n    };\n    SendStream.prototype.removeContentHeaderFields = function removeContentHeaderFields() {\n      var res = this.res;\n      res.removeHeader(\"Content-Encoding\");\n      res.removeHeader(\"Content-Language\");\n      res.removeHeader(\"Content-Length\");\n      res.removeHeader(\"Content-Range\");\n      res.removeHeader(\"Content-Type\");\n    };\n    SendStream.prototype.notModified = function notModified() {\n      var res = this.res;\n      debug(\"not modified\");\n      this.removeContentHeaderFields();\n      res.statusCode = 304;\n      res.end();\n    };\n    SendStream.prototype.headersAlreadySent = function headersAlreadySent() {\n      var err2 = new Error(\"Can't set headers after they are sent.\");\n      debug(\"headers already sent\");\n      this.error(500, err2);\n    };\n    SendStream.prototype.isCachable = function isCachable() {\n      var statusCode = this.res.statusCode;\n      return statusCode >= 200 && statusCode < 300 || statusCode === 304;\n    };\n    SendStream.prototype.onStatError = function onStatError(error) {\n      switch (error.code) {\n        case \"ENAMETOOLONG\":\n        case \"ENOENT\":\n        case \"ENOTDIR\":\n          this.error(404, error);\n          break;\n        default:\n          this.error(500, error);\n          break;\n      }\n    };\n    SendStream.prototype.isFresh = function isFresh() {\n      return fresh(this.req.headers, {\n        etag: this.res.getHeader(\"ETag\"),\n        \"last-modified\": this.res.getHeader(\"Last-Modified\")\n      });\n    };\n    SendStream.prototype.isRangeFresh = function isRangeFresh() {\n      var ifRange = this.req.headers[\"if-range\"];\n      if (!ifRange) {\n        return true;\n      }\n      if (ifRange.indexOf('\"') !== -1) {\n        var etag2 = this.res.getHeader(\"ETag\");\n        return Boolean(etag2 && ifRange.indexOf(etag2) !== -1);\n      }\n      var lastModified = this.res.getHeader(\"Last-Modified\");\n      return parseHttpDate(lastModified) <= parseHttpDate(ifRange);\n    };\n    SendStream.prototype.redirect = function redirect(path2) {\n      var res = this.res;\n      if (hasListeners(this, \"directory\")) {\n        this.emit(\"directory\", res, path2);\n        return;\n      }\n      if (this.hasTrailingSlash()) {\n        this.error(403);\n        return;\n      }\n      var loc = encodeUrl(collapseLeadingSlashes(this.path + \"/\"));\n      var doc = createHtmlDocument(\"Redirecting\", \"Redirecting to \" + escapeHtml(loc));\n      res.statusCode = 301;\n      res.setHeader(\"Content-Type\", \"text/html; charset=UTF-8\");\n      res.setHeader(\"Content-Length\", Buffer.byteLength(doc));\n      res.setHeader(\"Content-Security-Policy\", \"default-src 'none'\");\n      res.setHeader(\"X-Content-Type-Options\", \"nosniff\");\n      res.setHeader(\"Location\", loc);\n      res.end(doc);\n    };\n    SendStream.prototype.pipe = function pipe(res) {\n      var root = this._root;\n      this.res = res;\n      var path2 = decode(this.path);\n      if (path2 === -1) {\n        this.error(400);\n        return res;\n      }\n      if (~path2.indexOf(\"\\0\")) {\n        this.error(400);\n        return res;\n      }\n      var parts;\n      if (root !== null) {\n        if (path2) {\n          path2 = normalize(\".\" + sep + path2);\n        }\n        if (UP_PATH_REGEXP.test(path2)) {\n          debug('malicious path \"%s\"', path2);\n          this.error(403);\n          return res;\n        }\n        parts = path2.split(sep);\n        path2 = normalize(join(root, path2));\n      } else {\n        if (UP_PATH_REGEXP.test(path2)) {\n          debug('malicious path \"%s\"', path2);\n          this.error(403);\n          return res;\n        }\n        parts = normalize(path2).split(sep);\n        path2 = resolve(path2);\n      }\n      if (containsDotFile(parts)) {\n        debug('%s dotfile \"%s\"', this._dotfiles, path2);\n        switch (this._dotfiles) {\n          case \"allow\":\n            break;\n          case \"deny\":\n            this.error(403);\n            return res;\n          case \"ignore\":\n          default:\n            this.error(404);\n            return res;\n        }\n      }\n      if (this._index.length && this.hasTrailingSlash()) {\n        this.sendIndex(path2);\n        return res;\n      }\n      this.sendFile(path2);\n      return res;\n    };\n    SendStream.prototype.send = function send2(path2, stat) {\n      var len = stat.size;\n      var options = this.options;\n      var opts = {};\n      var res = this.res;\n      var req = this.req;\n      var ranges = req.headers.range;\n      var offset = options.start || 0;\n      if (res.headersSent) {\n        this.headersAlreadySent();\n        return;\n      }\n      debug('pipe \"%s\"', path2);\n      this.setHeader(path2, stat);\n      this.type(path2);\n      if (this.isConditionalGET()) {\n        if (this.isPreconditionFailure()) {\n          this.error(412);\n          return;\n        }\n        if (this.isCachable() && this.isFresh()) {\n          this.notModified();\n          return;\n        }\n      }\n      len = Math.max(0, len - offset);\n      if (options.end !== void 0) {\n        var bytes = options.end - offset + 1;\n        if (len > bytes) len = bytes;\n      }\n      if (this._acceptRanges && BYTES_RANGE_REGEXP.test(ranges)) {\n        ranges = parseRange(len, ranges, {\n          combine: true\n        });\n        if (!this.isRangeFresh()) {\n          debug(\"range stale\");\n          ranges = -2;\n        }\n        if (ranges === -1) {\n          debug(\"range unsatisfiable\");\n          res.setHeader(\"Content-Range\", contentRange(\"bytes\", len));\n          return this.error(416, {\n            headers: { \"Content-Range\": res.getHeader(\"Content-Range\") }\n          });\n        }\n        if (ranges !== -2 && ranges.length === 1) {\n          debug(\"range %j\", ranges);\n          res.statusCode = 206;\n          res.setHeader(\"Content-Range\", contentRange(\"bytes\", len, ranges[0]));\n          offset += ranges[0].start;\n          len = ranges[0].end - ranges[0].start + 1;\n        }\n      }\n      for (var prop in options) {\n        opts[prop] = options[prop];\n      }\n      opts.start = offset;\n      opts.end = Math.max(offset, offset + len - 1);\n      res.setHeader(\"Content-Length\", len);\n      if (req.method === \"HEAD\") {\n        res.end();\n        return;\n      }\n      this.stream(path2, opts);\n    };\n    SendStream.prototype.sendFile = function sendFile(path2) {\n      var i = 0;\n      var self2 = this;\n      debug('stat \"%s\"', path2);\n      fs.stat(path2, function onstat(err2, stat) {\n        var pathEndsWithSep = path2[path2.length - 1] === sep;\n        if (err2 && err2.code === \"ENOENT\" && !extname(path2) && !pathEndsWithSep) {\n          return next(err2);\n        }\n        if (err2) return self2.onStatError(err2);\n        if (stat.isDirectory()) return self2.redirect(path2);\n        if (pathEndsWithSep) return self2.error(404);\n        self2.emit(\"file\", path2, stat);\n        self2.send(path2, stat);\n      });\n      function next(err2) {\n        if (self2._extensions.length <= i) {\n          return err2 ? self2.onStatError(err2) : self2.error(404);\n        }\n        var p = path2 + \".\" + self2._extensions[i++];\n        debug('stat \"%s\"', p);\n        fs.stat(p, function(err3, stat) {\n          if (err3) return next(err3);\n          if (stat.isDirectory()) return next();\n          self2.emit(\"file\", p, stat);\n          self2.send(p, stat);\n        });\n      }\n    };\n    SendStream.prototype.sendIndex = function sendIndex(path2) {\n      var i = -1;\n      var self2 = this;\n      function next(err2) {\n        if (++i >= self2._index.length) {\n          if (err2) return self2.onStatError(err2);\n          return self2.error(404);\n        }\n        var p = join(path2, self2._index[i]);\n        debug('stat \"%s\"', p);\n        fs.stat(p, function(err3, stat) {\n          if (err3) return next(err3);\n          if (stat.isDirectory()) return next();\n          self2.emit(\"file\", p, stat);\n          self2.send(p, stat);\n        });\n      }\n      next();\n    };\n    SendStream.prototype.stream = function stream(path2, options) {\n      var self2 = this;\n      var res = this.res;\n      var stream2 = fs.createReadStream(path2, options);\n      this.emit(\"stream\", stream2);\n      stream2.pipe(res);\n      function cleanup() {\n        stream2.destroy();\n      }\n      onFinished(res, cleanup);\n      stream2.on(\"error\", function onerror(err2) {\n        cleanup();\n        self2.onStatError(err2);\n      });\n      stream2.on(\"end\", function onend() {\n        self2.emit(\"end\");\n      });\n    };\n    SendStream.prototype.type = function type(path2) {\n      var res = this.res;\n      if (res.getHeader(\"Content-Type\")) return;\n      var ext = extname(path2);\n      var type2 = mime.contentType(ext) || \"application/octet-stream\";\n      debug(\"content-type %s\", type2);\n      res.setHeader(\"Content-Type\", type2);\n    };\n    SendStream.prototype.setHeader = function setHeader(path2, stat) {\n      var res = this.res;\n      this.emit(\"headers\", res, path2, stat);\n      if (this._acceptRanges && !res.getHeader(\"Accept-Ranges\")) {\n        debug(\"accept ranges\");\n        res.setHeader(\"Accept-Ranges\", \"bytes\");\n      }\n      if (this._cacheControl && !res.getHeader(\"Cache-Control\")) {\n        var cacheControl = \"public, max-age=\" + Math.floor(this._maxage / 1e3);\n        if (this._immutable) {\n          cacheControl += \", immutable\";\n        }\n        debug(\"cache-control %s\", cacheControl);\n        res.setHeader(\"Cache-Control\", cacheControl);\n      }\n      if (this._lastModified && !res.getHeader(\"Last-Modified\")) {\n        var modified = stat.mtime.toUTCString();\n        debug(\"modified %s\", modified);\n        res.setHeader(\"Last-Modified\", modified);\n      }\n      if (this._etag && !res.getHeader(\"ETag\")) {\n        var val = etag(stat);\n        debug(\"etag %s\", val);\n        res.setHeader(\"ETag\", val);\n      }\n    };\n    function clearHeaders(res) {\n      for (const header of res.getHeaderNames()) {\n        res.removeHeader(header);\n      }\n    }\n    function collapseLeadingSlashes(str) {\n      for (var i = 0; i < str.length; i++) {\n        if (str[i] !== \"/\") {\n          break;\n        }\n      }\n      return i > 1 ? \"/\" + str.substr(i) : str;\n    }\n    function containsDotFile(parts) {\n      for (var i = 0; i < parts.length; i++) {\n        var part = parts[i];\n        if (part.length > 1 && part[0] === \".\") {\n          return true;\n        }\n      }\n      return false;\n    }\n    function contentRange(type, size, range) {\n      return type + \" \" + (range ? range.start + \"-\" + range.end : \"*\") + \"/\" + size;\n    }\n    function createHtmlDocument(title, body) {\n      return '<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n<meta charset=\"utf-8\">\\n<title>' + title + \"</title>\\n</head>\\n<body>\\n<pre>\" + body + \"</pre>\\n</body>\\n</html>\\n\";\n    }\n    function createHttpError(status, err2) {\n      if (!err2) {\n        return createError(status);\n      }\n      return err2 instanceof Error ? createError(status, err2, { expose: false }) : createError(status, err2);\n    }\n    function decode(path2) {\n      try {\n        return decodeURIComponent(path2);\n      } catch (err2) {\n        return -1;\n      }\n    }\n    function hasListeners(emitter, type) {\n      var count = typeof emitter.listenerCount !== \"function\" ? emitter.listeners(type).length : emitter.listenerCount(type);\n      return count > 0;\n    }\n    function normalizeList(val, name) {\n      var list = [].concat(val || []);\n      for (var i = 0; i < list.length; i++) {\n        if (typeof list[i] !== \"string\") {\n          throw new TypeError(name + \" must be array of strings or false\");\n        }\n      }\n      return list;\n    }\n    function parseHttpDate(date) {\n      var timestamp = date && Date.parse(date);\n      return typeof timestamp === \"number\" ? timestamp : NaN;\n    }\n    function parseTokenList(str) {\n      var end = 0;\n      var list = [];\n      var start = 0;\n      for (var i = 0, len = str.length; i < len; i++) {\n        switch (str.charCodeAt(i)) {\n          case 32:\n            if (start === end) {\n              start = end = i + 1;\n            }\n            break;\n          case 44:\n            if (start !== end) {\n              list.push(str.substring(start, end));\n            }\n            start = end = i + 1;\n            break;\n          default:\n            end = i + 1;\n            break;\n        }\n      }\n      if (start !== end) {\n        list.push(str.substring(start, end));\n      }\n      return list;\n    }\n    function setHeaders(res, headers) {\n      var keys = Object.keys(headers);\n      for (var i = 0; i < keys.length; i++) {\n        var key = keys[i];\n        res.setHeader(key, headers[key]);\n      }\n    }\n  }\n});\n\n// node_modules/vary/index.js\nvar require_vary = __commonJS({\n  \"node_modules/vary/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = vary;\n    module2.exports.append = append;\n    var FIELD_NAME_REGEXP = /^[!#$%&'*+\\-.^_`|~0-9A-Za-z]+$/;\n    function append(header, field) {\n      if (typeof header !== \"string\") {\n        throw new TypeError(\"header argument is required\");\n      }\n      if (!field) {\n        throw new TypeError(\"field argument is required\");\n      }\n      var fields = !Array.isArray(field) ? parse(String(field)) : field;\n      for (var j = 0; j < fields.length; j++) {\n        if (!FIELD_NAME_REGEXP.test(fields[j])) {\n          throw new TypeError(\"field argument contains an invalid header name\");\n        }\n      }\n      if (header === \"*\") {\n        return header;\n      }\n      var val = header;\n      var vals = parse(header.toLowerCase());\n      if (fields.indexOf(\"*\") !== -1 || vals.indexOf(\"*\") !== -1) {\n        return \"*\";\n      }\n      for (var i = 0; i < fields.length; i++) {\n        var fld = fields[i].toLowerCase();\n        if (vals.indexOf(fld) === -1) {\n          vals.push(fld);\n          val = val ? val + \", \" + fields[i] : fields[i];\n        }\n      }\n      return val;\n    }\n    function parse(header) {\n      var end = 0;\n      var list = [];\n      var start = 0;\n      for (var i = 0, len = header.length; i < len; i++) {\n        switch (header.charCodeAt(i)) {\n          case 32:\n            if (start === end) {\n              start = end = i + 1;\n            }\n            break;\n          case 44:\n            list.push(header.substring(start, end));\n            start = end = i + 1;\n            break;\n          default:\n            end = i + 1;\n            break;\n        }\n      }\n      list.push(header.substring(start, end));\n      return list;\n    }\n    function vary(res, field) {\n      if (!res || !res.getHeader || !res.setHeader) {\n        throw new TypeError(\"res argument is required\");\n      }\n      var val = res.getHeader(\"Vary\") || \"\";\n      var header = Array.isArray(val) ? val.join(\", \") : String(val);\n      if (val = append(header, field)) {\n        res.setHeader(\"Vary\", val);\n      }\n    }\n  }\n});\n\n// node_modules/express/lib/response.js\nvar require_response = __commonJS({\n  \"node_modules/express/lib/response.js\"(exports2, module2) {\n    \"use strict\";\n    var contentDisposition = require_content_disposition();\n    var createError = require_http_errors();\n    var encodeUrl = require_encodeurl();\n    var escapeHtml = require_escape_html();\n    var http = require(\"node:http\");\n    var onFinished = require_on_finished();\n    var mime = require_mime_types2();\n    var path = require(\"node:path\");\n    var pathIsAbsolute = require(\"node:path\").isAbsolute;\n    var statuses = require_statuses();\n    var sign = require_cookie_signature().sign;\n    var normalizeType = require_utils3().normalizeType;\n    var normalizeTypes = require_utils3().normalizeTypes;\n    var setCharset = require_utils3().setCharset;\n    var cookie = require_cookie();\n    var send = require_send();\n    var extname = path.extname;\n    var resolve = path.resolve;\n    var vary = require_vary();\n    var res = Object.create(http.ServerResponse.prototype);\n    module2.exports = res;\n    res.status = function status(code) {\n      if (!Number.isInteger(code)) {\n        throw new TypeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be an integer.`);\n      }\n      if (code < 100 || code > 999) {\n        throw new RangeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be greater than 99 and less than 1000.`);\n      }\n      this.statusCode = code;\n      return this;\n    };\n    res.links = function(links) {\n      var link = this.get(\"Link\") || \"\";\n      if (link) link += \", \";\n      return this.set(\"Link\", link + Object.keys(links).map(function(rel) {\n        if (Array.isArray(links[rel])) {\n          return links[rel].map(function(singleLink) {\n            return `<${singleLink}>; rel=\"${rel}\"`;\n          }).join(\", \");\n        } else {\n          return `<${links[rel]}>; rel=\"${rel}\"`;\n        }\n      }).join(\", \"));\n    };\n    res.send = function send2(body) {\n      var chunk = body;\n      var encoding;\n      var req = this.req;\n      var type;\n      var app = this.app;\n      switch (typeof chunk) {\n        // string defaulting to html\n        case \"string\":\n          if (!this.get(\"Content-Type\")) {\n            this.type(\"html\");\n          }\n          break;\n        case \"boolean\":\n        case \"number\":\n        case \"object\":\n          if (chunk === null) {\n            chunk = \"\";\n          } else if (ArrayBuffer.isView(chunk)) {\n            if (!this.get(\"Content-Type\")) {\n              this.type(\"bin\");\n            }\n          } else {\n            return this.json(chunk);\n          }\n          break;\n      }\n      if (typeof chunk === \"string\") {\n        encoding = \"utf8\";\n        type = this.get(\"Content-Type\");\n        if (typeof type === \"string\") {\n          this.set(\"Content-Type\", setCharset(type, \"utf-8\"));\n        }\n      }\n      var etagFn = app.get(\"etag fn\");\n      var generateETag = !this.get(\"ETag\") && typeof etagFn === \"function\";\n      var len;\n      if (chunk !== void 0) {\n        if (Buffer.isBuffer(chunk)) {\n          len = chunk.length;\n        } else if (!generateETag && chunk.length < 1e3) {\n          len = Buffer.byteLength(chunk, encoding);\n        } else {\n          chunk = Buffer.from(chunk, encoding);\n          encoding = void 0;\n          len = chunk.length;\n        }\n        this.set(\"Content-Length\", len);\n      }\n      var etag;\n      if (generateETag && len !== void 0) {\n        if (etag = etagFn(chunk, encoding)) {\n          this.set(\"ETag\", etag);\n        }\n      }\n      if (req.fresh) this.status(304);\n      if (204 === this.statusCode || 304 === this.statusCode) {\n        this.removeHeader(\"Content-Type\");\n        this.removeHeader(\"Content-Length\");\n        this.removeHeader(\"Transfer-Encoding\");\n        chunk = \"\";\n      }\n      if (this.statusCode === 205) {\n        this.set(\"Content-Length\", \"0\");\n        this.removeHeader(\"Transfer-Encoding\");\n        chunk = \"\";\n      }\n      if (req.method === \"HEAD\") {\n        this.end();\n      } else {\n        this.end(chunk, encoding);\n      }\n      return this;\n    };\n    res.json = function json(obj) {\n      var app = this.app;\n      var escape2 = app.get(\"json escape\");\n      var replacer = app.get(\"json replacer\");\n      var spaces = app.get(\"json spaces\");\n      var body = stringify(obj, replacer, spaces, escape2);\n      if (!this.get(\"Content-Type\")) {\n        this.set(\"Content-Type\", \"application/json\");\n      }\n      return this.send(body);\n    };\n    res.jsonp = function jsonp(obj) {\n      var app = this.app;\n      var escape2 = app.get(\"json escape\");\n      var replacer = app.get(\"json replacer\");\n      var spaces = app.get(\"json spaces\");\n      var body = stringify(obj, replacer, spaces, escape2);\n      var callback = this.req.query[app.get(\"jsonp callback name\")];\n      if (!this.get(\"Content-Type\")) {\n        this.set(\"X-Content-Type-Options\", \"nosniff\");\n        this.set(\"Content-Type\", \"application/json\");\n      }\n      if (Array.isArray(callback)) {\n        callback = callback[0];\n      }\n      if (typeof callback === \"string\" && callback.length !== 0) {\n        this.set(\"X-Content-Type-Options\", \"nosniff\");\n        this.set(\"Content-Type\", \"text/javascript\");\n        callback = callback.replace(/[^\\[\\]\\w$.]/g, \"\");\n        if (body === void 0) {\n          body = \"\";\n        } else if (typeof body === \"string\") {\n          body = body.replace(/\\u2028/g, \"\\\\u2028\").replace(/\\u2029/g, \"\\\\u2029\");\n        }\n        body = \"/**/ typeof \" + callback + \" === 'function' && \" + callback + \"(\" + body + \");\";\n      }\n      return this.send(body);\n    };\n    res.sendStatus = function sendStatus(statusCode) {\n      var body = statuses.message[statusCode] || String(statusCode);\n      this.status(statusCode);\n      this.type(\"txt\");\n      return this.send(body);\n    };\n    res.sendFile = function sendFile(path2, options, callback) {\n      var done = callback;\n      var req = this.req;\n      var res2 = this;\n      var next = req.next;\n      var opts = options || {};\n      if (!path2) {\n        throw new TypeError(\"path argument is required to res.sendFile\");\n      }\n      if (typeof path2 !== \"string\") {\n        throw new TypeError(\"path must be a string to res.sendFile\");\n      }\n      if (typeof options === \"function\") {\n        done = options;\n        opts = {};\n      }\n      if (!opts.root && !pathIsAbsolute(path2)) {\n        throw new TypeError(\"path must be absolute or specify root to res.sendFile\");\n      }\n      var pathname = encodeURI(path2);\n      opts.etag = this.app.enabled(\"etag\");\n      var file = send(req, pathname, opts);\n      sendfile(res2, file, opts, function(err2) {\n        if (done) return done(err2);\n        if (err2 && err2.code === \"EISDIR\") return next();\n        if (err2 && err2.code !== \"ECONNABORTED\" && err2.syscall !== \"write\") {\n          next(err2);\n        }\n      });\n    };\n    res.download = function download(path2, filename, options, callback) {\n      var done = callback;\n      var name = filename;\n      var opts = options || null;\n      if (typeof filename === \"function\") {\n        done = filename;\n        name = null;\n        opts = null;\n      } else if (typeof options === \"function\") {\n        done = options;\n        opts = null;\n      }\n      if (typeof filename === \"object\" && (typeof options === \"function\" || options === void 0)) {\n        name = null;\n        opts = filename;\n      }\n      var headers = {\n        \"Content-Disposition\": contentDisposition(name || path2)\n      };\n      if (opts && opts.headers) {\n        var keys = Object.keys(opts.headers);\n        for (var i = 0; i < keys.length; i++) {\n          var key = keys[i];\n          if (key.toLowerCase() !== \"content-disposition\") {\n            headers[key] = opts.headers[key];\n          }\n        }\n      }\n      opts = Object.create(opts);\n      opts.headers = headers;\n      var fullPath = !opts.root ? resolve(path2) : path2;\n      return this.sendFile(fullPath, opts, done);\n    };\n    res.contentType = res.type = function contentType2(type) {\n      var ct = type.indexOf(\"/\") === -1 ? mime.contentType(type) || \"application/octet-stream\" : type;\n      return this.set(\"Content-Type\", ct);\n    };\n    res.format = function(obj) {\n      var req = this.req;\n      var next = req.next;\n      var keys = Object.keys(obj).filter(function(v) {\n        return v !== \"default\";\n      });\n      var key = keys.length > 0 ? req.accepts(keys) : false;\n      this.vary(\"Accept\");\n      if (key) {\n        this.set(\"Content-Type\", normalizeType(key).value);\n        obj[key](req, this, next);\n      } else if (obj.default) {\n        obj.default(req, this, next);\n      } else {\n        next(createError(406, {\n          types: normalizeTypes(keys).map(function(o) {\n            return o.value;\n          })\n        }));\n      }\n      return this;\n    };\n    res.attachment = function attachment(filename) {\n      if (filename) {\n        this.type(extname(filename));\n      }\n      this.set(\"Content-Disposition\", contentDisposition(filename));\n      return this;\n    };\n    res.append = function append(field, val) {\n      var prev = this.get(field);\n      var value = val;\n      if (prev) {\n        value = Array.isArray(prev) ? prev.concat(val) : Array.isArray(val) ? [prev].concat(val) : [prev, val];\n      }\n      return this.set(field, value);\n    };\n    res.set = res.header = function header(field, val) {\n      if (arguments.length === 2) {\n        var value = Array.isArray(val) ? val.map(String) : String(val);\n        if (field.toLowerCase() === \"content-type\") {\n          if (Array.isArray(value)) {\n            throw new TypeError(\"Content-Type cannot be set to an Array\");\n          }\n          value = mime.contentType(value);\n        }\n        this.setHeader(field, value);\n      } else {\n        for (var key in field) {\n          this.set(key, field[key]);\n        }\n      }\n      return this;\n    };\n    res.get = function(field) {\n      return this.getHeader(field);\n    };\n    res.clearCookie = function clearCookie(name, options) {\n      const opts = { path: \"/\", ...options, expires: /* @__PURE__ */ new Date(1) };\n      delete opts.maxAge;\n      return this.cookie(name, \"\", opts);\n    };\n    res.cookie = function(name, value, options) {\n      var opts = { ...options };\n      var secret = this.req.secret;\n      var signed = opts.signed;\n      if (signed && !secret) {\n        throw new Error('cookieParser(\"secret\") required for signed cookies');\n      }\n      var val = typeof value === \"object\" ? \"j:\" + JSON.stringify(value) : String(value);\n      if (signed) {\n        val = \"s:\" + sign(val, secret);\n      }\n      if (opts.maxAge != null) {\n        var maxAge = opts.maxAge - 0;\n        if (!isNaN(maxAge)) {\n          opts.expires = new Date(Date.now() + maxAge);\n          opts.maxAge = Math.floor(maxAge / 1e3);\n        }\n      }\n      if (opts.path == null) {\n        opts.path = \"/\";\n      }\n      this.append(\"Set-Cookie\", cookie.serialize(name, String(val), opts));\n      return this;\n    };\n    res.location = function location(url) {\n      return this.set(\"Location\", encodeUrl(url));\n    };\n    res.redirect = function redirect(url) {\n      var address = url;\n      var body;\n      var status = 302;\n      if (arguments.length === 2) {\n        status = arguments[0];\n        address = arguments[1];\n      }\n      address = this.location(address).get(\"Location\");\n      this.format({\n        text: function() {\n          body = statuses.message[status] + \". Redirecting to \" + address;\n        },\n        html: function() {\n          var u = escapeHtml(address);\n          body = \"<p>\" + statuses.message[status] + \". Redirecting to \" + u + \"</p>\";\n        },\n        default: function() {\n          body = \"\";\n        }\n      });\n      this.status(status);\n      this.set(\"Content-Length\", Buffer.byteLength(body));\n      if (this.req.method === \"HEAD\") {\n        this.end();\n      } else {\n        this.end(body);\n      }\n    };\n    res.vary = function(field) {\n      vary(this, field);\n      return this;\n    };\n    res.render = function render(view, options, callback) {\n      var app = this.req.app;\n      var done = callback;\n      var opts = options || {};\n      var req = this.req;\n      var self2 = this;\n      if (typeof options === \"function\") {\n        done = options;\n        opts = {};\n      }\n      opts._locals = self2.locals;\n      done = done || function(err2, str) {\n        if (err2) return req.next(err2);\n        self2.send(str);\n      };\n      app.render(view, opts, done);\n    };\n    function sendfile(res2, file, options, callback) {\n      var done = false;\n      var streaming;\n      function onaborted() {\n        if (done) return;\n        done = true;\n        var err2 = new Error(\"Request aborted\");\n        err2.code = \"ECONNABORTED\";\n        callback(err2);\n      }\n      function ondirectory() {\n        if (done) return;\n        done = true;\n        var err2 = new Error(\"EISDIR, read\");\n        err2.code = \"EISDIR\";\n        callback(err2);\n      }\n      function onerror(err2) {\n        if (done) return;\n        done = true;\n        callback(err2);\n      }\n      function onend() {\n        if (done) return;\n        done = true;\n        callback();\n      }\n      function onfile() {\n        streaming = false;\n      }\n      function onfinish(err2) {\n        if (err2 && err2.code === \"ECONNRESET\") return onaborted();\n        if (err2) return onerror(err2);\n        if (done) return;\n        setImmediate(function() {\n          if (streaming !== false && !done) {\n            onaborted();\n            return;\n          }\n          if (done) return;\n          done = true;\n          callback();\n        });\n      }\n      function onstream() {\n        streaming = true;\n      }\n      file.on(\"directory\", ondirectory);\n      file.on(\"end\", onend);\n      file.on(\"error\", onerror);\n      file.on(\"file\", onfile);\n      file.on(\"stream\", onstream);\n      onFinished(res2, onfinish);\n      if (options.headers) {\n        file.on(\"headers\", function headers(res3) {\n          var obj = options.headers;\n          var keys = Object.keys(obj);\n          for (var i = 0; i < keys.length; i++) {\n            var k = keys[i];\n            res3.setHeader(k, obj[k]);\n          }\n        });\n      }\n      file.pipe(res2);\n    }\n    function stringify(value, replacer, spaces, escape2) {\n      var json = replacer || spaces ? JSON.stringify(value, replacer, spaces) : JSON.stringify(value);\n      if (escape2 && typeof json === \"string\") {\n        json = json.replace(/[<>&]/g, function(c) {\n          switch (c.charCodeAt(0)) {\n            case 60:\n              return \"\\\\u003c\";\n            case 62:\n              return \"\\\\u003e\";\n            case 38:\n              return \"\\\\u0026\";\n            /* istanbul ignore next: unreachable default */\n            default:\n              return c;\n          }\n        });\n      }\n      return json;\n    }\n  }\n});\n\n// node_modules/serve-static/index.js\nvar require_serve_static = __commonJS({\n  \"node_modules/serve-static/index.js\"(exports2, module2) {\n    \"use strict\";\n    var encodeUrl = require_encodeurl();\n    var escapeHtml = require_escape_html();\n    var parseUrl = require_parseurl();\n    var resolve = require(\"path\").resolve;\n    var send = require_send();\n    var url = require(\"url\");\n    module2.exports = serveStatic;\n    function serveStatic(root, options) {\n      if (!root) {\n        throw new TypeError(\"root path required\");\n      }\n      if (typeof root !== \"string\") {\n        throw new TypeError(\"root path must be a string\");\n      }\n      var opts = Object.create(options || null);\n      var fallthrough = opts.fallthrough !== false;\n      var redirect = opts.redirect !== false;\n      var setHeaders = opts.setHeaders;\n      if (setHeaders && typeof setHeaders !== \"function\") {\n        throw new TypeError(\"option setHeaders must be function\");\n      }\n      opts.maxage = opts.maxage || opts.maxAge || 0;\n      opts.root = resolve(root);\n      var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();\n      return function serveStatic2(req, res, next) {\n        if (req.method !== \"GET\" && req.method !== \"HEAD\") {\n          if (fallthrough) {\n            return next();\n          }\n          res.statusCode = 405;\n          res.setHeader(\"Allow\", \"GET, HEAD\");\n          res.setHeader(\"Content-Length\", \"0\");\n          res.end();\n          return;\n        }\n        var forwardError = !fallthrough;\n        var originalUrl = parseUrl.original(req);\n        var path = parseUrl(req).pathname;\n        if (path === \"/\" && originalUrl.pathname.substr(-1) !== \"/\") {\n          path = \"\";\n        }\n        var stream = send(req, path, opts);\n        stream.on(\"directory\", onDirectory);\n        if (setHeaders) {\n          stream.on(\"headers\", setHeaders);\n        }\n        if (fallthrough) {\n          stream.on(\"file\", function onFile() {\n            forwardError = true;\n          });\n        }\n        stream.on(\"error\", function error(err2) {\n          if (forwardError || !(err2.statusCode < 500)) {\n            next(err2);\n            return;\n          }\n          next();\n        });\n        stream.pipe(res);\n      };\n    }\n    function collapseLeadingSlashes(str) {\n      for (var i = 0; i < str.length; i++) {\n        if (str.charCodeAt(i) !== 47) {\n          break;\n        }\n      }\n      return i > 1 ? \"/\" + str.substr(i) : str;\n    }\n    function createHtmlDocument(title, body) {\n      return '<!DOCTYPE html>\\n<html lang=\"en\">\\n<head>\\n<meta charset=\"utf-8\">\\n<title>' + title + \"</title>\\n</head>\\n<body>\\n<pre>\" + body + \"</pre>\\n</body>\\n</html>\\n\";\n    }\n    function createNotFoundDirectoryListener() {\n      return function notFound() {\n        this.error(404);\n      };\n    }\n    function createRedirectDirectoryListener() {\n      return function redirect(res) {\n        if (this.hasTrailingSlash()) {\n          this.error(404);\n          return;\n        }\n        var originalUrl = parseUrl.original(this.req);\n        originalUrl.path = null;\n        originalUrl.pathname = collapseLeadingSlashes(originalUrl.pathname + \"/\");\n        var loc = encodeUrl(url.format(originalUrl));\n        var doc = createHtmlDocument(\"Redirecting\", \"Redirecting to \" + escapeHtml(loc));\n        res.statusCode = 301;\n        res.setHeader(\"Content-Type\", \"text/html; charset=UTF-8\");\n        res.setHeader(\"Content-Length\", Buffer.byteLength(doc));\n        res.setHeader(\"Content-Security-Policy\", \"default-src 'none'\");\n        res.setHeader(\"X-Content-Type-Options\", \"nosniff\");\n        res.setHeader(\"Location\", loc);\n        res.end(doc);\n      };\n    }\n  }\n});\n\n// node_modules/express/lib/express.js\nvar require_express = __commonJS({\n  \"node_modules/express/lib/express.js\"(exports2, module2) {\n    \"use strict\";\n    var bodyParser = require_body_parser();\n    var EventEmitter = require(\"node:events\").EventEmitter;\n    var mixin = require_merge_descriptors();\n    var proto = require_application();\n    var Router = require_router();\n    var req = require_request();\n    var res = require_response();\n    exports2 = module2.exports = createApplication;\n    function createApplication() {\n      var app = function(req2, res2, next) {\n        app.handle(req2, res2, next);\n      };\n      mixin(app, EventEmitter.prototype, false);\n      mixin(app, proto, false);\n      app.request = Object.create(req, {\n        app: { configurable: true, enumerable: true, writable: true, value: app }\n      });\n      app.response = Object.create(res, {\n        app: { configurable: true, enumerable: true, writable: true, value: app }\n      });\n      app.init();\n      return app;\n    }\n    exports2.application = proto;\n    exports2.request = req;\n    exports2.response = res;\n    exports2.Route = Router.Route;\n    exports2.Router = Router;\n    exports2.json = bodyParser.json;\n    exports2.raw = bodyParser.raw;\n    exports2.static = require_serve_static();\n    exports2.text = bodyParser.text;\n    exports2.urlencoded = bodyParser.urlencoded;\n  }\n});\n\n// node_modules/express/index.js\nvar require_express2 = __commonJS({\n  \"node_modules/express/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = require_express();\n  }\n});\n\n// node_modules/lodash/lodash.js\nvar require_lodash = __commonJS({\n  \"node_modules/lodash/lodash.js\"(exports2, module2) {\n    (function() {\n      var undefined2;\n      var VERSION = \"4.17.21\";\n      var LARGE_ARRAY_SIZE = 200;\n      var CORE_ERROR_TEXT = \"Unsupported core-js use. Try https://npms.io/search?q=ponyfill.\", FUNC_ERROR_TEXT = \"Expected a function\", INVALID_TEMPL_VAR_ERROR_TEXT = \"Invalid `variable` option passed into `_.template`\";\n      var HASH_UNDEFINED = \"__lodash_hash_undefined__\";\n      var MAX_MEMOIZE_SIZE = 500;\n      var PLACEHOLDER = \"__lodash_placeholder__\";\n      var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;\n      var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;\n      var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;\n      var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = \"...\";\n      var HOT_COUNT = 800, HOT_SPAN = 16;\n      var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;\n      var INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0;\n      var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n      var wrapFlags = [\n        [\"ary\", WRAP_ARY_FLAG],\n        [\"bind\", WRAP_BIND_FLAG],\n        [\"bindKey\", WRAP_BIND_KEY_FLAG],\n        [\"curry\", WRAP_CURRY_FLAG],\n        [\"curryRight\", WRAP_CURRY_RIGHT_FLAG],\n        [\"flip\", WRAP_FLIP_FLAG],\n        [\"partial\", WRAP_PARTIAL_FLAG],\n        [\"partialRight\", WRAP_PARTIAL_RIGHT_FLAG],\n        [\"rearg\", WRAP_REARG_FLAG]\n      ];\n      var argsTag = \"[object Arguments]\", arrayTag = \"[object Array]\", asyncTag = \"[object AsyncFunction]\", boolTag = \"[object Boolean]\", dateTag = \"[object Date]\", domExcTag = \"[object DOMException]\", errorTag = \"[object Error]\", funcTag = \"[object Function]\", genTag = \"[object GeneratorFunction]\", mapTag = \"[object Map]\", numberTag = \"[object Number]\", nullTag = \"[object Null]\", objectTag = \"[object Object]\", promiseTag = \"[object Promise]\", proxyTag = \"[object Proxy]\", regexpTag = \"[object RegExp]\", setTag = \"[object Set]\", stringTag = \"[object String]\", symbolTag = \"[object Symbol]\", undefinedTag = \"[object Undefined]\", weakMapTag = \"[object WeakMap]\", weakSetTag = \"[object WeakSet]\";\n      var arrayBufferTag = \"[object ArrayBuffer]\", dataViewTag = \"[object DataView]\", float32Tag = \"[object Float32Array]\", float64Tag = \"[object Float64Array]\", int8Tag = \"[object Int8Array]\", int16Tag = \"[object Int16Array]\", int32Tag = \"[object Int32Array]\", uint8Tag = \"[object Uint8Array]\", uint8ClampedTag = \"[object Uint8ClampedArray]\", uint16Tag = \"[object Uint16Array]\", uint32Tag = \"[object Uint32Array]\";\n      var reEmptyStringLeading = /\\b__p \\+= '';/g, reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g, reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n      var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>\"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n      var reEscape = /<%-([\\s\\S]+?)%>/g, reEvaluate = /<%([\\s\\S]+?)%>/g, reInterpolate = /<%=([\\s\\S]+?)%>/g;\n      var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/, reIsPlainProp = /^\\w*$/, rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n      var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);\n      var reTrimStart = /^\\s+/;\n      var reWhitespace = /\\s/;\n      var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/, reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/, reSplitDetails = /,? & /;\n      var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n      var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\n      var reEscapeChar = /\\\\(\\\\)?/g;\n      var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n      var reFlags = /\\w*$/;\n      var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n      var reIsBinary = /^0b[01]+$/i;\n      var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n      var reIsOctal = /^0o[0-7]+$/i;\n      var reIsUint = /^(?:0|[1-9]\\d*)$/;\n      var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n      var reNoMatch = /($^)/;\n      var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n      var rsAstralRange = \"\\\\ud800-\\\\udfff\", rsComboMarksRange = \"\\\\u0300-\\\\u036f\", reComboHalfMarksRange = \"\\\\ufe20-\\\\ufe2f\", rsComboSymbolsRange = \"\\\\u20d0-\\\\u20ff\", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = \"\\\\u2700-\\\\u27bf\", rsLowerRange = \"a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff\", rsMathOpRange = \"\\\\xac\\\\xb1\\\\xd7\\\\xf7\", rsNonCharRange = \"\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf\", rsPunctuationRange = \"\\\\u2000-\\\\u206f\", rsSpaceRange = \" \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000\", rsUpperRange = \"A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde\", rsVarRange = \"\\\\ufe0e\\\\ufe0f\", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n      var rsApos = \"['\\u2019]\", rsAstral = \"[\" + rsAstralRange + \"]\", rsBreak = \"[\" + rsBreakRange + \"]\", rsCombo = \"[\" + rsComboRange + \"]\", rsDigits = \"\\\\d+\", rsDingbat = \"[\" + rsDingbatRange + \"]\", rsLower = \"[\" + rsLowerRange + \"]\", rsMisc = \"[^\" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + \"]\", rsFitz = \"\\\\ud83c[\\\\udffb-\\\\udfff]\", rsModifier = \"(?:\" + rsCombo + \"|\" + rsFitz + \")\", rsNonAstral = \"[^\" + rsAstralRange + \"]\", rsRegional = \"(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}\", rsSurrPair = \"[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]\", rsUpper = \"[\" + rsUpperRange + \"]\", rsZWJ = \"\\\\u200d\";\n      var rsMiscLower = \"(?:\" + rsLower + \"|\" + rsMisc + \")\", rsMiscUpper = \"(?:\" + rsUpper + \"|\" + rsMisc + \")\", rsOptContrLower = \"(?:\" + rsApos + \"(?:d|ll|m|re|s|t|ve))?\", rsOptContrUpper = \"(?:\" + rsApos + \"(?:D|LL|M|RE|S|T|VE))?\", reOptMod = rsModifier + \"?\", rsOptVar = \"[\" + rsVarRange + \"]?\", rsOptJoin = \"(?:\" + rsZWJ + \"(?:\" + [rsNonAstral, rsRegional, rsSurrPair].join(\"|\") + \")\" + rsOptVar + reOptMod + \")*\", rsOrdLower = \"\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])\", rsOrdUpper = \"\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])\", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = \"(?:\" + [rsDingbat, rsRegional, rsSurrPair].join(\"|\") + \")\" + rsSeq, rsSymbol = \"(?:\" + [rsNonAstral + rsCombo + \"?\", rsCombo, rsRegional, rsSurrPair, rsAstral].join(\"|\") + \")\";\n      var reApos = RegExp(rsApos, \"g\");\n      var reComboMark = RegExp(rsCombo, \"g\");\n      var reUnicode = RegExp(rsFitz + \"(?=\" + rsFitz + \")|\" + rsSymbol + rsSeq, \"g\");\n      var reUnicodeWord = RegExp([\n        rsUpper + \"?\" + rsLower + \"+\" + rsOptContrLower + \"(?=\" + [rsBreak, rsUpper, \"$\"].join(\"|\") + \")\",\n        rsMiscUpper + \"+\" + rsOptContrUpper + \"(?=\" + [rsBreak, rsUpper + rsMiscLower, \"$\"].join(\"|\") + \")\",\n        rsUpper + \"?\" + rsMiscLower + \"+\" + rsOptContrLower,\n        rsUpper + \"+\" + rsOptContrUpper,\n        rsOrdUpper,\n        rsOrdLower,\n        rsDigits,\n        rsEmoji\n      ].join(\"|\"), \"g\");\n      var reHasUnicode = RegExp(\"[\" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + \"]\");\n      var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n      var contextProps = [\n        \"Array\",\n        \"Buffer\",\n        \"DataView\",\n        \"Date\",\n        \"Error\",\n        \"Float32Array\",\n        \"Float64Array\",\n        \"Function\",\n        \"Int8Array\",\n        \"Int16Array\",\n        \"Int32Array\",\n        \"Map\",\n        \"Math\",\n        \"Object\",\n        \"Promise\",\n        \"RegExp\",\n        \"Set\",\n        \"String\",\n        \"Symbol\",\n        \"TypeError\",\n        \"Uint8Array\",\n        \"Uint8ClampedArray\",\n        \"Uint16Array\",\n        \"Uint32Array\",\n        \"WeakMap\",\n        \"_\",\n        \"clearTimeout\",\n        \"isFinite\",\n        \"parseInt\",\n        \"setTimeout\"\n      ];\n      var templateCounter = -1;\n      var typedArrayTags = {};\n      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;\n      typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n      var cloneableTags = {};\n      cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n      cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;\n      var deburredLetters = {\n        // Latin-1 Supplement block.\n        \"\\xC0\": \"A\",\n        \"\\xC1\": \"A\",\n        \"\\xC2\": \"A\",\n        \"\\xC3\": \"A\",\n        \"\\xC4\": \"A\",\n        \"\\xC5\": \"A\",\n        \"\\xE0\": \"a\",\n        \"\\xE1\": \"a\",\n        \"\\xE2\": \"a\",\n        \"\\xE3\": \"a\",\n        \"\\xE4\": \"a\",\n        \"\\xE5\": \"a\",\n        \"\\xC7\": \"C\",\n        \"\\xE7\": \"c\",\n        \"\\xD0\": \"D\",\n        \"\\xF0\": \"d\",\n        \"\\xC8\": \"E\",\n        \"\\xC9\": \"E\",\n        \"\\xCA\": \"E\",\n        \"\\xCB\": \"E\",\n        \"\\xE8\": \"e\",\n        \"\\xE9\": \"e\",\n        \"\\xEA\": \"e\",\n        \"\\xEB\": \"e\",\n        \"\\xCC\": \"I\",\n        \"\\xCD\": \"I\",\n        \"\\xCE\": \"I\",\n        \"\\xCF\": \"I\",\n        \"\\xEC\": \"i\",\n        \"\\xED\": \"i\",\n        \"\\xEE\": \"i\",\n        \"\\xEF\": \"i\",\n        \"\\xD1\": \"N\",\n        \"\\xF1\": \"n\",\n        \"\\xD2\": \"O\",\n        \"\\xD3\": \"O\",\n        \"\\xD4\": \"O\",\n        \"\\xD5\": \"O\",\n        \"\\xD6\": \"O\",\n        \"\\xD8\": \"O\",\n        \"\\xF2\": \"o\",\n        \"\\xF3\": \"o\",\n        \"\\xF4\": \"o\",\n        \"\\xF5\": \"o\",\n        \"\\xF6\": \"o\",\n        \"\\xF8\": \"o\",\n        \"\\xD9\": \"U\",\n        \"\\xDA\": \"U\",\n        \"\\xDB\": \"U\",\n        \"\\xDC\": \"U\",\n        \"\\xF9\": \"u\",\n        \"\\xFA\": \"u\",\n        \"\\xFB\": \"u\",\n        \"\\xFC\": \"u\",\n        \"\\xDD\": \"Y\",\n        \"\\xFD\": \"y\",\n        \"\\xFF\": \"y\",\n        \"\\xC6\": \"Ae\",\n        \"\\xE6\": \"ae\",\n        \"\\xDE\": \"Th\",\n        \"\\xFE\": \"th\",\n        \"\\xDF\": \"ss\",\n        // Latin Extended-A block.\n        \"\\u0100\": \"A\",\n        \"\\u0102\": \"A\",\n        \"\\u0104\": \"A\",\n        \"\\u0101\": \"a\",\n        \"\\u0103\": \"a\",\n        \"\\u0105\": \"a\",\n        \"\\u0106\": \"C\",\n        \"\\u0108\": \"C\",\n        \"\\u010A\": \"C\",\n        \"\\u010C\": \"C\",\n        \"\\u0107\": \"c\",\n        \"\\u0109\": \"c\",\n        \"\\u010B\": \"c\",\n        \"\\u010D\": \"c\",\n        \"\\u010E\": \"D\",\n        \"\\u0110\": \"D\",\n        \"\\u010F\": \"d\",\n        \"\\u0111\": \"d\",\n        \"\\u0112\": \"E\",\n        \"\\u0114\": \"E\",\n        \"\\u0116\": \"E\",\n        \"\\u0118\": \"E\",\n        \"\\u011A\": \"E\",\n        \"\\u0113\": \"e\",\n        \"\\u0115\": \"e\",\n        \"\\u0117\": \"e\",\n        \"\\u0119\": \"e\",\n        \"\\u011B\": \"e\",\n        \"\\u011C\": \"G\",\n        \"\\u011E\": \"G\",\n        \"\\u0120\": \"G\",\n        \"\\u0122\": \"G\",\n        \"\\u011D\": \"g\",\n        \"\\u011F\": \"g\",\n        \"\\u0121\": \"g\",\n        \"\\u0123\": \"g\",\n        \"\\u0124\": \"H\",\n        \"\\u0126\": \"H\",\n        \"\\u0125\": \"h\",\n        \"\\u0127\": \"h\",\n        \"\\u0128\": \"I\",\n        \"\\u012A\": \"I\",\n        \"\\u012C\": \"I\",\n        \"\\u012E\": \"I\",\n        \"\\u0130\": \"I\",\n        \"\\u0129\": \"i\",\n        \"\\u012B\": \"i\",\n        \"\\u012D\": \"i\",\n        \"\\u012F\": \"i\",\n        \"\\u0131\": \"i\",\n        \"\\u0134\": \"J\",\n        \"\\u0135\": \"j\",\n        \"\\u0136\": \"K\",\n        \"\\u0137\": \"k\",\n        \"\\u0138\": \"k\",\n        \"\\u0139\": \"L\",\n        \"\\u013B\": \"L\",\n        \"\\u013D\": \"L\",\n        \"\\u013F\": \"L\",\n        \"\\u0141\": \"L\",\n        \"\\u013A\": \"l\",\n        \"\\u013C\": \"l\",\n        \"\\u013E\": \"l\",\n        \"\\u0140\": \"l\",\n        \"\\u0142\": \"l\",\n        \"\\u0143\": \"N\",\n        \"\\u0145\": \"N\",\n        \"\\u0147\": \"N\",\n        \"\\u014A\": \"N\",\n        \"\\u0144\": \"n\",\n        \"\\u0146\": \"n\",\n        \"\\u0148\": \"n\",\n        \"\\u014B\": \"n\",\n        \"\\u014C\": \"O\",\n        \"\\u014E\": \"O\",\n        \"\\u0150\": \"O\",\n        \"\\u014D\": \"o\",\n        \"\\u014F\": \"o\",\n        \"\\u0151\": \"o\",\n        \"\\u0154\": \"R\",\n        \"\\u0156\": \"R\",\n        \"\\u0158\": \"R\",\n        \"\\u0155\": \"r\",\n        \"\\u0157\": \"r\",\n        \"\\u0159\": \"r\",\n        \"\\u015A\": \"S\",\n        \"\\u015C\": \"S\",\n        \"\\u015E\": \"S\",\n        \"\\u0160\": \"S\",\n        \"\\u015B\": \"s\",\n        \"\\u015D\": \"s\",\n        \"\\u015F\": \"s\",\n        \"\\u0161\": \"s\",\n        \"\\u0162\": \"T\",\n        \"\\u0164\": \"T\",\n        \"\\u0166\": \"T\",\n        \"\\u0163\": \"t\",\n        \"\\u0165\": \"t\",\n        \"\\u0167\": \"t\",\n        \"\\u0168\": \"U\",\n        \"\\u016A\": \"U\",\n        \"\\u016C\": \"U\",\n        \"\\u016E\": \"U\",\n        \"\\u0170\": \"U\",\n        \"\\u0172\": \"U\",\n        \"\\u0169\": \"u\",\n        \"\\u016B\": \"u\",\n        \"\\u016D\": \"u\",\n        \"\\u016F\": \"u\",\n        \"\\u0171\": \"u\",\n        \"\\u0173\": \"u\",\n        \"\\u0174\": \"W\",\n        \"\\u0175\": \"w\",\n        \"\\u0176\": \"Y\",\n        \"\\u0177\": \"y\",\n        \"\\u0178\": \"Y\",\n        \"\\u0179\": \"Z\",\n        \"\\u017B\": \"Z\",\n        \"\\u017D\": \"Z\",\n        \"\\u017A\": \"z\",\n        \"\\u017C\": \"z\",\n        \"\\u017E\": \"z\",\n        \"\\u0132\": \"IJ\",\n        \"\\u0133\": \"ij\",\n        \"\\u0152\": \"Oe\",\n        \"\\u0153\": \"oe\",\n        \"\\u0149\": \"'n\",\n        \"\\u017F\": \"s\"\n      };\n      var htmlEscapes = {\n        \"&\": \"&amp;\",\n        \"<\": \"&lt;\",\n        \">\": \"&gt;\",\n        '\"': \"&quot;\",\n        \"'\": \"&#39;\"\n      };\n      var htmlUnescapes = {\n        \"&amp;\": \"&\",\n        \"&lt;\": \"<\",\n        \"&gt;\": \">\",\n        \"&quot;\": '\"',\n        \"&#39;\": \"'\"\n      };\n      var stringEscapes = {\n        \"\\\\\": \"\\\\\",\n        \"'\": \"'\",\n        \"\\n\": \"n\",\n        \"\\r\": \"r\",\n        \"\\u2028\": \"u2028\",\n        \"\\u2029\": \"u2029\"\n      };\n      var freeParseFloat = parseFloat, freeParseInt = parseInt;\n      var freeGlobal = typeof global == \"object\" && global && global.Object === Object && global;\n      var freeSelf = typeof self == \"object\" && self && self.Object === Object && self;\n      var root = freeGlobal || freeSelf || Function(\"return this\")();\n      var freeExports = typeof exports2 == \"object\" && exports2 && !exports2.nodeType && exports2;\n      var freeModule = freeExports && typeof module2 == \"object\" && module2 && !module2.nodeType && module2;\n      var moduleExports = freeModule && freeModule.exports === freeExports;\n      var freeProcess = moduleExports && freeGlobal.process;\n      var nodeUtil = function() {\n        try {\n          var types = freeModule && freeModule.require && freeModule.require(\"util\").types;\n          if (types) {\n            return types;\n          }\n          return freeProcess && freeProcess.binding && freeProcess.binding(\"util\");\n        } catch (e) {\n        }\n      }();\n      var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n      function apply(func, thisArg, args) {\n        switch (args.length) {\n          case 0:\n            return func.call(thisArg);\n          case 1:\n            return func.call(thisArg, args[0]);\n          case 2:\n            return func.call(thisArg, args[0], args[1]);\n          case 3:\n            return func.call(thisArg, args[0], args[1], args[2]);\n        }\n        return func.apply(thisArg, args);\n      }\n      function arrayAggregator(array, setter, iteratee, accumulator) {\n        var index = -1, length = array == null ? 0 : array.length;\n        while (++index < length) {\n          var value = array[index];\n          setter(accumulator, value, iteratee(value), array);\n        }\n        return accumulator;\n      }\n      function arrayEach(array, iteratee) {\n        var index = -1, length = array == null ? 0 : array.length;\n        while (++index < length) {\n          if (iteratee(array[index], index, array) === false) {\n            break;\n          }\n        }\n        return array;\n      }\n      function arrayEachRight(array, iteratee) {\n        var length = array == null ? 0 : array.length;\n        while (length--) {\n          if (iteratee(array[length], length, array) === false) {\n            break;\n          }\n        }\n        return array;\n      }\n      function arrayEvery(array, predicate) {\n        var index = -1, length = array == null ? 0 : array.length;\n        while (++index < length) {\n          if (!predicate(array[index], index, array)) {\n            return false;\n          }\n        }\n        return true;\n      }\n      function arrayFilter(array, predicate) {\n        var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];\n        while (++index < length) {\n          var value = array[index];\n          if (predicate(value, index, array)) {\n            result[resIndex++] = value;\n          }\n        }\n        return result;\n      }\n      function arrayIncludes(array, value) {\n        var length = array == null ? 0 : array.length;\n        return !!length && baseIndexOf(array, value, 0) > -1;\n      }\n      function arrayIncludesWith(array, value, comparator) {\n        var index = -1, length = array == null ? 0 : array.length;\n        while (++index < length) {\n          if (comparator(value, array[index])) {\n            return true;\n          }\n        }\n        return false;\n      }\n      function arrayMap(array, iteratee) {\n        var index = -1, length = array == null ? 0 : array.length, result = Array(length);\n        while (++index < length) {\n          result[index] = iteratee(array[index], index, array);\n        }\n        return result;\n      }\n      function arrayPush(array, values) {\n        var index = -1, length = values.length, offset = array.length;\n        while (++index < length) {\n          array[offset + index] = values[index];\n        }\n        return array;\n      }\n      function arrayReduce(array, iteratee, accumulator, initAccum) {\n        var index = -1, length = array == null ? 0 : array.length;\n        if (initAccum && length) {\n          accumulator = array[++index];\n        }\n        while (++index < length) {\n          accumulator = iteratee(accumulator, array[index], index, array);\n        }\n        return accumulator;\n      }\n      function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n        var length = array == null ? 0 : array.length;\n        if (initAccum && length) {\n          accumulator = array[--length];\n        }\n        while (length--) {\n          accumulator = iteratee(accumulator, array[length], length, array);\n        }\n        return accumulator;\n      }\n      function arraySome(array, predicate) {\n        var index = -1, length = array == null ? 0 : array.length;\n        while (++index < length) {\n          if (predicate(array[index], index, array)) {\n            return true;\n          }\n        }\n        return false;\n      }\n      var asciiSize = baseProperty(\"length\");\n      function asciiToArray(string) {\n        return string.split(\"\");\n      }\n      function asciiWords(string) {\n        return string.match(reAsciiWord) || [];\n      }\n      function baseFindKey(collection, predicate, eachFunc) {\n        var result;\n        eachFunc(collection, function(value, key, collection2) {\n          if (predicate(value, key, collection2)) {\n            result = key;\n            return false;\n          }\n        });\n        return result;\n      }\n      function baseFindIndex(array, predicate, fromIndex, fromRight) {\n        var length = array.length, index = fromIndex + (fromRight ? 1 : -1);\n        while (fromRight ? index-- : ++index < length) {\n          if (predicate(array[index], index, array)) {\n            return index;\n          }\n        }\n        return -1;\n      }\n      function baseIndexOf(array, value, fromIndex) {\n        return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);\n      }\n      function baseIndexOfWith(array, value, fromIndex, comparator) {\n        var index = fromIndex - 1, length = array.length;\n        while (++index < length) {\n          if (comparator(array[index], value)) {\n            return index;\n          }\n        }\n        return -1;\n      }\n      function baseIsNaN(value) {\n        return value !== value;\n      }\n      function baseMean(array, iteratee) {\n        var length = array == null ? 0 : array.length;\n        return length ? baseSum(array, iteratee) / length : NAN;\n      }\n      function baseProperty(key) {\n        return function(object) {\n          return object == null ? undefined2 : object[key];\n        };\n      }\n      function basePropertyOf(object) {\n        return function(key) {\n          return object == null ? undefined2 : object[key];\n        };\n      }\n      function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n        eachFunc(collection, function(value, index, collection2) {\n          accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);\n        });\n        return accumulator;\n      }\n      function baseSortBy(array, comparer) {\n        var length = array.length;\n        array.sort(comparer);\n        while (length--) {\n          array[length] = array[length].value;\n        }\n        return array;\n      }\n      function baseSum(array, iteratee) {\n        var result, index = -1, length = array.length;\n        while (++index < length) {\n          var current = iteratee(array[index]);\n          if (current !== undefined2) {\n            result = result === undefined2 ? current : result + current;\n          }\n        }\n        return result;\n      }\n      function baseTimes(n, iteratee) {\n        var index = -1, result = Array(n);\n        while (++index < n) {\n          result[index] = iteratee(index);\n        }\n        return result;\n      }\n      function baseToPairs(object, props) {\n        return arrayMap(props, function(key) {\n          return [key, object[key]];\n        });\n      }\n      function baseTrim(string) {\n        return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, \"\") : string;\n      }\n      function baseUnary(func) {\n        return function(value) {\n          return func(value);\n        };\n      }\n      function baseValues(object, props) {\n        return arrayMap(props, function(key) {\n          return object[key];\n        });\n      }\n      function cacheHas(cache, key) {\n        return cache.has(key);\n      }\n      function charsStartIndex(strSymbols, chrSymbols) {\n        var index = -1, length = strSymbols.length;\n        while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {\n        }\n        return index;\n      }\n      function charsEndIndex(strSymbols, chrSymbols) {\n        var index = strSymbols.length;\n        while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {\n        }\n        return index;\n      }\n      function countHolders(array, placeholder) {\n        var length = array.length, result = 0;\n        while (length--) {\n          if (array[length] === placeholder) {\n            ++result;\n          }\n        }\n        return result;\n      }\n      var deburrLetter = basePropertyOf(deburredLetters);\n      var escapeHtmlChar = basePropertyOf(htmlEscapes);\n      function escapeStringChar(chr) {\n        return \"\\\\\" + stringEscapes[chr];\n      }\n      function getValue(object, key) {\n        return object == null ? undefined2 : object[key];\n      }\n      function hasUnicode(string) {\n        return reHasUnicode.test(string);\n      }\n      function hasUnicodeWord(string) {\n        return reHasUnicodeWord.test(string);\n      }\n      function iteratorToArray(iterator) {\n        var data, result = [];\n        while (!(data = iterator.next()).done) {\n          result.push(data.value);\n        }\n        return result;\n      }\n      function mapToArray(map) {\n        var index = -1, result = Array(map.size);\n        map.forEach(function(value, key) {\n          result[++index] = [key, value];\n        });\n        return result;\n      }\n      function overArg(func, transform) {\n        return function(arg) {\n          return func(transform(arg));\n        };\n      }\n      function replaceHolders(array, placeholder) {\n        var index = -1, length = array.length, resIndex = 0, result = [];\n        while (++index < length) {\n          var value = array[index];\n          if (value === placeholder || value === PLACEHOLDER) {\n            array[index] = PLACEHOLDER;\n            result[resIndex++] = index;\n          }\n        }\n        return result;\n      }\n      function setToArray(set) {\n        var index = -1, result = Array(set.size);\n        set.forEach(function(value) {\n          result[++index] = value;\n        });\n        return result;\n      }\n      function setToPairs(set) {\n        var index = -1, result = Array(set.size);\n        set.forEach(function(value) {\n          result[++index] = [value, value];\n        });\n        return result;\n      }\n      function strictIndexOf(array, value, fromIndex) {\n        var index = fromIndex - 1, length = array.length;\n        while (++index < length) {\n          if (array[index] === value) {\n            return index;\n          }\n        }\n        return -1;\n      }\n      function strictLastIndexOf(array, value, fromIndex) {\n        var index = fromIndex + 1;\n        while (index--) {\n          if (array[index] === value) {\n            return index;\n          }\n        }\n        return index;\n      }\n      function stringSize(string) {\n        return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);\n      }\n      function stringToArray(string) {\n        return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);\n      }\n      function trimmedEndIndex(string) {\n        var index = string.length;\n        while (index-- && reWhitespace.test(string.charAt(index))) {\n        }\n        return index;\n      }\n      var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n      function unicodeSize(string) {\n        var result = reUnicode.lastIndex = 0;\n        while (reUnicode.test(string)) {\n          ++result;\n        }\n        return result;\n      }\n      function unicodeToArray(string) {\n        return string.match(reUnicode) || [];\n      }\n      function unicodeWords(string) {\n        return string.match(reUnicodeWord) || [];\n      }\n      var runInContext = function runInContext2(context) {\n        context = context == null ? root : _2.defaults(root.Object(), context, _2.pick(root, contextProps));\n        var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError;\n        var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;\n        var coreJsData = context[\"__core-js_shared__\"];\n        var funcToString = funcProto.toString;\n        var hasOwnProperty = objectProto.hasOwnProperty;\n        var idCounter = 0;\n        var maskSrcKey = function() {\n          var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || \"\");\n          return uid ? \"Symbol(src)_1.\" + uid : \"\";\n        }();\n        var nativeObjectToString = objectProto.toString;\n        var objectCtorString = funcToString.call(Object2);\n        var oldDash = root._;\n        var reIsNative = RegExp2(\n          \"^\" + funcToString.call(hasOwnProperty).replace(reRegExpChar, \"\\\\$&\").replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, \"$1.*?\") + \"$\"\n        );\n        var Buffer2 = moduleExports ? context.Buffer : undefined2, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined2, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined2, symIterator = Symbol2 ? Symbol2.iterator : undefined2, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined2;\n        var defineProperty = function() {\n          try {\n            var func = getNative(Object2, \"defineProperty\");\n            func({}, \"\", {});\n            return func;\n          } catch (e) {\n          }\n        }();\n        var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n        var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined2, nativeIsFinite = context.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;\n        var DataView2 = getNative(context, \"DataView\"), Map2 = getNative(context, \"Map\"), Promise2 = getNative(context, \"Promise\"), Set2 = getNative(context, \"Set\"), WeakMap2 = getNative(context, \"WeakMap\"), nativeCreate = getNative(Object2, \"create\");\n        var metaMap = WeakMap2 && new WeakMap2();\n        var realNames = {};\n        var dataViewCtorString = toSource(DataView2), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);\n        var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2;\n        function lodash(value) {\n          if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n            if (value instanceof LodashWrapper) {\n              return value;\n            }\n            if (hasOwnProperty.call(value, \"__wrapped__\")) {\n              return wrapperClone(value);\n            }\n          }\n          return new LodashWrapper(value);\n        }\n        var baseCreate = /* @__PURE__ */ function() {\n          function object() {\n          }\n          return function(proto) {\n            if (!isObject(proto)) {\n              return {};\n            }\n            if (objectCreate) {\n              return objectCreate(proto);\n            }\n            object.prototype = proto;\n            var result2 = new object();\n            object.prototype = undefined2;\n            return result2;\n          };\n        }();\n        function baseLodash() {\n        }\n        function LodashWrapper(value, chainAll) {\n          this.__wrapped__ = value;\n          this.__actions__ = [];\n          this.__chain__ = !!chainAll;\n          this.__index__ = 0;\n          this.__values__ = undefined2;\n        }\n        lodash.templateSettings = {\n          /**\n           * Used to detect `data` property values to be HTML-escaped.\n           *\n           * @memberOf _.templateSettings\n           * @type {RegExp}\n           */\n          \"escape\": reEscape,\n          /**\n           * Used to detect code to be evaluated.\n           *\n           * @memberOf _.templateSettings\n           * @type {RegExp}\n           */\n          \"evaluate\": reEvaluate,\n          /**\n           * Used to detect `data` property values to inject.\n           *\n           * @memberOf _.templateSettings\n           * @type {RegExp}\n           */\n          \"interpolate\": reInterpolate,\n          /**\n           * Used to reference the data object in the template text.\n           *\n           * @memberOf _.templateSettings\n           * @type {string}\n           */\n          \"variable\": \"\",\n          /**\n           * Used to import variables into the compiled template.\n           *\n           * @memberOf _.templateSettings\n           * @type {Object}\n           */\n          \"imports\": {\n            /**\n             * A reference to the `lodash` function.\n             *\n             * @memberOf _.templateSettings.imports\n             * @type {Function}\n             */\n            \"_\": lodash\n          }\n        };\n        lodash.prototype = baseLodash.prototype;\n        lodash.prototype.constructor = lodash;\n        LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n        LodashWrapper.prototype.constructor = LodashWrapper;\n        function LazyWrapper(value) {\n          this.__wrapped__ = value;\n          this.__actions__ = [];\n          this.__dir__ = 1;\n          this.__filtered__ = false;\n          this.__iteratees__ = [];\n          this.__takeCount__ = MAX_ARRAY_LENGTH;\n          this.__views__ = [];\n        }\n        function lazyClone() {\n          var result2 = new LazyWrapper(this.__wrapped__);\n          result2.__actions__ = copyArray(this.__actions__);\n          result2.__dir__ = this.__dir__;\n          result2.__filtered__ = this.__filtered__;\n          result2.__iteratees__ = copyArray(this.__iteratees__);\n          result2.__takeCount__ = this.__takeCount__;\n          result2.__views__ = copyArray(this.__views__);\n          return result2;\n        }\n        function lazyReverse() {\n          if (this.__filtered__) {\n            var result2 = new LazyWrapper(this);\n            result2.__dir__ = -1;\n            result2.__filtered__ = true;\n          } else {\n            result2 = this.clone();\n            result2.__dir__ *= -1;\n          }\n          return result2;\n        }\n        function lazyValue() {\n          var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);\n          if (!isArr || !isRight && arrLength == length && takeCount == length) {\n            return baseWrapperValue(array, this.__actions__);\n          }\n          var result2 = [];\n          outer:\n            while (length-- && resIndex < takeCount) {\n              index += dir;\n              var iterIndex = -1, value = array[index];\n              while (++iterIndex < iterLength) {\n                var data = iteratees[iterIndex], iteratee2 = data.iteratee, type = data.type, computed = iteratee2(value);\n                if (type == LAZY_MAP_FLAG) {\n                  value = computed;\n                } else if (!computed) {\n                  if (type == LAZY_FILTER_FLAG) {\n                    continue outer;\n                  } else {\n                    break outer;\n                  }\n                }\n              }\n              result2[resIndex++] = value;\n            }\n          return result2;\n        }\n        LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n        LazyWrapper.prototype.constructor = LazyWrapper;\n        function Hash(entries) {\n          var index = -1, length = entries == null ? 0 : entries.length;\n          this.clear();\n          while (++index < length) {\n            var entry2 = entries[index];\n            this.set(entry2[0], entry2[1]);\n          }\n        }\n        function hashClear() {\n          this.__data__ = nativeCreate ? nativeCreate(null) : {};\n          this.size = 0;\n        }\n        function hashDelete(key) {\n          var result2 = this.has(key) && delete this.__data__[key];\n          this.size -= result2 ? 1 : 0;\n          return result2;\n        }\n        function hashGet(key) {\n          var data = this.__data__;\n          if (nativeCreate) {\n            var result2 = data[key];\n            return result2 === HASH_UNDEFINED ? undefined2 : result2;\n          }\n          return hasOwnProperty.call(data, key) ? data[key] : undefined2;\n        }\n        function hashHas(key) {\n          var data = this.__data__;\n          return nativeCreate ? data[key] !== undefined2 : hasOwnProperty.call(data, key);\n        }\n        function hashSet(key, value) {\n          var data = this.__data__;\n          this.size += this.has(key) ? 0 : 1;\n          data[key] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value;\n          return this;\n        }\n        Hash.prototype.clear = hashClear;\n        Hash.prototype[\"delete\"] = hashDelete;\n        Hash.prototype.get = hashGet;\n        Hash.prototype.has = hashHas;\n        Hash.prototype.set = hashSet;\n        function ListCache(entries) {\n          var index = -1, length = entries == null ? 0 : entries.length;\n          this.clear();\n          while (++index < length) {\n            var entry2 = entries[index];\n            this.set(entry2[0], entry2[1]);\n          }\n        }\n        function listCacheClear() {\n          this.__data__ = [];\n          this.size = 0;\n        }\n        function listCacheDelete(key) {\n          var data = this.__data__, index = assocIndexOf(data, key);\n          if (index < 0) {\n            return false;\n          }\n          var lastIndex = data.length - 1;\n          if (index == lastIndex) {\n            data.pop();\n          } else {\n            splice.call(data, index, 1);\n          }\n          --this.size;\n          return true;\n        }\n        function listCacheGet(key) {\n          var data = this.__data__, index = assocIndexOf(data, key);\n          return index < 0 ? undefined2 : data[index][1];\n        }\n        function listCacheHas(key) {\n          return assocIndexOf(this.__data__, key) > -1;\n        }\n        function listCacheSet(key, value) {\n          var data = this.__data__, index = assocIndexOf(data, key);\n          if (index < 0) {\n            ++this.size;\n            data.push([key, value]);\n          } else {\n            data[index][1] = value;\n          }\n          return this;\n        }\n        ListCache.prototype.clear = listCacheClear;\n        ListCache.prototype[\"delete\"] = listCacheDelete;\n        ListCache.prototype.get = listCacheGet;\n        ListCache.prototype.has = listCacheHas;\n        ListCache.prototype.set = listCacheSet;\n        function MapCache(entries) {\n          var index = -1, length = entries == null ? 0 : entries.length;\n          this.clear();\n          while (++index < length) {\n            var entry2 = entries[index];\n            this.set(entry2[0], entry2[1]);\n          }\n        }\n        function mapCacheClear() {\n          this.size = 0;\n          this.__data__ = {\n            \"hash\": new Hash(),\n            \"map\": new (Map2 || ListCache)(),\n            \"string\": new Hash()\n          };\n        }\n        function mapCacheDelete(key) {\n          var result2 = getMapData(this, key)[\"delete\"](key);\n          this.size -= result2 ? 1 : 0;\n          return result2;\n        }\n        function mapCacheGet(key) {\n          return getMapData(this, key).get(key);\n        }\n        function mapCacheHas(key) {\n          return getMapData(this, key).has(key);\n        }\n        function mapCacheSet(key, value) {\n          var data = getMapData(this, key), size2 = data.size;\n          data.set(key, value);\n          this.size += data.size == size2 ? 0 : 1;\n          return this;\n        }\n        MapCache.prototype.clear = mapCacheClear;\n        MapCache.prototype[\"delete\"] = mapCacheDelete;\n        MapCache.prototype.get = mapCacheGet;\n        MapCache.prototype.has = mapCacheHas;\n        MapCache.prototype.set = mapCacheSet;\n        function SetCache(values2) {\n          var index = -1, length = values2 == null ? 0 : values2.length;\n          this.__data__ = new MapCache();\n          while (++index < length) {\n            this.add(values2[index]);\n          }\n        }\n        function setCacheAdd(value) {\n          this.__data__.set(value, HASH_UNDEFINED);\n          return this;\n        }\n        function setCacheHas(value) {\n          return this.__data__.has(value);\n        }\n        SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n        SetCache.prototype.has = setCacheHas;\n        function Stack(entries) {\n          var data = this.__data__ = new ListCache(entries);\n          this.size = data.size;\n        }\n        function stackClear() {\n          this.__data__ = new ListCache();\n          this.size = 0;\n        }\n        function stackDelete(key) {\n          var data = this.__data__, result2 = data[\"delete\"](key);\n          this.size = data.size;\n          return result2;\n        }\n        function stackGet(key) {\n          return this.__data__.get(key);\n        }\n        function stackHas(key) {\n          return this.__data__.has(key);\n        }\n        function stackSet(key, value) {\n          var data = this.__data__;\n          if (data instanceof ListCache) {\n            var pairs = data.__data__;\n            if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {\n              pairs.push([key, value]);\n              this.size = ++data.size;\n              return this;\n            }\n            data = this.__data__ = new MapCache(pairs);\n          }\n          data.set(key, value);\n          this.size = data.size;\n          return this;\n        }\n        Stack.prototype.clear = stackClear;\n        Stack.prototype[\"delete\"] = stackDelete;\n        Stack.prototype.get = stackGet;\n        Stack.prototype.has = stackHas;\n        Stack.prototype.set = stackSet;\n        function arrayLikeKeys(value, inherited) {\n          var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length;\n          for (var key in value) {\n            if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.\n            (key == \"length\" || // Node.js 0.10 has enumerable non-index properties on buffers.\n            isBuff && (key == \"offset\" || key == \"parent\") || // PhantomJS 2 has enumerable non-index properties on typed arrays.\n            isType && (key == \"buffer\" || key == \"byteLength\" || key == \"byteOffset\") || // Skip index properties.\n            isIndex(key, length)))) {\n              result2.push(key);\n            }\n          }\n          return result2;\n        }\n        function arraySample(array) {\n          var length = array.length;\n          return length ? array[baseRandom(0, length - 1)] : undefined2;\n        }\n        function arraySampleSize(array, n) {\n          return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n        }\n        function arrayShuffle(array) {\n          return shuffleSelf(copyArray(array));\n        }\n        function assignMergeValue(object, key, value) {\n          if (value !== undefined2 && !eq(object[key], value) || value === undefined2 && !(key in object)) {\n            baseAssignValue(object, key, value);\n          }\n        }\n        function assignValue(object, key, value) {\n          var objValue = object[key];\n          if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined2 && !(key in object)) {\n            baseAssignValue(object, key, value);\n          }\n        }\n        function assocIndexOf(array, key) {\n          var length = array.length;\n          while (length--) {\n            if (eq(array[length][0], key)) {\n              return length;\n            }\n          }\n          return -1;\n        }\n        function baseAggregator(collection, setter, iteratee2, accumulator) {\n          baseEach(collection, function(value, key, collection2) {\n            setter(accumulator, value, iteratee2(value), collection2);\n          });\n          return accumulator;\n        }\n        function baseAssign(object, source) {\n          return object && copyObject(source, keys(source), object);\n        }\n        function baseAssignIn(object, source) {\n          return object && copyObject(source, keysIn(source), object);\n        }\n        function baseAssignValue(object, key, value) {\n          if (key == \"__proto__\" && defineProperty) {\n            defineProperty(object, key, {\n              \"configurable\": true,\n              \"enumerable\": true,\n              \"value\": value,\n              \"writable\": true\n            });\n          } else {\n            object[key] = value;\n          }\n        }\n        function baseAt(object, paths) {\n          var index = -1, length = paths.length, result2 = Array2(length), skip = object == null;\n          while (++index < length) {\n            result2[index] = skip ? undefined2 : get(object, paths[index]);\n          }\n          return result2;\n        }\n        function baseClamp(number, lower, upper) {\n          if (number === number) {\n            if (upper !== undefined2) {\n              number = number <= upper ? number : upper;\n            }\n            if (lower !== undefined2) {\n              number = number >= lower ? number : lower;\n            }\n          }\n          return number;\n        }\n        function baseClone(value, bitmask, customizer, key, object, stack) {\n          var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;\n          if (customizer) {\n            result2 = object ? customizer(value, key, object, stack) : customizer(value);\n          }\n          if (result2 !== undefined2) {\n            return result2;\n          }\n          if (!isObject(value)) {\n            return value;\n          }\n          var isArr = isArray(value);\n          if (isArr) {\n            result2 = initCloneArray(value);\n            if (!isDeep) {\n              return copyArray(value, result2);\n            }\n          } else {\n            var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;\n            if (isBuffer(value)) {\n              return cloneBuffer(value, isDeep);\n            }\n            if (tag == objectTag || tag == argsTag || isFunc && !object) {\n              result2 = isFlat || isFunc ? {} : initCloneObject(value);\n              if (!isDeep) {\n                return isFlat ? copySymbolsIn(value, baseAssignIn(result2, value)) : copySymbols(value, baseAssign(result2, value));\n              }\n            } else {\n              if (!cloneableTags[tag]) {\n                return object ? value : {};\n              }\n              result2 = initCloneByTag(value, tag, isDeep);\n            }\n          }\n          stack || (stack = new Stack());\n          var stacked = stack.get(value);\n          if (stacked) {\n            return stacked;\n          }\n          stack.set(value, result2);\n          if (isSet(value)) {\n            value.forEach(function(subValue) {\n              result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n            });\n          } else if (isMap(value)) {\n            value.forEach(function(subValue, key2) {\n              result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));\n            });\n          }\n          var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;\n          var props = isArr ? undefined2 : keysFunc(value);\n          arrayEach(props || value, function(subValue, key2) {\n            if (props) {\n              key2 = subValue;\n              subValue = value[key2];\n            }\n            assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));\n          });\n          return result2;\n        }\n        function baseConforms(source) {\n          var props = keys(source);\n          return function(object) {\n            return baseConformsTo(object, source, props);\n          };\n        }\n        function baseConformsTo(object, source, props) {\n          var length = props.length;\n          if (object == null) {\n            return !length;\n          }\n          object = Object2(object);\n          while (length--) {\n            var key = props[length], predicate = source[key], value = object[key];\n            if (value === undefined2 && !(key in object) || !predicate(value)) {\n              return false;\n            }\n          }\n          return true;\n        }\n        function baseDelay(func, wait, args) {\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          return setTimeout(function() {\n            func.apply(undefined2, args);\n          }, wait);\n        }\n        function baseDifference(array, values2, iteratee2, comparator) {\n          var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;\n          if (!length) {\n            return result2;\n          }\n          if (iteratee2) {\n            values2 = arrayMap(values2, baseUnary(iteratee2));\n          }\n          if (comparator) {\n            includes2 = arrayIncludesWith;\n            isCommon = false;\n          } else if (values2.length >= LARGE_ARRAY_SIZE) {\n            includes2 = cacheHas;\n            isCommon = false;\n            values2 = new SetCache(values2);\n          }\n          outer:\n            while (++index < length) {\n              var value = array[index], computed = iteratee2 == null ? value : iteratee2(value);\n              value = comparator || value !== 0 ? value : 0;\n              if (isCommon && computed === computed) {\n                var valuesIndex = valuesLength;\n                while (valuesIndex--) {\n                  if (values2[valuesIndex] === computed) {\n                    continue outer;\n                  }\n                }\n                result2.push(value);\n              } else if (!includes2(values2, computed, comparator)) {\n                result2.push(value);\n              }\n            }\n          return result2;\n        }\n        var baseEach = createBaseEach(baseForOwn);\n        var baseEachRight = createBaseEach(baseForOwnRight, true);\n        function baseEvery(collection, predicate) {\n          var result2 = true;\n          baseEach(collection, function(value, index, collection2) {\n            result2 = !!predicate(value, index, collection2);\n            return result2;\n          });\n          return result2;\n        }\n        function baseExtremum(array, iteratee2, comparator) {\n          var index = -1, length = array.length;\n          while (++index < length) {\n            var value = array[index], current = iteratee2(value);\n            if (current != null && (computed === undefined2 ? current === current && !isSymbol(current) : comparator(current, computed))) {\n              var computed = current, result2 = value;\n            }\n          }\n          return result2;\n        }\n        function baseFill(array, value, start, end) {\n          var length = array.length;\n          start = toInteger(start);\n          if (start < 0) {\n            start = -start > length ? 0 : length + start;\n          }\n          end = end === undefined2 || end > length ? length : toInteger(end);\n          if (end < 0) {\n            end += length;\n          }\n          end = start > end ? 0 : toLength(end);\n          while (start < end) {\n            array[start++] = value;\n          }\n          return array;\n        }\n        function baseFilter(collection, predicate) {\n          var result2 = [];\n          baseEach(collection, function(value, index, collection2) {\n            if (predicate(value, index, collection2)) {\n              result2.push(value);\n            }\n          });\n          return result2;\n        }\n        function baseFlatten(array, depth, predicate, isStrict, result2) {\n          var index = -1, length = array.length;\n          predicate || (predicate = isFlattenable);\n          result2 || (result2 = []);\n          while (++index < length) {\n            var value = array[index];\n            if (depth > 0 && predicate(value)) {\n              if (depth > 1) {\n                baseFlatten(value, depth - 1, predicate, isStrict, result2);\n              } else {\n                arrayPush(result2, value);\n              }\n            } else if (!isStrict) {\n              result2[result2.length] = value;\n            }\n          }\n          return result2;\n        }\n        var baseFor = createBaseFor();\n        var baseForRight = createBaseFor(true);\n        function baseForOwn(object, iteratee2) {\n          return object && baseFor(object, iteratee2, keys);\n        }\n        function baseForOwnRight(object, iteratee2) {\n          return object && baseForRight(object, iteratee2, keys);\n        }\n        function baseFunctions(object, props) {\n          return arrayFilter(props, function(key) {\n            return isFunction(object[key]);\n          });\n        }\n        function baseGet(object, path) {\n          path = castPath(path, object);\n          var index = 0, length = path.length;\n          while (object != null && index < length) {\n            object = object[toKey(path[index++])];\n          }\n          return index && index == length ? object : undefined2;\n        }\n        function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n          var result2 = keysFunc(object);\n          return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object));\n        }\n        function baseGetTag(value) {\n          if (value == null) {\n            return value === undefined2 ? undefinedTag : nullTag;\n          }\n          return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString(value);\n        }\n        function baseGt(value, other) {\n          return value > other;\n        }\n        function baseHas(object, key) {\n          return object != null && hasOwnProperty.call(object, key);\n        }\n        function baseHasIn(object, key) {\n          return object != null && key in Object2(object);\n        }\n        function baseInRange(number, start, end) {\n          return number >= nativeMin(start, end) && number < nativeMax(start, end);\n        }\n        function baseIntersection(arrays, iteratee2, comparator) {\n          var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];\n          while (othIndex--) {\n            var array = arrays[othIndex];\n            if (othIndex && iteratee2) {\n              array = arrayMap(array, baseUnary(iteratee2));\n            }\n            maxLength = nativeMin(array.length, maxLength);\n            caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined2;\n          }\n          array = arrays[0];\n          var index = -1, seen = caches[0];\n          outer:\n            while (++index < length && result2.length < maxLength) {\n              var value = array[index], computed = iteratee2 ? iteratee2(value) : value;\n              value = comparator || value !== 0 ? value : 0;\n              if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) {\n                othIndex = othLength;\n                while (--othIndex) {\n                  var cache = caches[othIndex];\n                  if (!(cache ? cacheHas(cache, computed) : includes2(arrays[othIndex], computed, comparator))) {\n                    continue outer;\n                  }\n                }\n                if (seen) {\n                  seen.push(computed);\n                }\n                result2.push(value);\n              }\n            }\n          return result2;\n        }\n        function baseInverter(object, setter, iteratee2, accumulator) {\n          baseForOwn(object, function(value, key, object2) {\n            setter(accumulator, iteratee2(value), key, object2);\n          });\n          return accumulator;\n        }\n        function baseInvoke(object, path, args) {\n          path = castPath(path, object);\n          object = parent(object, path);\n          var func = object == null ? object : object[toKey(last(path))];\n          return func == null ? undefined2 : apply(func, object, args);\n        }\n        function baseIsArguments(value) {\n          return isObjectLike(value) && baseGetTag(value) == argsTag;\n        }\n        function baseIsArrayBuffer(value) {\n          return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n        }\n        function baseIsDate(value) {\n          return isObjectLike(value) && baseGetTag(value) == dateTag;\n        }\n        function baseIsEqual(value, other, bitmask, customizer, stack) {\n          if (value === other) {\n            return true;\n          }\n          if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {\n            return value !== value && other !== other;\n          }\n          return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n        }\n        function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n          var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);\n          objTag = objTag == argsTag ? objectTag : objTag;\n          othTag = othTag == argsTag ? objectTag : othTag;\n          var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;\n          if (isSameTag && isBuffer(object)) {\n            if (!isBuffer(other)) {\n              return false;\n            }\n            objIsArr = true;\n            objIsObj = false;\n          }\n          if (isSameTag && !objIsObj) {\n            stack || (stack = new Stack());\n            return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n          }\n          if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n            var objIsWrapped = objIsObj && hasOwnProperty.call(object, \"__wrapped__\"), othIsWrapped = othIsObj && hasOwnProperty.call(other, \"__wrapped__\");\n            if (objIsWrapped || othIsWrapped) {\n              var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;\n              stack || (stack = new Stack());\n              return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n            }\n          }\n          if (!isSameTag) {\n            return false;\n          }\n          stack || (stack = new Stack());\n          return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n        }\n        function baseIsMap(value) {\n          return isObjectLike(value) && getTag(value) == mapTag;\n        }\n        function baseIsMatch(object, source, matchData, customizer) {\n          var index = matchData.length, length = index, noCustomizer = !customizer;\n          if (object == null) {\n            return !length;\n          }\n          object = Object2(object);\n          while (index--) {\n            var data = matchData[index];\n            if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {\n              return false;\n            }\n          }\n          while (++index < length) {\n            data = matchData[index];\n            var key = data[0], objValue = object[key], srcValue = data[1];\n            if (noCustomizer && data[2]) {\n              if (objValue === undefined2 && !(key in object)) {\n                return false;\n              }\n            } else {\n              var stack = new Stack();\n              if (customizer) {\n                var result2 = customizer(objValue, srcValue, key, object, source, stack);\n              }\n              if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {\n                return false;\n              }\n            }\n          }\n          return true;\n        }\n        function baseIsNative(value) {\n          if (!isObject(value) || isMasked(value)) {\n            return false;\n          }\n          var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n          return pattern.test(toSource(value));\n        }\n        function baseIsRegExp(value) {\n          return isObjectLike(value) && baseGetTag(value) == regexpTag;\n        }\n        function baseIsSet(value) {\n          return isObjectLike(value) && getTag(value) == setTag;\n        }\n        function baseIsTypedArray(value) {\n          return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n        }\n        function baseIteratee(value) {\n          if (typeof value == \"function\") {\n            return value;\n          }\n          if (value == null) {\n            return identity;\n          }\n          if (typeof value == \"object\") {\n            return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);\n          }\n          return property(value);\n        }\n        function baseKeys(object) {\n          if (!isPrototype(object)) {\n            return nativeKeys(object);\n          }\n          var result2 = [];\n          for (var key in Object2(object)) {\n            if (hasOwnProperty.call(object, key) && key != \"constructor\") {\n              result2.push(key);\n            }\n          }\n          return result2;\n        }\n        function baseKeysIn(object) {\n          if (!isObject(object)) {\n            return nativeKeysIn(object);\n          }\n          var isProto = isPrototype(object), result2 = [];\n          for (var key in object) {\n            if (!(key == \"constructor\" && (isProto || !hasOwnProperty.call(object, key)))) {\n              result2.push(key);\n            }\n          }\n          return result2;\n        }\n        function baseLt(value, other) {\n          return value < other;\n        }\n        function baseMap(collection, iteratee2) {\n          var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];\n          baseEach(collection, function(value, key, collection2) {\n            result2[++index] = iteratee2(value, key, collection2);\n          });\n          return result2;\n        }\n        function baseMatches(source) {\n          var matchData = getMatchData(source);\n          if (matchData.length == 1 && matchData[0][2]) {\n            return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n          }\n          return function(object) {\n            return object === source || baseIsMatch(object, source, matchData);\n          };\n        }\n        function baseMatchesProperty(path, srcValue) {\n          if (isKey(path) && isStrictComparable(srcValue)) {\n            return matchesStrictComparable(toKey(path), srcValue);\n          }\n          return function(object) {\n            var objValue = get(object, path);\n            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n          };\n        }\n        function baseMerge(object, source, srcIndex, customizer, stack) {\n          if (object === source) {\n            return;\n          }\n          baseFor(source, function(srcValue, key) {\n            stack || (stack = new Stack());\n            if (isObject(srcValue)) {\n              baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n            } else {\n              var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + \"\", object, source, stack) : undefined2;\n              if (newValue === undefined2) {\n                newValue = srcValue;\n              }\n              assignMergeValue(object, key, newValue);\n            }\n          }, keysIn);\n        }\n        function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n          var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);\n          if (stacked) {\n            assignMergeValue(object, key, stacked);\n            return;\n          }\n          var newValue = customizer ? customizer(objValue, srcValue, key + \"\", object, source, stack) : undefined2;\n          var isCommon = newValue === undefined2;\n          if (isCommon) {\n            var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n            newValue = srcValue;\n            if (isArr || isBuff || isTyped) {\n              if (isArray(objValue)) {\n                newValue = objValue;\n              } else if (isArrayLikeObject(objValue)) {\n                newValue = copyArray(objValue);\n              } else if (isBuff) {\n                isCommon = false;\n                newValue = cloneBuffer(srcValue, true);\n              } else if (isTyped) {\n                isCommon = false;\n                newValue = cloneTypedArray(srcValue, true);\n              } else {\n                newValue = [];\n              }\n            } else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n              newValue = objValue;\n              if (isArguments(objValue)) {\n                newValue = toPlainObject(objValue);\n              } else if (!isObject(objValue) || isFunction(objValue)) {\n                newValue = initCloneObject(srcValue);\n              }\n            } else {\n              isCommon = false;\n            }\n          }\n          if (isCommon) {\n            stack.set(srcValue, newValue);\n            mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n            stack[\"delete\"](srcValue);\n          }\n          assignMergeValue(object, key, newValue);\n        }\n        function baseNth(array, n) {\n          var length = array.length;\n          if (!length) {\n            return;\n          }\n          n += n < 0 ? length : 0;\n          return isIndex(n, length) ? array[n] : undefined2;\n        }\n        function baseOrderBy(collection, iteratees, orders) {\n          if (iteratees.length) {\n            iteratees = arrayMap(iteratees, function(iteratee2) {\n              if (isArray(iteratee2)) {\n                return function(value) {\n                  return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);\n                };\n              }\n              return iteratee2;\n            });\n          } else {\n            iteratees = [identity];\n          }\n          var index = -1;\n          iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n          var result2 = baseMap(collection, function(value, key, collection2) {\n            var criteria = arrayMap(iteratees, function(iteratee2) {\n              return iteratee2(value);\n            });\n            return { \"criteria\": criteria, \"index\": ++index, \"value\": value };\n          });\n          return baseSortBy(result2, function(object, other) {\n            return compareMultiple(object, other, orders);\n          });\n        }\n        function basePick(object, paths) {\n          return basePickBy(object, paths, function(value, path) {\n            return hasIn(object, path);\n          });\n        }\n        function basePickBy(object, paths, predicate) {\n          var index = -1, length = paths.length, result2 = {};\n          while (++index < length) {\n            var path = paths[index], value = baseGet(object, path);\n            if (predicate(value, path)) {\n              baseSet(result2, castPath(path, object), value);\n            }\n          }\n          return result2;\n        }\n        function basePropertyDeep(path) {\n          return function(object) {\n            return baseGet(object, path);\n          };\n        }\n        function basePullAll(array, values2, iteratee2, comparator) {\n          var indexOf2 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array;\n          if (array === values2) {\n            values2 = copyArray(values2);\n          }\n          if (iteratee2) {\n            seen = arrayMap(array, baseUnary(iteratee2));\n          }\n          while (++index < length) {\n            var fromIndex = 0, value = values2[index], computed = iteratee2 ? iteratee2(value) : value;\n            while ((fromIndex = indexOf2(seen, computed, fromIndex, comparator)) > -1) {\n              if (seen !== array) {\n                splice.call(seen, fromIndex, 1);\n              }\n              splice.call(array, fromIndex, 1);\n            }\n          }\n          return array;\n        }\n        function basePullAt(array, indexes) {\n          var length = array ? indexes.length : 0, lastIndex = length - 1;\n          while (length--) {\n            var index = indexes[length];\n            if (length == lastIndex || index !== previous) {\n              var previous = index;\n              if (isIndex(index)) {\n                splice.call(array, index, 1);\n              } else {\n                baseUnset(array, index);\n              }\n            }\n          }\n          return array;\n        }\n        function baseRandom(lower, upper) {\n          return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n        }\n        function baseRange(start, end, step, fromRight) {\n          var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);\n          while (length--) {\n            result2[fromRight ? length : ++index] = start;\n            start += step;\n          }\n          return result2;\n        }\n        function baseRepeat(string, n) {\n          var result2 = \"\";\n          if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n            return result2;\n          }\n          do {\n            if (n % 2) {\n              result2 += string;\n            }\n            n = nativeFloor(n / 2);\n            if (n) {\n              string += string;\n            }\n          } while (n);\n          return result2;\n        }\n        function baseRest(func, start) {\n          return setToString(overRest(func, start, identity), func + \"\");\n        }\n        function baseSample(collection) {\n          return arraySample(values(collection));\n        }\n        function baseSampleSize(collection, n) {\n          var array = values(collection);\n          return shuffleSelf(array, baseClamp(n, 0, array.length));\n        }\n        function baseSet(object, path, value, customizer) {\n          if (!isObject(object)) {\n            return object;\n          }\n          path = castPath(path, object);\n          var index = -1, length = path.length, lastIndex = length - 1, nested = object;\n          while (nested != null && ++index < length) {\n            var key = toKey(path[index]), newValue = value;\n            if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n              return object;\n            }\n            if (index != lastIndex) {\n              var objValue = nested[key];\n              newValue = customizer ? customizer(objValue, key, nested) : undefined2;\n              if (newValue === undefined2) {\n                newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};\n              }\n            }\n            assignValue(nested, key, newValue);\n            nested = nested[key];\n          }\n          return object;\n        }\n        var baseSetData = !metaMap ? identity : function(func, data) {\n          metaMap.set(func, data);\n          return func;\n        };\n        var baseSetToString = !defineProperty ? identity : function(func, string) {\n          return defineProperty(func, \"toString\", {\n            \"configurable\": true,\n            \"enumerable\": false,\n            \"value\": constant(string),\n            \"writable\": true\n          });\n        };\n        function baseShuffle(collection) {\n          return shuffleSelf(values(collection));\n        }\n        function baseSlice(array, start, end) {\n          var index = -1, length = array.length;\n          if (start < 0) {\n            start = -start > length ? 0 : length + start;\n          }\n          end = end > length ? length : end;\n          if (end < 0) {\n            end += length;\n          }\n          length = start > end ? 0 : end - start >>> 0;\n          start >>>= 0;\n          var result2 = Array2(length);\n          while (++index < length) {\n            result2[index] = array[index + start];\n          }\n          return result2;\n        }\n        function baseSome(collection, predicate) {\n          var result2;\n          baseEach(collection, function(value, index, collection2) {\n            result2 = predicate(value, index, collection2);\n            return !result2;\n          });\n          return !!result2;\n        }\n        function baseSortedIndex(array, value, retHighest) {\n          var low = 0, high = array == null ? low : array.length;\n          if (typeof value == \"number\" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n            while (low < high) {\n              var mid = low + high >>> 1, computed = array[mid];\n              if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {\n                low = mid + 1;\n              } else {\n                high = mid;\n              }\n            }\n            return high;\n          }\n          return baseSortedIndexBy(array, value, identity, retHighest);\n        }\n        function baseSortedIndexBy(array, value, iteratee2, retHighest) {\n          var low = 0, high = array == null ? 0 : array.length;\n          if (high === 0) {\n            return 0;\n          }\n          value = iteratee2(value);\n          var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined2;\n          while (low < high) {\n            var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined2, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);\n            if (valIsNaN) {\n              var setLow = retHighest || othIsReflexive;\n            } else if (valIsUndefined) {\n              setLow = othIsReflexive && (retHighest || othIsDefined);\n            } else if (valIsNull) {\n              setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n            } else if (valIsSymbol) {\n              setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n            } else if (othIsNull || othIsSymbol) {\n              setLow = false;\n            } else {\n              setLow = retHighest ? computed <= value : computed < value;\n            }\n            if (setLow) {\n              low = mid + 1;\n            } else {\n              high = mid;\n            }\n          }\n          return nativeMin(high, MAX_ARRAY_INDEX);\n        }\n        function baseSortedUniq(array, iteratee2) {\n          var index = -1, length = array.length, resIndex = 0, result2 = [];\n          while (++index < length) {\n            var value = array[index], computed = iteratee2 ? iteratee2(value) : value;\n            if (!index || !eq(computed, seen)) {\n              var seen = computed;\n              result2[resIndex++] = value === 0 ? 0 : value;\n            }\n          }\n          return result2;\n        }\n        function baseToNumber(value) {\n          if (typeof value == \"number\") {\n            return value;\n          }\n          if (isSymbol(value)) {\n            return NAN;\n          }\n          return +value;\n        }\n        function baseToString(value) {\n          if (typeof value == \"string\") {\n            return value;\n          }\n          if (isArray(value)) {\n            return arrayMap(value, baseToString) + \"\";\n          }\n          if (isSymbol(value)) {\n            return symbolToString ? symbolToString.call(value) : \"\";\n          }\n          var result2 = value + \"\";\n          return result2 == \"0\" && 1 / value == -INFINITY ? \"-0\" : result2;\n        }\n        function baseUniq(array, iteratee2, comparator) {\n          var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;\n          if (comparator) {\n            isCommon = false;\n            includes2 = arrayIncludesWith;\n          } else if (length >= LARGE_ARRAY_SIZE) {\n            var set2 = iteratee2 ? null : createSet(array);\n            if (set2) {\n              return setToArray(set2);\n            }\n            isCommon = false;\n            includes2 = cacheHas;\n            seen = new SetCache();\n          } else {\n            seen = iteratee2 ? [] : result2;\n          }\n          outer:\n            while (++index < length) {\n              var value = array[index], computed = iteratee2 ? iteratee2(value) : value;\n              value = comparator || value !== 0 ? value : 0;\n              if (isCommon && computed === computed) {\n                var seenIndex = seen.length;\n                while (seenIndex--) {\n                  if (seen[seenIndex] === computed) {\n                    continue outer;\n                  }\n                }\n                if (iteratee2) {\n                  seen.push(computed);\n                }\n                result2.push(value);\n              } else if (!includes2(seen, computed, comparator)) {\n                if (seen !== result2) {\n                  seen.push(computed);\n                }\n                result2.push(value);\n              }\n            }\n          return result2;\n        }\n        function baseUnset(object, path) {\n          path = castPath(path, object);\n          object = parent(object, path);\n          return object == null || delete object[toKey(last(path))];\n        }\n        function baseUpdate(object, path, updater, customizer) {\n          return baseSet(object, path, updater(baseGet(object, path)), customizer);\n        }\n        function baseWhile(array, predicate, isDrop, fromRight) {\n          var length = array.length, index = fromRight ? length : -1;\n          while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {\n          }\n          return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);\n        }\n        function baseWrapperValue(value, actions) {\n          var result2 = value;\n          if (result2 instanceof LazyWrapper) {\n            result2 = result2.value();\n          }\n          return arrayReduce(actions, function(result3, action) {\n            return action.func.apply(action.thisArg, arrayPush([result3], action.args));\n          }, result2);\n        }\n        function baseXor(arrays, iteratee2, comparator) {\n          var length = arrays.length;\n          if (length < 2) {\n            return length ? baseUniq(arrays[0]) : [];\n          }\n          var index = -1, result2 = Array2(length);\n          while (++index < length) {\n            var array = arrays[index], othIndex = -1;\n            while (++othIndex < length) {\n              if (othIndex != index) {\n                result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator);\n              }\n            }\n          }\n          return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);\n        }\n        function baseZipObject(props, values2, assignFunc) {\n          var index = -1, length = props.length, valsLength = values2.length, result2 = {};\n          while (++index < length) {\n            var value = index < valsLength ? values2[index] : undefined2;\n            assignFunc(result2, props[index], value);\n          }\n          return result2;\n        }\n        function castArrayLikeObject(value) {\n          return isArrayLikeObject(value) ? value : [];\n        }\n        function castFunction(value) {\n          return typeof value == \"function\" ? value : identity;\n        }\n        function castPath(value, object) {\n          if (isArray(value)) {\n            return value;\n          }\n          return isKey(value, object) ? [value] : stringToPath(toString(value));\n        }\n        var castRest = baseRest;\n        function castSlice(array, start, end) {\n          var length = array.length;\n          end = end === undefined2 ? length : end;\n          return !start && end >= length ? array : baseSlice(array, start, end);\n        }\n        var clearTimeout = ctxClearTimeout || function(id) {\n          return root.clearTimeout(id);\n        };\n        function cloneBuffer(buffer, isDeep) {\n          if (isDeep) {\n            return buffer.slice();\n          }\n          var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n          buffer.copy(result2);\n          return result2;\n        }\n        function cloneArrayBuffer(arrayBuffer) {\n          var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);\n          new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer));\n          return result2;\n        }\n        function cloneDataView(dataView, isDeep) {\n          var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n          return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n        }\n        function cloneRegExp(regexp) {\n          var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n          result2.lastIndex = regexp.lastIndex;\n          return result2;\n        }\n        function cloneSymbol(symbol) {\n          return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};\n        }\n        function cloneTypedArray(typedArray, isDeep) {\n          var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n          return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n        }\n        function compareAscending(value, other) {\n          if (value !== other) {\n            var valIsDefined = value !== undefined2, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);\n            var othIsDefined = other !== undefined2, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);\n            if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {\n              return 1;\n            }\n            if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {\n              return -1;\n            }\n          }\n          return 0;\n        }\n        function compareMultiple(object, other, orders) {\n          var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;\n          while (++index < length) {\n            var result2 = compareAscending(objCriteria[index], othCriteria[index]);\n            if (result2) {\n              if (index >= ordersLength) {\n                return result2;\n              }\n              var order = orders[index];\n              return result2 * (order == \"desc\" ? -1 : 1);\n            }\n          }\n          return object.index - other.index;\n        }\n        function composeArgs(args, partials, holders, isCurried) {\n          var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;\n          while (++leftIndex < leftLength) {\n            result2[leftIndex] = partials[leftIndex];\n          }\n          while (++argsIndex < holdersLength) {\n            if (isUncurried || argsIndex < argsLength) {\n              result2[holders[argsIndex]] = args[argsIndex];\n            }\n          }\n          while (rangeLength--) {\n            result2[leftIndex++] = args[argsIndex++];\n          }\n          return result2;\n        }\n        function composeArgsRight(args, partials, holders, isCurried) {\n          var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;\n          while (++argsIndex < rangeLength) {\n            result2[argsIndex] = args[argsIndex];\n          }\n          var offset = argsIndex;\n          while (++rightIndex < rightLength) {\n            result2[offset + rightIndex] = partials[rightIndex];\n          }\n          while (++holdersIndex < holdersLength) {\n            if (isUncurried || argsIndex < argsLength) {\n              result2[offset + holders[holdersIndex]] = args[argsIndex++];\n            }\n          }\n          return result2;\n        }\n        function copyArray(source, array) {\n          var index = -1, length = source.length;\n          array || (array = Array2(length));\n          while (++index < length) {\n            array[index] = source[index];\n          }\n          return array;\n        }\n        function copyObject(source, props, object, customizer) {\n          var isNew = !object;\n          object || (object = {});\n          var index = -1, length = props.length;\n          while (++index < length) {\n            var key = props[index];\n            var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined2;\n            if (newValue === undefined2) {\n              newValue = source[key];\n            }\n            if (isNew) {\n              baseAssignValue(object, key, newValue);\n            } else {\n              assignValue(object, key, newValue);\n            }\n          }\n          return object;\n        }\n        function copySymbols(source, object) {\n          return copyObject(source, getSymbols(source), object);\n        }\n        function copySymbolsIn(source, object) {\n          return copyObject(source, getSymbolsIn(source), object);\n        }\n        function createAggregator(setter, initializer) {\n          return function(collection, iteratee2) {\n            var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};\n            return func(collection, setter, getIteratee(iteratee2, 2), accumulator);\n          };\n        }\n        function createAssigner(assigner) {\n          return baseRest(function(object, sources) {\n            var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined2, guard = length > 2 ? sources[2] : undefined2;\n            customizer = assigner.length > 3 && typeof customizer == \"function\" ? (length--, customizer) : undefined2;\n            if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n              customizer = length < 3 ? undefined2 : customizer;\n              length = 1;\n            }\n            object = Object2(object);\n            while (++index < length) {\n              var source = sources[index];\n              if (source) {\n                assigner(object, source, index, customizer);\n              }\n            }\n            return object;\n          });\n        }\n        function createBaseEach(eachFunc, fromRight) {\n          return function(collection, iteratee2) {\n            if (collection == null) {\n              return collection;\n            }\n            if (!isArrayLike(collection)) {\n              return eachFunc(collection, iteratee2);\n            }\n            var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection);\n            while (fromRight ? index-- : ++index < length) {\n              if (iteratee2(iterable[index], index, iterable) === false) {\n                break;\n              }\n            }\n            return collection;\n          };\n        }\n        function createBaseFor(fromRight) {\n          return function(object, iteratee2, keysFunc) {\n            var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;\n            while (length--) {\n              var key = props[fromRight ? length : ++index];\n              if (iteratee2(iterable[key], key, iterable) === false) {\n                break;\n              }\n            }\n            return object;\n          };\n        }\n        function createBind(func, bitmask, thisArg) {\n          var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);\n          function wrapper() {\n            var fn = this && this !== root && this instanceof wrapper ? Ctor : func;\n            return fn.apply(isBind ? thisArg : this, arguments);\n          }\n          return wrapper;\n        }\n        function createCaseFirst(methodName) {\n          return function(string) {\n            string = toString(string);\n            var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined2;\n            var chr = strSymbols ? strSymbols[0] : string.charAt(0);\n            var trailing = strSymbols ? castSlice(strSymbols, 1).join(\"\") : string.slice(1);\n            return chr[methodName]() + trailing;\n          };\n        }\n        function createCompounder(callback) {\n          return function(string) {\n            return arrayReduce(words(deburr(string).replace(reApos, \"\")), callback, \"\");\n          };\n        }\n        function createCtor(Ctor) {\n          return function() {\n            var args = arguments;\n            switch (args.length) {\n              case 0:\n                return new Ctor();\n              case 1:\n                return new Ctor(args[0]);\n              case 2:\n                return new Ctor(args[0], args[1]);\n              case 3:\n                return new Ctor(args[0], args[1], args[2]);\n              case 4:\n                return new Ctor(args[0], args[1], args[2], args[3]);\n              case 5:\n                return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n              case 6:\n                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n              case 7:\n                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n            }\n            var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);\n            return isObject(result2) ? result2 : thisBinding;\n          };\n        }\n        function createCurry(func, bitmask, arity) {\n          var Ctor = createCtor(func);\n          function wrapper() {\n            var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper);\n            while (index--) {\n              args[index] = arguments[index];\n            }\n            var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);\n            length -= holders.length;\n            if (length < arity) {\n              return createRecurry(\n                func,\n                bitmask,\n                createHybrid,\n                wrapper.placeholder,\n                undefined2,\n                args,\n                holders,\n                undefined2,\n                undefined2,\n                arity - length\n              );\n            }\n            var fn = this && this !== root && this instanceof wrapper ? Ctor : func;\n            return apply(fn, this, args);\n          }\n          return wrapper;\n        }\n        function createFind(findIndexFunc) {\n          return function(collection, predicate, fromIndex) {\n            var iterable = Object2(collection);\n            if (!isArrayLike(collection)) {\n              var iteratee2 = getIteratee(predicate, 3);\n              collection = keys(collection);\n              predicate = function(key) {\n                return iteratee2(iterable[key], key, iterable);\n              };\n            }\n            var index = findIndexFunc(collection, predicate, fromIndex);\n            return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2;\n          };\n        }\n        function createFlow(fromRight) {\n          return flatRest(function(funcs) {\n            var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;\n            if (fromRight) {\n              funcs.reverse();\n            }\n            while (index--) {\n              var func = funcs[index];\n              if (typeof func != \"function\") {\n                throw new TypeError2(FUNC_ERROR_TEXT);\n              }\n              if (prereq && !wrapper && getFuncName(func) == \"wrapper\") {\n                var wrapper = new LodashWrapper([], true);\n              }\n            }\n            index = wrapper ? index : length;\n            while (++index < length) {\n              func = funcs[index];\n              var funcName = getFuncName(func), data = funcName == \"wrapper\" ? getData(func) : undefined2;\n              if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) {\n                wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n              } else {\n                wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);\n              }\n            }\n            return function() {\n              var args = arguments, value = args[0];\n              if (wrapper && args.length == 1 && isArray(value)) {\n                return wrapper.plant(value).value();\n              }\n              var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value;\n              while (++index2 < length) {\n                result2 = funcs[index2].call(this, result2);\n              }\n              return result2;\n            };\n          });\n        }\n        function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {\n          var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined2 : createCtor(func);\n          function wrapper() {\n            var length = arguments.length, args = Array2(length), index = length;\n            while (index--) {\n              args[index] = arguments[index];\n            }\n            if (isCurried) {\n              var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);\n            }\n            if (partials) {\n              args = composeArgs(args, partials, holders, isCurried);\n            }\n            if (partialsRight) {\n              args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n            }\n            length -= holdersCount;\n            if (isCurried && length < arity) {\n              var newHolders = replaceHolders(args, placeholder);\n              return createRecurry(\n                func,\n                bitmask,\n                createHybrid,\n                wrapper.placeholder,\n                thisArg,\n                args,\n                newHolders,\n                argPos,\n                ary2,\n                arity - length\n              );\n            }\n            var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;\n            length = args.length;\n            if (argPos) {\n              args = reorder(args, argPos);\n            } else if (isFlip && length > 1) {\n              args.reverse();\n            }\n            if (isAry && ary2 < length) {\n              args.length = ary2;\n            }\n            if (this && this !== root && this instanceof wrapper) {\n              fn = Ctor || createCtor(fn);\n            }\n            return fn.apply(thisBinding, args);\n          }\n          return wrapper;\n        }\n        function createInverter(setter, toIteratee) {\n          return function(object, iteratee2) {\n            return baseInverter(object, setter, toIteratee(iteratee2), {});\n          };\n        }\n        function createMathOperation(operator, defaultValue) {\n          return function(value, other) {\n            var result2;\n            if (value === undefined2 && other === undefined2) {\n              return defaultValue;\n            }\n            if (value !== undefined2) {\n              result2 = value;\n            }\n            if (other !== undefined2) {\n              if (result2 === undefined2) {\n                return other;\n              }\n              if (typeof value == \"string\" || typeof other == \"string\") {\n                value = baseToString(value);\n                other = baseToString(other);\n              } else {\n                value = baseToNumber(value);\n                other = baseToNumber(other);\n              }\n              result2 = operator(value, other);\n            }\n            return result2;\n          };\n        }\n        function createOver(arrayFunc) {\n          return flatRest(function(iteratees) {\n            iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n            return baseRest(function(args) {\n              var thisArg = this;\n              return arrayFunc(iteratees, function(iteratee2) {\n                return apply(iteratee2, thisArg, args);\n              });\n            });\n          });\n        }\n        function createPadding(length, chars) {\n          chars = chars === undefined2 ? \" \" : baseToString(chars);\n          var charsLength = chars.length;\n          if (charsLength < 2) {\n            return charsLength ? baseRepeat(chars, length) : chars;\n          }\n          var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n          return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join(\"\") : result2.slice(0, length);\n        }\n        function createPartial(func, bitmask, thisArg, partials) {\n          var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);\n          function wrapper() {\n            var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;\n            while (++leftIndex < leftLength) {\n              args[leftIndex] = partials[leftIndex];\n            }\n            while (argsLength--) {\n              args[leftIndex++] = arguments[++argsIndex];\n            }\n            return apply(fn, isBind ? thisArg : this, args);\n          }\n          return wrapper;\n        }\n        function createRange(fromRight) {\n          return function(start, end, step) {\n            if (step && typeof step != \"number\" && isIterateeCall(start, end, step)) {\n              end = step = undefined2;\n            }\n            start = toFinite(start);\n            if (end === undefined2) {\n              end = start;\n              start = 0;\n            } else {\n              end = toFinite(end);\n            }\n            step = step === undefined2 ? start < end ? 1 : -1 : toFinite(step);\n            return baseRange(start, end, step, fromRight);\n          };\n        }\n        function createRelationalOperation(operator) {\n          return function(value, other) {\n            if (!(typeof value == \"string\" && typeof other == \"string\")) {\n              value = toNumber(value);\n              other = toNumber(other);\n            }\n            return operator(value, other);\n          };\n        }\n        function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {\n          var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined2, newHoldersRight = isCurry ? undefined2 : holders, newPartials = isCurry ? partials : undefined2, newPartialsRight = isCurry ? undefined2 : partials;\n          bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;\n          bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n          if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n            bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n          }\n          var newData = [\n            func,\n            bitmask,\n            thisArg,\n            newPartials,\n            newHolders,\n            newPartialsRight,\n            newHoldersRight,\n            argPos,\n            ary2,\n            arity\n          ];\n          var result2 = wrapFunc.apply(undefined2, newData);\n          if (isLaziable(func)) {\n            setData(result2, newData);\n          }\n          result2.placeholder = placeholder;\n          return setWrapToString(result2, func, bitmask);\n        }\n        function createRound(methodName) {\n          var func = Math2[methodName];\n          return function(number, precision) {\n            number = toNumber(number);\n            precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n            if (precision && nativeIsFinite(number)) {\n              var pair = (toString(number) + \"e\").split(\"e\"), value = func(pair[0] + \"e\" + (+pair[1] + precision));\n              pair = (toString(value) + \"e\").split(\"e\");\n              return +(pair[0] + \"e\" + (+pair[1] - precision));\n            }\n            return func(number);\n          };\n        }\n        var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values2) {\n          return new Set2(values2);\n        };\n        function createToPairs(keysFunc) {\n          return function(object) {\n            var tag = getTag(object);\n            if (tag == mapTag) {\n              return mapToArray(object);\n            }\n            if (tag == setTag) {\n              return setToPairs(object);\n            }\n            return baseToPairs(object, keysFunc(object));\n          };\n        }\n        function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {\n          var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n          if (!isBindKey && typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          var length = partials ? partials.length : 0;\n          if (!length) {\n            bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n            partials = holders = undefined2;\n          }\n          ary2 = ary2 === undefined2 ? ary2 : nativeMax(toInteger(ary2), 0);\n          arity = arity === undefined2 ? arity : toInteger(arity);\n          length -= holders ? holders.length : 0;\n          if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n            var partialsRight = partials, holdersRight = holders;\n            partials = holders = undefined2;\n          }\n          var data = isBindKey ? undefined2 : getData(func);\n          var newData = [\n            func,\n            bitmask,\n            thisArg,\n            partials,\n            holders,\n            partialsRight,\n            holdersRight,\n            argPos,\n            ary2,\n            arity\n          ];\n          if (data) {\n            mergeData(newData, data);\n          }\n          func = newData[0];\n          bitmask = newData[1];\n          thisArg = newData[2];\n          partials = newData[3];\n          holders = newData[4];\n          arity = newData[9] = newData[9] === undefined2 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);\n          if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n            bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n          }\n          if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n            var result2 = createBind(func, bitmask, thisArg);\n          } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n            result2 = createCurry(func, bitmask, arity);\n          } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n            result2 = createPartial(func, bitmask, thisArg, partials);\n          } else {\n            result2 = createHybrid.apply(undefined2, newData);\n          }\n          var setter = data ? baseSetData : setData;\n          return setWrapToString(setter(result2, newData), func, bitmask);\n        }\n        function customDefaultsAssignIn(objValue, srcValue, key, object) {\n          if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key)) {\n            return srcValue;\n          }\n          return objValue;\n        }\n        function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n          if (isObject(objValue) && isObject(srcValue)) {\n            stack.set(srcValue, objValue);\n            baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);\n            stack[\"delete\"](srcValue);\n          }\n          return objValue;\n        }\n        function customOmitClone(value) {\n          return isPlainObject(value) ? undefined2 : value;\n        }\n        function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;\n          if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n            return false;\n          }\n          var arrStacked = stack.get(array);\n          var othStacked = stack.get(other);\n          if (arrStacked && othStacked) {\n            return arrStacked == other && othStacked == array;\n          }\n          var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined2;\n          stack.set(array, other);\n          stack.set(other, array);\n          while (++index < arrLength) {\n            var arrValue = array[index], othValue = other[index];\n            if (customizer) {\n              var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);\n            }\n            if (compared !== undefined2) {\n              if (compared) {\n                continue;\n              }\n              result2 = false;\n              break;\n            }\n            if (seen) {\n              if (!arraySome(other, function(othValue2, othIndex) {\n                if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {\n                  return seen.push(othIndex);\n                }\n              })) {\n                result2 = false;\n                break;\n              }\n            } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              result2 = false;\n              break;\n            }\n          }\n          stack[\"delete\"](array);\n          stack[\"delete\"](other);\n          return result2;\n        }\n        function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n          switch (tag) {\n            case dataViewTag:\n              if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {\n                return false;\n              }\n              object = object.buffer;\n              other = other.buffer;\n            case arrayBufferTag:\n              if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {\n                return false;\n              }\n              return true;\n            case boolTag:\n            case dateTag:\n            case numberTag:\n              return eq(+object, +other);\n            case errorTag:\n              return object.name == other.name && object.message == other.message;\n            case regexpTag:\n            case stringTag:\n              return object == other + \"\";\n            case mapTag:\n              var convert = mapToArray;\n            case setTag:\n              var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n              convert || (convert = setToArray);\n              if (object.size != other.size && !isPartial) {\n                return false;\n              }\n              var stacked = stack.get(object);\n              if (stacked) {\n                return stacked == other;\n              }\n              bitmask |= COMPARE_UNORDERED_FLAG;\n              stack.set(object, other);\n              var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n              stack[\"delete\"](object);\n              return result2;\n            case symbolTag:\n              if (symbolValueOf) {\n                return symbolValueOf.call(object) == symbolValueOf.call(other);\n              }\n          }\n          return false;\n        }\n        function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n          var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;\n          if (objLength != othLength && !isPartial) {\n            return false;\n          }\n          var index = objLength;\n          while (index--) {\n            var key = objProps[index];\n            if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n              return false;\n            }\n          }\n          var objStacked = stack.get(object);\n          var othStacked = stack.get(other);\n          if (objStacked && othStacked) {\n            return objStacked == other && othStacked == object;\n          }\n          var result2 = true;\n          stack.set(object, other);\n          stack.set(other, object);\n          var skipCtor = isPartial;\n          while (++index < objLength) {\n            key = objProps[index];\n            var objValue = object[key], othValue = other[key];\n            if (customizer) {\n              var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);\n            }\n            if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {\n              result2 = false;\n              break;\n            }\n            skipCtor || (skipCtor = key == \"constructor\");\n          }\n          if (result2 && !skipCtor) {\n            var objCtor = object.constructor, othCtor = other.constructor;\n            if (objCtor != othCtor && (\"constructor\" in object && \"constructor\" in other) && !(typeof objCtor == \"function\" && objCtor instanceof objCtor && typeof othCtor == \"function\" && othCtor instanceof othCtor)) {\n              result2 = false;\n            }\n          }\n          stack[\"delete\"](object);\n          stack[\"delete\"](other);\n          return result2;\n        }\n        function flatRest(func) {\n          return setToString(overRest(func, undefined2, flatten), func + \"\");\n        }\n        function getAllKeys(object) {\n          return baseGetAllKeys(object, keys, getSymbols);\n        }\n        function getAllKeysIn(object) {\n          return baseGetAllKeys(object, keysIn, getSymbolsIn);\n        }\n        var getData = !metaMap ? noop : function(func) {\n          return metaMap.get(func);\n        };\n        function getFuncName(func) {\n          var result2 = func.name + \"\", array = realNames[result2], length = hasOwnProperty.call(realNames, result2) ? array.length : 0;\n          while (length--) {\n            var data = array[length], otherFunc = data.func;\n            if (otherFunc == null || otherFunc == func) {\n              return data.name;\n            }\n          }\n          return result2;\n        }\n        function getHolder(func) {\n          var object = hasOwnProperty.call(lodash, \"placeholder\") ? lodash : func;\n          return object.placeholder;\n        }\n        function getIteratee() {\n          var result2 = lodash.iteratee || iteratee;\n          result2 = result2 === iteratee ? baseIteratee : result2;\n          return arguments.length ? result2(arguments[0], arguments[1]) : result2;\n        }\n        function getMapData(map2, key) {\n          var data = map2.__data__;\n          return isKeyable(key) ? data[typeof key == \"string\" ? \"string\" : \"hash\"] : data.map;\n        }\n        function getMatchData(object) {\n          var result2 = keys(object), length = result2.length;\n          while (length--) {\n            var key = result2[length], value = object[key];\n            result2[length] = [key, value, isStrictComparable(value)];\n          }\n          return result2;\n        }\n        function getNative(object, key) {\n          var value = getValue(object, key);\n          return baseIsNative(value) ? value : undefined2;\n        }\n        function getRawTag(value) {\n          var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];\n          try {\n            value[symToStringTag] = undefined2;\n            var unmasked = true;\n          } catch (e) {\n          }\n          var result2 = nativeObjectToString.call(value);\n          if (unmasked) {\n            if (isOwn) {\n              value[symToStringTag] = tag;\n            } else {\n              delete value[symToStringTag];\n            }\n          }\n          return result2;\n        }\n        var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n          if (object == null) {\n            return [];\n          }\n          object = Object2(object);\n          return arrayFilter(nativeGetSymbols(object), function(symbol) {\n            return propertyIsEnumerable.call(object, symbol);\n          });\n        };\n        var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n          var result2 = [];\n          while (object) {\n            arrayPush(result2, getSymbols(object));\n            object = getPrototype(object);\n          }\n          return result2;\n        };\n        var getTag = baseGetTag;\n        if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {\n          getTag = function(value) {\n            var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : \"\";\n            if (ctorString) {\n              switch (ctorString) {\n                case dataViewCtorString:\n                  return dataViewTag;\n                case mapCtorString:\n                  return mapTag;\n                case promiseCtorString:\n                  return promiseTag;\n                case setCtorString:\n                  return setTag;\n                case weakMapCtorString:\n                  return weakMapTag;\n              }\n            }\n            return result2;\n          };\n        }\n        function getView(start, end, transforms) {\n          var index = -1, length = transforms.length;\n          while (++index < length) {\n            var data = transforms[index], size2 = data.size;\n            switch (data.type) {\n              case \"drop\":\n                start += size2;\n                break;\n              case \"dropRight\":\n                end -= size2;\n                break;\n              case \"take\":\n                end = nativeMin(end, start + size2);\n                break;\n              case \"takeRight\":\n                start = nativeMax(start, end - size2);\n                break;\n            }\n          }\n          return { \"start\": start, \"end\": end };\n        }\n        function getWrapDetails(source) {\n          var match = source.match(reWrapDetails);\n          return match ? match[1].split(reSplitDetails) : [];\n        }\n        function hasPath(object, path, hasFunc) {\n          path = castPath(path, object);\n          var index = -1, length = path.length, result2 = false;\n          while (++index < length) {\n            var key = toKey(path[index]);\n            if (!(result2 = object != null && hasFunc(object, key))) {\n              break;\n            }\n            object = object[key];\n          }\n          if (result2 || ++index != length) {\n            return result2;\n          }\n          length = object == null ? 0 : object.length;\n          return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));\n        }\n        function initCloneArray(array) {\n          var length = array.length, result2 = new array.constructor(length);\n          if (length && typeof array[0] == \"string\" && hasOwnProperty.call(array, \"index\")) {\n            result2.index = array.index;\n            result2.input = array.input;\n          }\n          return result2;\n        }\n        function initCloneObject(object) {\n          return typeof object.constructor == \"function\" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};\n        }\n        function initCloneByTag(object, tag, isDeep) {\n          var Ctor = object.constructor;\n          switch (tag) {\n            case arrayBufferTag:\n              return cloneArrayBuffer(object);\n            case boolTag:\n            case dateTag:\n              return new Ctor(+object);\n            case dataViewTag:\n              return cloneDataView(object, isDeep);\n            case float32Tag:\n            case float64Tag:\n            case int8Tag:\n            case int16Tag:\n            case int32Tag:\n            case uint8Tag:\n            case uint8ClampedTag:\n            case uint16Tag:\n            case uint32Tag:\n              return cloneTypedArray(object, isDeep);\n            case mapTag:\n              return new Ctor();\n            case numberTag:\n            case stringTag:\n              return new Ctor(object);\n            case regexpTag:\n              return cloneRegExp(object);\n            case setTag:\n              return new Ctor();\n            case symbolTag:\n              return cloneSymbol(object);\n          }\n        }\n        function insertWrapDetails(source, details) {\n          var length = details.length;\n          if (!length) {\n            return source;\n          }\n          var lastIndex = length - 1;\n          details[lastIndex] = (length > 1 ? \"& \" : \"\") + details[lastIndex];\n          details = details.join(length > 2 ? \", \" : \" \");\n          return source.replace(reWrapComment, \"{\\n/* [wrapped with \" + details + \"] */\\n\");\n        }\n        function isFlattenable(value) {\n          return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);\n        }\n        function isIndex(value, length) {\n          var type = typeof value;\n          length = length == null ? MAX_SAFE_INTEGER : length;\n          return !!length && (type == \"number\" || type != \"symbol\" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);\n        }\n        function isIterateeCall(value, index, object) {\n          if (!isObject(object)) {\n            return false;\n          }\n          var type = typeof index;\n          if (type == \"number\" ? isArrayLike(object) && isIndex(index, object.length) : type == \"string\" && index in object) {\n            return eq(object[index], value);\n          }\n          return false;\n        }\n        function isKey(value, object) {\n          if (isArray(value)) {\n            return false;\n          }\n          var type = typeof value;\n          if (type == \"number\" || type == \"symbol\" || type == \"boolean\" || value == null || isSymbol(value)) {\n            return true;\n          }\n          return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object);\n        }\n        function isKeyable(value) {\n          var type = typeof value;\n          return type == \"string\" || type == \"number\" || type == \"symbol\" || type == \"boolean\" ? value !== \"__proto__\" : value === null;\n        }\n        function isLaziable(func) {\n          var funcName = getFuncName(func), other = lodash[funcName];\n          if (typeof other != \"function\" || !(funcName in LazyWrapper.prototype)) {\n            return false;\n          }\n          if (func === other) {\n            return true;\n          }\n          var data = getData(other);\n          return !!data && func === data[0];\n        }\n        function isMasked(func) {\n          return !!maskSrcKey && maskSrcKey in func;\n        }\n        var isMaskable = coreJsData ? isFunction : stubFalse;\n        function isPrototype(value) {\n          var Ctor = value && value.constructor, proto = typeof Ctor == \"function\" && Ctor.prototype || objectProto;\n          return value === proto;\n        }\n        function isStrictComparable(value) {\n          return value === value && !isObject(value);\n        }\n        function matchesStrictComparable(key, srcValue) {\n          return function(object) {\n            if (object == null) {\n              return false;\n            }\n            return object[key] === srcValue && (srcValue !== undefined2 || key in Object2(object));\n          };\n        }\n        function memoizeCapped(func) {\n          var result2 = memoize(func, function(key) {\n            if (cache.size === MAX_MEMOIZE_SIZE) {\n              cache.clear();\n            }\n            return key;\n          });\n          var cache = result2.cache;\n          return result2;\n        }\n        function mergeData(data, source) {\n          var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n          var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;\n          if (!(isCommon || isCombo)) {\n            return data;\n          }\n          if (srcBitmask & WRAP_BIND_FLAG) {\n            data[2] = source[2];\n            newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n          }\n          var value = source[3];\n          if (value) {\n            var partials = data[3];\n            data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n            data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n          }\n          value = source[5];\n          if (value) {\n            partials = data[5];\n            data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n            data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n          }\n          value = source[7];\n          if (value) {\n            data[7] = value;\n          }\n          if (srcBitmask & WRAP_ARY_FLAG) {\n            data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n          }\n          if (data[9] == null) {\n            data[9] = source[9];\n          }\n          data[0] = source[0];\n          data[1] = newBitmask;\n          return data;\n        }\n        function nativeKeysIn(object) {\n          var result2 = [];\n          if (object != null) {\n            for (var key in Object2(object)) {\n              result2.push(key);\n            }\n          }\n          return result2;\n        }\n        function objectToString(value) {\n          return nativeObjectToString.call(value);\n        }\n        function overRest(func, start, transform2) {\n          start = nativeMax(start === undefined2 ? func.length - 1 : start, 0);\n          return function() {\n            var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length);\n            while (++index < length) {\n              array[index] = args[start + index];\n            }\n            index = -1;\n            var otherArgs = Array2(start + 1);\n            while (++index < start) {\n              otherArgs[index] = args[index];\n            }\n            otherArgs[start] = transform2(array);\n            return apply(func, this, otherArgs);\n          };\n        }\n        function parent(object, path) {\n          return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n        }\n        function reorder(array, indexes) {\n          var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);\n          while (length--) {\n            var index = indexes[length];\n            array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined2;\n          }\n          return array;\n        }\n        function safeGet(object, key) {\n          if (key === \"constructor\" && typeof object[key] === \"function\") {\n            return;\n          }\n          if (key == \"__proto__\") {\n            return;\n          }\n          return object[key];\n        }\n        var setData = shortOut(baseSetData);\n        var setTimeout = ctxSetTimeout || function(func, wait) {\n          return root.setTimeout(func, wait);\n        };\n        var setToString = shortOut(baseSetToString);\n        function setWrapToString(wrapper, reference, bitmask) {\n          var source = reference + \"\";\n          return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n        }\n        function shortOut(func) {\n          var count = 0, lastCalled = 0;\n          return function() {\n            var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);\n            lastCalled = stamp;\n            if (remaining > 0) {\n              if (++count >= HOT_COUNT) {\n                return arguments[0];\n              }\n            } else {\n              count = 0;\n            }\n            return func.apply(undefined2, arguments);\n          };\n        }\n        function shuffleSelf(array, size2) {\n          var index = -1, length = array.length, lastIndex = length - 1;\n          size2 = size2 === undefined2 ? length : size2;\n          while (++index < size2) {\n            var rand = baseRandom(index, lastIndex), value = array[rand];\n            array[rand] = array[index];\n            array[index] = value;\n          }\n          array.length = size2;\n          return array;\n        }\n        var stringToPath = memoizeCapped(function(string) {\n          var result2 = [];\n          if (string.charCodeAt(0) === 46) {\n            result2.push(\"\");\n          }\n          string.replace(rePropName, function(match, number, quote, subString) {\n            result2.push(quote ? subString.replace(reEscapeChar, \"$1\") : number || match);\n          });\n          return result2;\n        });\n        function toKey(value) {\n          if (typeof value == \"string\" || isSymbol(value)) {\n            return value;\n          }\n          var result2 = value + \"\";\n          return result2 == \"0\" && 1 / value == -INFINITY ? \"-0\" : result2;\n        }\n        function toSource(func) {\n          if (func != null) {\n            try {\n              return funcToString.call(func);\n            } catch (e) {\n            }\n            try {\n              return func + \"\";\n            } catch (e) {\n            }\n          }\n          return \"\";\n        }\n        function updateWrapDetails(details, bitmask) {\n          arrayEach(wrapFlags, function(pair) {\n            var value = \"_.\" + pair[0];\n            if (bitmask & pair[1] && !arrayIncludes(details, value)) {\n              details.push(value);\n            }\n          });\n          return details.sort();\n        }\n        function wrapperClone(wrapper) {\n          if (wrapper instanceof LazyWrapper) {\n            return wrapper.clone();\n          }\n          var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n          result2.__actions__ = copyArray(wrapper.__actions__);\n          result2.__index__ = wrapper.__index__;\n          result2.__values__ = wrapper.__values__;\n          return result2;\n        }\n        function chunk(array, size2, guard) {\n          if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined2) {\n            size2 = 1;\n          } else {\n            size2 = nativeMax(toInteger(size2), 0);\n          }\n          var length = array == null ? 0 : array.length;\n          if (!length || size2 < 1) {\n            return [];\n          }\n          var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2));\n          while (index < length) {\n            result2[resIndex++] = baseSlice(array, index, index += size2);\n          }\n          return result2;\n        }\n        function compact(array) {\n          var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];\n          while (++index < length) {\n            var value = array[index];\n            if (value) {\n              result2[resIndex++] = value;\n            }\n          }\n          return result2;\n        }\n        function concat() {\n          var length = arguments.length;\n          if (!length) {\n            return [];\n          }\n          var args = Array2(length - 1), array = arguments[0], index = length;\n          while (index--) {\n            args[index - 1] = arguments[index];\n          }\n          return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n        }\n        var difference = baseRest(function(array, values2) {\n          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];\n        });\n        var differenceBy = baseRest(function(array, values2) {\n          var iteratee2 = last(values2);\n          if (isArrayLikeObject(iteratee2)) {\n            iteratee2 = undefined2;\n          }\n          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];\n        });\n        var differenceWith = baseRest(function(array, values2) {\n          var comparator = last(values2);\n          if (isArrayLikeObject(comparator)) {\n            comparator = undefined2;\n          }\n          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined2, comparator) : [];\n        });\n        function drop(array, n, guard) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          n = guard || n === undefined2 ? 1 : toInteger(n);\n          return baseSlice(array, n < 0 ? 0 : n, length);\n        }\n        function dropRight(array, n, guard) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          n = guard || n === undefined2 ? 1 : toInteger(n);\n          n = length - n;\n          return baseSlice(array, 0, n < 0 ? 0 : n);\n        }\n        function dropRightWhile(array, predicate) {\n          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];\n        }\n        function dropWhile(array, predicate) {\n          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];\n        }\n        function fill(array, value, start, end) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          if (start && typeof start != \"number\" && isIterateeCall(array, value, start)) {\n            start = 0;\n            end = length;\n          }\n          return baseFill(array, value, start, end);\n        }\n        function findIndex(array, predicate, fromIndex) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return -1;\n          }\n          var index = fromIndex == null ? 0 : toInteger(fromIndex);\n          if (index < 0) {\n            index = nativeMax(length + index, 0);\n          }\n          return baseFindIndex(array, getIteratee(predicate, 3), index);\n        }\n        function findLastIndex(array, predicate, fromIndex) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return -1;\n          }\n          var index = length - 1;\n          if (fromIndex !== undefined2) {\n            index = toInteger(fromIndex);\n            index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n          }\n          return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n        }\n        function flatten(array) {\n          var length = array == null ? 0 : array.length;\n          return length ? baseFlatten(array, 1) : [];\n        }\n        function flattenDeep(array) {\n          var length = array == null ? 0 : array.length;\n          return length ? baseFlatten(array, INFINITY) : [];\n        }\n        function flattenDepth(array, depth) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          depth = depth === undefined2 ? 1 : toInteger(depth);\n          return baseFlatten(array, depth);\n        }\n        function fromPairs(pairs) {\n          var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};\n          while (++index < length) {\n            var pair = pairs[index];\n            result2[pair[0]] = pair[1];\n          }\n          return result2;\n        }\n        function head(array) {\n          return array && array.length ? array[0] : undefined2;\n        }\n        function indexOf(array, value, fromIndex) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return -1;\n          }\n          var index = fromIndex == null ? 0 : toInteger(fromIndex);\n          if (index < 0) {\n            index = nativeMax(length + index, 0);\n          }\n          return baseIndexOf(array, value, index);\n        }\n        function initial(array) {\n          var length = array == null ? 0 : array.length;\n          return length ? baseSlice(array, 0, -1) : [];\n        }\n        var intersection = baseRest(function(arrays) {\n          var mapped = arrayMap(arrays, castArrayLikeObject);\n          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];\n        });\n        var intersectionBy = baseRest(function(arrays) {\n          var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);\n          if (iteratee2 === last(mapped)) {\n            iteratee2 = undefined2;\n          } else {\n            mapped.pop();\n          }\n          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];\n        });\n        var intersectionWith = baseRest(function(arrays) {\n          var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);\n          comparator = typeof comparator == \"function\" ? comparator : undefined2;\n          if (comparator) {\n            mapped.pop();\n          }\n          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];\n        });\n        function join(array, separator) {\n          return array == null ? \"\" : nativeJoin.call(array, separator);\n        }\n        function last(array) {\n          var length = array == null ? 0 : array.length;\n          return length ? array[length - 1] : undefined2;\n        }\n        function lastIndexOf(array, value, fromIndex) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return -1;\n          }\n          var index = length;\n          if (fromIndex !== undefined2) {\n            index = toInteger(fromIndex);\n            index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n          }\n          return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);\n        }\n        function nth(array, n) {\n          return array && array.length ? baseNth(array, toInteger(n)) : undefined2;\n        }\n        var pull = baseRest(pullAll);\n        function pullAll(array, values2) {\n          return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;\n        }\n        function pullAllBy(array, values2, iteratee2) {\n          return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;\n        }\n        function pullAllWith(array, values2, comparator) {\n          return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array;\n        }\n        var pullAt = flatRest(function(array, indexes) {\n          var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);\n          basePullAt(array, arrayMap(indexes, function(index) {\n            return isIndex(index, length) ? +index : index;\n          }).sort(compareAscending));\n          return result2;\n        });\n        function remove(array, predicate) {\n          var result2 = [];\n          if (!(array && array.length)) {\n            return result2;\n          }\n          var index = -1, indexes = [], length = array.length;\n          predicate = getIteratee(predicate, 3);\n          while (++index < length) {\n            var value = array[index];\n            if (predicate(value, index, array)) {\n              result2.push(value);\n              indexes.push(index);\n            }\n          }\n          basePullAt(array, indexes);\n          return result2;\n        }\n        function reverse(array) {\n          return array == null ? array : nativeReverse.call(array);\n        }\n        function slice(array, start, end) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          if (end && typeof end != \"number\" && isIterateeCall(array, start, end)) {\n            start = 0;\n            end = length;\n          } else {\n            start = start == null ? 0 : toInteger(start);\n            end = end === undefined2 ? length : toInteger(end);\n          }\n          return baseSlice(array, start, end);\n        }\n        function sortedIndex(array, value) {\n          return baseSortedIndex(array, value);\n        }\n        function sortedIndexBy(array, value, iteratee2) {\n          return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));\n        }\n        function sortedIndexOf(array, value) {\n          var length = array == null ? 0 : array.length;\n          if (length) {\n            var index = baseSortedIndex(array, value);\n            if (index < length && eq(array[index], value)) {\n              return index;\n            }\n          }\n          return -1;\n        }\n        function sortedLastIndex(array, value) {\n          return baseSortedIndex(array, value, true);\n        }\n        function sortedLastIndexBy(array, value, iteratee2) {\n          return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);\n        }\n        function sortedLastIndexOf(array, value) {\n          var length = array == null ? 0 : array.length;\n          if (length) {\n            var index = baseSortedIndex(array, value, true) - 1;\n            if (eq(array[index], value)) {\n              return index;\n            }\n          }\n          return -1;\n        }\n        function sortedUniq(array) {\n          return array && array.length ? baseSortedUniq(array) : [];\n        }\n        function sortedUniqBy(array, iteratee2) {\n          return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];\n        }\n        function tail(array) {\n          var length = array == null ? 0 : array.length;\n          return length ? baseSlice(array, 1, length) : [];\n        }\n        function take(array, n, guard) {\n          if (!(array && array.length)) {\n            return [];\n          }\n          n = guard || n === undefined2 ? 1 : toInteger(n);\n          return baseSlice(array, 0, n < 0 ? 0 : n);\n        }\n        function takeRight(array, n, guard) {\n          var length = array == null ? 0 : array.length;\n          if (!length) {\n            return [];\n          }\n          n = guard || n === undefined2 ? 1 : toInteger(n);\n          n = length - n;\n          return baseSlice(array, n < 0 ? 0 : n, length);\n        }\n        function takeRightWhile(array, predicate) {\n          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];\n        }\n        function takeWhile(array, predicate) {\n          return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];\n        }\n        var union = baseRest(function(arrays) {\n          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n        });\n        var unionBy = baseRest(function(arrays) {\n          var iteratee2 = last(arrays);\n          if (isArrayLikeObject(iteratee2)) {\n            iteratee2 = undefined2;\n          }\n          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));\n        });\n        var unionWith = baseRest(function(arrays) {\n          var comparator = last(arrays);\n          comparator = typeof comparator == \"function\" ? comparator : undefined2;\n          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined2, comparator);\n        });\n        function uniq(array) {\n          return array && array.length ? baseUniq(array) : [];\n        }\n        function uniqBy(array, iteratee2) {\n          return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];\n        }\n        function uniqWith(array, comparator) {\n          comparator = typeof comparator == \"function\" ? comparator : undefined2;\n          return array && array.length ? baseUniq(array, undefined2, comparator) : [];\n        }\n        function unzip(array) {\n          if (!(array && array.length)) {\n            return [];\n          }\n          var length = 0;\n          array = arrayFilter(array, function(group) {\n            if (isArrayLikeObject(group)) {\n              length = nativeMax(group.length, length);\n              return true;\n            }\n          });\n          return baseTimes(length, function(index) {\n            return arrayMap(array, baseProperty(index));\n          });\n        }\n        function unzipWith(array, iteratee2) {\n          if (!(array && array.length)) {\n            return [];\n          }\n          var result2 = unzip(array);\n          if (iteratee2 == null) {\n            return result2;\n          }\n          return arrayMap(result2, function(group) {\n            return apply(iteratee2, undefined2, group);\n          });\n        }\n        var without = baseRest(function(array, values2) {\n          return isArrayLikeObject(array) ? baseDifference(array, values2) : [];\n        });\n        var xor = baseRest(function(arrays) {\n          return baseXor(arrayFilter(arrays, isArrayLikeObject));\n        });\n        var xorBy = baseRest(function(arrays) {\n          var iteratee2 = last(arrays);\n          if (isArrayLikeObject(iteratee2)) {\n            iteratee2 = undefined2;\n          }\n          return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));\n        });\n        var xorWith = baseRest(function(arrays) {\n          var comparator = last(arrays);\n          comparator = typeof comparator == \"function\" ? comparator : undefined2;\n          return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined2, comparator);\n        });\n        var zip = baseRest(unzip);\n        function zipObject(props, values2) {\n          return baseZipObject(props || [], values2 || [], assignValue);\n        }\n        function zipObjectDeep(props, values2) {\n          return baseZipObject(props || [], values2 || [], baseSet);\n        }\n        var zipWith = baseRest(function(arrays) {\n          var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined2;\n          iteratee2 = typeof iteratee2 == \"function\" ? (arrays.pop(), iteratee2) : undefined2;\n          return unzipWith(arrays, iteratee2);\n        });\n        function chain(value) {\n          var result2 = lodash(value);\n          result2.__chain__ = true;\n          return result2;\n        }\n        function tap(value, interceptor) {\n          interceptor(value);\n          return value;\n        }\n        function thru(value, interceptor) {\n          return interceptor(value);\n        }\n        var wrapperAt = flatRest(function(paths) {\n          var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {\n            return baseAt(object, paths);\n          };\n          if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {\n            return this.thru(interceptor);\n          }\n          value = value.slice(start, +start + (length ? 1 : 0));\n          value.__actions__.push({\n            \"func\": thru,\n            \"args\": [interceptor],\n            \"thisArg\": undefined2\n          });\n          return new LodashWrapper(value, this.__chain__).thru(function(array) {\n            if (length && !array.length) {\n              array.push(undefined2);\n            }\n            return array;\n          });\n        });\n        function wrapperChain() {\n          return chain(this);\n        }\n        function wrapperCommit() {\n          return new LodashWrapper(this.value(), this.__chain__);\n        }\n        function wrapperNext() {\n          if (this.__values__ === undefined2) {\n            this.__values__ = toArray(this.value());\n          }\n          var done = this.__index__ >= this.__values__.length, value = done ? undefined2 : this.__values__[this.__index__++];\n          return { \"done\": done, \"value\": value };\n        }\n        function wrapperToIterator() {\n          return this;\n        }\n        function wrapperPlant(value) {\n          var result2, parent2 = this;\n          while (parent2 instanceof baseLodash) {\n            var clone2 = wrapperClone(parent2);\n            clone2.__index__ = 0;\n            clone2.__values__ = undefined2;\n            if (result2) {\n              previous.__wrapped__ = clone2;\n            } else {\n              result2 = clone2;\n            }\n            var previous = clone2;\n            parent2 = parent2.__wrapped__;\n          }\n          previous.__wrapped__ = value;\n          return result2;\n        }\n        function wrapperReverse() {\n          var value = this.__wrapped__;\n          if (value instanceof LazyWrapper) {\n            var wrapped = value;\n            if (this.__actions__.length) {\n              wrapped = new LazyWrapper(this);\n            }\n            wrapped = wrapped.reverse();\n            wrapped.__actions__.push({\n              \"func\": thru,\n              \"args\": [reverse],\n              \"thisArg\": undefined2\n            });\n            return new LodashWrapper(wrapped, this.__chain__);\n          }\n          return this.thru(reverse);\n        }\n        function wrapperValue() {\n          return baseWrapperValue(this.__wrapped__, this.__actions__);\n        }\n        var countBy = createAggregator(function(result2, value, key) {\n          if (hasOwnProperty.call(result2, key)) {\n            ++result2[key];\n          } else {\n            baseAssignValue(result2, key, 1);\n          }\n        });\n        function every(collection, predicate, guard) {\n          var func = isArray(collection) ? arrayEvery : baseEvery;\n          if (guard && isIterateeCall(collection, predicate, guard)) {\n            predicate = undefined2;\n          }\n          return func(collection, getIteratee(predicate, 3));\n        }\n        function filter(collection, predicate) {\n          var func = isArray(collection) ? arrayFilter : baseFilter;\n          return func(collection, getIteratee(predicate, 3));\n        }\n        var find = createFind(findIndex);\n        var findLast = createFind(findLastIndex);\n        function flatMap(collection, iteratee2) {\n          return baseFlatten(map(collection, iteratee2), 1);\n        }\n        function flatMapDeep(collection, iteratee2) {\n          return baseFlatten(map(collection, iteratee2), INFINITY);\n        }\n        function flatMapDepth(collection, iteratee2, depth) {\n          depth = depth === undefined2 ? 1 : toInteger(depth);\n          return baseFlatten(map(collection, iteratee2), depth);\n        }\n        function forEach(collection, iteratee2) {\n          var func = isArray(collection) ? arrayEach : baseEach;\n          return func(collection, getIteratee(iteratee2, 3));\n        }\n        function forEachRight(collection, iteratee2) {\n          var func = isArray(collection) ? arrayEachRight : baseEachRight;\n          return func(collection, getIteratee(iteratee2, 3));\n        }\n        var groupBy = createAggregator(function(result2, value, key) {\n          if (hasOwnProperty.call(result2, key)) {\n            result2[key].push(value);\n          } else {\n            baseAssignValue(result2, key, [value]);\n          }\n        });\n        function includes(collection, value, fromIndex, guard) {\n          collection = isArrayLike(collection) ? collection : values(collection);\n          fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;\n          var length = collection.length;\n          if (fromIndex < 0) {\n            fromIndex = nativeMax(length + fromIndex, 0);\n          }\n          return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;\n        }\n        var invokeMap = baseRest(function(collection, path, args) {\n          var index = -1, isFunc = typeof path == \"function\", result2 = isArrayLike(collection) ? Array2(collection.length) : [];\n          baseEach(collection, function(value) {\n            result2[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n          });\n          return result2;\n        });\n        var keyBy = createAggregator(function(result2, value, key) {\n          baseAssignValue(result2, key, value);\n        });\n        function map(collection, iteratee2) {\n          var func = isArray(collection) ? arrayMap : baseMap;\n          return func(collection, getIteratee(iteratee2, 3));\n        }\n        function orderBy(collection, iteratees, orders, guard) {\n          if (collection == null) {\n            return [];\n          }\n          if (!isArray(iteratees)) {\n            iteratees = iteratees == null ? [] : [iteratees];\n          }\n          orders = guard ? undefined2 : orders;\n          if (!isArray(orders)) {\n            orders = orders == null ? [] : [orders];\n          }\n          return baseOrderBy(collection, iteratees, orders);\n        }\n        var partition = createAggregator(function(result2, value, key) {\n          result2[key ? 0 : 1].push(value);\n        }, function() {\n          return [[], []];\n        });\n        function reduce(collection, iteratee2, accumulator) {\n          var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;\n          return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);\n        }\n        function reduceRight(collection, iteratee2, accumulator) {\n          var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;\n          return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);\n        }\n        function reject(collection, predicate) {\n          var func = isArray(collection) ? arrayFilter : baseFilter;\n          return func(collection, negate(getIteratee(predicate, 3)));\n        }\n        function sample(collection) {\n          var func = isArray(collection) ? arraySample : baseSample;\n          return func(collection);\n        }\n        function sampleSize(collection, n, guard) {\n          if (guard ? isIterateeCall(collection, n, guard) : n === undefined2) {\n            n = 1;\n          } else {\n            n = toInteger(n);\n          }\n          var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n          return func(collection, n);\n        }\n        function shuffle(collection) {\n          var func = isArray(collection) ? arrayShuffle : baseShuffle;\n          return func(collection);\n        }\n        function size(collection) {\n          if (collection == null) {\n            return 0;\n          }\n          if (isArrayLike(collection)) {\n            return isString(collection) ? stringSize(collection) : collection.length;\n          }\n          var tag = getTag(collection);\n          if (tag == mapTag || tag == setTag) {\n            return collection.size;\n          }\n          return baseKeys(collection).length;\n        }\n        function some(collection, predicate, guard) {\n          var func = isArray(collection) ? arraySome : baseSome;\n          if (guard && isIterateeCall(collection, predicate, guard)) {\n            predicate = undefined2;\n          }\n          return func(collection, getIteratee(predicate, 3));\n        }\n        var sortBy = baseRest(function(collection, iteratees) {\n          if (collection == null) {\n            return [];\n          }\n          var length = iteratees.length;\n          if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n            iteratees = [];\n          } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n            iteratees = [iteratees[0]];\n          }\n          return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n        });\n        var now = ctxNow || function() {\n          return root.Date.now();\n        };\n        function after(n, func) {\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          n = toInteger(n);\n          return function() {\n            if (--n < 1) {\n              return func.apply(this, arguments);\n            }\n          };\n        }\n        function ary(func, n, guard) {\n          n = guard ? undefined2 : n;\n          n = func && n == null ? func.length : n;\n          return createWrap(func, WRAP_ARY_FLAG, undefined2, undefined2, undefined2, undefined2, n);\n        }\n        function before(n, func) {\n          var result2;\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          n = toInteger(n);\n          return function() {\n            if (--n > 0) {\n              result2 = func.apply(this, arguments);\n            }\n            if (n <= 1) {\n              func = undefined2;\n            }\n            return result2;\n          };\n        }\n        var bind = baseRest(function(func, thisArg, partials) {\n          var bitmask = WRAP_BIND_FLAG;\n          if (partials.length) {\n            var holders = replaceHolders(partials, getHolder(bind));\n            bitmask |= WRAP_PARTIAL_FLAG;\n          }\n          return createWrap(func, bitmask, thisArg, partials, holders);\n        });\n        var bindKey = baseRest(function(object, key, partials) {\n          var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n          if (partials.length) {\n            var holders = replaceHolders(partials, getHolder(bindKey));\n            bitmask |= WRAP_PARTIAL_FLAG;\n          }\n          return createWrap(key, bitmask, object, partials, holders);\n        });\n        function curry(func, arity, guard) {\n          arity = guard ? undefined2 : arity;\n          var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);\n          result2.placeholder = curry.placeholder;\n          return result2;\n        }\n        function curryRight(func, arity, guard) {\n          arity = guard ? undefined2 : arity;\n          var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);\n          result2.placeholder = curryRight.placeholder;\n          return result2;\n        }\n        function debounce(func, wait, options) {\n          var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          wait = toNumber(wait) || 0;\n          if (isObject(options)) {\n            leading = !!options.leading;\n            maxing = \"maxWait\" in options;\n            maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n            trailing = \"trailing\" in options ? !!options.trailing : trailing;\n          }\n          function invokeFunc(time) {\n            var args = lastArgs, thisArg = lastThis;\n            lastArgs = lastThis = undefined2;\n            lastInvokeTime = time;\n            result2 = func.apply(thisArg, args);\n            return result2;\n          }\n          function leadingEdge(time) {\n            lastInvokeTime = time;\n            timerId = setTimeout(timerExpired, wait);\n            return leading ? invokeFunc(time) : result2;\n          }\n          function remainingWait(time) {\n            var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;\n            return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;\n          }\n          function shouldInvoke(time) {\n            var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;\n            return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;\n          }\n          function timerExpired() {\n            var time = now();\n            if (shouldInvoke(time)) {\n              return trailingEdge(time);\n            }\n            timerId = setTimeout(timerExpired, remainingWait(time));\n          }\n          function trailingEdge(time) {\n            timerId = undefined2;\n            if (trailing && lastArgs) {\n              return invokeFunc(time);\n            }\n            lastArgs = lastThis = undefined2;\n            return result2;\n          }\n          function cancel() {\n            if (timerId !== undefined2) {\n              clearTimeout(timerId);\n            }\n            lastInvokeTime = 0;\n            lastArgs = lastCallTime = lastThis = timerId = undefined2;\n          }\n          function flush() {\n            return timerId === undefined2 ? result2 : trailingEdge(now());\n          }\n          function debounced() {\n            var time = now(), isInvoking = shouldInvoke(time);\n            lastArgs = arguments;\n            lastThis = this;\n            lastCallTime = time;\n            if (isInvoking) {\n              if (timerId === undefined2) {\n                return leadingEdge(lastCallTime);\n              }\n              if (maxing) {\n                clearTimeout(timerId);\n                timerId = setTimeout(timerExpired, wait);\n                return invokeFunc(lastCallTime);\n              }\n            }\n            if (timerId === undefined2) {\n              timerId = setTimeout(timerExpired, wait);\n            }\n            return result2;\n          }\n          debounced.cancel = cancel;\n          debounced.flush = flush;\n          return debounced;\n        }\n        var defer = baseRest(function(func, args) {\n          return baseDelay(func, 1, args);\n        });\n        var delay = baseRest(function(func, wait, args) {\n          return baseDelay(func, toNumber(wait) || 0, args);\n        });\n        function flip(func) {\n          return createWrap(func, WRAP_FLIP_FLAG);\n        }\n        function memoize(func, resolver) {\n          if (typeof func != \"function\" || resolver != null && typeof resolver != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          var memoized = function() {\n            var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;\n            if (cache.has(key)) {\n              return cache.get(key);\n            }\n            var result2 = func.apply(this, args);\n            memoized.cache = cache.set(key, result2) || cache;\n            return result2;\n          };\n          memoized.cache = new (memoize.Cache || MapCache)();\n          return memoized;\n        }\n        memoize.Cache = MapCache;\n        function negate(predicate) {\n          if (typeof predicate != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          return function() {\n            var args = arguments;\n            switch (args.length) {\n              case 0:\n                return !predicate.call(this);\n              case 1:\n                return !predicate.call(this, args[0]);\n              case 2:\n                return !predicate.call(this, args[0], args[1]);\n              case 3:\n                return !predicate.call(this, args[0], args[1], args[2]);\n            }\n            return !predicate.apply(this, args);\n          };\n        }\n        function once(func) {\n          return before(2, func);\n        }\n        var overArgs = castRest(function(func, transforms) {\n          transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n          var funcsLength = transforms.length;\n          return baseRest(function(args) {\n            var index = -1, length = nativeMin(args.length, funcsLength);\n            while (++index < length) {\n              args[index] = transforms[index].call(this, args[index]);\n            }\n            return apply(func, this, args);\n          });\n        });\n        var partial = baseRest(function(func, partials) {\n          var holders = replaceHolders(partials, getHolder(partial));\n          return createWrap(func, WRAP_PARTIAL_FLAG, undefined2, partials, holders);\n        });\n        var partialRight = baseRest(function(func, partials) {\n          var holders = replaceHolders(partials, getHolder(partialRight));\n          return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined2, partials, holders);\n        });\n        var rearg = flatRest(function(func, indexes) {\n          return createWrap(func, WRAP_REARG_FLAG, undefined2, undefined2, undefined2, indexes);\n        });\n        function rest(func, start) {\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          start = start === undefined2 ? start : toInteger(start);\n          return baseRest(func, start);\n        }\n        function spread(func, start) {\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          start = start == null ? 0 : nativeMax(toInteger(start), 0);\n          return baseRest(function(args) {\n            var array = args[start], otherArgs = castSlice(args, 0, start);\n            if (array) {\n              arrayPush(otherArgs, array);\n            }\n            return apply(func, this, otherArgs);\n          });\n        }\n        function throttle(func, wait, options) {\n          var leading = true, trailing = true;\n          if (typeof func != \"function\") {\n            throw new TypeError2(FUNC_ERROR_TEXT);\n          }\n          if (isObject(options)) {\n            leading = \"leading\" in options ? !!options.leading : leading;\n            trailing = \"trailing\" in options ? !!options.trailing : trailing;\n          }\n          return debounce(func, wait, {\n            \"leading\": leading,\n            \"maxWait\": wait,\n            \"trailing\": trailing\n          });\n        }\n        function unary(func) {\n          return ary(func, 1);\n        }\n        function wrap(value, wrapper) {\n          return partial(castFunction(wrapper), value);\n        }\n        function castArray() {\n          if (!arguments.length) {\n            return [];\n          }\n          var value = arguments[0];\n          return isArray(value) ? value : [value];\n        }\n        function clone(value) {\n          return baseClone(value, CLONE_SYMBOLS_FLAG);\n        }\n        function cloneWith(value, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n        }\n        function cloneDeep(value) {\n          return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n        }\n        function cloneDeepWith(value, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n        }\n        function conformsTo(object, source) {\n          return source == null || baseConformsTo(object, source, keys(source));\n        }\n        function eq(value, other) {\n          return value === other || value !== value && other !== other;\n        }\n        var gt = createRelationalOperation(baseGt);\n        var gte = createRelationalOperation(function(value, other) {\n          return value >= other;\n        });\n        var isArguments = baseIsArguments(/* @__PURE__ */ function() {\n          return arguments;\n        }()) ? baseIsArguments : function(value) {\n          return isObjectLike(value) && hasOwnProperty.call(value, \"callee\") && !propertyIsEnumerable.call(value, \"callee\");\n        };\n        var isArray = Array2.isArray;\n        var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n        function isArrayLike(value) {\n          return value != null && isLength(value.length) && !isFunction(value);\n        }\n        function isArrayLikeObject(value) {\n          return isObjectLike(value) && isArrayLike(value);\n        }\n        function isBoolean(value) {\n          return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;\n        }\n        var isBuffer = nativeIsBuffer || stubFalse;\n        var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n        function isElement(value) {\n          return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n        }\n        function isEmpty(value) {\n          if (value == null) {\n            return true;\n          }\n          if (isArrayLike(value) && (isArray(value) || typeof value == \"string\" || typeof value.splice == \"function\" || isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n            return !value.length;\n          }\n          var tag = getTag(value);\n          if (tag == mapTag || tag == setTag) {\n            return !value.size;\n          }\n          if (isPrototype(value)) {\n            return !baseKeys(value).length;\n          }\n          for (var key in value) {\n            if (hasOwnProperty.call(value, key)) {\n              return false;\n            }\n          }\n          return true;\n        }\n        function isEqual(value, other) {\n          return baseIsEqual(value, other);\n        }\n        function isEqualWith(value, other, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          var result2 = customizer ? customizer(value, other) : undefined2;\n          return result2 === undefined2 ? baseIsEqual(value, other, undefined2, customizer) : !!result2;\n        }\n        function isError(value) {\n          if (!isObjectLike(value)) {\n            return false;\n          }\n          var tag = baseGetTag(value);\n          return tag == errorTag || tag == domExcTag || typeof value.message == \"string\" && typeof value.name == \"string\" && !isPlainObject(value);\n        }\n        function isFinite2(value) {\n          return typeof value == \"number\" && nativeIsFinite(value);\n        }\n        function isFunction(value) {\n          if (!isObject(value)) {\n            return false;\n          }\n          var tag = baseGetTag(value);\n          return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n        }\n        function isInteger(value) {\n          return typeof value == \"number\" && value == toInteger(value);\n        }\n        function isLength(value) {\n          return typeof value == \"number\" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n        }\n        function isObject(value) {\n          var type = typeof value;\n          return value != null && (type == \"object\" || type == \"function\");\n        }\n        function isObjectLike(value) {\n          return value != null && typeof value == \"object\";\n        }\n        var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n        function isMatch(object, source) {\n          return object === source || baseIsMatch(object, source, getMatchData(source));\n        }\n        function isMatchWith(object, source, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          return baseIsMatch(object, source, getMatchData(source), customizer);\n        }\n        function isNaN2(value) {\n          return isNumber(value) && value != +value;\n        }\n        function isNative(value) {\n          if (isMaskable(value)) {\n            throw new Error2(CORE_ERROR_TEXT);\n          }\n          return baseIsNative(value);\n        }\n        function isNull(value) {\n          return value === null;\n        }\n        function isNil(value) {\n          return value == null;\n        }\n        function isNumber(value) {\n          return typeof value == \"number\" || isObjectLike(value) && baseGetTag(value) == numberTag;\n        }\n        function isPlainObject(value) {\n          if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n            return false;\n          }\n          var proto = getPrototype(value);\n          if (proto === null) {\n            return true;\n          }\n          var Ctor = hasOwnProperty.call(proto, \"constructor\") && proto.constructor;\n          return typeof Ctor == \"function\" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;\n        }\n        var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n        function isSafeInteger(value) {\n          return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n        }\n        var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n        function isString(value) {\n          return typeof value == \"string\" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;\n        }\n        function isSymbol(value) {\n          return typeof value == \"symbol\" || isObjectLike(value) && baseGetTag(value) == symbolTag;\n        }\n        var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n        function isUndefined(value) {\n          return value === undefined2;\n        }\n        function isWeakMap(value) {\n          return isObjectLike(value) && getTag(value) == weakMapTag;\n        }\n        function isWeakSet(value) {\n          return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n        }\n        var lt = createRelationalOperation(baseLt);\n        var lte = createRelationalOperation(function(value, other) {\n          return value <= other;\n        });\n        function toArray(value) {\n          if (!value) {\n            return [];\n          }\n          if (isArrayLike(value)) {\n            return isString(value) ? stringToArray(value) : copyArray(value);\n          }\n          if (symIterator && value[symIterator]) {\n            return iteratorToArray(value[symIterator]());\n          }\n          var tag = getTag(value), func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values;\n          return func(value);\n        }\n        function toFinite(value) {\n          if (!value) {\n            return value === 0 ? value : 0;\n          }\n          value = toNumber(value);\n          if (value === INFINITY || value === -INFINITY) {\n            var sign = value < 0 ? -1 : 1;\n            return sign * MAX_INTEGER;\n          }\n          return value === value ? value : 0;\n        }\n        function toInteger(value) {\n          var result2 = toFinite(value), remainder = result2 % 1;\n          return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;\n        }\n        function toLength(value) {\n          return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n        }\n        function toNumber(value) {\n          if (typeof value == \"number\") {\n            return value;\n          }\n          if (isSymbol(value)) {\n            return NAN;\n          }\n          if (isObject(value)) {\n            var other = typeof value.valueOf == \"function\" ? value.valueOf() : value;\n            value = isObject(other) ? other + \"\" : other;\n          }\n          if (typeof value != \"string\") {\n            return value === 0 ? value : +value;\n          }\n          value = baseTrim(value);\n          var isBinary = reIsBinary.test(value);\n          return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;\n        }\n        function toPlainObject(value) {\n          return copyObject(value, keysIn(value));\n        }\n        function toSafeInteger(value) {\n          return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;\n        }\n        function toString(value) {\n          return value == null ? \"\" : baseToString(value);\n        }\n        var assign = createAssigner(function(object, source) {\n          if (isPrototype(source) || isArrayLike(source)) {\n            copyObject(source, keys(source), object);\n            return;\n          }\n          for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n              assignValue(object, key, source[key]);\n            }\n          }\n        });\n        var assignIn = createAssigner(function(object, source) {\n          copyObject(source, keysIn(source), object);\n        });\n        var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n          copyObject(source, keysIn(source), object, customizer);\n        });\n        var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n          copyObject(source, keys(source), object, customizer);\n        });\n        var at = flatRest(baseAt);\n        function create(prototype, properties) {\n          var result2 = baseCreate(prototype);\n          return properties == null ? result2 : baseAssign(result2, properties);\n        }\n        var defaults = baseRest(function(object, sources) {\n          object = Object2(object);\n          var index = -1;\n          var length = sources.length;\n          var guard = length > 2 ? sources[2] : undefined2;\n          if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n            length = 1;\n          }\n          while (++index < length) {\n            var source = sources[index];\n            var props = keysIn(source);\n            var propsIndex = -1;\n            var propsLength = props.length;\n            while (++propsIndex < propsLength) {\n              var key = props[propsIndex];\n              var value = object[key];\n              if (value === undefined2 || eq(value, objectProto[key]) && !hasOwnProperty.call(object, key)) {\n                object[key] = source[key];\n              }\n            }\n          }\n          return object;\n        });\n        var defaultsDeep = baseRest(function(args) {\n          args.push(undefined2, customDefaultsMerge);\n          return apply(mergeWith, undefined2, args);\n        });\n        function findKey(object, predicate) {\n          return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n        }\n        function findLastKey(object, predicate) {\n          return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n        }\n        function forIn(object, iteratee2) {\n          return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);\n        }\n        function forInRight(object, iteratee2) {\n          return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);\n        }\n        function forOwn(object, iteratee2) {\n          return object && baseForOwn(object, getIteratee(iteratee2, 3));\n        }\n        function forOwnRight(object, iteratee2) {\n          return object && baseForOwnRight(object, getIteratee(iteratee2, 3));\n        }\n        function functions(object) {\n          return object == null ? [] : baseFunctions(object, keys(object));\n        }\n        function functionsIn(object) {\n          return object == null ? [] : baseFunctions(object, keysIn(object));\n        }\n        function get(object, path, defaultValue) {\n          var result2 = object == null ? undefined2 : baseGet(object, path);\n          return result2 === undefined2 ? defaultValue : result2;\n        }\n        function has(object, path) {\n          return object != null && hasPath(object, path, baseHas);\n        }\n        function hasIn(object, path) {\n          return object != null && hasPath(object, path, baseHasIn);\n        }\n        var invert = createInverter(function(result2, value, key) {\n          if (value != null && typeof value.toString != \"function\") {\n            value = nativeObjectToString.call(value);\n          }\n          result2[value] = key;\n        }, constant(identity));\n        var invertBy = createInverter(function(result2, value, key) {\n          if (value != null && typeof value.toString != \"function\") {\n            value = nativeObjectToString.call(value);\n          }\n          if (hasOwnProperty.call(result2, value)) {\n            result2[value].push(key);\n          } else {\n            result2[value] = [key];\n          }\n        }, getIteratee);\n        var invoke = baseRest(baseInvoke);\n        function keys(object) {\n          return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n        }\n        function keysIn(object) {\n          return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n        }\n        function mapKeys(object, iteratee2) {\n          var result2 = {};\n          iteratee2 = getIteratee(iteratee2, 3);\n          baseForOwn(object, function(value, key, object2) {\n            baseAssignValue(result2, iteratee2(value, key, object2), value);\n          });\n          return result2;\n        }\n        function mapValues(object, iteratee2) {\n          var result2 = {};\n          iteratee2 = getIteratee(iteratee2, 3);\n          baseForOwn(object, function(value, key, object2) {\n            baseAssignValue(result2, key, iteratee2(value, key, object2));\n          });\n          return result2;\n        }\n        var merge = createAssigner(function(object, source, srcIndex) {\n          baseMerge(object, source, srcIndex);\n        });\n        var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n          baseMerge(object, source, srcIndex, customizer);\n        });\n        var omit = flatRest(function(object, paths) {\n          var result2 = {};\n          if (object == null) {\n            return result2;\n          }\n          var isDeep = false;\n          paths = arrayMap(paths, function(path) {\n            path = castPath(path, object);\n            isDeep || (isDeep = path.length > 1);\n            return path;\n          });\n          copyObject(object, getAllKeysIn(object), result2);\n          if (isDeep) {\n            result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n          }\n          var length = paths.length;\n          while (length--) {\n            baseUnset(result2, paths[length]);\n          }\n          return result2;\n        });\n        function omitBy(object, predicate) {\n          return pickBy(object, negate(getIteratee(predicate)));\n        }\n        var pick = flatRest(function(object, paths) {\n          return object == null ? {} : basePick(object, paths);\n        });\n        function pickBy(object, predicate) {\n          if (object == null) {\n            return {};\n          }\n          var props = arrayMap(getAllKeysIn(object), function(prop) {\n            return [prop];\n          });\n          predicate = getIteratee(predicate);\n          return basePickBy(object, props, function(value, path) {\n            return predicate(value, path[0]);\n          });\n        }\n        function result(object, path, defaultValue) {\n          path = castPath(path, object);\n          var index = -1, length = path.length;\n          if (!length) {\n            length = 1;\n            object = undefined2;\n          }\n          while (++index < length) {\n            var value = object == null ? undefined2 : object[toKey(path[index])];\n            if (value === undefined2) {\n              index = length;\n              value = defaultValue;\n            }\n            object = isFunction(value) ? value.call(object) : value;\n          }\n          return object;\n        }\n        function set(object, path, value) {\n          return object == null ? object : baseSet(object, path, value);\n        }\n        function setWith(object, path, value, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          return object == null ? object : baseSet(object, path, value, customizer);\n        }\n        var toPairs = createToPairs(keys);\n        var toPairsIn = createToPairs(keysIn);\n        function transform(object, iteratee2, accumulator) {\n          var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n          iteratee2 = getIteratee(iteratee2, 4);\n          if (accumulator == null) {\n            var Ctor = object && object.constructor;\n            if (isArrLike) {\n              accumulator = isArr ? new Ctor() : [];\n            } else if (isObject(object)) {\n              accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n            } else {\n              accumulator = {};\n            }\n          }\n          (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {\n            return iteratee2(accumulator, value, index, object2);\n          });\n          return accumulator;\n        }\n        function unset(object, path) {\n          return object == null ? true : baseUnset(object, path);\n        }\n        function update(object, path, updater) {\n          return object == null ? object : baseUpdate(object, path, castFunction(updater));\n        }\n        function updateWith(object, path, updater, customizer) {\n          customizer = typeof customizer == \"function\" ? customizer : undefined2;\n          return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n        }\n        function values(object) {\n          return object == null ? [] : baseValues(object, keys(object));\n        }\n        function valuesIn(object) {\n          return object == null ? [] : baseValues(object, keysIn(object));\n        }\n        function clamp(number, lower, upper) {\n          if (upper === undefined2) {\n            upper = lower;\n            lower = undefined2;\n          }\n          if (upper !== undefined2) {\n            upper = toNumber(upper);\n            upper = upper === upper ? upper : 0;\n          }\n          if (lower !== undefined2) {\n            lower = toNumber(lower);\n            lower = lower === lower ? lower : 0;\n          }\n          return baseClamp(toNumber(number), lower, upper);\n        }\n        function inRange(number, start, end) {\n          start = toFinite(start);\n          if (end === undefined2) {\n            end = start;\n            start = 0;\n          } else {\n            end = toFinite(end);\n          }\n          number = toNumber(number);\n          return baseInRange(number, start, end);\n        }\n        function random(lower, upper, floating) {\n          if (floating && typeof floating != \"boolean\" && isIterateeCall(lower, upper, floating)) {\n            upper = floating = undefined2;\n          }\n          if (floating === undefined2) {\n            if (typeof upper == \"boolean\") {\n              floating = upper;\n              upper = undefined2;\n            } else if (typeof lower == \"boolean\") {\n              floating = lower;\n              lower = undefined2;\n            }\n          }\n          if (lower === undefined2 && upper === undefined2) {\n            lower = 0;\n            upper = 1;\n          } else {\n            lower = toFinite(lower);\n            if (upper === undefined2) {\n              upper = lower;\n              lower = 0;\n            } else {\n              upper = toFinite(upper);\n            }\n          }\n          if (lower > upper) {\n            var temp = lower;\n            lower = upper;\n            upper = temp;\n          }\n          if (floating || lower % 1 || upper % 1) {\n            var rand = nativeRandom();\n            return nativeMin(lower + rand * (upper - lower + freeParseFloat(\"1e-\" + ((rand + \"\").length - 1))), upper);\n          }\n          return baseRandom(lower, upper);\n        }\n        var camelCase = createCompounder(function(result2, word, index) {\n          word = word.toLowerCase();\n          return result2 + (index ? capitalize(word) : word);\n        });\n        function capitalize(string) {\n          return upperFirst(toString(string).toLowerCase());\n        }\n        function deburr(string) {\n          string = toString(string);\n          return string && string.replace(reLatin, deburrLetter).replace(reComboMark, \"\");\n        }\n        function endsWith(string, target, position) {\n          string = toString(string);\n          target = baseToString(target);\n          var length = string.length;\n          position = position === undefined2 ? length : baseClamp(toInteger(position), 0, length);\n          var end = position;\n          position -= target.length;\n          return position >= 0 && string.slice(position, end) == target;\n        }\n        function escape2(string) {\n          string = toString(string);\n          return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;\n        }\n        function escapeRegExp(string) {\n          string = toString(string);\n          return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, \"\\\\$&\") : string;\n        }\n        var kebabCase = createCompounder(function(result2, word, index) {\n          return result2 + (index ? \"-\" : \"\") + word.toLowerCase();\n        });\n        var lowerCase = createCompounder(function(result2, word, index) {\n          return result2 + (index ? \" \" : \"\") + word.toLowerCase();\n        });\n        var lowerFirst = createCaseFirst(\"toLowerCase\");\n        function pad(string, length, chars) {\n          string = toString(string);\n          length = toInteger(length);\n          var strLength = length ? stringSize(string) : 0;\n          if (!length || strLength >= length) {\n            return string;\n          }\n          var mid = (length - strLength) / 2;\n          return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars);\n        }\n        function padEnd(string, length, chars) {\n          string = toString(string);\n          length = toInteger(length);\n          var strLength = length ? stringSize(string) : 0;\n          return length && strLength < length ? string + createPadding(length - strLength, chars) : string;\n        }\n        function padStart(string, length, chars) {\n          string = toString(string);\n          length = toInteger(length);\n          var strLength = length ? stringSize(string) : 0;\n          return length && strLength < length ? createPadding(length - strLength, chars) + string : string;\n        }\n        function parseInt2(string, radix, guard) {\n          if (guard || radix == null) {\n            radix = 0;\n          } else if (radix) {\n            radix = +radix;\n          }\n          return nativeParseInt(toString(string).replace(reTrimStart, \"\"), radix || 0);\n        }\n        function repeat(string, n, guard) {\n          if (guard ? isIterateeCall(string, n, guard) : n === undefined2) {\n            n = 1;\n          } else {\n            n = toInteger(n);\n          }\n          return baseRepeat(toString(string), n);\n        }\n        function replace() {\n          var args = arguments, string = toString(args[0]);\n          return args.length < 3 ? string : string.replace(args[1], args[2]);\n        }\n        var snakeCase = createCompounder(function(result2, word, index) {\n          return result2 + (index ? \"_\" : \"\") + word.toLowerCase();\n        });\n        function split(string, separator, limit) {\n          if (limit && typeof limit != \"number\" && isIterateeCall(string, separator, limit)) {\n            separator = limit = undefined2;\n          }\n          limit = limit === undefined2 ? MAX_ARRAY_LENGTH : limit >>> 0;\n          if (!limit) {\n            return [];\n          }\n          string = toString(string);\n          if (string && (typeof separator == \"string\" || separator != null && !isRegExp(separator))) {\n            separator = baseToString(separator);\n            if (!separator && hasUnicode(string)) {\n              return castSlice(stringToArray(string), 0, limit);\n            }\n          }\n          return string.split(separator, limit);\n        }\n        var startCase = createCompounder(function(result2, word, index) {\n          return result2 + (index ? \" \" : \"\") + upperFirst(word);\n        });\n        function startsWith(string, target, position) {\n          string = toString(string);\n          position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);\n          target = baseToString(target);\n          return string.slice(position, position + target.length) == target;\n        }\n        function template(string, options, guard) {\n          var settings = lodash.templateSettings;\n          if (guard && isIterateeCall(string, options, guard)) {\n            options = undefined2;\n          }\n          string = toString(string);\n          options = assignInWith({}, options, settings, customDefaultsAssignIn);\n          var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);\n          var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = \"__p += '\";\n          var reDelimiters = RegExp2(\n            (options.escape || reNoMatch).source + \"|\" + interpolate.source + \"|\" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + \"|\" + (options.evaluate || reNoMatch).source + \"|$\",\n            \"g\"\n          );\n          var sourceURL = \"//# sourceURL=\" + (hasOwnProperty.call(options, \"sourceURL\") ? (options.sourceURL + \"\").replace(/\\s/g, \" \") : \"lodash.templateSources[\" + ++templateCounter + \"]\") + \"\\n\";\n          string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n            interpolateValue || (interpolateValue = esTemplateValue);\n            source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n            if (escapeValue) {\n              isEscaping = true;\n              source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n            }\n            if (evaluateValue) {\n              isEvaluating = true;\n              source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n            }\n            if (interpolateValue) {\n              source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n            }\n            index = offset + match.length;\n            return match;\n          });\n          source += \"';\\n\";\n          var variable = hasOwnProperty.call(options, \"variable\") && options.variable;\n          if (!variable) {\n            source = \"with (obj) {\\n\" + source + \"\\n}\\n\";\n          } else if (reForbiddenIdentifierChars.test(variable)) {\n            throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);\n          }\n          source = (isEvaluating ? source.replace(reEmptyStringLeading, \"\") : source).replace(reEmptyStringMiddle, \"$1\").replace(reEmptyStringTrailing, \"$1;\");\n          source = \"function(\" + (variable || \"obj\") + \") {\\n\" + (variable ? \"\" : \"obj || (obj = {});\\n\") + \"var __t, __p = ''\" + (isEscaping ? \", __e = _.escape\" : \"\") + (isEvaluating ? \", __j = Array.prototype.join;\\nfunction print() { __p += __j.call(arguments, '') }\\n\" : \";\\n\") + source + \"return __p\\n}\";\n          var result2 = attempt(function() {\n            return Function2(importsKeys, sourceURL + \"return \" + source).apply(undefined2, importsValues);\n          });\n          result2.source = source;\n          if (isError(result2)) {\n            throw result2;\n          }\n          return result2;\n        }\n        function toLower(value) {\n          return toString(value).toLowerCase();\n        }\n        function toUpper(value) {\n          return toString(value).toUpperCase();\n        }\n        function trim(string, chars, guard) {\n          string = toString(string);\n          if (string && (guard || chars === undefined2)) {\n            return baseTrim(string);\n          }\n          if (!string || !(chars = baseToString(chars))) {\n            return string;\n          }\n          var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;\n          return castSlice(strSymbols, start, end).join(\"\");\n        }\n        function trimEnd(string, chars, guard) {\n          string = toString(string);\n          if (string && (guard || chars === undefined2)) {\n            return string.slice(0, trimmedEndIndex(string) + 1);\n          }\n          if (!string || !(chars = baseToString(chars))) {\n            return string;\n          }\n          var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n          return castSlice(strSymbols, 0, end).join(\"\");\n        }\n        function trimStart(string, chars, guard) {\n          string = toString(string);\n          if (string && (guard || chars === undefined2)) {\n            return string.replace(reTrimStart, \"\");\n          }\n          if (!string || !(chars = baseToString(chars))) {\n            return string;\n          }\n          var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));\n          return castSlice(strSymbols, start).join(\"\");\n        }\n        function truncate(string, options) {\n          var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;\n          if (isObject(options)) {\n            var separator = \"separator\" in options ? options.separator : separator;\n            length = \"length\" in options ? toInteger(options.length) : length;\n            omission = \"omission\" in options ? baseToString(options.omission) : omission;\n          }\n          string = toString(string);\n          var strLength = string.length;\n          if (hasUnicode(string)) {\n            var strSymbols = stringToArray(string);\n            strLength = strSymbols.length;\n          }\n          if (length >= strLength) {\n            return string;\n          }\n          var end = length - stringSize(omission);\n          if (end < 1) {\n            return omission;\n          }\n          var result2 = strSymbols ? castSlice(strSymbols, 0, end).join(\"\") : string.slice(0, end);\n          if (separator === undefined2) {\n            return result2 + omission;\n          }\n          if (strSymbols) {\n            end += result2.length - end;\n          }\n          if (isRegExp(separator)) {\n            if (string.slice(end).search(separator)) {\n              var match, substring = result2;\n              if (!separator.global) {\n                separator = RegExp2(separator.source, toString(reFlags.exec(separator)) + \"g\");\n              }\n              separator.lastIndex = 0;\n              while (match = separator.exec(substring)) {\n                var newEnd = match.index;\n              }\n              result2 = result2.slice(0, newEnd === undefined2 ? end : newEnd);\n            }\n          } else if (string.indexOf(baseToString(separator), end) != end) {\n            var index = result2.lastIndexOf(separator);\n            if (index > -1) {\n              result2 = result2.slice(0, index);\n            }\n          }\n          return result2 + omission;\n        }\n        function unescape2(string) {\n          string = toString(string);\n          return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;\n        }\n        var upperCase = createCompounder(function(result2, word, index) {\n          return result2 + (index ? \" \" : \"\") + word.toUpperCase();\n        });\n        var upperFirst = createCaseFirst(\"toUpperCase\");\n        function words(string, pattern, guard) {\n          string = toString(string);\n          pattern = guard ? undefined2 : pattern;\n          if (pattern === undefined2) {\n            return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n          }\n          return string.match(pattern) || [];\n        }\n        var attempt = baseRest(function(func, args) {\n          try {\n            return apply(func, undefined2, args);\n          } catch (e) {\n            return isError(e) ? e : new Error2(e);\n          }\n        });\n        var bindAll = flatRest(function(object, methodNames) {\n          arrayEach(methodNames, function(key) {\n            key = toKey(key);\n            baseAssignValue(object, key, bind(object[key], object));\n          });\n          return object;\n        });\n        function cond(pairs) {\n          var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee();\n          pairs = !length ? [] : arrayMap(pairs, function(pair) {\n            if (typeof pair[1] != \"function\") {\n              throw new TypeError2(FUNC_ERROR_TEXT);\n            }\n            return [toIteratee(pair[0]), pair[1]];\n          });\n          return baseRest(function(args) {\n            var index = -1;\n            while (++index < length) {\n              var pair = pairs[index];\n              if (apply(pair[0], this, args)) {\n                return apply(pair[1], this, args);\n              }\n            }\n          });\n        }\n        function conforms(source) {\n          return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n        }\n        function constant(value) {\n          return function() {\n            return value;\n          };\n        }\n        function defaultTo(value, defaultValue) {\n          return value == null || value !== value ? defaultValue : value;\n        }\n        var flow = createFlow();\n        var flowRight = createFlow(true);\n        function identity(value) {\n          return value;\n        }\n        function iteratee(func) {\n          return baseIteratee(typeof func == \"function\" ? func : baseClone(func, CLONE_DEEP_FLAG));\n        }\n        function matches(source) {\n          return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n        }\n        function matchesProperty(path, srcValue) {\n          return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n        }\n        var method = baseRest(function(path, args) {\n          return function(object) {\n            return baseInvoke(object, path, args);\n          };\n        });\n        var methodOf = baseRest(function(object, args) {\n          return function(path) {\n            return baseInvoke(object, path, args);\n          };\n        });\n        function mixin(object, source, options) {\n          var props = keys(source), methodNames = baseFunctions(source, props);\n          if (options == null && !(isObject(source) && (methodNames.length || !props.length))) {\n            options = source;\n            source = object;\n            object = this;\n            methodNames = baseFunctions(source, keys(source));\n          }\n          var chain2 = !(isObject(options) && \"chain\" in options) || !!options.chain, isFunc = isFunction(object);\n          arrayEach(methodNames, function(methodName) {\n            var func = source[methodName];\n            object[methodName] = func;\n            if (isFunc) {\n              object.prototype[methodName] = function() {\n                var chainAll = this.__chain__;\n                if (chain2 || chainAll) {\n                  var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__);\n                  actions.push({ \"func\": func, \"args\": arguments, \"thisArg\": object });\n                  result2.__chain__ = chainAll;\n                  return result2;\n                }\n                return func.apply(object, arrayPush([this.value()], arguments));\n              };\n            }\n          });\n          return object;\n        }\n        function noConflict() {\n          if (root._ === this) {\n            root._ = oldDash;\n          }\n          return this;\n        }\n        function noop() {\n        }\n        function nthArg(n) {\n          n = toInteger(n);\n          return baseRest(function(args) {\n            return baseNth(args, n);\n          });\n        }\n        var over = createOver(arrayMap);\n        var overEvery = createOver(arrayEvery);\n        var overSome = createOver(arraySome);\n        function property(path) {\n          return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n        }\n        function propertyOf(object) {\n          return function(path) {\n            return object == null ? undefined2 : baseGet(object, path);\n          };\n        }\n        var range = createRange();\n        var rangeRight = createRange(true);\n        function stubArray() {\n          return [];\n        }\n        function stubFalse() {\n          return false;\n        }\n        function stubObject() {\n          return {};\n        }\n        function stubString() {\n          return \"\";\n        }\n        function stubTrue() {\n          return true;\n        }\n        function times(n, iteratee2) {\n          n = toInteger(n);\n          if (n < 1 || n > MAX_SAFE_INTEGER) {\n            return [];\n          }\n          var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);\n          iteratee2 = getIteratee(iteratee2);\n          n -= MAX_ARRAY_LENGTH;\n          var result2 = baseTimes(length, iteratee2);\n          while (++index < n) {\n            iteratee2(index);\n          }\n          return result2;\n        }\n        function toPath(value) {\n          if (isArray(value)) {\n            return arrayMap(value, toKey);\n          }\n          return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n        }\n        function uniqueId(prefix) {\n          var id = ++idCounter;\n          return toString(prefix) + id;\n        }\n        var add = createMathOperation(function(augend, addend) {\n          return augend + addend;\n        }, 0);\n        var ceil = createRound(\"ceil\");\n        var divide = createMathOperation(function(dividend, divisor) {\n          return dividend / divisor;\n        }, 1);\n        var floor = createRound(\"floor\");\n        function max(array) {\n          return array && array.length ? baseExtremum(array, identity, baseGt) : undefined2;\n        }\n        function maxBy(array, iteratee2) {\n          return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;\n        }\n        function mean(array) {\n          return baseMean(array, identity);\n        }\n        function meanBy(array, iteratee2) {\n          return baseMean(array, getIteratee(iteratee2, 2));\n        }\n        function min(array) {\n          return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2;\n        }\n        function minBy(array, iteratee2) {\n          return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2;\n        }\n        var multiply = createMathOperation(function(multiplier, multiplicand) {\n          return multiplier * multiplicand;\n        }, 1);\n        var round = createRound(\"round\");\n        var subtract = createMathOperation(function(minuend, subtrahend) {\n          return minuend - subtrahend;\n        }, 0);\n        function sum(array) {\n          return array && array.length ? baseSum(array, identity) : 0;\n        }\n        function sumBy(array, iteratee2) {\n          return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;\n        }\n        lodash.after = after;\n        lodash.ary = ary;\n        lodash.assign = assign;\n        lodash.assignIn = assignIn;\n        lodash.assignInWith = assignInWith;\n        lodash.assignWith = assignWith;\n        lodash.at = at;\n        lodash.before = before;\n        lodash.bind = bind;\n        lodash.bindAll = bindAll;\n        lodash.bindKey = bindKey;\n        lodash.castArray = castArray;\n        lodash.chain = chain;\n        lodash.chunk = chunk;\n        lodash.compact = compact;\n        lodash.concat = concat;\n        lodash.cond = cond;\n        lodash.conforms = conforms;\n        lodash.constant = constant;\n        lodash.countBy = countBy;\n        lodash.create = create;\n        lodash.curry = curry;\n        lodash.curryRight = curryRight;\n        lodash.debounce = debounce;\n        lodash.defaults = defaults;\n        lodash.defaultsDeep = defaultsDeep;\n        lodash.defer = defer;\n        lodash.delay = delay;\n        lodash.difference = difference;\n        lodash.differenceBy = differenceBy;\n        lodash.differenceWith = differenceWith;\n        lodash.drop = drop;\n        lodash.dropRight = dropRight;\n        lodash.dropRightWhile = dropRightWhile;\n        lodash.dropWhile = dropWhile;\n        lodash.fill = fill;\n        lodash.filter = filter;\n        lodash.flatMap = flatMap;\n        lodash.flatMapDeep = flatMapDeep;\n        lodash.flatMapDepth = flatMapDepth;\n        lodash.flatten = flatten;\n        lodash.flattenDeep = flattenDeep;\n        lodash.flattenDepth = flattenDepth;\n        lodash.flip = flip;\n        lodash.flow = flow;\n        lodash.flowRight = flowRight;\n        lodash.fromPairs = fromPairs;\n        lodash.functions = functions;\n        lodash.functionsIn = functionsIn;\n        lodash.groupBy = groupBy;\n        lodash.initial = initial;\n        lodash.intersection = intersection;\n        lodash.intersectionBy = intersectionBy;\n        lodash.intersectionWith = intersectionWith;\n        lodash.invert = invert;\n        lodash.invertBy = invertBy;\n        lodash.invokeMap = invokeMap;\n        lodash.iteratee = iteratee;\n        lodash.keyBy = keyBy;\n        lodash.keys = keys;\n        lodash.keysIn = keysIn;\n        lodash.map = map;\n        lodash.mapKeys = mapKeys;\n        lodash.mapValues = mapValues;\n        lodash.matches = matches;\n        lodash.matchesProperty = matchesProperty;\n        lodash.memoize = memoize;\n        lodash.merge = merge;\n        lodash.mergeWith = mergeWith;\n        lodash.method = method;\n        lodash.methodOf = methodOf;\n        lodash.mixin = mixin;\n        lodash.negate = negate;\n        lodash.nthArg = nthArg;\n        lodash.omit = omit;\n        lodash.omitBy = omitBy;\n        lodash.once = once;\n        lodash.orderBy = orderBy;\n        lodash.over = over;\n        lodash.overArgs = overArgs;\n        lodash.overEvery = overEvery;\n        lodash.overSome = overSome;\n        lodash.partial = partial;\n        lodash.partialRight = partialRight;\n        lodash.partition = partition;\n        lodash.pick = pick;\n        lodash.pickBy = pickBy;\n        lodash.property = property;\n        lodash.propertyOf = propertyOf;\n        lodash.pull = pull;\n        lodash.pullAll = pullAll;\n        lodash.pullAllBy = pullAllBy;\n        lodash.pullAllWith = pullAllWith;\n        lodash.pullAt = pullAt;\n        lodash.range = range;\n        lodash.rangeRight = rangeRight;\n        lodash.rearg = rearg;\n        lodash.reject = reject;\n        lodash.remove = remove;\n        lodash.rest = rest;\n        lodash.reverse = reverse;\n        lodash.sampleSize = sampleSize;\n        lodash.set = set;\n        lodash.setWith = setWith;\n        lodash.shuffle = shuffle;\n        lodash.slice = slice;\n        lodash.sortBy = sortBy;\n        lodash.sortedUniq = sortedUniq;\n        lodash.sortedUniqBy = sortedUniqBy;\n        lodash.split = split;\n        lodash.spread = spread;\n        lodash.tail = tail;\n        lodash.take = take;\n        lodash.takeRight = takeRight;\n        lodash.takeRightWhile = takeRightWhile;\n        lodash.takeWhile = takeWhile;\n        lodash.tap = tap;\n        lodash.throttle = throttle;\n        lodash.thru = thru;\n        lodash.toArray = toArray;\n        lodash.toPairs = toPairs;\n        lodash.toPairsIn = toPairsIn;\n        lodash.toPath = toPath;\n        lodash.toPlainObject = toPlainObject;\n        lodash.transform = transform;\n        lodash.unary = unary;\n        lodash.union = union;\n        lodash.unionBy = unionBy;\n        lodash.unionWith = unionWith;\n        lodash.uniq = uniq;\n        lodash.uniqBy = uniqBy;\n        lodash.uniqWith = uniqWith;\n        lodash.unset = unset;\n        lodash.unzip = unzip;\n        lodash.unzipWith = unzipWith;\n        lodash.update = update;\n        lodash.updateWith = updateWith;\n        lodash.values = values;\n        lodash.valuesIn = valuesIn;\n        lodash.without = without;\n        lodash.words = words;\n        lodash.wrap = wrap;\n        lodash.xor = xor;\n        lodash.xorBy = xorBy;\n        lodash.xorWith = xorWith;\n        lodash.zip = zip;\n        lodash.zipObject = zipObject;\n        lodash.zipObjectDeep = zipObjectDeep;\n        lodash.zipWith = zipWith;\n        lodash.entries = toPairs;\n        lodash.entriesIn = toPairsIn;\n        lodash.extend = assignIn;\n        lodash.extendWith = assignInWith;\n        mixin(lodash, lodash);\n        lodash.add = add;\n        lodash.attempt = attempt;\n        lodash.camelCase = camelCase;\n        lodash.capitalize = capitalize;\n        lodash.ceil = ceil;\n        lodash.clamp = clamp;\n        lodash.clone = clone;\n        lodash.cloneDeep = cloneDeep;\n        lodash.cloneDeepWith = cloneDeepWith;\n        lodash.cloneWith = cloneWith;\n        lodash.conformsTo = conformsTo;\n        lodash.deburr = deburr;\n        lodash.defaultTo = defaultTo;\n        lodash.divide = divide;\n        lodash.endsWith = endsWith;\n        lodash.eq = eq;\n        lodash.escape = escape2;\n        lodash.escapeRegExp = escapeRegExp;\n        lodash.every = every;\n        lodash.find = find;\n        lodash.findIndex = findIndex;\n        lodash.findKey = findKey;\n        lodash.findLast = findLast;\n        lodash.findLastIndex = findLastIndex;\n        lodash.findLastKey = findLastKey;\n        lodash.floor = floor;\n        lodash.forEach = forEach;\n        lodash.forEachRight = forEachRight;\n        lodash.forIn = forIn;\n        lodash.forInRight = forInRight;\n        lodash.forOwn = forOwn;\n        lodash.forOwnRight = forOwnRight;\n        lodash.get = get;\n        lodash.gt = gt;\n        lodash.gte = gte;\n        lodash.has = has;\n        lodash.hasIn = hasIn;\n        lodash.head = head;\n        lodash.identity = identity;\n        lodash.includes = includes;\n        lodash.indexOf = indexOf;\n        lodash.inRange = inRange;\n        lodash.invoke = invoke;\n        lodash.isArguments = isArguments;\n        lodash.isArray = isArray;\n        lodash.isArrayBuffer = isArrayBuffer;\n        lodash.isArrayLike = isArrayLike;\n        lodash.isArrayLikeObject = isArrayLikeObject;\n        lodash.isBoolean = isBoolean;\n        lodash.isBuffer = isBuffer;\n        lodash.isDate = isDate;\n        lodash.isElement = isElement;\n        lodash.isEmpty = isEmpty;\n        lodash.isEqual = isEqual;\n        lodash.isEqualWith = isEqualWith;\n        lodash.isError = isError;\n        lodash.isFinite = isFinite2;\n        lodash.isFunction = isFunction;\n        lodash.isInteger = isInteger;\n        lodash.isLength = isLength;\n        lodash.isMap = isMap;\n        lodash.isMatch = isMatch;\n        lodash.isMatchWith = isMatchWith;\n        lodash.isNaN = isNaN2;\n        lodash.isNative = isNative;\n        lodash.isNil = isNil;\n        lodash.isNull = isNull;\n        lodash.isNumber = isNumber;\n        lodash.isObject = isObject;\n        lodash.isObjectLike = isObjectLike;\n        lodash.isPlainObject = isPlainObject;\n        lodash.isRegExp = isRegExp;\n        lodash.isSafeInteger = isSafeInteger;\n        lodash.isSet = isSet;\n        lodash.isString = isString;\n        lodash.isSymbol = isSymbol;\n        lodash.isTypedArray = isTypedArray;\n        lodash.isUndefined = isUndefined;\n        lodash.isWeakMap = isWeakMap;\n        lodash.isWeakSet = isWeakSet;\n        lodash.join = join;\n        lodash.kebabCase = kebabCase;\n        lodash.last = last;\n        lodash.lastIndexOf = lastIndexOf;\n        lodash.lowerCase = lowerCase;\n        lodash.lowerFirst = lowerFirst;\n        lodash.lt = lt;\n        lodash.lte = lte;\n        lodash.max = max;\n        lodash.maxBy = maxBy;\n        lodash.mean = mean;\n        lodash.meanBy = meanBy;\n        lodash.min = min;\n        lodash.minBy = minBy;\n        lodash.stubArray = stubArray;\n        lodash.stubFalse = stubFalse;\n        lodash.stubObject = stubObject;\n        lodash.stubString = stubString;\n        lodash.stubTrue = stubTrue;\n        lodash.multiply = multiply;\n        lodash.nth = nth;\n        lodash.noConflict = noConflict;\n        lodash.noop = noop;\n        lodash.now = now;\n        lodash.pad = pad;\n        lodash.padEnd = padEnd;\n        lodash.padStart = padStart;\n        lodash.parseInt = parseInt2;\n        lodash.random = random;\n        lodash.reduce = reduce;\n        lodash.reduceRight = reduceRight;\n        lodash.repeat = repeat;\n        lodash.replace = replace;\n        lodash.result = result;\n        lodash.round = round;\n        lodash.runInContext = runInContext2;\n        lodash.sample = sample;\n        lodash.size = size;\n        lodash.snakeCase = snakeCase;\n        lodash.some = some;\n        lodash.sortedIndex = sortedIndex;\n        lodash.sortedIndexBy = sortedIndexBy;\n        lodash.sortedIndexOf = sortedIndexOf;\n        lodash.sortedLastIndex = sortedLastIndex;\n        lodash.sortedLastIndexBy = sortedLastIndexBy;\n        lodash.sortedLastIndexOf = sortedLastIndexOf;\n        lodash.startCase = startCase;\n        lodash.startsWith = startsWith;\n        lodash.subtract = subtract;\n        lodash.sum = sum;\n        lodash.sumBy = sumBy;\n        lodash.template = template;\n        lodash.times = times;\n        lodash.toFinite = toFinite;\n        lodash.toInteger = toInteger;\n        lodash.toLength = toLength;\n        lodash.toLower = toLower;\n        lodash.toNumber = toNumber;\n        lodash.toSafeInteger = toSafeInteger;\n        lodash.toString = toString;\n        lodash.toUpper = toUpper;\n        lodash.trim = trim;\n        lodash.trimEnd = trimEnd;\n        lodash.trimStart = trimStart;\n        lodash.truncate = truncate;\n        lodash.unescape = unescape2;\n        lodash.uniqueId = uniqueId;\n        lodash.upperCase = upperCase;\n        lodash.upperFirst = upperFirst;\n        lodash.each = forEach;\n        lodash.eachRight = forEachRight;\n        lodash.first = head;\n        mixin(lodash, function() {\n          var source = {};\n          baseForOwn(lodash, function(func, methodName) {\n            if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n              source[methodName] = func;\n            }\n          });\n          return source;\n        }(), { \"chain\": false });\n        lodash.VERSION = VERSION;\n        arrayEach([\"bind\", \"bindKey\", \"curry\", \"curryRight\", \"partial\", \"partialRight\"], function(methodName) {\n          lodash[methodName].placeholder = lodash;\n        });\n        arrayEach([\"drop\", \"take\"], function(methodName, index) {\n          LazyWrapper.prototype[methodName] = function(n) {\n            n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0);\n            var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();\n            if (result2.__filtered__) {\n              result2.__takeCount__ = nativeMin(n, result2.__takeCount__);\n            } else {\n              result2.__views__.push({\n                \"size\": nativeMin(n, MAX_ARRAY_LENGTH),\n                \"type\": methodName + (result2.__dir__ < 0 ? \"Right\" : \"\")\n              });\n            }\n            return result2;\n          };\n          LazyWrapper.prototype[methodName + \"Right\"] = function(n) {\n            return this.reverse()[methodName](n).reverse();\n          };\n        });\n        arrayEach([\"filter\", \"map\", \"takeWhile\"], function(methodName, index) {\n          var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n          LazyWrapper.prototype[methodName] = function(iteratee2) {\n            var result2 = this.clone();\n            result2.__iteratees__.push({\n              \"iteratee\": getIteratee(iteratee2, 3),\n              \"type\": type\n            });\n            result2.__filtered__ = result2.__filtered__ || isFilter;\n            return result2;\n          };\n        });\n        arrayEach([\"head\", \"last\"], function(methodName, index) {\n          var takeName = \"take\" + (index ? \"Right\" : \"\");\n          LazyWrapper.prototype[methodName] = function() {\n            return this[takeName](1).value()[0];\n          };\n        });\n        arrayEach([\"initial\", \"tail\"], function(methodName, index) {\n          var dropName = \"drop\" + (index ? \"\" : \"Right\");\n          LazyWrapper.prototype[methodName] = function() {\n            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n          };\n        });\n        LazyWrapper.prototype.compact = function() {\n          return this.filter(identity);\n        };\n        LazyWrapper.prototype.find = function(predicate) {\n          return this.filter(predicate).head();\n        };\n        LazyWrapper.prototype.findLast = function(predicate) {\n          return this.reverse().find(predicate);\n        };\n        LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n          if (typeof path == \"function\") {\n            return new LazyWrapper(this);\n          }\n          return this.map(function(value) {\n            return baseInvoke(value, path, args);\n          });\n        });\n        LazyWrapper.prototype.reject = function(predicate) {\n          return this.filter(negate(getIteratee(predicate)));\n        };\n        LazyWrapper.prototype.slice = function(start, end) {\n          start = toInteger(start);\n          var result2 = this;\n          if (result2.__filtered__ && (start > 0 || end < 0)) {\n            return new LazyWrapper(result2);\n          }\n          if (start < 0) {\n            result2 = result2.takeRight(-start);\n          } else if (start) {\n            result2 = result2.drop(start);\n          }\n          if (end !== undefined2) {\n            end = toInteger(end);\n            result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);\n          }\n          return result2;\n        };\n        LazyWrapper.prototype.takeRightWhile = function(predicate) {\n          return this.reverse().takeWhile(predicate).reverse();\n        };\n        LazyWrapper.prototype.toArray = function() {\n          return this.take(MAX_ARRAY_LENGTH);\n        };\n        baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n          var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? \"take\" + (methodName == \"last\" ? \"Right\" : \"\") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);\n          if (!lodashFunc) {\n            return;\n          }\n          lodash.prototype[methodName] = function() {\n            var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value);\n            var interceptor = function(value2) {\n              var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));\n              return isTaker && chainAll ? result3[0] : result3;\n            };\n            if (useLazy && checkIteratee && typeof iteratee2 == \"function\" && iteratee2.length != 1) {\n              isLazy = useLazy = false;\n            }\n            var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;\n            if (!retUnwrapped && useLazy) {\n              value = onlyLazy ? value : new LazyWrapper(this);\n              var result2 = func.apply(value, args);\n              result2.__actions__.push({ \"func\": thru, \"args\": [interceptor], \"thisArg\": undefined2 });\n              return new LodashWrapper(result2, chainAll);\n            }\n            if (isUnwrapped && onlyLazy) {\n              return func.apply(this, args);\n            }\n            result2 = this.thru(interceptor);\n            return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;\n          };\n        });\n        arrayEach([\"pop\", \"push\", \"shift\", \"sort\", \"splice\", \"unshift\"], function(methodName) {\n          var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? \"tap\" : \"thru\", retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n          lodash.prototype[methodName] = function() {\n            var args = arguments;\n            if (retUnwrapped && !this.__chain__) {\n              var value = this.value();\n              return func.apply(isArray(value) ? value : [], args);\n            }\n            return this[chainName](function(value2) {\n              return func.apply(isArray(value2) ? value2 : [], args);\n            });\n          };\n        });\n        baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n          var lodashFunc = lodash[methodName];\n          if (lodashFunc) {\n            var key = lodashFunc.name + \"\";\n            if (!hasOwnProperty.call(realNames, key)) {\n              realNames[key] = [];\n            }\n            realNames[key].push({ \"name\": methodName, \"func\": lodashFunc });\n          }\n        });\n        realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{\n          \"name\": \"wrapper\",\n          \"func\": undefined2\n        }];\n        LazyWrapper.prototype.clone = lazyClone;\n        LazyWrapper.prototype.reverse = lazyReverse;\n        LazyWrapper.prototype.value = lazyValue;\n        lodash.prototype.at = wrapperAt;\n        lodash.prototype.chain = wrapperChain;\n        lodash.prototype.commit = wrapperCommit;\n        lodash.prototype.next = wrapperNext;\n        lodash.prototype.plant = wrapperPlant;\n        lodash.prototype.reverse = wrapperReverse;\n        lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n        lodash.prototype.first = lodash.prototype.head;\n        if (symIterator) {\n          lodash.prototype[symIterator] = wrapperToIterator;\n        }\n        return lodash;\n      };\n      var _2 = runInContext();\n      if (typeof define == \"function\" && typeof define.amd == \"object\" && define.amd) {\n        root._ = _2;\n        define(function() {\n          return _2;\n        });\n      } else if (freeModule) {\n        (freeModule.exports = _2)._ = _2;\n        freeExports._ = _2;\n      } else {\n        root._ = _2;\n      }\n    }).call(exports2);\n  }\n});\n\n// node_modules/color-name/index.js\nvar require_color_name = __commonJS({\n  \"node_modules/color-name/index.js\"(exports2, module2) {\n    \"use strict\";\n    module2.exports = {\n      \"aliceblue\": [240, 248, 255],\n      \"antiquewhite\": [250, 235, 215],\n      \"aqua\": [0, 255, 255],\n      \"aquamarine\": [127, 255, 212],\n      \"azure\": [240, 255, 255],\n      \"beige\": [245, 245, 220],\n      \"bisque\": [255, 228, 196],\n      \"black\": [0, 0, 0],\n      \"blanchedalmond\": [255, 235, 205],\n      \"blue\": [0, 0, 255],\n      \"blueviolet\": [138, 43, 226],\n      \"brown\": [165, 42, 42],\n      \"burlywood\": [222, 184, 135],\n      \"cadetblue\": [95, 158, 160],\n      \"chartreuse\": [127, 255, 0],\n      \"chocolate\": [210, 105, 30],\n      \"coral\": [255, 127, 80],\n      \"cornflowerblue\": [100, 149, 237],\n      \"cornsilk\": [255, 248, 220],\n      \"crimson\": [220, 20, 60],\n      \"cyan\": [0, 255, 255],\n      \"darkblue\": [0, 0, 139],\n      \"darkcyan\": [0, 139, 139],\n      \"darkgoldenrod\": [184, 134, 11],\n      \"darkgray\": [169, 169, 169],\n      \"darkgreen\": [0, 100, 0],\n      \"darkgrey\": [169, 169, 169],\n      \"darkkhaki\": [189, 183, 107],\n      \"darkmagenta\": [139, 0, 139],\n      \"darkolivegreen\": [85, 107, 47],\n      \"darkorange\": [255, 140, 0],\n      \"darkorchid\": [153, 50, 204],\n      \"darkred\": [139, 0, 0],\n      \"darksalmon\": [233, 150, 122],\n      \"darkseagreen\": [143, 188, 143],\n      \"darkslateblue\": [72, 61, 139],\n      \"darkslategray\": [47, 79, 79],\n      \"darkslategrey\": [47, 79, 79],\n      \"darkturquoise\": [0, 206, 209],\n      \"darkviolet\": [148, 0, 211],\n      \"deeppink\": [255, 20, 147],\n      \"deepskyblue\": [0, 191, 255],\n      \"dimgray\": [105, 105, 105],\n      \"dimgrey\": [105, 105, 105],\n      \"dodgerblue\": [30, 144, 255],\n      \"firebrick\": [178, 34, 34],\n      \"floralwhite\": [255, 250, 240],\n      \"forestgreen\": [34, 139, 34],\n      \"fuchsia\": [255, 0, 255],\n      \"gainsboro\": [220, 220, 220],\n      \"ghostwhite\": [248, 248, 255],\n      \"gold\": [255, 215, 0],\n      \"goldenrod\": [218, 165, 32],\n      \"gray\": [128, 128, 128],\n      \"green\": [0, 128, 0],\n      \"greenyellow\": [173, 255, 47],\n      \"grey\": [128, 128, 128],\n      \"honeydew\": [240, 255, 240],\n      \"hotpink\": [255, 105, 180],\n      \"indianred\": [205, 92, 92],\n      \"indigo\": [75, 0, 130],\n      \"ivory\": [255, 255, 240],\n      \"khaki\": [240, 230, 140],\n      \"lavender\": [230, 230, 250],\n      \"lavenderblush\": [255, 240, 245],\n      \"lawngreen\": [124, 252, 0],\n      \"lemonchiffon\": [255, 250, 205],\n      \"lightblue\": [173, 216, 230],\n      \"lightcoral\": [240, 128, 128],\n      \"lightcyan\": [224, 255, 255],\n      \"lightgoldenrodyellow\": [250, 250, 210],\n      \"lightgray\": [211, 211, 211],\n      \"lightgreen\": [144, 238, 144],\n      \"lightgrey\": [211, 211, 211],\n      \"lightpink\": [255, 182, 193],\n      \"lightsalmon\": [255, 160, 122],\n      \"lightseagreen\": [32, 178, 170],\n      \"lightskyblue\": [135, 206, 250],\n      \"lightslategray\": [119, 136, 153],\n      \"lightslategrey\": [119, 136, 153],\n      \"lightsteelblue\": [176, 196, 222],\n      \"lightyellow\": [255, 255, 224],\n      \"lime\": [0, 255, 0],\n      \"limegreen\": [50, 205, 50],\n      \"linen\": [250, 240, 230],\n      \"magenta\": [255, 0, 255],\n      \"maroon\": [128, 0, 0],\n      \"mediumaquamarine\": [102, 205, 170],\n      \"mediumblue\": [0, 0, 205],\n      \"mediumorchid\": [186, 85, 211],\n      \"mediumpurple\": [147, 112, 219],\n      \"mediumseagreen\": [60, 179, 113],\n      \"mediumslateblue\": [123, 104, 238],\n      \"mediumspringgreen\": [0, 250, 154],\n      \"mediumturquoise\": [72, 209, 204],\n      \"mediumvioletred\": [199, 21, 133],\n      \"midnightblue\": [25, 25, 112],\n      \"mintcream\": [245, 255, 250],\n      \"mistyrose\": [255, 228, 225],\n      \"moccasin\": [255, 228, 181],\n      \"navajowhite\": [255, 222, 173],\n      \"navy\": [0, 0, 128],\n      \"oldlace\": [253, 245, 230],\n      \"olive\": [128, 128, 0],\n      \"olivedrab\": [107, 142, 35],\n      \"orange\": [255, 165, 0],\n      \"orangered\": [255, 69, 0],\n      \"orchid\": [218, 112, 214],\n      \"palegoldenrod\": [238, 232, 170],\n      \"palegreen\": [152, 251, 152],\n      \"paleturquoise\": [175, 238, 238],\n      \"palevioletred\": [219, 112, 147],\n      \"papayawhip\": [255, 239, 213],\n      \"peachpuff\": [255, 218, 185],\n      \"peru\": [205, 133, 63],\n      \"pink\": [255, 192, 203],\n      \"plum\": [221, 160, 221],\n      \"powderblue\": [176, 224, 230],\n      \"purple\": [128, 0, 128],\n      \"rebeccapurple\": [102, 51, 153],\n      \"red\": [255, 0, 0],\n      \"rosybrown\": [188, 143, 143],\n      \"royalblue\": [65, 105, 225],\n      \"saddlebrown\": [139, 69, 19],\n      \"salmon\": [250, 128, 114],\n      \"sandybrown\": [244, 164, 96],\n      \"seagreen\": [46, 139, 87],\n      \"seashell\": [255, 245, 238],\n      \"sienna\": [160, 82, 45],\n      \"silver\": [192, 192, 192],\n      \"skyblue\": [135, 206, 235],\n      \"slateblue\": [106, 90, 205],\n      \"slategray\": [112, 128, 144],\n      \"slategrey\": [112, 128, 144],\n      \"snow\": [255, 250, 250],\n      \"springgreen\": [0, 255, 127],\n      \"steelblue\": [70, 130, 180],\n      \"tan\": [210, 180, 140],\n      \"teal\": [0, 128, 128],\n      \"thistle\": [216, 191, 216],\n      \"tomato\": [255, 99, 71],\n      \"turquoise\": [64, 224, 208],\n      \"violet\": [238, 130, 238],\n      \"wheat\": [245, 222, 179],\n      \"white\": [255, 255, 255],\n      \"whitesmoke\": [245, 245, 245],\n      \"yellow\": [255, 255, 0],\n      \"yellowgreen\": [154, 205, 50]\n    };\n  }\n});\n\n// node_modules/color-convert/conversions.js\nvar require_conversions = __commonJS({\n  \"node_modules/color-convert/conversions.js\"(exports2, module2) {\n    var cssKeywords = require_color_name();\n    var reverseKeywords = {};\n    for (const key of Object.keys(cssKeywords)) {\n      reverseKeywords[cssKeywords[key]] = key;\n    }\n    var convert = {\n      rgb: { channels: 3, labels: \"rgb\" },\n      hsl: { channels: 3, labels: \"hsl\" },\n      hsv: { channels: 3, labels: \"hsv\" },\n      hwb: { channels: 3, labels: \"hwb\" },\n      cmyk: { channels: 4, labels: \"cmyk\" },\n      xyz: { channels: 3, labels: \"xyz\" },\n      lab: { channels: 3, labels: \"lab\" },\n      lch: { channels: 3, labels: \"lch\" },\n      hex: { channels: 1, labels: [\"hex\"] },\n      keyword: { channels: 1, labels: [\"keyword\"] },\n      ansi16: { channels: 1, labels: [\"ansi16\"] },\n      ansi256: { channels: 1, labels: [\"ansi256\"] },\n      hcg: { channels: 3, labels: [\"h\", \"c\", \"g\"] },\n      apple: { channels: 3, labels: [\"r16\", \"g16\", \"b16\"] },\n      gray: { channels: 1, labels: [\"gray\"] }\n    };\n    module2.exports = convert;\n    for (const model of Object.keys(convert)) {\n      if (!(\"channels\" in convert[model])) {\n        throw new Error(\"missing channels property: \" + model);\n      }\n      if (!(\"labels\" in convert[model])) {\n        throw new Error(\"missing channel labels property: \" + model);\n      }\n      if (convert[model].labels.length !== convert[model].channels) {\n        throw new Error(\"channel and label counts mismatch: \" + model);\n      }\n      const { channels, labels } = convert[model];\n      delete convert[model].channels;\n      delete convert[model].labels;\n      Object.defineProperty(convert[model], \"channels\", { value: channels });\n      Object.defineProperty(convert[model], \"labels\", { value: labels });\n    }\n    convert.rgb.hsl = function(rgb) {\n      const r = rgb[0] / 255;\n      const g = rgb[1] / 255;\n      const b = rgb[2] / 255;\n      const min = Math.min(r, g, b);\n      const max = Math.max(r, g, b);\n      const delta = max - min;\n      let h;\n      let s;\n      if (max === min) {\n        h = 0;\n      } else if (r === max) {\n        h = (g - b) / delta;\n      } else if (g === max) {\n        h = 2 + (b - r) / delta;\n      } else if (b === max) {\n        h = 4 + (r - g) / delta;\n      }\n      h = Math.min(h * 60, 360);\n      if (h < 0) {\n        h += 360;\n      }\n      const l = (min + max) / 2;\n      if (max === min) {\n        s = 0;\n      } else if (l <= 0.5) {\n        s = delta / (max + min);\n      } else {\n        s = delta / (2 - max - min);\n      }\n      return [h, s * 100, l * 100];\n    };\n    convert.rgb.hsv = function(rgb) {\n      let rdif;\n      let gdif;\n      let bdif;\n      let h;\n      let s;\n      const r = rgb[0] / 255;\n      const g = rgb[1] / 255;\n      const b = rgb[2] / 255;\n      const v = Math.max(r, g, b);\n      const diff = v - Math.min(r, g, b);\n      const diffc = function(c) {\n        return (v - c) / 6 / diff + 1 / 2;\n      };\n      if (diff === 0) {\n        h = 0;\n        s = 0;\n      } else {\n        s = diff / v;\n        rdif = diffc(r);\n        gdif = diffc(g);\n        bdif = diffc(b);\n        if (r === v) {\n          h = bdif - gdif;\n        } else if (g === v) {\n          h = 1 / 3 + rdif - bdif;\n        } else if (b === v) {\n          h = 2 / 3 + gdif - rdif;\n        }\n        if (h < 0) {\n          h += 1;\n        } else if (h > 1) {\n          h -= 1;\n        }\n      }\n      return [\n        h * 360,\n        s * 100,\n        v * 100\n      ];\n    };\n    convert.rgb.hwb = function(rgb) {\n      const r = rgb[0];\n      const g = rgb[1];\n      let b = rgb[2];\n      const h = convert.rgb.hsl(rgb)[0];\n      const w = 1 / 255 * Math.min(r, Math.min(g, b));\n      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));\n      return [h, w * 100, b * 100];\n    };\n    convert.rgb.cmyk = function(rgb) {\n      const r = rgb[0] / 255;\n      const g = rgb[1] / 255;\n      const b = rgb[2] / 255;\n      const k = Math.min(1 - r, 1 - g, 1 - b);\n      const c = (1 - r - k) / (1 - k) || 0;\n      const m = (1 - g - k) / (1 - k) || 0;\n      const y = (1 - b - k) / (1 - k) || 0;\n      return [c * 100, m * 100, y * 100, k * 100];\n    };\n    function comparativeDistance(x, y) {\n      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;\n    }\n    convert.rgb.keyword = function(rgb) {\n      const reversed = reverseKeywords[rgb];\n      if (reversed) {\n        return reversed;\n      }\n      let currentClosestDistance = Infinity;\n      let currentClosestKeyword;\n      for (const keyword of Object.keys(cssKeywords)) {\n        const value = cssKeywords[keyword];\n        const distance = comparativeDistance(rgb, value);\n        if (distance < currentClosestDistance) {\n          currentClosestDistance = distance;\n          currentClosestKeyword = keyword;\n        }\n      }\n      return currentClosestKeyword;\n    };\n    convert.keyword.rgb = function(keyword) {\n      return cssKeywords[keyword];\n    };\n    convert.rgb.xyz = function(rgb) {\n      let r = rgb[0] / 255;\n      let g = rgb[1] / 255;\n      let b = rgb[2] / 255;\n      r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;\n      g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;\n      b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;\n      const x = r * 0.4124 + g * 0.3576 + b * 0.1805;\n      const y = r * 0.2126 + g * 0.7152 + b * 0.0722;\n      const z2 = r * 0.0193 + g * 0.1192 + b * 0.9505;\n      return [x * 100, y * 100, z2 * 100];\n    };\n    convert.rgb.lab = function(rgb) {\n      const xyz = convert.rgb.xyz(rgb);\n      let x = xyz[0];\n      let y = xyz[1];\n      let z2 = xyz[2];\n      x /= 95.047;\n      y /= 100;\n      z2 /= 108.883;\n      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;\n      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;\n      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;\n      const l = 116 * y - 16;\n      const a = 500 * (x - y);\n      const b = 200 * (y - z2);\n      return [l, a, b];\n    };\n    convert.hsl.rgb = function(hsl) {\n      const h = hsl[0] / 360;\n      const s = hsl[1] / 100;\n      const l = hsl[2] / 100;\n      let t2;\n      let t3;\n      let val;\n      if (s === 0) {\n        val = l * 255;\n        return [val, val, val];\n      }\n      if (l < 0.5) {\n        t2 = l * (1 + s);\n      } else {\n        t2 = l + s - l * s;\n      }\n      const t1 = 2 * l - t2;\n      const rgb = [0, 0, 0];\n      for (let i = 0; i < 3; i++) {\n        t3 = h + 1 / 3 * -(i - 1);\n        if (t3 < 0) {\n          t3++;\n        }\n        if (t3 > 1) {\n          t3--;\n        }\n        if (6 * t3 < 1) {\n          val = t1 + (t2 - t1) * 6 * t3;\n        } else if (2 * t3 < 1) {\n          val = t2;\n        } else if (3 * t3 < 2) {\n          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;\n        } else {\n          val = t1;\n        }\n        rgb[i] = val * 255;\n      }\n      return rgb;\n    };\n    convert.hsl.hsv = function(hsl) {\n      const h = hsl[0];\n      let s = hsl[1] / 100;\n      let l = hsl[2] / 100;\n      let smin = s;\n      const lmin = Math.max(l, 0.01);\n      l *= 2;\n      s *= l <= 1 ? l : 2 - l;\n      smin *= lmin <= 1 ? lmin : 2 - lmin;\n      const v = (l + s) / 2;\n      const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);\n      return [h, sv * 100, v * 100];\n    };\n    convert.hsv.rgb = function(hsv) {\n      const h = hsv[0] / 60;\n      const s = hsv[1] / 100;\n      let v = hsv[2] / 100;\n      const hi = Math.floor(h) % 6;\n      const f = h - Math.floor(h);\n      const p = 255 * v * (1 - s);\n      const q = 255 * v * (1 - s * f);\n      const t = 255 * v * (1 - s * (1 - f));\n      v *= 255;\n      switch (hi) {\n        case 0:\n          return [v, t, p];\n        case 1:\n          return [q, v, p];\n        case 2:\n          return [p, v, t];\n        case 3:\n          return [p, q, v];\n        case 4:\n          return [t, p, v];\n        case 5:\n          return [v, p, q];\n      }\n    };\n    convert.hsv.hsl = function(hsv) {\n      const h = hsv[0];\n      const s = hsv[1] / 100;\n      const v = hsv[2] / 100;\n      const vmin = Math.max(v, 0.01);\n      let sl;\n      let l;\n      l = (2 - s) * v;\n      const lmin = (2 - s) * vmin;\n      sl = s * vmin;\n      sl /= lmin <= 1 ? lmin : 2 - lmin;\n      sl = sl || 0;\n      l /= 2;\n      return [h, sl * 100, l * 100];\n    };\n    convert.hwb.rgb = function(hwb) {\n      const h = hwb[0] / 360;\n      let wh = hwb[1] / 100;\n      let bl = hwb[2] / 100;\n      const ratio = wh + bl;\n      let f;\n      if (ratio > 1) {\n        wh /= ratio;\n        bl /= ratio;\n      }\n      const i = Math.floor(6 * h);\n      const v = 1 - bl;\n      f = 6 * h - i;\n      if ((i & 1) !== 0) {\n        f = 1 - f;\n      }\n      const n = wh + f * (v - wh);\n      let r;\n      let g;\n      let b;\n      switch (i) {\n        default:\n        case 6:\n        case 0:\n          r = v;\n          g = n;\n          b = wh;\n          break;\n        case 1:\n          r = n;\n          g = v;\n          b = wh;\n          break;\n        case 2:\n          r = wh;\n          g = v;\n          b = n;\n          break;\n        case 3:\n          r = wh;\n          g = n;\n          b = v;\n          break;\n        case 4:\n          r = n;\n          g = wh;\n          b = v;\n          break;\n        case 5:\n          r = v;\n          g = wh;\n          b = n;\n          break;\n      }\n      return [r * 255, g * 255, b * 255];\n    };\n    convert.cmyk.rgb = function(cmyk) {\n      const c = cmyk[0] / 100;\n      const m = cmyk[1] / 100;\n      const y = cmyk[2] / 100;\n      const k = cmyk[3] / 100;\n      const r = 1 - Math.min(1, c * (1 - k) + k);\n      const g = 1 - Math.min(1, m * (1 - k) + k);\n      const b = 1 - Math.min(1, y * (1 - k) + k);\n      return [r * 255, g * 255, b * 255];\n    };\n    convert.xyz.rgb = function(xyz) {\n      const x = xyz[0] / 100;\n      const y = xyz[1] / 100;\n      const z2 = xyz[2] / 100;\n      let r;\n      let g;\n      let b;\n      r = x * 3.2406 + y * -1.5372 + z2 * -0.4986;\n      g = x * -0.9689 + y * 1.8758 + z2 * 0.0415;\n      b = x * 0.0557 + y * -0.204 + z2 * 1.057;\n      r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;\n      g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;\n      b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;\n      r = Math.min(Math.max(0, r), 1);\n      g = Math.min(Math.max(0, g), 1);\n      b = Math.min(Math.max(0, b), 1);\n      return [r * 255, g * 255, b * 255];\n    };\n    convert.xyz.lab = function(xyz) {\n      let x = xyz[0];\n      let y = xyz[1];\n      let z2 = xyz[2];\n      x /= 95.047;\n      y /= 100;\n      z2 /= 108.883;\n      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;\n      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;\n      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;\n      const l = 116 * y - 16;\n      const a = 500 * (x - y);\n      const b = 200 * (y - z2);\n      return [l, a, b];\n    };\n    convert.lab.xyz = function(lab) {\n      const l = lab[0];\n      const a = lab[1];\n      const b = lab[2];\n      let x;\n      let y;\n      let z2;\n      y = (l + 16) / 116;\n      x = a / 500 + y;\n      z2 = y - b / 200;\n      const y2 = y ** 3;\n      const x2 = x ** 3;\n      const z22 = z2 ** 3;\n      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;\n      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;\n      z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787;\n      x *= 95.047;\n      y *= 100;\n      z2 *= 108.883;\n      return [x, y, z2];\n    };\n    convert.lab.lch = function(lab) {\n      const l = lab[0];\n      const a = lab[1];\n      const b = lab[2];\n      let h;\n      const hr = Math.atan2(b, a);\n      h = hr * 360 / 2 / Math.PI;\n      if (h < 0) {\n        h += 360;\n      }\n      const c = Math.sqrt(a * a + b * b);\n      return [l, c, h];\n    };\n    convert.lch.lab = function(lch) {\n      const l = lch[0];\n      const c = lch[1];\n      const h = lch[2];\n      const hr = h / 360 * 2 * Math.PI;\n      const a = c * Math.cos(hr);\n      const b = c * Math.sin(hr);\n      return [l, a, b];\n    };\n    convert.rgb.ansi16 = function(args, saturation = null) {\n      const [r, g, b] = args;\n      let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;\n      value = Math.round(value / 50);\n      if (value === 0) {\n        return 30;\n      }\n      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));\n      if (value === 2) {\n        ansi += 60;\n      }\n      return ansi;\n    };\n    convert.hsv.ansi16 = function(args) {\n      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);\n    };\n    convert.rgb.ansi256 = function(args) {\n      const r = args[0];\n      const g = args[1];\n      const b = args[2];\n      if (r === g && g === b) {\n        if (r < 8) {\n          return 16;\n        }\n        if (r > 248) {\n          return 231;\n        }\n        return Math.round((r - 8) / 247 * 24) + 232;\n      }\n      const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);\n      return ansi;\n    };\n    convert.ansi16.rgb = function(args) {\n      let color = args % 10;\n      if (color === 0 || color === 7) {\n        if (args > 50) {\n          color += 3.5;\n        }\n        color = color / 10.5 * 255;\n        return [color, color, color];\n      }\n      const mult = (~~(args > 50) + 1) * 0.5;\n      const r = (color & 1) * mult * 255;\n      const g = (color >> 1 & 1) * mult * 255;\n      const b = (color >> 2 & 1) * mult * 255;\n      return [r, g, b];\n    };\n    convert.ansi256.rgb = function(args) {\n      if (args >= 232) {\n        const c = (args - 232) * 10 + 8;\n        return [c, c, c];\n      }\n      args -= 16;\n      let rem;\n      const r = Math.floor(args / 36) / 5 * 255;\n      const g = Math.floor((rem = args % 36) / 6) / 5 * 255;\n      const b = rem % 6 / 5 * 255;\n      return [r, g, b];\n    };\n    convert.rgb.hex = function(args) {\n      const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);\n      const string = integer.toString(16).toUpperCase();\n      return \"000000\".substring(string.length) + string;\n    };\n    convert.hex.rgb = function(args) {\n      const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);\n      if (!match) {\n        return [0, 0, 0];\n      }\n      let colorString = match[0];\n      if (match[0].length === 3) {\n        colorString = colorString.split(\"\").map((char) => {\n          return char + char;\n        }).join(\"\");\n      }\n      const integer = parseInt(colorString, 16);\n      const r = integer >> 16 & 255;\n      const g = integer >> 8 & 255;\n      const b = integer & 255;\n      return [r, g, b];\n    };\n    convert.rgb.hcg = function(rgb) {\n      const r = rgb[0] / 255;\n      const g = rgb[1] / 255;\n      const b = rgb[2] / 255;\n      const max = Math.max(Math.max(r, g), b);\n      const min = Math.min(Math.min(r, g), b);\n      const chroma = max - min;\n      let grayscale;\n      let hue;\n      if (chroma < 1) {\n        grayscale = min / (1 - chroma);\n      } else {\n        grayscale = 0;\n      }\n      if (chroma <= 0) {\n        hue = 0;\n      } else if (max === r) {\n        hue = (g - b) / chroma % 6;\n      } else if (max === g) {\n        hue = 2 + (b - r) / chroma;\n      } else {\n        hue = 4 + (r - g) / chroma;\n      }\n      hue /= 6;\n      hue %= 1;\n      return [hue * 360, chroma * 100, grayscale * 100];\n    };\n    convert.hsl.hcg = function(hsl) {\n      const s = hsl[1] / 100;\n      const l = hsl[2] / 100;\n      const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);\n      let f = 0;\n      if (c < 1) {\n        f = (l - 0.5 * c) / (1 - c);\n      }\n      return [hsl[0], c * 100, f * 100];\n    };\n    convert.hsv.hcg = function(hsv) {\n      const s = hsv[1] / 100;\n      const v = hsv[2] / 100;\n      const c = s * v;\n      let f = 0;\n      if (c < 1) {\n        f = (v - c) / (1 - c);\n      }\n      return [hsv[0], c * 100, f * 100];\n    };\n    convert.hcg.rgb = function(hcg) {\n      const h = hcg[0] / 360;\n      const c = hcg[1] / 100;\n      const g = hcg[2] / 100;\n      if (c === 0) {\n        return [g * 255, g * 255, g * 255];\n      }\n      const pure = [0, 0, 0];\n      const hi = h % 1 * 6;\n      const v = hi % 1;\n      const w = 1 - v;\n      let mg = 0;\n      switch (Math.floor(hi)) {\n        case 0:\n          pure[0] = 1;\n          pure[1] = v;\n          pure[2] = 0;\n          break;\n        case 1:\n          pure[0] = w;\n          pure[1] = 1;\n          pure[2] = 0;\n          break;\n        case 2:\n          pure[0] = 0;\n          pure[1] = 1;\n          pure[2] = v;\n          break;\n        case 3:\n          pure[0] = 0;\n          pure[1] = w;\n          pure[2] = 1;\n          break;\n        case 4:\n          pure[0] = v;\n          pure[1] = 0;\n          pure[2] = 1;\n          break;\n        default:\n          pure[0] = 1;\n          pure[1] = 0;\n          pure[2] = w;\n      }\n      mg = (1 - c) * g;\n      return [\n        (c * pure[0] + mg) * 255,\n        (c * pure[1] + mg) * 255,\n        (c * pure[2] + mg) * 255\n      ];\n    };\n    convert.hcg.hsv = function(hcg) {\n      const c = hcg[1] / 100;\n      const g = hcg[2] / 100;\n      const v = c + g * (1 - c);\n      let f = 0;\n      if (v > 0) {\n        f = c / v;\n      }\n      return [hcg[0], f * 100, v * 100];\n    };\n    convert.hcg.hsl = function(hcg) {\n      const c = hcg[1] / 100;\n      const g = hcg[2] / 100;\n      const l = g * (1 - c) + 0.5 * c;\n      let s = 0;\n      if (l > 0 && l < 0.5) {\n        s = c / (2 * l);\n      } else if (l >= 0.5 && l < 1) {\n        s = c / (2 * (1 - l));\n      }\n      return [hcg[0], s * 100, l * 100];\n    };\n    convert.hcg.hwb = function(hcg) {\n      const c = hcg[1] / 100;\n      const g = hcg[2] / 100;\n      const v = c + g * (1 - c);\n      return [hcg[0], (v - c) * 100, (1 - v) * 100];\n    };\n    convert.hwb.hcg = function(hwb) {\n      const w = hwb[1] / 100;\n      const b = hwb[2] / 100;\n      const v = 1 - b;\n      const c = v - w;\n      let g = 0;\n      if (c < 1) {\n        g = (v - c) / (1 - c);\n      }\n      return [hwb[0], c * 100, g * 100];\n    };\n    convert.apple.rgb = function(apple) {\n      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];\n    };\n    convert.rgb.apple = function(rgb) {\n      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];\n    };\n    convert.gray.rgb = function(args) {\n      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];\n    };\n    convert.gray.hsl = function(args) {\n      return [0, 0, args[0]];\n    };\n    convert.gray.hsv = convert.gray.hsl;\n    convert.gray.hwb = function(gray) {\n      return [0, 100, gray[0]];\n    };\n    convert.gray.cmyk = function(gray) {\n      return [0, 0, 0, gray[0]];\n    };\n    convert.gray.lab = function(gray) {\n      return [gray[0], 0, 0];\n    };\n    convert.gray.hex = function(gray) {\n      const val = Math.round(gray[0] / 100 * 255) & 255;\n      const integer = (val << 16) + (val << 8) + val;\n      const string = integer.toString(16).toUpperCase();\n      return \"000000\".substring(string.length) + string;\n    };\n    convert.rgb.gray = function(rgb) {\n      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;\n      return [val / 255 * 100];\n    };\n  }\n});\n\n// node_modules/color-convert/route.js\nvar require_route2 = __commonJS({\n  \"node_modules/color-convert/route.js\"(exports2, module2) {\n    var conversions = require_conversions();\n    function buildGraph() {\n      const graph = {};\n      const models = Object.keys(conversions);\n      for (let len = models.length, i = 0; i < len; i++) {\n        graph[models[i]] = {\n          // http://jsperf.com/1-vs-infinity\n          // micro-opt, but this is simple.\n          distance: -1,\n          parent: null\n        };\n      }\n      return graph;\n    }\n    function deriveBFS(fromModel) {\n      const graph = buildGraph();\n      const queue = [fromModel];\n      graph[fromModel].distance = 0;\n      while (queue.length) {\n        const current = queue.pop();\n        const adjacents = Object.keys(conversions[current]);\n        for (let len = adjacents.length, i = 0; i < len; i++) {\n          const adjacent = adjacents[i];\n          const node = graph[adjacent];\n          if (node.distance === -1) {\n            node.distance = graph[current].distance + 1;\n            node.parent = current;\n            queue.unshift(adjacent);\n          }\n        }\n      }\n      return graph;\n    }\n    function link(from, to) {\n      return function(args) {\n        return to(from(args));\n      };\n    }\n    function wrapConversion(toModel, graph) {\n      const path = [graph[toModel].parent, toModel];\n      let fn = conversions[graph[toModel].parent][toModel];\n      let cur = graph[toModel].parent;\n      while (graph[cur].parent) {\n        path.unshift(graph[cur].parent);\n        fn = link(conversions[graph[cur].parent][cur], fn);\n        cur = graph[cur].parent;\n      }\n      fn.conversion = path;\n      return fn;\n    }\n    module2.exports = function(fromModel) {\n      const graph = deriveBFS(fromModel);\n      const conversion = {};\n      const models = Object.keys(graph);\n      for (let len = models.length, i = 0; i < len; i++) {\n        const toModel = models[i];\n        const node = graph[toModel];\n        if (node.parent === null) {\n          continue;\n        }\n        conversion[toModel] = wrapConversion(toModel, graph);\n      }\n      return conversion;\n    };\n  }\n});\n\n// node_modules/color-convert/index.js\nvar require_color_convert = __commonJS({\n  \"node_modules/color-convert/index.js\"(exports2, module2) {\n    var conversions = require_conversions();\n    var route = require_route2();\n    var convert = {};\n    var models = Object.keys(conversions);\n    function wrapRaw(fn) {\n      const wrappedFn = function(...args) {\n        const arg0 = args[0];\n        if (arg0 === void 0 || arg0 === null) {\n          return arg0;\n        }\n        if (arg0.length > 1) {\n          args = arg0;\n        }\n        return fn(args);\n      };\n      if (\"conversion\" in fn) {\n        wrappedFn.conversion = fn.conversion;\n      }\n      return wrappedFn;\n    }\n    function wrapRounded(fn) {\n      const wrappedFn = function(...args) {\n        const arg0 = args[0];\n        if (arg0 === void 0 || arg0 === null) {\n          return arg0;\n        }\n        if (arg0.length > 1) {\n          args = arg0;\n        }\n        const result = fn(args);\n        if (typeof result === \"object\") {\n          for (let len = result.length, i = 0; i < len; i++) {\n            result[i] = Math.round(result[i]);\n          }\n        }\n        return result;\n      };\n      if (\"conversion\" in fn) {\n        wrappedFn.conversion = fn.conversion;\n      }\n      return wrappedFn;\n    }\n    models.forEach((fromModel) => {\n      convert[fromModel] = {};\n      Object.defineProperty(convert[fromModel], \"channels\", { value: conversions[fromModel].channels });\n      Object.defineProperty(convert[fromModel], \"labels\", { value: conversions[fromModel].labels });\n      const routes = route(fromModel);\n      const routeModels = Object.keys(routes);\n      routeModels.forEach((toModel) => {\n        const fn = routes[toModel];\n        convert[fromModel][toModel] = wrapRounded(fn);\n        convert[fromModel][toModel].raw = wrapRaw(fn);\n      });\n    });\n    module2.exports = convert;\n  }\n});\n\n// node_modules/ansi-styles/index.js\nvar require_ansi_styles = __commonJS({\n  \"node_modules/ansi-styles/index.js\"(exports2, module2) {\n    \"use strict\";\n    var wrapAnsi16 = (fn, offset) => (...args) => {\n      const code = fn(...args);\n      return `\\x1B[${code + offset}m`;\n    };\n    var wrapAnsi256 = (fn, offset) => (...args) => {\n      const code = fn(...args);\n      return `\\x1B[${38 + offset};5;${code}m`;\n    };\n    var wrapAnsi16m = (fn, offset) => (...args) => {\n      const rgb = fn(...args);\n      return `\\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;\n    };\n    var ansi2ansi = (n) => n;\n    var rgb2rgb = (r, g, b) => [r, g, b];\n    var setLazyProperty = (object, property, get) => {\n      Object.defineProperty(object, property, {\n        get: () => {\n          const value = get();\n          Object.defineProperty(object, property, {\n            value,\n            enumerable: true,\n            configurable: true\n          });\n          return value;\n        },\n        enumerable: true,\n        configurable: true\n      });\n    };\n    var colorConvert;\n    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {\n      if (colorConvert === void 0) {\n        colorConvert = require_color_convert();\n      }\n      const offset = isBackground ? 10 : 0;\n      const styles = {};\n      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {\n        const name = sourceSpace === \"ansi16\" ? \"ansi\" : sourceSpace;\n        if (sourceSpace === targetSpace) {\n          styles[name] = wrap(identity, offset);\n        } else if (typeof suite === \"object\") {\n          styles[name] = wrap(suite[targetSpace], offset);\n        }\n      }\n      return styles;\n    };\n    function assembleStyles() {\n      const codes = /* @__PURE__ */ new Map();\n      const styles = {\n        modifier: {\n          reset: [0, 0],\n          // 21 isn't widely supported and 22 does the same thing\n          bold: [1, 22],\n          dim: [2, 22],\n          italic: [3, 23],\n          underline: [4, 24],\n          inverse: [7, 27],\n          hidden: [8, 28],\n          strikethrough: [9, 29]\n        },\n        color: {\n          black: [30, 39],\n          red: [31, 39],\n          green: [32, 39],\n          yellow: [33, 39],\n          blue: [34, 39],\n          magenta: [35, 39],\n          cyan: [36, 39],\n          white: [37, 39],\n          // Bright color\n          blackBright: [90, 39],\n          redBright: [91, 39],\n          greenBright: [92, 39],\n          yellowBright: [93, 39],\n          blueBright: [94, 39],\n          magentaBright: [95, 39],\n          cyanBright: [96, 39],\n          whiteBright: [97, 39]\n        },\n        bgColor: {\n          bgBlack: [40, 49],\n          bgRed: [41, 49],\n          bgGreen: [42, 49],\n          bgYellow: [43, 49],\n          bgBlue: [44, 49],\n          bgMagenta: [45, 49],\n          bgCyan: [46, 49],\n          bgWhite: [47, 49],\n          // Bright color\n          bgBlackBright: [100, 49],\n          bgRedBright: [101, 49],\n          bgGreenBright: [102, 49],\n          bgYellowBright: [103, 49],\n          bgBlueBright: [104, 49],\n          bgMagentaBright: [105, 49],\n          bgCyanBright: [106, 49],\n          bgWhiteBright: [107, 49]\n        }\n      };\n      styles.color.gray = styles.color.blackBright;\n      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;\n      styles.color.grey = styles.color.blackBright;\n      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;\n      for (const [groupName, group] of Object.entries(styles)) {\n        for (const [styleName, style] of Object.entries(group)) {\n          styles[styleName] = {\n            open: `\\x1B[${style[0]}m`,\n            close: `\\x1B[${style[1]}m`\n          };\n          group[styleName] = styles[styleName];\n          codes.set(style[0], style[1]);\n        }\n        Object.defineProperty(styles, groupName, {\n          value: group,\n          enumerable: false\n        });\n      }\n      Object.defineProperty(styles, \"codes\", {\n        value: codes,\n        enumerable: false\n      });\n      styles.color.close = \"\\x1B[39m\";\n      styles.bgColor.close = \"\\x1B[49m\";\n      setLazyProperty(styles.color, \"ansi\", () => makeDynamicStyles(wrapAnsi16, \"ansi16\", ansi2ansi, false));\n      setLazyProperty(styles.color, \"ansi256\", () => makeDynamicStyles(wrapAnsi256, \"ansi256\", ansi2ansi, false));\n      setLazyProperty(styles.color, \"ansi16m\", () => makeDynamicStyles(wrapAnsi16m, \"rgb\", rgb2rgb, false));\n      setLazyProperty(styles.bgColor, \"ansi\", () => makeDynamicStyles(wrapAnsi16, \"ansi16\", ansi2ansi, true));\n      setLazyProperty(styles.bgColor, \"ansi256\", () => makeDynamicStyles(wrapAnsi256, \"ansi256\", ansi2ansi, true));\n      setLazyProperty(styles.bgColor, \"ansi16m\", () => makeDynamicStyles(wrapAnsi16m, \"rgb\", rgb2rgb, true));\n      return styles;\n    }\n    Object.defineProperty(module2, \"exports\", {\n      enumerable: true,\n      get: assembleStyles\n    });\n  }\n});\n\n// node_modules/chalk/source/util.js\nvar require_util = __commonJS({\n  \"node_modules/chalk/source/util.js\"(exports2, module2) {\n    \"use strict\";\n    var stringReplaceAll = (string, substring, replacer) => {\n      let index = string.indexOf(substring);\n      if (index === -1) {\n        return string;\n      }\n      const substringLength = substring.length;\n      let endIndex = 0;\n      let returnValue = \"\";\n      do {\n        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;\n        endIndex = index + substringLength;\n        index = string.indexOf(substring, endIndex);\n      } while (index !== -1);\n      returnValue += string.substr(endIndex);\n      return returnValue;\n    };\n    var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {\n      let endIndex = 0;\n      let returnValue = \"\";\n      do {\n        const gotCR = string[index - 1] === \"\\r\";\n        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? \"\\r\\n\" : \"\\n\") + postfix;\n        endIndex = index + 1;\n        index = string.indexOf(\"\\n\", endIndex);\n      } while (index !== -1);\n      returnValue += string.substr(endIndex);\n      return returnValue;\n    };\n    module2.exports = {\n      stringReplaceAll,\n      stringEncaseCRLFWithFirstIndex\n    };\n  }\n});\n\n// node_modules/chalk/source/templates.js\nvar require_templates = __commonJS({\n  \"node_modules/chalk/source/templates.js\"(exports2, module2) {\n    \"use strict\";\n    var TEMPLATE_REGEX = /(?:\\\\(u(?:[a-f\\d]{4}|\\{[a-f\\d]{1,6}\\})|x[a-f\\d]{2}|.))|(?:\\{(~)?(\\w+(?:\\([^)]*\\))?(?:\\.\\w+(?:\\([^)]*\\))?)*)(?:[ \\t]|(?=\\r?\\n)))|(\\})|((?:.|[\\r\\n\\f])+?)/gi;\n    var STYLE_REGEX = /(?:^|\\.)(\\w+)(?:\\(([^)]*)\\))?/g;\n    var STRING_REGEX = /^(['\"])((?:\\\\.|(?!\\1)[^\\\\])*)\\1$/;\n    var ESCAPE_REGEX = /\\\\(u(?:[a-f\\d]{4}|{[a-f\\d]{1,6}})|x[a-f\\d]{2}|.)|([^\\\\])/gi;\n    var ESCAPES = /* @__PURE__ */ new Map([\n      [\"n\", \"\\n\"],\n      [\"r\", \"\\r\"],\n      [\"t\", \"\t\"],\n      [\"b\", \"\\b\"],\n      [\"f\", \"\\f\"],\n      [\"v\", \"\\v\"],\n      [\"0\", \"\\0\"],\n      [\"\\\\\", \"\\\\\"],\n      [\"e\", \"\\x1B\"],\n      [\"a\", \"\\x07\"]\n    ]);\n    function unescape2(c) {\n      const u = c[0] === \"u\";\n      const bracket = c[1] === \"{\";\n      if (u && !bracket && c.length === 5 || c[0] === \"x\" && c.length === 3) {\n        return String.fromCharCode(parseInt(c.slice(1), 16));\n      }\n      if (u && bracket) {\n        return String.fromCodePoint(parseInt(c.slice(2, -1), 16));\n      }\n      return ESCAPES.get(c) || c;\n    }\n    function parseArguments(name, arguments_) {\n      const results = [];\n      const chunks = arguments_.trim().split(/\\s*,\\s*/g);\n      let matches;\n      for (const chunk of chunks) {\n        const number = Number(chunk);\n        if (!Number.isNaN(number)) {\n          results.push(number);\n        } else if (matches = chunk.match(STRING_REGEX)) {\n          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape2, character) => escape2 ? unescape2(escape2) : character));\n        } else {\n          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);\n        }\n      }\n      return results;\n    }\n    function parseStyle(style) {\n      STYLE_REGEX.lastIndex = 0;\n      const results = [];\n      let matches;\n      while ((matches = STYLE_REGEX.exec(style)) !== null) {\n        const name = matches[1];\n        if (matches[2]) {\n          const args = parseArguments(name, matches[2]);\n          results.push([name].concat(args));\n        } else {\n          results.push([name]);\n        }\n      }\n      return results;\n    }\n    function buildStyle(chalk2, styles) {\n      const enabled = {};\n      for (const layer of styles) {\n        for (const style of layer.styles) {\n          enabled[style[0]] = layer.inverse ? null : style.slice(1);\n        }\n      }\n      let current = chalk2;\n      for (const [styleName, styles2] of Object.entries(enabled)) {\n        if (!Array.isArray(styles2)) {\n          continue;\n        }\n        if (!(styleName in current)) {\n          throw new Error(`Unknown Chalk style: ${styleName}`);\n        }\n        current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];\n      }\n      return current;\n    }\n    module2.exports = (chalk2, temporary) => {\n      const styles = [];\n      const chunks = [];\n      let chunk = [];\n      temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {\n        if (escapeCharacter) {\n          chunk.push(unescape2(escapeCharacter));\n        } else if (style) {\n          const string = chunk.join(\"\");\n          chunk = [];\n          chunks.push(styles.length === 0 ? string : buildStyle(chalk2, styles)(string));\n          styles.push({ inverse, styles: parseStyle(style) });\n        } else if (close) {\n          if (styles.length === 0) {\n            throw new Error(\"Found extraneous } in Chalk template literal\");\n          }\n          chunks.push(buildStyle(chalk2, styles)(chunk.join(\"\")));\n          chunk = [];\n          styles.pop();\n        } else {\n          chunk.push(character);\n        }\n      });\n      chunks.push(chunk.join(\"\"));\n      if (styles.length > 0) {\n        const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? \"\" : \"s\"} (\\`}\\`)`;\n        throw new Error(errMessage);\n      }\n      return chunks.join(\"\");\n    };\n  }\n});\n\n// node_modules/chalk/source/index.js\nvar require_source = __commonJS({\n  \"node_modules/chalk/source/index.js\"(exports2, module2) {\n    \"use strict\";\n    var ansiStyles = require_ansi_styles();\n    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();\n    var {\n      stringReplaceAll,\n      stringEncaseCRLFWithFirstIndex\n    } = require_util();\n    var { isArray } = Array;\n    var levelMapping = [\n      \"ansi\",\n      \"ansi\",\n      \"ansi256\",\n      \"ansi16m\"\n    ];\n    var styles = /* @__PURE__ */ Object.create(null);\n    var applyOptions = (object, options = {}) => {\n      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {\n        throw new Error(\"The `level` option should be an integer from 0 to 3\");\n      }\n      const colorLevel = stdoutColor ? stdoutColor.level : 0;\n      object.level = options.level === void 0 ? colorLevel : options.level;\n    };\n    var ChalkClass = class {\n      constructor(options) {\n        return chalkFactory(options);\n      }\n    };\n    var chalkFactory = (options) => {\n      const chalk3 = {};\n      applyOptions(chalk3, options);\n      chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_);\n      Object.setPrototypeOf(chalk3, Chalk.prototype);\n      Object.setPrototypeOf(chalk3.template, chalk3);\n      chalk3.template.constructor = () => {\n        throw new Error(\"`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.\");\n      };\n      chalk3.template.Instance = ChalkClass;\n      return chalk3.template;\n    };\n    function Chalk(options) {\n      return chalkFactory(options);\n    }\n    for (const [styleName, style] of Object.entries(ansiStyles)) {\n      styles[styleName] = {\n        get() {\n          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);\n          Object.defineProperty(this, styleName, { value: builder });\n          return builder;\n        }\n      };\n    }\n    styles.visible = {\n      get() {\n        const builder = createBuilder(this, this._styler, true);\n        Object.defineProperty(this, \"visible\", { value: builder });\n        return builder;\n      }\n    };\n    var usedModels = [\"rgb\", \"hex\", \"keyword\", \"hsl\", \"hsv\", \"hwb\", \"ansi\", \"ansi256\"];\n    for (const model of usedModels) {\n      styles[model] = {\n        get() {\n          const { level } = this;\n          return function(...arguments_) {\n            const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);\n            return createBuilder(this, styler, this._isEmpty);\n          };\n        }\n      };\n    }\n    for (const model of usedModels) {\n      const bgModel = \"bg\" + model[0].toUpperCase() + model.slice(1);\n      styles[bgModel] = {\n        get() {\n          const { level } = this;\n          return function(...arguments_) {\n            const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);\n            return createBuilder(this, styler, this._isEmpty);\n          };\n        }\n      };\n    }\n    var proto = Object.defineProperties(() => {\n    }, {\n      ...styles,\n      level: {\n        enumerable: true,\n        get() {\n          return this._generator.level;\n        },\n        set(level) {\n          this._generator.level = level;\n        }\n      }\n    });\n    var createStyler = (open, close, parent) => {\n      let openAll;\n      let closeAll;\n      if (parent === void 0) {\n        openAll = open;\n        closeAll = close;\n      } else {\n        openAll = parent.openAll + open;\n        closeAll = close + parent.closeAll;\n      }\n      return {\n        open,\n        close,\n        openAll,\n        closeAll,\n        parent\n      };\n    };\n    var createBuilder = (self2, _styler, _isEmpty) => {\n      const builder = (...arguments_) => {\n        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {\n          return applyStyle(builder, chalkTag(builder, ...arguments_));\n        }\n        return applyStyle(builder, arguments_.length === 1 ? \"\" + arguments_[0] : arguments_.join(\" \"));\n      };\n      Object.setPrototypeOf(builder, proto);\n      builder._generator = self2;\n      builder._styler = _styler;\n      builder._isEmpty = _isEmpty;\n      return builder;\n    };\n    var applyStyle = (self2, string) => {\n      if (self2.level <= 0 || !string) {\n        return self2._isEmpty ? \"\" : string;\n      }\n      let styler = self2._styler;\n      if (styler === void 0) {\n        return string;\n      }\n      const { openAll, closeAll } = styler;\n      if (string.indexOf(\"\\x1B\") !== -1) {\n        while (styler !== void 0) {\n          string = stringReplaceAll(string, styler.close, styler.open);\n          styler = styler.parent;\n        }\n      }\n      const lfIndex = string.indexOf(\"\\n\");\n      if (lfIndex !== -1) {\n        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);\n      }\n      return openAll + string + closeAll;\n    };\n    var template;\n    var chalkTag = (chalk3, ...strings) => {\n      const [firstString] = strings;\n      if (!isArray(firstString) || !isArray(firstString.raw)) {\n        return strings.join(\" \");\n      }\n      const arguments_ = strings.slice(1);\n      const parts = [firstString.raw[0]];\n      for (let i = 1; i < firstString.length; i++) {\n        parts.push(\n          String(arguments_[i - 1]).replace(/[{}\\\\]/g, \"\\\\$&\"),\n          String(firstString.raw[i])\n        );\n      }\n      if (template === void 0) {\n        template = require_templates();\n      }\n      return template(chalk3, parts.join(\"\"));\n    };\n    Object.defineProperties(Chalk.prototype, styles);\n    var chalk2 = Chalk();\n    chalk2.supportsColor = stdoutColor;\n    chalk2.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });\n    chalk2.stderr.supportsColor = stderrColor;\n    module2.exports = chalk2;\n  }\n});\n\n// node_modules/object-assign/index.js\nvar require_object_assign = __commonJS({\n  \"node_modules/object-assign/index.js\"(exports2, module2) {\n    \"use strict\";\n    var getOwnPropertySymbols = Object.getOwnPropertySymbols;\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n    var propIsEnumerable = Object.prototype.propertyIsEnumerable;\n    function toObject(val) {\n      if (val === null || val === void 0) {\n        throw new TypeError(\"Object.assign cannot be called with null or undefined\");\n      }\n      return Object(val);\n    }\n    function shouldUseNative() {\n      try {\n        if (!Object.assign) {\n          return false;\n        }\n        var test1 = new String(\"abc\");\n        test1[5] = \"de\";\n        if (Object.getOwnPropertyNames(test1)[0] === \"5\") {\n          return false;\n        }\n        var test2 = {};\n        for (var i = 0; i < 10; i++) {\n          test2[\"_\" + String.fromCharCode(i)] = i;\n        }\n        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {\n          return test2[n];\n        });\n        if (order2.join(\"\") !== \"0123456789\") {\n          return false;\n        }\n        var test3 = {};\n        \"abcdefghijklmnopqrst\".split(\"\").forEach(function(letter) {\n          test3[letter] = letter;\n        });\n        if (Object.keys(Object.assign({}, test3)).join(\"\") !== \"abcdefghijklmnopqrst\") {\n          return false;\n        }\n        return true;\n      } catch (err2) {\n        return false;\n      }\n    }\n    module2.exports = shouldUseNative() ? Object.assign : function(target, source) {\n      var from;\n      var to = toObject(target);\n      var symbols;\n      for (var s = 1; s < arguments.length; s++) {\n        from = Object(arguments[s]);\n        for (var key in from) {\n          if (hasOwnProperty.call(from, key)) {\n            to[key] = from[key];\n          }\n        }\n        if (getOwnPropertySymbols) {\n          symbols = getOwnPropertySymbols(from);\n          for (var i = 0; i < symbols.length; i++) {\n            if (propIsEnumerable.call(from, symbols[i])) {\n              to[symbols[i]] = from[symbols[i]];\n            }\n          }\n        }\n      }\n      return to;\n    };\n  }\n});\n\n// node_modules/cors/lib/index.js\nvar require_lib4 = __commonJS({\n  \"node_modules/cors/lib/index.js\"(exports2, module2) {\n    (function() {\n      \"use strict\";\n      var assign = require_object_assign();\n      var vary = require_vary();\n      var defaults = {\n        origin: \"*\",\n        methods: \"GET,HEAD,PUT,PATCH,POST,DELETE\",\n        preflightContinue: false,\n        optionsSuccessStatus: 204\n      };\n      function isString(s) {\n        return typeof s === \"string\" || s instanceof String;\n      }\n      function isOriginAllowed(origin, allowedOrigin) {\n        if (Array.isArray(allowedOrigin)) {\n          for (var i = 0; i < allowedOrigin.length; ++i) {\n            if (isOriginAllowed(origin, allowedOrigin[i])) {\n              return true;\n            }\n          }\n          return false;\n        } else if (isString(allowedOrigin)) {\n          return origin === allowedOrigin;\n        } else if (allowedOrigin instanceof RegExp) {\n          return allowedOrigin.test(origin);\n        } else {\n          return !!allowedOrigin;\n        }\n      }\n      function configureOrigin(options, req) {\n        var requestOrigin = req.headers.origin, headers = [], isAllowed;\n        if (!options.origin || options.origin === \"*\") {\n          headers.push([{\n            key: \"Access-Control-Allow-Origin\",\n            value: \"*\"\n          }]);\n        } else if (isString(options.origin)) {\n          headers.push([{\n            key: \"Access-Control-Allow-Origin\",\n            value: options.origin\n          }]);\n          headers.push([{\n            key: \"Vary\",\n            value: \"Origin\"\n          }]);\n        } else {\n          isAllowed = isOriginAllowed(requestOrigin, options.origin);\n          headers.push([{\n            key: \"Access-Control-Allow-Origin\",\n            value: isAllowed ? requestOrigin : false\n          }]);\n          headers.push([{\n            key: \"Vary\",\n            value: \"Origin\"\n          }]);\n        }\n        return headers;\n      }\n      function configureMethods(options) {\n        var methods = options.methods;\n        if (methods.join) {\n          methods = options.methods.join(\",\");\n        }\n        return {\n          key: \"Access-Control-Allow-Methods\",\n          value: methods\n        };\n      }\n      function configureCredentials(options) {\n        if (options.credentials === true) {\n          return {\n            key: \"Access-Control-Allow-Credentials\",\n            value: \"true\"\n          };\n        }\n        return null;\n      }\n      function configureAllowedHeaders(options, req) {\n        var allowedHeaders = options.allowedHeaders || options.headers;\n        var headers = [];\n        if (!allowedHeaders) {\n          allowedHeaders = req.headers[\"access-control-request-headers\"];\n          headers.push([{\n            key: \"Vary\",\n            value: \"Access-Control-Request-Headers\"\n          }]);\n        } else if (allowedHeaders.join) {\n          allowedHeaders = allowedHeaders.join(\",\");\n        }\n        if (allowedHeaders && allowedHeaders.length) {\n          headers.push([{\n            key: \"Access-Control-Allow-Headers\",\n            value: allowedHeaders\n          }]);\n        }\n        return headers;\n      }\n      function configureExposedHeaders(options) {\n        var headers = options.exposedHeaders;\n        if (!headers) {\n          return null;\n        } else if (headers.join) {\n          headers = headers.join(\",\");\n        }\n        if (headers && headers.length) {\n          return {\n            key: \"Access-Control-Expose-Headers\",\n            value: headers\n          };\n        }\n        return null;\n      }\n      function configureMaxAge(options) {\n        var maxAge = (typeof options.maxAge === \"number\" || options.maxAge) && options.maxAge.toString();\n        if (maxAge && maxAge.length) {\n          return {\n            key: \"Access-Control-Max-Age\",\n            value: maxAge\n          };\n        }\n        return null;\n      }\n      function applyHeaders(headers, res) {\n        for (var i = 0, n = headers.length; i < n; i++) {\n          var header = headers[i];\n          if (header) {\n            if (Array.isArray(header)) {\n              applyHeaders(header, res);\n            } else if (header.key === \"Vary\" && header.value) {\n              vary(res, header.value);\n            } else if (header.value) {\n              res.setHeader(header.key, header.value);\n            }\n          }\n        }\n      }\n      function cors2(options, req, res, next) {\n        var headers = [], method = req.method && req.method.toUpperCase && req.method.toUpperCase();\n        if (method === \"OPTIONS\") {\n          headers.push(configureOrigin(options, req));\n          headers.push(configureCredentials(options, req));\n          headers.push(configureMethods(options, req));\n          headers.push(configureAllowedHeaders(options, req));\n          headers.push(configureMaxAge(options, req));\n          headers.push(configureExposedHeaders(options, req));\n          applyHeaders(headers, res);\n          if (options.preflightContinue) {\n            next();\n          } else {\n            res.statusCode = options.optionsSuccessStatus;\n            res.setHeader(\"Content-Length\", \"0\");\n            res.end();\n          }\n        } else {\n          headers.push(configureOrigin(options, req));\n          headers.push(configureCredentials(options, req));\n          headers.push(configureExposedHeaders(options, req));\n          applyHeaders(headers, res);\n          next();\n        }\n      }\n      function middlewareWrapper(o) {\n        var optionsCallback = null;\n        if (typeof o === \"function\") {\n          optionsCallback = o;\n        } else {\n          optionsCallback = function(req, cb) {\n            cb(null, o);\n          };\n        }\n        return function corsMiddleware(req, res, next) {\n          optionsCallback(req, function(err2, options) {\n            if (err2) {\n              next(err2);\n            } else {\n              var corsOptions = assign({}, defaults, options);\n              var originCallback = null;\n              if (corsOptions.origin && typeof corsOptions.origin === \"function\") {\n                originCallback = corsOptions.origin;\n              } else if (corsOptions.origin) {\n                originCallback = function(origin, cb) {\n                  cb(null, corsOptions.origin);\n                };\n              }\n              if (originCallback) {\n                originCallback(req.headers.origin, function(err22, origin) {\n                  if (err22 || !origin) {\n                    next(err22);\n                  } else {\n                    corsOptions.origin = origin;\n                    cors2(corsOptions, req, res, next);\n                  }\n                });\n              } else {\n                next();\n              }\n            }\n          });\n        };\n      }\n      module2.exports = middlewareWrapper;\n    })();\n  }\n});\n\n// node_modules/zod/lib/index.mjs\nvar util;\n(function(util2) {\n  util2.assertEqual = (val) => val;\n  function assertIs(_arg) {\n  }\n  util2.assertIs = assertIs;\n  function assertNever(_x) {\n    throw new Error();\n  }\n  util2.assertNever = assertNever;\n  util2.arrayToEnum = (items) => {\n    const obj = {};\n    for (const item of items) {\n      obj[item] = item;\n    }\n    return obj;\n  };\n  util2.getValidEnumValues = (obj) => {\n    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== \"number\");\n    const filtered = {};\n    for (const k of validKeys) {\n      filtered[k] = obj[k];\n    }\n    return util2.objectValues(filtered);\n  };\n  util2.objectValues = (obj) => {\n    return util2.objectKeys(obj).map(function(e) {\n      return obj[e];\n    });\n  };\n  util2.objectKeys = typeof Object.keys === \"function\" ? (obj) => Object.keys(obj) : (object) => {\n    const keys = [];\n    for (const key in object) {\n      if (Object.prototype.hasOwnProperty.call(object, key)) {\n        keys.push(key);\n      }\n    }\n    return keys;\n  };\n  util2.find = (arr, checker) => {\n    for (const item of arr) {\n      if (checker(item))\n        return item;\n    }\n    return void 0;\n  };\n  util2.isInteger = typeof Number.isInteger === \"function\" ? (val) => Number.isInteger(val) : (val) => typeof val === \"number\" && isFinite(val) && Math.floor(val) === val;\n  function joinValues(array, separator = \" | \") {\n    return array.map((val) => typeof val === \"string\" ? `'${val}'` : val).join(separator);\n  }\n  util2.joinValues = joinValues;\n  util2.jsonStringifyReplacer = (_2, value) => {\n    if (typeof value === \"bigint\") {\n      return value.toString();\n    }\n    return value;\n  };\n})(util || (util = {}));\nvar objectUtil;\n(function(objectUtil2) {\n  objectUtil2.mergeShapes = (first, second) => {\n    return {\n      ...first,\n      ...second\n      // second overwrites first\n    };\n  };\n})(objectUtil || (objectUtil = {}));\nvar ZodParsedType = util.arrayToEnum([\n  \"string\",\n  \"nan\",\n  \"number\",\n  \"integer\",\n  \"float\",\n  \"boolean\",\n  \"date\",\n  \"bigint\",\n  \"symbol\",\n  \"function\",\n  \"undefined\",\n  \"null\",\n  \"array\",\n  \"object\",\n  \"unknown\",\n  \"promise\",\n  \"void\",\n  \"never\",\n  \"map\",\n  \"set\"\n]);\nvar getParsedType = (data) => {\n  const t = typeof data;\n  switch (t) {\n    case \"undefined\":\n      return ZodParsedType.undefined;\n    case \"string\":\n      return ZodParsedType.string;\n    case \"number\":\n      return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;\n    case \"boolean\":\n      return ZodParsedType.boolean;\n    case \"function\":\n      return ZodParsedType.function;\n    case \"bigint\":\n      return ZodParsedType.bigint;\n    case \"symbol\":\n      return ZodParsedType.symbol;\n    case \"object\":\n      if (Array.isArray(data)) {\n        return ZodParsedType.array;\n      }\n      if (data === null) {\n        return ZodParsedType.null;\n      }\n      if (data.then && typeof data.then === \"function\" && data.catch && typeof data.catch === \"function\") {\n        return ZodParsedType.promise;\n      }\n      if (typeof Map !== \"undefined\" && data instanceof Map) {\n        return ZodParsedType.map;\n      }\n      if (typeof Set !== \"undefined\" && data instanceof Set) {\n        return ZodParsedType.set;\n      }\n      if (typeof Date !== \"undefined\" && data instanceof Date) {\n        return ZodParsedType.date;\n      }\n      return ZodParsedType.object;\n    default:\n      return ZodParsedType.unknown;\n  }\n};\nvar ZodIssueCode = util.arrayToEnum([\n  \"invalid_type\",\n  \"invalid_literal\",\n  \"custom\",\n  \"invalid_union\",\n  \"invalid_union_discriminator\",\n  \"invalid_enum_value\",\n  \"unrecognized_keys\",\n  \"invalid_arguments\",\n  \"invalid_return_type\",\n  \"invalid_date\",\n  \"invalid_string\",\n  \"too_small\",\n  \"too_big\",\n  \"invalid_intersection_types\",\n  \"not_multiple_of\",\n  \"not_finite\"\n]);\nvar quotelessJson = (obj) => {\n  const json = JSON.stringify(obj, null, 2);\n  return json.replace(/\"([^\"]+)\":/g, \"$1:\");\n};\nvar ZodError = class _ZodError extends Error {\n  get errors() {\n    return this.issues;\n  }\n  constructor(issues) {\n    super();\n    this.issues = [];\n    this.addIssue = (sub) => {\n      this.issues = [...this.issues, sub];\n    };\n    this.addIssues = (subs = []) => {\n      this.issues = [...this.issues, ...subs];\n    };\n    const actualProto = new.target.prototype;\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(this, actualProto);\n    } else {\n      this.__proto__ = actualProto;\n    }\n    this.name = \"ZodError\";\n    this.issues = issues;\n  }\n  format(_mapper) {\n    const mapper = _mapper || function(issue) {\n      return issue.message;\n    };\n    const fieldErrors = { _errors: [] };\n    const processError = (error) => {\n      for (const issue of error.issues) {\n        if (issue.code === \"invalid_union\") {\n          issue.unionErrors.map(processError);\n        } else if (issue.code === \"invalid_return_type\") {\n          processError(issue.returnTypeError);\n        } else if (issue.code === \"invalid_arguments\") {\n          processError(issue.argumentsError);\n        } else if (issue.path.length === 0) {\n          fieldErrors._errors.push(mapper(issue));\n        } else {\n          let curr = fieldErrors;\n          let i = 0;\n          while (i < issue.path.length) {\n            const el = issue.path[i];\n            const terminal = i === issue.path.length - 1;\n            if (!terminal) {\n              curr[el] = curr[el] || { _errors: [] };\n            } else {\n              curr[el] = curr[el] || { _errors: [] };\n              curr[el]._errors.push(mapper(issue));\n            }\n            curr = curr[el];\n            i++;\n          }\n        }\n      }\n    };\n    processError(this);\n    return fieldErrors;\n  }\n  static assert(value) {\n    if (!(value instanceof _ZodError)) {\n      throw new Error(`Not a ZodError: ${value}`);\n    }\n  }\n  toString() {\n    return this.message;\n  }\n  get message() {\n    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);\n  }\n  get isEmpty() {\n    return this.issues.length === 0;\n  }\n  flatten(mapper = (issue) => issue.message) {\n    const fieldErrors = {};\n    const formErrors = [];\n    for (const sub of this.issues) {\n      if (sub.path.length > 0) {\n        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];\n        fieldErrors[sub.path[0]].push(mapper(sub));\n      } else {\n        formErrors.push(mapper(sub));\n      }\n    }\n    return { formErrors, fieldErrors };\n  }\n  get formErrors() {\n    return this.flatten();\n  }\n};\nZodError.create = (issues) => {\n  const error = new ZodError(issues);\n  return error;\n};\nvar errorMap = (issue, _ctx) => {\n  let message;\n  switch (issue.code) {\n    case ZodIssueCode.invalid_type:\n      if (issue.received === ZodParsedType.undefined) {\n        message = \"Required\";\n      } else {\n        message = `Expected ${issue.expected}, received ${issue.received}`;\n      }\n      break;\n    case ZodIssueCode.invalid_literal:\n      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;\n      break;\n    case ZodIssueCode.unrecognized_keys:\n      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, \", \")}`;\n      break;\n    case ZodIssueCode.invalid_union:\n      message = `Invalid input`;\n      break;\n    case ZodIssueCode.invalid_union_discriminator:\n      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;\n      break;\n    case ZodIssueCode.invalid_enum_value:\n      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;\n      break;\n    case ZodIssueCode.invalid_arguments:\n      message = `Invalid function arguments`;\n      break;\n    case ZodIssueCode.invalid_return_type:\n      message = `Invalid function return type`;\n      break;\n    case ZodIssueCode.invalid_date:\n      message = `Invalid date`;\n      break;\n    case ZodIssueCode.invalid_string:\n      if (typeof issue.validation === \"object\") {\n        if (\"includes\" in issue.validation) {\n          message = `Invalid input: must include \"${issue.validation.includes}\"`;\n          if (typeof issue.validation.position === \"number\") {\n            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;\n          }\n        } else if (\"startsWith\" in issue.validation) {\n          message = `Invalid input: must start with \"${issue.validation.startsWith}\"`;\n        } else if (\"endsWith\" in issue.validation) {\n          message = `Invalid input: must end with \"${issue.validation.endsWith}\"`;\n        } else {\n          util.assertNever(issue.validation);\n        }\n      } else if (issue.validation !== \"regex\") {\n        message = `Invalid ${issue.validation}`;\n      } else {\n        message = \"Invalid\";\n      }\n      break;\n    case ZodIssueCode.too_small:\n      if (issue.type === \"array\")\n        message = `Array must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;\n      else if (issue.type === \"string\")\n        message = `String must contain ${issue.exact ? \"exactly\" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;\n      else if (issue.type === \"number\")\n        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;\n      else if (issue.type === \"date\")\n        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;\n      else\n        message = \"Invalid input\";\n      break;\n    case ZodIssueCode.too_big:\n      if (issue.type === \"array\")\n        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;\n      else if (issue.type === \"string\")\n        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;\n      else if (issue.type === \"number\")\n        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n      else if (issue.type === \"bigint\")\n        message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;\n      else if (issue.type === \"date\")\n        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;\n      else\n        message = \"Invalid input\";\n      break;\n    case ZodIssueCode.custom:\n      message = `Invalid input`;\n      break;\n    case ZodIssueCode.invalid_intersection_types:\n      message = `Intersection results could not be merged`;\n      break;\n    case ZodIssueCode.not_multiple_of:\n      message = `Number must be a multiple of ${issue.multipleOf}`;\n      break;\n    case ZodIssueCode.not_finite:\n      message = \"Number must be finite\";\n      break;\n    default:\n      message = _ctx.defaultError;\n      util.assertNever(issue);\n  }\n  return { message };\n};\nvar overrideErrorMap = errorMap;\nfunction setErrorMap(map) {\n  overrideErrorMap = map;\n}\nfunction getErrorMap() {\n  return overrideErrorMap;\n}\nvar makeIssue = (params) => {\n  const { data, path, errorMaps, issueData } = params;\n  const fullPath = [...path, ...issueData.path || []];\n  const fullIssue = {\n    ...issueData,\n    path: fullPath\n  };\n  if (issueData.message !== void 0) {\n    return {\n      ...issueData,\n      path: fullPath,\n      message: issueData.message\n    };\n  }\n  let errorMessage = \"\";\n  const maps = errorMaps.filter((m) => !!m).slice().reverse();\n  for (const map of maps) {\n    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;\n  }\n  return {\n    ...issueData,\n    path: fullPath,\n    message: errorMessage\n  };\n};\nvar EMPTY_PATH = [];\nfunction addIssueToContext(ctx, issueData) {\n  const overrideMap = getErrorMap();\n  const issue = makeIssue({\n    issueData,\n    data: ctx.data,\n    path: ctx.path,\n    errorMaps: [\n      ctx.common.contextualErrorMap,\n      // contextual error map is first priority\n      ctx.schemaErrorMap,\n      // then schema-bound map if available\n      overrideMap,\n      // then global override map\n      overrideMap === errorMap ? void 0 : errorMap\n      // then global default map\n    ].filter((x) => !!x)\n  });\n  ctx.common.issues.push(issue);\n}\nvar ParseStatus = class _ParseStatus {\n  constructor() {\n    this.value = \"valid\";\n  }\n  dirty() {\n    if (this.value === \"valid\")\n      this.value = \"dirty\";\n  }\n  abort() {\n    if (this.value !== \"aborted\")\n      this.value = \"aborted\";\n  }\n  static mergeArray(status, results) {\n    const arrayValue = [];\n    for (const s of results) {\n      if (s.status === \"aborted\")\n        return INVALID;\n      if (s.status === \"dirty\")\n        status.dirty();\n      arrayValue.push(s.value);\n    }\n    return { status: status.value, value: arrayValue };\n  }\n  static async mergeObjectAsync(status, pairs) {\n    const syncPairs = [];\n    for (const pair of pairs) {\n      const key = await pair.key;\n      const value = await pair.value;\n      syncPairs.push({\n        key,\n        value\n      });\n    }\n    return _ParseStatus.mergeObjectSync(status, syncPairs);\n  }\n  static mergeObjectSync(status, pairs) {\n    const finalObject = {};\n    for (const pair of pairs) {\n      const { key, value } = pair;\n      if (key.status === \"aborted\")\n        return INVALID;\n      if (value.status === \"aborted\")\n        return INVALID;\n      if (key.status === \"dirty\")\n        status.dirty();\n      if (value.status === \"dirty\")\n        status.dirty();\n      if (key.value !== \"__proto__\" && (typeof value.value !== \"undefined\" || pair.alwaysSet)) {\n        finalObject[key.value] = value.value;\n      }\n    }\n    return { status: status.value, value: finalObject };\n  }\n};\nvar INVALID = Object.freeze({\n  status: \"aborted\"\n});\nvar DIRTY = (value) => ({ status: \"dirty\", value });\nvar OK = (value) => ({ status: \"valid\", value });\nvar isAborted = (x) => x.status === \"aborted\";\nvar isDirty = (x) => x.status === \"dirty\";\nvar isValid = (x) => x.status === \"valid\";\nvar isAsync = (x) => typeof Promise !== \"undefined\" && x instanceof Promise;\nfunction __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\nfunction __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;\n}\nvar errorUtil;\n(function(errorUtil2) {\n  errorUtil2.errToObj = (message) => typeof message === \"string\" ? { message } : message || {};\n  errorUtil2.toString = (message) => typeof message === \"string\" ? message : message === null || message === void 0 ? void 0 : message.message;\n})(errorUtil || (errorUtil = {}));\nvar _ZodEnum_cache;\nvar _ZodNativeEnum_cache;\nvar ParseInputLazyPath = class {\n  constructor(parent, value, path, key) {\n    this._cachedPath = [];\n    this.parent = parent;\n    this.data = value;\n    this._path = path;\n    this._key = key;\n  }\n  get path() {\n    if (!this._cachedPath.length) {\n      if (this._key instanceof Array) {\n        this._cachedPath.push(...this._path, ...this._key);\n      } else {\n        this._cachedPath.push(...this._path, this._key);\n      }\n    }\n    return this._cachedPath;\n  }\n};\nvar handleResult = (ctx, result) => {\n  if (isValid(result)) {\n    return { success: true, data: result.value };\n  } else {\n    if (!ctx.common.issues.length) {\n      throw new Error(\"Validation failed but no issues detected.\");\n    }\n    return {\n      success: false,\n      get error() {\n        if (this._error)\n          return this._error;\n        const error = new ZodError(ctx.common.issues);\n        this._error = error;\n        return this._error;\n      }\n    };\n  }\n};\nfunction processCreateParams(params) {\n  if (!params)\n    return {};\n  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;\n  if (errorMap2 && (invalid_type_error || required_error)) {\n    throw new Error(`Can't use \"invalid_type_error\" or \"required_error\" in conjunction with custom error map.`);\n  }\n  if (errorMap2)\n    return { errorMap: errorMap2, description };\n  const customMap = (iss, ctx) => {\n    var _a, _b;\n    const { message } = params;\n    if (iss.code === \"invalid_enum_value\") {\n      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };\n    }\n    if (typeof ctx.data === \"undefined\") {\n      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };\n    }\n    if (iss.code !== \"invalid_type\")\n      return { message: ctx.defaultError };\n    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };\n  };\n  return { errorMap: customMap, description };\n}\nvar ZodType = class {\n  get description() {\n    return this._def.description;\n  }\n  _getType(input) {\n    return getParsedType(input.data);\n  }\n  _getOrReturnCtx(input, ctx) {\n    return ctx || {\n      common: input.parent.common,\n      data: input.data,\n      parsedType: getParsedType(input.data),\n      schemaErrorMap: this._def.errorMap,\n      path: input.path,\n      parent: input.parent\n    };\n  }\n  _processInputParams(input) {\n    return {\n      status: new ParseStatus(),\n      ctx: {\n        common: input.parent.common,\n        data: input.data,\n        parsedType: getParsedType(input.data),\n        schemaErrorMap: this._def.errorMap,\n        path: input.path,\n        parent: input.parent\n      }\n    };\n  }\n  _parseSync(input) {\n    const result = this._parse(input);\n    if (isAsync(result)) {\n      throw new Error(\"Synchronous parse encountered promise.\");\n    }\n    return result;\n  }\n  _parseAsync(input) {\n    const result = this._parse(input);\n    return Promise.resolve(result);\n  }\n  parse(data, params) {\n    const result = this.safeParse(data, params);\n    if (result.success)\n      return result.data;\n    throw result.error;\n  }\n  safeParse(data, params) {\n    var _a;\n    const ctx = {\n      common: {\n        issues: [],\n        async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,\n        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap\n      },\n      path: (params === null || params === void 0 ? void 0 : params.path) || [],\n      schemaErrorMap: this._def.errorMap,\n      parent: null,\n      data,\n      parsedType: getParsedType(data)\n    };\n    const result = this._parseSync({ data, path: ctx.path, parent: ctx });\n    return handleResult(ctx, result);\n  }\n  \"~validate\"(data) {\n    var _a, _b;\n    const ctx = {\n      common: {\n        issues: [],\n        async: !!this[\"~standard\"].async\n      },\n      path: [],\n      schemaErrorMap: this._def.errorMap,\n      parent: null,\n      data,\n      parsedType: getParsedType(data)\n    };\n    if (!this[\"~standard\"].async) {\n      try {\n        const result = this._parseSync({ data, path: [], parent: ctx });\n        return isValid(result) ? {\n          value: result.value\n        } : {\n          issues: ctx.common.issues\n        };\n      } catch (err2) {\n        if ((_b = (_a = err2 === null || err2 === void 0 ? void 0 : err2.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes(\"encountered\")) {\n          this[\"~standard\"].async = true;\n        }\n        ctx.common = {\n          issues: [],\n          async: true\n        };\n      }\n    }\n    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {\n      value: result.value\n    } : {\n      issues: ctx.common.issues\n    });\n  }\n  async parseAsync(data, params) {\n    const result = await this.safeParseAsync(data, params);\n    if (result.success)\n      return result.data;\n    throw result.error;\n  }\n  async safeParseAsync(data, params) {\n    const ctx = {\n      common: {\n        issues: [],\n        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,\n        async: true\n      },\n      path: (params === null || params === void 0 ? void 0 : params.path) || [],\n      schemaErrorMap: this._def.errorMap,\n      parent: null,\n      data,\n      parsedType: getParsedType(data)\n    };\n    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });\n    const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));\n    return handleResult(ctx, result);\n  }\n  refine(check, message) {\n    const getIssueProperties = (val) => {\n      if (typeof message === \"string\" || typeof message === \"undefined\") {\n        return { message };\n      } else if (typeof message === \"function\") {\n        return message(val);\n      } else {\n        return message;\n      }\n    };\n    return this._refinement((val, ctx) => {\n      const result = check(val);\n      const setError = () => ctx.addIssue({\n        code: ZodIssueCode.custom,\n        ...getIssueProperties(val)\n      });\n      if (typeof Promise !== \"undefined\" && result instanceof Promise) {\n        return result.then((data) => {\n          if (!data) {\n            setError();\n            return false;\n          } else {\n            return true;\n          }\n        });\n      }\n      if (!result) {\n        setError();\n        return false;\n      } else {\n        return true;\n      }\n    });\n  }\n  refinement(check, refinementData) {\n    return this._refinement((val, ctx) => {\n      if (!check(val)) {\n        ctx.addIssue(typeof refinementData === \"function\" ? refinementData(val, ctx) : refinementData);\n        return false;\n      } else {\n        return true;\n      }\n    });\n  }\n  _refinement(refinement) {\n    return new ZodEffects({\n      schema: this,\n      typeName: ZodFirstPartyTypeKind.ZodEffects,\n      effect: { type: \"refinement\", refinement }\n    });\n  }\n  superRefine(refinement) {\n    return this._refinement(refinement);\n  }\n  constructor(def) {\n    this.spa = this.safeParseAsync;\n    this._def = def;\n    this.parse = this.parse.bind(this);\n    this.safeParse = this.safeParse.bind(this);\n    this.parseAsync = this.parseAsync.bind(this);\n    this.safeParseAsync = this.safeParseAsync.bind(this);\n    this.spa = this.spa.bind(this);\n    this.refine = this.refine.bind(this);\n    this.refinement = this.refinement.bind(this);\n    this.superRefine = this.superRefine.bind(this);\n    this.optional = this.optional.bind(this);\n    this.nullable = this.nullable.bind(this);\n    this.nullish = this.nullish.bind(this);\n    this.array = this.array.bind(this);\n    this.promise = this.promise.bind(this);\n    this.or = this.or.bind(this);\n    this.and = this.and.bind(this);\n    this.transform = this.transform.bind(this);\n    this.brand = this.brand.bind(this);\n    this.default = this.default.bind(this);\n    this.catch = this.catch.bind(this);\n    this.describe = this.describe.bind(this);\n    this.pipe = this.pipe.bind(this);\n    this.readonly = this.readonly.bind(this);\n    this.isNullable = this.isNullable.bind(this);\n    this.isOptional = this.isOptional.bind(this);\n    this[\"~standard\"] = {\n      version: 1,\n      vendor: \"zod\",\n      validate: (data) => this[\"~validate\"](data)\n    };\n  }\n  optional() {\n    return ZodOptional.create(this, this._def);\n  }\n  nullable() {\n    return ZodNullable.create(this, this._def);\n  }\n  nullish() {\n    return this.nullable().optional();\n  }\n  array() {\n    return ZodArray.create(this);\n  }\n  promise() {\n    return ZodPromise.create(this, this._def);\n  }\n  or(option) {\n    return ZodUnion.create([this, option], this._def);\n  }\n  and(incoming) {\n    return ZodIntersection.create(this, incoming, this._def);\n  }\n  transform(transform) {\n    return new ZodEffects({\n      ...processCreateParams(this._def),\n      schema: this,\n      typeName: ZodFirstPartyTypeKind.ZodEffects,\n      effect: { type: \"transform\", transform }\n    });\n  }\n  default(def) {\n    const defaultValueFunc = typeof def === \"function\" ? def : () => def;\n    return new ZodDefault({\n      ...processCreateParams(this._def),\n      innerType: this,\n      defaultValue: defaultValueFunc,\n      typeName: ZodFirstPartyTypeKind.ZodDefault\n    });\n  }\n  brand() {\n    return new ZodBranded({\n      typeName: ZodFirstPartyTypeKind.ZodBranded,\n      type: this,\n      ...processCreateParams(this._def)\n    });\n  }\n  catch(def) {\n    const catchValueFunc = typeof def === \"function\" ? def : () => def;\n    return new ZodCatch({\n      ...processCreateParams(this._def),\n      innerType: this,\n      catchValue: catchValueFunc,\n      typeName: ZodFirstPartyTypeKind.ZodCatch\n    });\n  }\n  describe(description) {\n    const This = this.constructor;\n    return new This({\n      ...this._def,\n      description\n    });\n  }\n  pipe(target) {\n    return ZodPipeline.create(this, target);\n  }\n  readonly() {\n    return ZodReadonly.create(this);\n  }\n  isOptional() {\n    return this.safeParse(void 0).success;\n  }\n  isNullable() {\n    return this.safeParse(null).success;\n  }\n};\nvar cuidRegex = /^c[^\\s-]{8,}$/i;\nvar cuid2Regex = /^[0-9a-z]+$/;\nvar ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;\nvar uuidRegex = /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/i;\nvar nanoidRegex = /^[a-z0-9_-]{21}$/i;\nvar jwtRegex = /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/;\nvar durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\\d+Y)|(?:[-+]?\\d+[.,]\\d+Y$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:(?:[-+]?\\d+W)|(?:[-+]?\\d+[.,]\\d+W$))?(?:(?:[-+]?\\d+D)|(?:[-+]?\\d+[.,]\\d+D$))?(?:T(?=[\\d+-])(?:(?:[-+]?\\d+H)|(?:[-+]?\\d+[.,]\\d+H$))?(?:(?:[-+]?\\d+M)|(?:[-+]?\\d+[.,]\\d+M$))?(?:[-+]?\\d+(?:[.,]\\d+)?S)?)??$/;\nvar emailRegex = /^(?!\\.)(?!.*\\.\\.)([A-Z0-9_'+\\-\\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\\-]*\\.)+[A-Z]{2,}$/i;\nvar _emojiRegex = `^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$`;\nvar emojiRegex;\nvar ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;\nvar ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/;\nvar ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;\nvar ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;\nvar base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;\nvar base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;\nvar dateRegexSource = `((\\\\d\\\\d[2468][048]|\\\\d\\\\d[13579][26]|\\\\d\\\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\\\d|30)|(02)-(0[1-9]|1\\\\d|2[0-8])))`;\nvar dateRegex = new RegExp(`^${dateRegexSource}$`);\nfunction timeRegexSource(args) {\n  let regex = `([01]\\\\d|2[0-3]):[0-5]\\\\d:[0-5]\\\\d`;\n  if (args.precision) {\n    regex = `${regex}\\\\.\\\\d{${args.precision}}`;\n  } else if (args.precision == null) {\n    regex = `${regex}(\\\\.\\\\d+)?`;\n  }\n  return regex;\n}\nfunction timeRegex(args) {\n  return new RegExp(`^${timeRegexSource(args)}$`);\n}\nfunction datetimeRegex(args) {\n  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;\n  const opts = [];\n  opts.push(args.local ? `Z?` : `Z`);\n  if (args.offset)\n    opts.push(`([+-]\\\\d{2}:?\\\\d{2})`);\n  regex = `${regex}(${opts.join(\"|\")})`;\n  return new RegExp(`^${regex}$`);\n}\nfunction isValidIP(ip, version) {\n  if ((version === \"v4\" || !version) && ipv4Regex.test(ip)) {\n    return true;\n  }\n  if ((version === \"v6\" || !version) && ipv6Regex.test(ip)) {\n    return true;\n  }\n  return false;\n}\nfunction isValidJWT(jwt, alg) {\n  if (!jwtRegex.test(jwt))\n    return false;\n  try {\n    const [header] = jwt.split(\".\");\n    const base64 = header.replace(/-/g, \"+\").replace(/_/g, \"/\").padEnd(header.length + (4 - header.length % 4) % 4, \"=\");\n    const decoded = JSON.parse(atob(base64));\n    if (typeof decoded !== \"object\" || decoded === null)\n      return false;\n    if (!decoded.typ || !decoded.alg)\n      return false;\n    if (alg && decoded.alg !== alg)\n      return false;\n    return true;\n  } catch (_a) {\n    return false;\n  }\n}\nfunction isValidCidr(ip, version) {\n  if ((version === \"v4\" || !version) && ipv4CidrRegex.test(ip)) {\n    return true;\n  }\n  if ((version === \"v6\" || !version) && ipv6CidrRegex.test(ip)) {\n    return true;\n  }\n  return false;\n}\nvar ZodString = class _ZodString extends ZodType {\n  _parse(input) {\n    if (this._def.coerce) {\n      input.data = String(input.data);\n    }\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.string) {\n      const ctx2 = this._getOrReturnCtx(input);\n      addIssueToContext(ctx2, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.string,\n        received: ctx2.parsedType\n      });\n      return INVALID;\n    }\n    const status = new ParseStatus();\n    let ctx = void 0;\n    for (const check of this._def.checks) {\n      if (check.kind === \"min\") {\n        if (input.data.length < check.value) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_small,\n            minimum: check.value,\n            type: \"string\",\n            inclusive: true,\n            exact: false,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"max\") {\n        if (input.data.length > check.value) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_big,\n            maximum: check.value,\n            type: \"string\",\n            inclusive: true,\n            exact: false,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"length\") {\n        const tooBig = input.data.length > check.value;\n        const tooSmall = input.data.length < check.value;\n        if (tooBig || tooSmall) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          if (tooBig) {\n            addIssueToContext(ctx, {\n              code: ZodIssueCode.too_big,\n              maximum: check.value,\n              type: \"string\",\n              inclusive: true,\n              exact: true,\n              message: check.message\n            });\n          } else if (tooSmall) {\n            addIssueToContext(ctx, {\n              code: ZodIssueCode.too_small,\n              minimum: check.value,\n              type: \"string\",\n              inclusive: true,\n              exact: true,\n              message: check.message\n            });\n          }\n          status.dirty();\n        }\n      } else if (check.kind === \"email\") {\n        if (!emailRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"email\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"emoji\") {\n        if (!emojiRegex) {\n          emojiRegex = new RegExp(_emojiRegex, \"u\");\n        }\n        if (!emojiRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"emoji\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"uuid\") {\n        if (!uuidRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"uuid\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"nanoid\") {\n        if (!nanoidRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"nanoid\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"cuid\") {\n        if (!cuidRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"cuid\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"cuid2\") {\n        if (!cuid2Regex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"cuid2\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"ulid\") {\n        if (!ulidRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"ulid\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"url\") {\n        try {\n          new URL(input.data);\n        } catch (_a) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"url\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"regex\") {\n        check.regex.lastIndex = 0;\n        const testResult = check.regex.test(input.data);\n        if (!testResult) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"regex\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"trim\") {\n        input.data = input.data.trim();\n      } else if (check.kind === \"includes\") {\n        if (!input.data.includes(check.value, check.position)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: { includes: check.value, position: check.position },\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"toLowerCase\") {\n        input.data = input.data.toLowerCase();\n      } else if (check.kind === \"toUpperCase\") {\n        input.data = input.data.toUpperCase();\n      } else if (check.kind === \"startsWith\") {\n        if (!input.data.startsWith(check.value)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: { startsWith: check.value },\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"endsWith\") {\n        if (!input.data.endsWith(check.value)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: { endsWith: check.value },\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"datetime\") {\n        const regex = datetimeRegex(check);\n        if (!regex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: \"datetime\",\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"date\") {\n        const regex = dateRegex;\n        if (!regex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: \"date\",\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"time\") {\n        const regex = timeRegex(check);\n        if (!regex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_string,\n            validation: \"time\",\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"duration\") {\n        if (!durationRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"duration\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"ip\") {\n        if (!isValidIP(input.data, check.version)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"ip\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"jwt\") {\n        if (!isValidJWT(input.data, check.alg)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"jwt\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"cidr\") {\n        if (!isValidCidr(input.data, check.version)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"cidr\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"base64\") {\n        if (!base64Regex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"base64\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"base64url\") {\n        if (!base64urlRegex.test(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            validation: \"base64url\",\n            code: ZodIssueCode.invalid_string,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else {\n        util.assertNever(check);\n      }\n    }\n    return { status: status.value, value: input.data };\n  }\n  _regex(regex, validation, message) {\n    return this.refinement((data) => regex.test(data), {\n      validation,\n      code: ZodIssueCode.invalid_string,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  _addCheck(check) {\n    return new _ZodString({\n      ...this._def,\n      checks: [...this._def.checks, check]\n    });\n  }\n  email(message) {\n    return this._addCheck({ kind: \"email\", ...errorUtil.errToObj(message) });\n  }\n  url(message) {\n    return this._addCheck({ kind: \"url\", ...errorUtil.errToObj(message) });\n  }\n  emoji(message) {\n    return this._addCheck({ kind: \"emoji\", ...errorUtil.errToObj(message) });\n  }\n  uuid(message) {\n    return this._addCheck({ kind: \"uuid\", ...errorUtil.errToObj(message) });\n  }\n  nanoid(message) {\n    return this._addCheck({ kind: \"nanoid\", ...errorUtil.errToObj(message) });\n  }\n  cuid(message) {\n    return this._addCheck({ kind: \"cuid\", ...errorUtil.errToObj(message) });\n  }\n  cuid2(message) {\n    return this._addCheck({ kind: \"cuid2\", ...errorUtil.errToObj(message) });\n  }\n  ulid(message) {\n    return this._addCheck({ kind: \"ulid\", ...errorUtil.errToObj(message) });\n  }\n  base64(message) {\n    return this._addCheck({ kind: \"base64\", ...errorUtil.errToObj(message) });\n  }\n  base64url(message) {\n    return this._addCheck({\n      kind: \"base64url\",\n      ...errorUtil.errToObj(message)\n    });\n  }\n  jwt(options) {\n    return this._addCheck({ kind: \"jwt\", ...errorUtil.errToObj(options) });\n  }\n  ip(options) {\n    return this._addCheck({ kind: \"ip\", ...errorUtil.errToObj(options) });\n  }\n  cidr(options) {\n    return this._addCheck({ kind: \"cidr\", ...errorUtil.errToObj(options) });\n  }\n  datetime(options) {\n    var _a, _b;\n    if (typeof options === \"string\") {\n      return this._addCheck({\n        kind: \"datetime\",\n        precision: null,\n        offset: false,\n        local: false,\n        message: options\n      });\n    }\n    return this._addCheck({\n      kind: \"datetime\",\n      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === \"undefined\" ? null : options === null || options === void 0 ? void 0 : options.precision,\n      offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,\n      local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,\n      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)\n    });\n  }\n  date(message) {\n    return this._addCheck({ kind: \"date\", message });\n  }\n  time(options) {\n    if (typeof options === \"string\") {\n      return this._addCheck({\n        kind: \"time\",\n        precision: null,\n        message: options\n      });\n    }\n    return this._addCheck({\n      kind: \"time\",\n      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === \"undefined\" ? null : options === null || options === void 0 ? void 0 : options.precision,\n      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)\n    });\n  }\n  duration(message) {\n    return this._addCheck({ kind: \"duration\", ...errorUtil.errToObj(message) });\n  }\n  regex(regex, message) {\n    return this._addCheck({\n      kind: \"regex\",\n      regex,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  includes(value, options) {\n    return this._addCheck({\n      kind: \"includes\",\n      value,\n      position: options === null || options === void 0 ? void 0 : options.position,\n      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)\n    });\n  }\n  startsWith(value, message) {\n    return this._addCheck({\n      kind: \"startsWith\",\n      value,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  endsWith(value, message) {\n    return this._addCheck({\n      kind: \"endsWith\",\n      value,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  min(minLength, message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: minLength,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  max(maxLength, message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: maxLength,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  length(len, message) {\n    return this._addCheck({\n      kind: \"length\",\n      value: len,\n      ...errorUtil.errToObj(message)\n    });\n  }\n  /**\n   * Equivalent to `.min(1)`\n   */\n  nonempty(message) {\n    return this.min(1, errorUtil.errToObj(message));\n  }\n  trim() {\n    return new _ZodString({\n      ...this._def,\n      checks: [...this._def.checks, { kind: \"trim\" }]\n    });\n  }\n  toLowerCase() {\n    return new _ZodString({\n      ...this._def,\n      checks: [...this._def.checks, { kind: \"toLowerCase\" }]\n    });\n  }\n  toUpperCase() {\n    return new _ZodString({\n      ...this._def,\n      checks: [...this._def.checks, { kind: \"toUpperCase\" }]\n    });\n  }\n  get isDatetime() {\n    return !!this._def.checks.find((ch) => ch.kind === \"datetime\");\n  }\n  get isDate() {\n    return !!this._def.checks.find((ch) => ch.kind === \"date\");\n  }\n  get isTime() {\n    return !!this._def.checks.find((ch) => ch.kind === \"time\");\n  }\n  get isDuration() {\n    return !!this._def.checks.find((ch) => ch.kind === \"duration\");\n  }\n  get isEmail() {\n    return !!this._def.checks.find((ch) => ch.kind === \"email\");\n  }\n  get isURL() {\n    return !!this._def.checks.find((ch) => ch.kind === \"url\");\n  }\n  get isEmoji() {\n    return !!this._def.checks.find((ch) => ch.kind === \"emoji\");\n  }\n  get isUUID() {\n    return !!this._def.checks.find((ch) => ch.kind === \"uuid\");\n  }\n  get isNANOID() {\n    return !!this._def.checks.find((ch) => ch.kind === \"nanoid\");\n  }\n  get isCUID() {\n    return !!this._def.checks.find((ch) => ch.kind === \"cuid\");\n  }\n  get isCUID2() {\n    return !!this._def.checks.find((ch) => ch.kind === \"cuid2\");\n  }\n  get isULID() {\n    return !!this._def.checks.find((ch) => ch.kind === \"ulid\");\n  }\n  get isIP() {\n    return !!this._def.checks.find((ch) => ch.kind === \"ip\");\n  }\n  get isCIDR() {\n    return !!this._def.checks.find((ch) => ch.kind === \"cidr\");\n  }\n  get isBase64() {\n    return !!this._def.checks.find((ch) => ch.kind === \"base64\");\n  }\n  get isBase64url() {\n    return !!this._def.checks.find((ch) => ch.kind === \"base64url\");\n  }\n  get minLength() {\n    let min = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"min\") {\n        if (min === null || ch.value > min)\n          min = ch.value;\n      }\n    }\n    return min;\n  }\n  get maxLength() {\n    let max = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"max\") {\n        if (max === null || ch.value < max)\n          max = ch.value;\n      }\n    }\n    return max;\n  }\n};\nZodString.create = (params) => {\n  var _a;\n  return new ZodString({\n    checks: [],\n    typeName: ZodFirstPartyTypeKind.ZodString,\n    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,\n    ...processCreateParams(params)\n  });\n};\nfunction floatSafeRemainder(val, step) {\n  const valDecCount = (val.toString().split(\".\")[1] || \"\").length;\n  const stepDecCount = (step.toString().split(\".\")[1] || \"\").length;\n  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;\n  const valInt = parseInt(val.toFixed(decCount).replace(\".\", \"\"));\n  const stepInt = parseInt(step.toFixed(decCount).replace(\".\", \"\"));\n  return valInt % stepInt / Math.pow(10, decCount);\n}\nvar ZodNumber = class _ZodNumber extends ZodType {\n  constructor() {\n    super(...arguments);\n    this.min = this.gte;\n    this.max = this.lte;\n    this.step = this.multipleOf;\n  }\n  _parse(input) {\n    if (this._def.coerce) {\n      input.data = Number(input.data);\n    }\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.number) {\n      const ctx2 = this._getOrReturnCtx(input);\n      addIssueToContext(ctx2, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.number,\n        received: ctx2.parsedType\n      });\n      return INVALID;\n    }\n    let ctx = void 0;\n    const status = new ParseStatus();\n    for (const check of this._def.checks) {\n      if (check.kind === \"int\") {\n        if (!util.isInteger(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.invalid_type,\n            expected: \"integer\",\n            received: \"float\",\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"min\") {\n        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n        if (tooSmall) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_small,\n            minimum: check.value,\n            type: \"number\",\n            inclusive: check.inclusive,\n            exact: false,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"max\") {\n        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n        if (tooBig) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_big,\n            maximum: check.value,\n            type: \"number\",\n            inclusive: check.inclusive,\n            exact: false,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"multipleOf\") {\n        if (floatSafeRemainder(input.data, check.value) !== 0) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.not_multiple_of,\n            multipleOf: check.value,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"finite\") {\n        if (!Number.isFinite(input.data)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.not_finite,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else {\n        util.assertNever(check);\n      }\n    }\n    return { status: status.value, value: input.data };\n  }\n  gte(value, message) {\n    return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n  }\n  gt(value, message) {\n    return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n  }\n  lte(value, message) {\n    return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n  }\n  lt(value, message) {\n    return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n  }\n  setLimit(kind, value, inclusive, message) {\n    return new _ZodNumber({\n      ...this._def,\n      checks: [\n        ...this._def.checks,\n        {\n          kind,\n          value,\n          inclusive,\n          message: errorUtil.toString(message)\n        }\n      ]\n    });\n  }\n  _addCheck(check) {\n    return new _ZodNumber({\n      ...this._def,\n      checks: [...this._def.checks, check]\n    });\n  }\n  int(message) {\n    return this._addCheck({\n      kind: \"int\",\n      message: errorUtil.toString(message)\n    });\n  }\n  positive(message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: 0,\n      inclusive: false,\n      message: errorUtil.toString(message)\n    });\n  }\n  negative(message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: 0,\n      inclusive: false,\n      message: errorUtil.toString(message)\n    });\n  }\n  nonpositive(message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: 0,\n      inclusive: true,\n      message: errorUtil.toString(message)\n    });\n  }\n  nonnegative(message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: 0,\n      inclusive: true,\n      message: errorUtil.toString(message)\n    });\n  }\n  multipleOf(value, message) {\n    return this._addCheck({\n      kind: \"multipleOf\",\n      value,\n      message: errorUtil.toString(message)\n    });\n  }\n  finite(message) {\n    return this._addCheck({\n      kind: \"finite\",\n      message: errorUtil.toString(message)\n    });\n  }\n  safe(message) {\n    return this._addCheck({\n      kind: \"min\",\n      inclusive: true,\n      value: Number.MIN_SAFE_INTEGER,\n      message: errorUtil.toString(message)\n    })._addCheck({\n      kind: \"max\",\n      inclusive: true,\n      value: Number.MAX_SAFE_INTEGER,\n      message: errorUtil.toString(message)\n    });\n  }\n  get minValue() {\n    let min = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"min\") {\n        if (min === null || ch.value > min)\n          min = ch.value;\n      }\n    }\n    return min;\n  }\n  get maxValue() {\n    let max = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"max\") {\n        if (max === null || ch.value < max)\n          max = ch.value;\n      }\n    }\n    return max;\n  }\n  get isInt() {\n    return !!this._def.checks.find((ch) => ch.kind === \"int\" || ch.kind === \"multipleOf\" && util.isInteger(ch.value));\n  }\n  get isFinite() {\n    let max = null, min = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"finite\" || ch.kind === \"int\" || ch.kind === \"multipleOf\") {\n        return true;\n      } else if (ch.kind === \"min\") {\n        if (min === null || ch.value > min)\n          min = ch.value;\n      } else if (ch.kind === \"max\") {\n        if (max === null || ch.value < max)\n          max = ch.value;\n      }\n    }\n    return Number.isFinite(min) && Number.isFinite(max);\n  }\n};\nZodNumber.create = (params) => {\n  return new ZodNumber({\n    checks: [],\n    typeName: ZodFirstPartyTypeKind.ZodNumber,\n    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,\n    ...processCreateParams(params)\n  });\n};\nvar ZodBigInt = class _ZodBigInt extends ZodType {\n  constructor() {\n    super(...arguments);\n    this.min = this.gte;\n    this.max = this.lte;\n  }\n  _parse(input) {\n    if (this._def.coerce) {\n      try {\n        input.data = BigInt(input.data);\n      } catch (_a) {\n        return this._getInvalidInput(input);\n      }\n    }\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.bigint) {\n      return this._getInvalidInput(input);\n    }\n    let ctx = void 0;\n    const status = new ParseStatus();\n    for (const check of this._def.checks) {\n      if (check.kind === \"min\") {\n        const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;\n        if (tooSmall) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_small,\n            type: \"bigint\",\n            minimum: check.value,\n            inclusive: check.inclusive,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"max\") {\n        const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;\n        if (tooBig) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_big,\n            type: \"bigint\",\n            maximum: check.value,\n            inclusive: check.inclusive,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"multipleOf\") {\n        if (input.data % check.value !== BigInt(0)) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.not_multiple_of,\n            multipleOf: check.value,\n            message: check.message\n          });\n          status.dirty();\n        }\n      } else {\n        util.assertNever(check);\n      }\n    }\n    return { status: status.value, value: input.data };\n  }\n  _getInvalidInput(input) {\n    const ctx = this._getOrReturnCtx(input);\n    addIssueToContext(ctx, {\n      code: ZodIssueCode.invalid_type,\n      expected: ZodParsedType.bigint,\n      received: ctx.parsedType\n    });\n    return INVALID;\n  }\n  gte(value, message) {\n    return this.setLimit(\"min\", value, true, errorUtil.toString(message));\n  }\n  gt(value, message) {\n    return this.setLimit(\"min\", value, false, errorUtil.toString(message));\n  }\n  lte(value, message) {\n    return this.setLimit(\"max\", value, true, errorUtil.toString(message));\n  }\n  lt(value, message) {\n    return this.setLimit(\"max\", value, false, errorUtil.toString(message));\n  }\n  setLimit(kind, value, inclusive, message) {\n    return new _ZodBigInt({\n      ...this._def,\n      checks: [\n        ...this._def.checks,\n        {\n          kind,\n          value,\n          inclusive,\n          message: errorUtil.toString(message)\n        }\n      ]\n    });\n  }\n  _addCheck(check) {\n    return new _ZodBigInt({\n      ...this._def,\n      checks: [...this._def.checks, check]\n    });\n  }\n  positive(message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: BigInt(0),\n      inclusive: false,\n      message: errorUtil.toString(message)\n    });\n  }\n  negative(message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: BigInt(0),\n      inclusive: false,\n      message: errorUtil.toString(message)\n    });\n  }\n  nonpositive(message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: BigInt(0),\n      inclusive: true,\n      message: errorUtil.toString(message)\n    });\n  }\n  nonnegative(message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: BigInt(0),\n      inclusive: true,\n      message: errorUtil.toString(message)\n    });\n  }\n  multipleOf(value, message) {\n    return this._addCheck({\n      kind: \"multipleOf\",\n      value,\n      message: errorUtil.toString(message)\n    });\n  }\n  get minValue() {\n    let min = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"min\") {\n        if (min === null || ch.value > min)\n          min = ch.value;\n      }\n    }\n    return min;\n  }\n  get maxValue() {\n    let max = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"max\") {\n        if (max === null || ch.value < max)\n          max = ch.value;\n      }\n    }\n    return max;\n  }\n};\nZodBigInt.create = (params) => {\n  var _a;\n  return new ZodBigInt({\n    checks: [],\n    typeName: ZodFirstPartyTypeKind.ZodBigInt,\n    coerce: (_a = params === null || params === void 0 ? void 0 : params.coerce) !== null && _a !== void 0 ? _a : false,\n    ...processCreateParams(params)\n  });\n};\nvar ZodBoolean = class extends ZodType {\n  _parse(input) {\n    if (this._def.coerce) {\n      input.data = Boolean(input.data);\n    }\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.boolean) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.boolean,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n};\nZodBoolean.create = (params) => {\n  return new ZodBoolean({\n    typeName: ZodFirstPartyTypeKind.ZodBoolean,\n    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,\n    ...processCreateParams(params)\n  });\n};\nvar ZodDate = class _ZodDate extends ZodType {\n  _parse(input) {\n    if (this._def.coerce) {\n      input.data = new Date(input.data);\n    }\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.date) {\n      const ctx2 = this._getOrReturnCtx(input);\n      addIssueToContext(ctx2, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.date,\n        received: ctx2.parsedType\n      });\n      return INVALID;\n    }\n    if (isNaN(input.data.getTime())) {\n      const ctx2 = this._getOrReturnCtx(input);\n      addIssueToContext(ctx2, {\n        code: ZodIssueCode.invalid_date\n      });\n      return INVALID;\n    }\n    const status = new ParseStatus();\n    let ctx = void 0;\n    for (const check of this._def.checks) {\n      if (check.kind === \"min\") {\n        if (input.data.getTime() < check.value) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_small,\n            message: check.message,\n            inclusive: true,\n            exact: false,\n            minimum: check.value,\n            type: \"date\"\n          });\n          status.dirty();\n        }\n      } else if (check.kind === \"max\") {\n        if (input.data.getTime() > check.value) {\n          ctx = this._getOrReturnCtx(input, ctx);\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.too_big,\n            message: check.message,\n            inclusive: true,\n            exact: false,\n            maximum: check.value,\n            type: \"date\"\n          });\n          status.dirty();\n        }\n      } else {\n        util.assertNever(check);\n      }\n    }\n    return {\n      status: status.value,\n      value: new Date(input.data.getTime())\n    };\n  }\n  _addCheck(check) {\n    return new _ZodDate({\n      ...this._def,\n      checks: [...this._def.checks, check]\n    });\n  }\n  min(minDate, message) {\n    return this._addCheck({\n      kind: \"min\",\n      value: minDate.getTime(),\n      message: errorUtil.toString(message)\n    });\n  }\n  max(maxDate, message) {\n    return this._addCheck({\n      kind: \"max\",\n      value: maxDate.getTime(),\n      message: errorUtil.toString(message)\n    });\n  }\n  get minDate() {\n    let min = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"min\") {\n        if (min === null || ch.value > min)\n          min = ch.value;\n      }\n    }\n    return min != null ? new Date(min) : null;\n  }\n  get maxDate() {\n    let max = null;\n    for (const ch of this._def.checks) {\n      if (ch.kind === \"max\") {\n        if (max === null || ch.value < max)\n          max = ch.value;\n      }\n    }\n    return max != null ? new Date(max) : null;\n  }\n};\nZodDate.create = (params) => {\n  return new ZodDate({\n    checks: [],\n    coerce: (params === null || params === void 0 ? void 0 : params.coerce) || false,\n    typeName: ZodFirstPartyTypeKind.ZodDate,\n    ...processCreateParams(params)\n  });\n};\nvar ZodSymbol = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.symbol) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.symbol,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n};\nZodSymbol.create = (params) => {\n  return new ZodSymbol({\n    typeName: ZodFirstPartyTypeKind.ZodSymbol,\n    ...processCreateParams(params)\n  });\n};\nvar ZodUndefined = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.undefined) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.undefined,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n};\nZodUndefined.create = (params) => {\n  return new ZodUndefined({\n    typeName: ZodFirstPartyTypeKind.ZodUndefined,\n    ...processCreateParams(params)\n  });\n};\nvar ZodNull = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.null) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.null,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n};\nZodNull.create = (params) => {\n  return new ZodNull({\n    typeName: ZodFirstPartyTypeKind.ZodNull,\n    ...processCreateParams(params)\n  });\n};\nvar ZodAny = class extends ZodType {\n  constructor() {\n    super(...arguments);\n    this._any = true;\n  }\n  _parse(input) {\n    return OK(input.data);\n  }\n};\nZodAny.create = (params) => {\n  return new ZodAny({\n    typeName: ZodFirstPartyTypeKind.ZodAny,\n    ...processCreateParams(params)\n  });\n};\nvar ZodUnknown = class extends ZodType {\n  constructor() {\n    super(...arguments);\n    this._unknown = true;\n  }\n  _parse(input) {\n    return OK(input.data);\n  }\n};\nZodUnknown.create = (params) => {\n  return new ZodUnknown({\n    typeName: ZodFirstPartyTypeKind.ZodUnknown,\n    ...processCreateParams(params)\n  });\n};\nvar ZodNever = class extends ZodType {\n  _parse(input) {\n    const ctx = this._getOrReturnCtx(input);\n    addIssueToContext(ctx, {\n      code: ZodIssueCode.invalid_type,\n      expected: ZodParsedType.never,\n      received: ctx.parsedType\n    });\n    return INVALID;\n  }\n};\nZodNever.create = (params) => {\n  return new ZodNever({\n    typeName: ZodFirstPartyTypeKind.ZodNever,\n    ...processCreateParams(params)\n  });\n};\nvar ZodVoid = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.undefined) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.void,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n};\nZodVoid.create = (params) => {\n  return new ZodVoid({\n    typeName: ZodFirstPartyTypeKind.ZodVoid,\n    ...processCreateParams(params)\n  });\n};\nvar ZodArray = class _ZodArray extends ZodType {\n  _parse(input) {\n    const { ctx, status } = this._processInputParams(input);\n    const def = this._def;\n    if (ctx.parsedType !== ZodParsedType.array) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.array,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    if (def.exactLength !== null) {\n      const tooBig = ctx.data.length > def.exactLength.value;\n      const tooSmall = ctx.data.length < def.exactLength.value;\n      if (tooBig || tooSmall) {\n        addIssueToContext(ctx, {\n          code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,\n          minimum: tooSmall ? def.exactLength.value : void 0,\n          maximum: tooBig ? def.exactLength.value : void 0,\n          type: \"array\",\n          inclusive: true,\n          exact: true,\n          message: def.exactLength.message\n        });\n        status.dirty();\n      }\n    }\n    if (def.minLength !== null) {\n      if (ctx.data.length < def.minLength.value) {\n        addIssueToContext(ctx, {\n          code: ZodIssueCode.too_small,\n          minimum: def.minLength.value,\n          type: \"array\",\n          inclusive: true,\n          exact: false,\n          message: def.minLength.message\n        });\n        status.dirty();\n      }\n    }\n    if (def.maxLength !== null) {\n      if (ctx.data.length > def.maxLength.value) {\n        addIssueToContext(ctx, {\n          code: ZodIssueCode.too_big,\n          maximum: def.maxLength.value,\n          type: \"array\",\n          inclusive: true,\n          exact: false,\n          message: def.maxLength.message\n        });\n        status.dirty();\n      }\n    }\n    if (ctx.common.async) {\n      return Promise.all([...ctx.data].map((item, i) => {\n        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n      })).then((result2) => {\n        return ParseStatus.mergeArray(status, result2);\n      });\n    }\n    const result = [...ctx.data].map((item, i) => {\n      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));\n    });\n    return ParseStatus.mergeArray(status, result);\n  }\n  get element() {\n    return this._def.type;\n  }\n  min(minLength, message) {\n    return new _ZodArray({\n      ...this._def,\n      minLength: { value: minLength, message: errorUtil.toString(message) }\n    });\n  }\n  max(maxLength, message) {\n    return new _ZodArray({\n      ...this._def,\n      maxLength: { value: maxLength, message: errorUtil.toString(message) }\n    });\n  }\n  length(len, message) {\n    return new _ZodArray({\n      ...this._def,\n      exactLength: { value: len, message: errorUtil.toString(message) }\n    });\n  }\n  nonempty(message) {\n    return this.min(1, message);\n  }\n};\nZodArray.create = (schema, params) => {\n  return new ZodArray({\n    type: schema,\n    minLength: null,\n    maxLength: null,\n    exactLength: null,\n    typeName: ZodFirstPartyTypeKind.ZodArray,\n    ...processCreateParams(params)\n  });\n};\nfunction deepPartialify(schema) {\n  if (schema instanceof ZodObject) {\n    const newShape = {};\n    for (const key in schema.shape) {\n      const fieldSchema = schema.shape[key];\n      newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));\n    }\n    return new ZodObject({\n      ...schema._def,\n      shape: () => newShape\n    });\n  } else if (schema instanceof ZodArray) {\n    return new ZodArray({\n      ...schema._def,\n      type: deepPartialify(schema.element)\n    });\n  } else if (schema instanceof ZodOptional) {\n    return ZodOptional.create(deepPartialify(schema.unwrap()));\n  } else if (schema instanceof ZodNullable) {\n    return ZodNullable.create(deepPartialify(schema.unwrap()));\n  } else if (schema instanceof ZodTuple) {\n    return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));\n  } else {\n    return schema;\n  }\n}\nvar ZodObject = class _ZodObject extends ZodType {\n  constructor() {\n    super(...arguments);\n    this._cached = null;\n    this.nonstrict = this.passthrough;\n    this.augment = this.extend;\n  }\n  _getCached() {\n    if (this._cached !== null)\n      return this._cached;\n    const shape = this._def.shape();\n    const keys = util.objectKeys(shape);\n    return this._cached = { shape, keys };\n  }\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.object) {\n      const ctx2 = this._getOrReturnCtx(input);\n      addIssueToContext(ctx2, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.object,\n        received: ctx2.parsedType\n      });\n      return INVALID;\n    }\n    const { status, ctx } = this._processInputParams(input);\n    const { shape, keys: shapeKeys } = this._getCached();\n    const extraKeys = [];\n    if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === \"strip\")) {\n      for (const key in ctx.data) {\n        if (!shapeKeys.includes(key)) {\n          extraKeys.push(key);\n        }\n      }\n    }\n    const pairs = [];\n    for (const key of shapeKeys) {\n      const keyValidator = shape[key];\n      const value = ctx.data[key];\n      pairs.push({\n        key: { status: \"valid\", value: key },\n        value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),\n        alwaysSet: key in ctx.data\n      });\n    }\n    if (this._def.catchall instanceof ZodNever) {\n      const unknownKeys = this._def.unknownKeys;\n      if (unknownKeys === \"passthrough\") {\n        for (const key of extraKeys) {\n          pairs.push({\n            key: { status: \"valid\", value: key },\n            value: { status: \"valid\", value: ctx.data[key] }\n          });\n        }\n      } else if (unknownKeys === \"strict\") {\n        if (extraKeys.length > 0) {\n          addIssueToContext(ctx, {\n            code: ZodIssueCode.unrecognized_keys,\n            keys: extraKeys\n          });\n          status.dirty();\n        }\n      } else if (unknownKeys === \"strip\") ;\n      else {\n        throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);\n      }\n    } else {\n      const catchall = this._def.catchall;\n      for (const key of extraKeys) {\n        const value = ctx.data[key];\n        pairs.push({\n          key: { status: \"valid\", value: key },\n          value: catchall._parse(\n            new ParseInputLazyPath(ctx, value, ctx.path, key)\n            //, ctx.child(key), value, getParsedType(value)\n          ),\n          alwaysSet: key in ctx.data\n        });\n      }\n    }\n    if (ctx.common.async) {\n      return Promise.resolve().then(async () => {\n        const syncPairs = [];\n        for (const pair of pairs) {\n          const key = await pair.key;\n          const value = await pair.value;\n          syncPairs.push({\n            key,\n            value,\n            alwaysSet: pair.alwaysSet\n          });\n        }\n        return syncPairs;\n      }).then((syncPairs) => {\n        return ParseStatus.mergeObjectSync(status, syncPairs);\n      });\n    } else {\n      return ParseStatus.mergeObjectSync(status, pairs);\n    }\n  }\n  get shape() {\n    return this._def.shape();\n  }\n  strict(message) {\n    errorUtil.errToObj;\n    return new _ZodObject({\n      ...this._def,\n      unknownKeys: \"strict\",\n      ...message !== void 0 ? {\n        errorMap: (issue, ctx) => {\n          var _a, _b, _c, _d;\n          const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;\n          if (issue.code === \"unrecognized_keys\")\n            return {\n              message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError\n            };\n          return {\n            message: defaultError\n          };\n        }\n      } : {}\n    });\n  }\n  strip() {\n    return new _ZodObject({\n      ...this._def,\n      unknownKeys: \"strip\"\n    });\n  }\n  passthrough() {\n    return new _ZodObject({\n      ...this._def,\n      unknownKeys: \"passthrough\"\n    });\n  }\n  // const AugmentFactory =\n  //   <Def extends ZodObjectDef>(def: Def) =>\n  //   <Augmentation extends ZodRawShape>(\n  //     augmentation: Augmentation\n  //   ): ZodObject<\n  //     extendShape<ReturnType<Def[\"shape\"]>, Augmentation>,\n  //     Def[\"unknownKeys\"],\n  //     Def[\"catchall\"]\n  //   > => {\n  //     return new ZodObject({\n  //       ...def,\n  //       shape: () => ({\n  //         ...def.shape(),\n  //         ...augmentation,\n  //       }),\n  //     }) as any;\n  //   };\n  extend(augmentation) {\n    return new _ZodObject({\n      ...this._def,\n      shape: () => ({\n        ...this._def.shape(),\n        ...augmentation\n      })\n    });\n  }\n  /**\n   * Prior to zod@1.0.12 there was a bug in the\n   * inferred type of merged objects. Please\n   * upgrade if you are experiencing issues.\n   */\n  merge(merging) {\n    const merged = new _ZodObject({\n      unknownKeys: merging._def.unknownKeys,\n      catchall: merging._def.catchall,\n      shape: () => ({\n        ...this._def.shape(),\n        ...merging._def.shape()\n      }),\n      typeName: ZodFirstPartyTypeKind.ZodObject\n    });\n    return merged;\n  }\n  // merge<\n  //   Incoming extends AnyZodObject,\n  //   Augmentation extends Incoming[\"shape\"],\n  //   NewOutput extends {\n  //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation\n  //       ? Augmentation[k][\"_output\"]\n  //       : k extends keyof Output\n  //       ? Output[k]\n  //       : never;\n  //   },\n  //   NewInput extends {\n  //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation\n  //       ? Augmentation[k][\"_input\"]\n  //       : k extends keyof Input\n  //       ? Input[k]\n  //       : never;\n  //   }\n  // >(\n  //   merging: Incoming\n  // ): ZodObject<\n  //   extendShape<T, ReturnType<Incoming[\"_def\"][\"shape\"]>>,\n  //   Incoming[\"_def\"][\"unknownKeys\"],\n  //   Incoming[\"_def\"][\"catchall\"],\n  //   NewOutput,\n  //   NewInput\n  // > {\n  //   const merged: any = new ZodObject({\n  //     unknownKeys: merging._def.unknownKeys,\n  //     catchall: merging._def.catchall,\n  //     shape: () =>\n  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n  //     typeName: ZodFirstPartyTypeKind.ZodObject,\n  //   }) as any;\n  //   return merged;\n  // }\n  setKey(key, schema) {\n    return this.augment({ [key]: schema });\n  }\n  // merge<Incoming extends AnyZodObject>(\n  //   merging: Incoming\n  // ): //ZodObject<T & Incoming[\"_shape\"], UnknownKeys, Catchall> = (merging) => {\n  // ZodObject<\n  //   extendShape<T, ReturnType<Incoming[\"_def\"][\"shape\"]>>,\n  //   Incoming[\"_def\"][\"unknownKeys\"],\n  //   Incoming[\"_def\"][\"catchall\"]\n  // > {\n  //   // const mergedShape = objectUtil.mergeShapes(\n  //   //   this._def.shape(),\n  //   //   merging._def.shape()\n  //   // );\n  //   const merged: any = new ZodObject({\n  //     unknownKeys: merging._def.unknownKeys,\n  //     catchall: merging._def.catchall,\n  //     shape: () =>\n  //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),\n  //     typeName: ZodFirstPartyTypeKind.ZodObject,\n  //   }) as any;\n  //   return merged;\n  // }\n  catchall(index) {\n    return new _ZodObject({\n      ...this._def,\n      catchall: index\n    });\n  }\n  pick(mask) {\n    const shape = {};\n    util.objectKeys(mask).forEach((key) => {\n      if (mask[key] && this.shape[key]) {\n        shape[key] = this.shape[key];\n      }\n    });\n    return new _ZodObject({\n      ...this._def,\n      shape: () => shape\n    });\n  }\n  omit(mask) {\n    const shape = {};\n    util.objectKeys(this.shape).forEach((key) => {\n      if (!mask[key]) {\n        shape[key] = this.shape[key];\n      }\n    });\n    return new _ZodObject({\n      ...this._def,\n      shape: () => shape\n    });\n  }\n  /**\n   * @deprecated\n   */\n  deepPartial() {\n    return deepPartialify(this);\n  }\n  partial(mask) {\n    const newShape = {};\n    util.objectKeys(this.shape).forEach((key) => {\n      const fieldSchema = this.shape[key];\n      if (mask && !mask[key]) {\n        newShape[key] = fieldSchema;\n      } else {\n        newShape[key] = fieldSchema.optional();\n      }\n    });\n    return new _ZodObject({\n      ...this._def,\n      shape: () => newShape\n    });\n  }\n  required(mask) {\n    const newShape = {};\n    util.objectKeys(this.shape).forEach((key) => {\n      if (mask && !mask[key]) {\n        newShape[key] = this.shape[key];\n      } else {\n        const fieldSchema = this.shape[key];\n        let newField = fieldSchema;\n        while (newField instanceof ZodOptional) {\n          newField = newField._def.innerType;\n        }\n        newShape[key] = newField;\n      }\n    });\n    return new _ZodObject({\n      ...this._def,\n      shape: () => newShape\n    });\n  }\n  keyof() {\n    return createZodEnum(util.objectKeys(this.shape));\n  }\n};\nZodObject.create = (shape, params) => {\n  return new ZodObject({\n    shape: () => shape,\n    unknownKeys: \"strip\",\n    catchall: ZodNever.create(),\n    typeName: ZodFirstPartyTypeKind.ZodObject,\n    ...processCreateParams(params)\n  });\n};\nZodObject.strictCreate = (shape, params) => {\n  return new ZodObject({\n    shape: () => shape,\n    unknownKeys: \"strict\",\n    catchall: ZodNever.create(),\n    typeName: ZodFirstPartyTypeKind.ZodObject,\n    ...processCreateParams(params)\n  });\n};\nZodObject.lazycreate = (shape, params) => {\n  return new ZodObject({\n    shape,\n    unknownKeys: \"strip\",\n    catchall: ZodNever.create(),\n    typeName: ZodFirstPartyTypeKind.ZodObject,\n    ...processCreateParams(params)\n  });\n};\nvar ZodUnion = class extends ZodType {\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    const options = this._def.options;\n    function handleResults(results) {\n      for (const result of results) {\n        if (result.result.status === \"valid\") {\n          return result.result;\n        }\n      }\n      for (const result of results) {\n        if (result.result.status === \"dirty\") {\n          ctx.common.issues.push(...result.ctx.common.issues);\n          return result.result;\n        }\n      }\n      const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_union,\n        unionErrors\n      });\n      return INVALID;\n    }\n    if (ctx.common.async) {\n      return Promise.all(options.map(async (option) => {\n        const childCtx = {\n          ...ctx,\n          common: {\n            ...ctx.common,\n            issues: []\n          },\n          parent: null\n        };\n        return {\n          result: await option._parseAsync({\n            data: ctx.data,\n            path: ctx.path,\n            parent: childCtx\n          }),\n          ctx: childCtx\n        };\n      })).then(handleResults);\n    } else {\n      let dirty = void 0;\n      const issues = [];\n      for (const option of options) {\n        const childCtx = {\n          ...ctx,\n          common: {\n            ...ctx.common,\n            issues: []\n          },\n          parent: null\n        };\n        const result = option._parseSync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: childCtx\n        });\n        if (result.status === \"valid\") {\n          return result;\n        } else if (result.status === \"dirty\" && !dirty) {\n          dirty = { result, ctx: childCtx };\n        }\n        if (childCtx.common.issues.length) {\n          issues.push(childCtx.common.issues);\n        }\n      }\n      if (dirty) {\n        ctx.common.issues.push(...dirty.ctx.common.issues);\n        return dirty.result;\n      }\n      const unionErrors = issues.map((issues2) => new ZodError(issues2));\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_union,\n        unionErrors\n      });\n      return INVALID;\n    }\n  }\n  get options() {\n    return this._def.options;\n  }\n};\nZodUnion.create = (types, params) => {\n  return new ZodUnion({\n    options: types,\n    typeName: ZodFirstPartyTypeKind.ZodUnion,\n    ...processCreateParams(params)\n  });\n};\nvar getDiscriminator = (type) => {\n  if (type instanceof ZodLazy) {\n    return getDiscriminator(type.schema);\n  } else if (type instanceof ZodEffects) {\n    return getDiscriminator(type.innerType());\n  } else if (type instanceof ZodLiteral) {\n    return [type.value];\n  } else if (type instanceof ZodEnum) {\n    return type.options;\n  } else if (type instanceof ZodNativeEnum) {\n    return util.objectValues(type.enum);\n  } else if (type instanceof ZodDefault) {\n    return getDiscriminator(type._def.innerType);\n  } else if (type instanceof ZodUndefined) {\n    return [void 0];\n  } else if (type instanceof ZodNull) {\n    return [null];\n  } else if (type instanceof ZodOptional) {\n    return [void 0, ...getDiscriminator(type.unwrap())];\n  } else if (type instanceof ZodNullable) {\n    return [null, ...getDiscriminator(type.unwrap())];\n  } else if (type instanceof ZodBranded) {\n    return getDiscriminator(type.unwrap());\n  } else if (type instanceof ZodReadonly) {\n    return getDiscriminator(type.unwrap());\n  } else if (type instanceof ZodCatch) {\n    return getDiscriminator(type._def.innerType);\n  } else {\n    return [];\n  }\n};\nvar ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.object) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.object,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    const discriminator = this.discriminator;\n    const discriminatorValue = ctx.data[discriminator];\n    const option = this.optionsMap.get(discriminatorValue);\n    if (!option) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_union_discriminator,\n        options: Array.from(this.optionsMap.keys()),\n        path: [discriminator]\n      });\n      return INVALID;\n    }\n    if (ctx.common.async) {\n      return option._parseAsync({\n        data: ctx.data,\n        path: ctx.path,\n        parent: ctx\n      });\n    } else {\n      return option._parseSync({\n        data: ctx.data,\n        path: ctx.path,\n        parent: ctx\n      });\n    }\n  }\n  get discriminator() {\n    return this._def.discriminator;\n  }\n  get options() {\n    return this._def.options;\n  }\n  get optionsMap() {\n    return this._def.optionsMap;\n  }\n  /**\n   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.\n   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must\n   * have a different value for each object in the union.\n   * @param discriminator the name of the discriminator property\n   * @param types an array of object schemas\n   * @param params\n   */\n  static create(discriminator, options, params) {\n    const optionsMap = /* @__PURE__ */ new Map();\n    for (const type of options) {\n      const discriminatorValues = getDiscriminator(type.shape[discriminator]);\n      if (!discriminatorValues.length) {\n        throw new Error(`A discriminator value for key \\`${discriminator}\\` could not be extracted from all schema options`);\n      }\n      for (const value of discriminatorValues) {\n        if (optionsMap.has(value)) {\n          throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);\n        }\n        optionsMap.set(value, type);\n      }\n    }\n    return new _ZodDiscriminatedUnion({\n      typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,\n      discriminator,\n      options,\n      optionsMap,\n      ...processCreateParams(params)\n    });\n  }\n};\nfunction mergeValues(a, b) {\n  const aType = getParsedType(a);\n  const bType = getParsedType(b);\n  if (a === b) {\n    return { valid: true, data: a };\n  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {\n    const bKeys = util.objectKeys(b);\n    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);\n    const newObj = { ...a, ...b };\n    for (const key of sharedKeys) {\n      const sharedValue = mergeValues(a[key], b[key]);\n      if (!sharedValue.valid) {\n        return { valid: false };\n      }\n      newObj[key] = sharedValue.data;\n    }\n    return { valid: true, data: newObj };\n  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {\n    if (a.length !== b.length) {\n      return { valid: false };\n    }\n    const newArray = [];\n    for (let index = 0; index < a.length; index++) {\n      const itemA = a[index];\n      const itemB = b[index];\n      const sharedValue = mergeValues(itemA, itemB);\n      if (!sharedValue.valid) {\n        return { valid: false };\n      }\n      newArray.push(sharedValue.data);\n    }\n    return { valid: true, data: newArray };\n  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {\n    return { valid: true, data: a };\n  } else {\n    return { valid: false };\n  }\n}\nvar ZodIntersection = class extends ZodType {\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    const handleParsed = (parsedLeft, parsedRight) => {\n      if (isAborted(parsedLeft) || isAborted(parsedRight)) {\n        return INVALID;\n      }\n      const merged = mergeValues(parsedLeft.value, parsedRight.value);\n      if (!merged.valid) {\n        addIssueToContext(ctx, {\n          code: ZodIssueCode.invalid_intersection_types\n        });\n        return INVALID;\n      }\n      if (isDirty(parsedLeft) || isDirty(parsedRight)) {\n        status.dirty();\n      }\n      return { status: status.value, value: merged.data };\n    };\n    if (ctx.common.async) {\n      return Promise.all([\n        this._def.left._parseAsync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: ctx\n        }),\n        this._def.right._parseAsync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: ctx\n        })\n      ]).then(([left, right]) => handleParsed(left, right));\n    } else {\n      return handleParsed(this._def.left._parseSync({\n        data: ctx.data,\n        path: ctx.path,\n        parent: ctx\n      }), this._def.right._parseSync({\n        data: ctx.data,\n        path: ctx.path,\n        parent: ctx\n      }));\n    }\n  }\n};\nZodIntersection.create = (left, right, params) => {\n  return new ZodIntersection({\n    left,\n    right,\n    typeName: ZodFirstPartyTypeKind.ZodIntersection,\n    ...processCreateParams(params)\n  });\n};\nvar ZodTuple = class _ZodTuple extends ZodType {\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.array) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.array,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    if (ctx.data.length < this._def.items.length) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.too_small,\n        minimum: this._def.items.length,\n        inclusive: true,\n        exact: false,\n        type: \"array\"\n      });\n      return INVALID;\n    }\n    const rest = this._def.rest;\n    if (!rest && ctx.data.length > this._def.items.length) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.too_big,\n        maximum: this._def.items.length,\n        inclusive: true,\n        exact: false,\n        type: \"array\"\n      });\n      status.dirty();\n    }\n    const items = [...ctx.data].map((item, itemIndex) => {\n      const schema = this._def.items[itemIndex] || this._def.rest;\n      if (!schema)\n        return null;\n      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));\n    }).filter((x) => !!x);\n    if (ctx.common.async) {\n      return Promise.all(items).then((results) => {\n        return ParseStatus.mergeArray(status, results);\n      });\n    } else {\n      return ParseStatus.mergeArray(status, items);\n    }\n  }\n  get items() {\n    return this._def.items;\n  }\n  rest(rest) {\n    return new _ZodTuple({\n      ...this._def,\n      rest\n    });\n  }\n};\nZodTuple.create = (schemas, params) => {\n  if (!Array.isArray(schemas)) {\n    throw new Error(\"You must pass an array of schemas to z.tuple([ ... ])\");\n  }\n  return new ZodTuple({\n    items: schemas,\n    typeName: ZodFirstPartyTypeKind.ZodTuple,\n    rest: null,\n    ...processCreateParams(params)\n  });\n};\nvar ZodRecord = class _ZodRecord extends ZodType {\n  get keySchema() {\n    return this._def.keyType;\n  }\n  get valueSchema() {\n    return this._def.valueType;\n  }\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.object) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.object,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    const pairs = [];\n    const keyType = this._def.keyType;\n    const valueType = this._def.valueType;\n    for (const key in ctx.data) {\n      pairs.push({\n        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),\n        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),\n        alwaysSet: key in ctx.data\n      });\n    }\n    if (ctx.common.async) {\n      return ParseStatus.mergeObjectAsync(status, pairs);\n    } else {\n      return ParseStatus.mergeObjectSync(status, pairs);\n    }\n  }\n  get element() {\n    return this._def.valueType;\n  }\n  static create(first, second, third) {\n    if (second instanceof ZodType) {\n      return new _ZodRecord({\n        keyType: first,\n        valueType: second,\n        typeName: ZodFirstPartyTypeKind.ZodRecord,\n        ...processCreateParams(third)\n      });\n    }\n    return new _ZodRecord({\n      keyType: ZodString.create(),\n      valueType: first,\n      typeName: ZodFirstPartyTypeKind.ZodRecord,\n      ...processCreateParams(second)\n    });\n  }\n};\nvar ZodMap = class extends ZodType {\n  get keySchema() {\n    return this._def.keyType;\n  }\n  get valueSchema() {\n    return this._def.valueType;\n  }\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.map) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.map,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    const keyType = this._def.keyType;\n    const valueType = this._def.valueType;\n    const pairs = [...ctx.data.entries()].map(([key, value], index) => {\n      return {\n        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, \"key\"])),\n        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, \"value\"]))\n      };\n    });\n    if (ctx.common.async) {\n      const finalMap = /* @__PURE__ */ new Map();\n      return Promise.resolve().then(async () => {\n        for (const pair of pairs) {\n          const key = await pair.key;\n          const value = await pair.value;\n          if (key.status === \"aborted\" || value.status === \"aborted\") {\n            return INVALID;\n          }\n          if (key.status === \"dirty\" || value.status === \"dirty\") {\n            status.dirty();\n          }\n          finalMap.set(key.value, value.value);\n        }\n        return { status: status.value, value: finalMap };\n      });\n    } else {\n      const finalMap = /* @__PURE__ */ new Map();\n      for (const pair of pairs) {\n        const key = pair.key;\n        const value = pair.value;\n        if (key.status === \"aborted\" || value.status === \"aborted\") {\n          return INVALID;\n        }\n        if (key.status === \"dirty\" || value.status === \"dirty\") {\n          status.dirty();\n        }\n        finalMap.set(key.value, value.value);\n      }\n      return { status: status.value, value: finalMap };\n    }\n  }\n};\nZodMap.create = (keyType, valueType, params) => {\n  return new ZodMap({\n    valueType,\n    keyType,\n    typeName: ZodFirstPartyTypeKind.ZodMap,\n    ...processCreateParams(params)\n  });\n};\nvar ZodSet = class _ZodSet extends ZodType {\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.set) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.set,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    const def = this._def;\n    if (def.minSize !== null) {\n      if (ctx.data.size < def.minSize.value) {\n        addIssueToContext(ctx, {\n          code: ZodIssueCode.too_small,\n          minimum: def.minSize.value,\n          type: \"set\",\n          inclusive: true,\n          exact: false,\n          message: def.minSize.message\n        });\n        status.dirty();\n      }\n    }\n    if (def.maxSize !== null) {\n      if (ctx.data.size > def.maxSize.value) {\n        addIssueToContext(ctx, {\n          code: ZodIssueCode.too_big,\n          maximum: def.maxSize.value,\n          type: \"set\",\n          inclusive: true,\n          exact: false,\n          message: def.maxSize.message\n        });\n        status.dirty();\n      }\n    }\n    const valueType = this._def.valueType;\n    function finalizeSet(elements2) {\n      const parsedSet = /* @__PURE__ */ new Set();\n      for (const element of elements2) {\n        if (element.status === \"aborted\")\n          return INVALID;\n        if (element.status === \"dirty\")\n          status.dirty();\n        parsedSet.add(element.value);\n      }\n      return { status: status.value, value: parsedSet };\n    }\n    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));\n    if (ctx.common.async) {\n      return Promise.all(elements).then((elements2) => finalizeSet(elements2));\n    } else {\n      return finalizeSet(elements);\n    }\n  }\n  min(minSize, message) {\n    return new _ZodSet({\n      ...this._def,\n      minSize: { value: minSize, message: errorUtil.toString(message) }\n    });\n  }\n  max(maxSize, message) {\n    return new _ZodSet({\n      ...this._def,\n      maxSize: { value: maxSize, message: errorUtil.toString(message) }\n    });\n  }\n  size(size, message) {\n    return this.min(size, message).max(size, message);\n  }\n  nonempty(message) {\n    return this.min(1, message);\n  }\n};\nZodSet.create = (valueType, params) => {\n  return new ZodSet({\n    valueType,\n    minSize: null,\n    maxSize: null,\n    typeName: ZodFirstPartyTypeKind.ZodSet,\n    ...processCreateParams(params)\n  });\n};\nvar ZodFunction = class _ZodFunction extends ZodType {\n  constructor() {\n    super(...arguments);\n    this.validate = this.implement;\n  }\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.function) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.function,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    function makeArgsIssue(args, error) {\n      return makeIssue({\n        data: args,\n        path: ctx.path,\n        errorMaps: [\n          ctx.common.contextualErrorMap,\n          ctx.schemaErrorMap,\n          getErrorMap(),\n          errorMap\n        ].filter((x) => !!x),\n        issueData: {\n          code: ZodIssueCode.invalid_arguments,\n          argumentsError: error\n        }\n      });\n    }\n    function makeReturnsIssue(returns, error) {\n      return makeIssue({\n        data: returns,\n        path: ctx.path,\n        errorMaps: [\n          ctx.common.contextualErrorMap,\n          ctx.schemaErrorMap,\n          getErrorMap(),\n          errorMap\n        ].filter((x) => !!x),\n        issueData: {\n          code: ZodIssueCode.invalid_return_type,\n          returnTypeError: error\n        }\n      });\n    }\n    const params = { errorMap: ctx.common.contextualErrorMap };\n    const fn = ctx.data;\n    if (this._def.returns instanceof ZodPromise) {\n      const me = this;\n      return OK(async function(...args) {\n        const error = new ZodError([]);\n        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {\n          error.addIssue(makeArgsIssue(args, e));\n          throw error;\n        });\n        const result = await Reflect.apply(fn, this, parsedArgs);\n        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {\n          error.addIssue(makeReturnsIssue(result, e));\n          throw error;\n        });\n        return parsedReturns;\n      });\n    } else {\n      const me = this;\n      return OK(function(...args) {\n        const parsedArgs = me._def.args.safeParse(args, params);\n        if (!parsedArgs.success) {\n          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);\n        }\n        const result = Reflect.apply(fn, this, parsedArgs.data);\n        const parsedReturns = me._def.returns.safeParse(result, params);\n        if (!parsedReturns.success) {\n          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);\n        }\n        return parsedReturns.data;\n      });\n    }\n  }\n  parameters() {\n    return this._def.args;\n  }\n  returnType() {\n    return this._def.returns;\n  }\n  args(...items) {\n    return new _ZodFunction({\n      ...this._def,\n      args: ZodTuple.create(items).rest(ZodUnknown.create())\n    });\n  }\n  returns(returnType) {\n    return new _ZodFunction({\n      ...this._def,\n      returns: returnType\n    });\n  }\n  implement(func) {\n    const validatedFunc = this.parse(func);\n    return validatedFunc;\n  }\n  strictImplement(func) {\n    const validatedFunc = this.parse(func);\n    return validatedFunc;\n  }\n  static create(args, returns, params) {\n    return new _ZodFunction({\n      args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),\n      returns: returns || ZodUnknown.create(),\n      typeName: ZodFirstPartyTypeKind.ZodFunction,\n      ...processCreateParams(params)\n    });\n  }\n};\nvar ZodLazy = class extends ZodType {\n  get schema() {\n    return this._def.getter();\n  }\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    const lazySchema = this._def.getter();\n    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });\n  }\n};\nZodLazy.create = (getter, params) => {\n  return new ZodLazy({\n    getter,\n    typeName: ZodFirstPartyTypeKind.ZodLazy,\n    ...processCreateParams(params)\n  });\n};\nvar ZodLiteral = class extends ZodType {\n  _parse(input) {\n    if (input.data !== this._def.value) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        received: ctx.data,\n        code: ZodIssueCode.invalid_literal,\n        expected: this._def.value\n      });\n      return INVALID;\n    }\n    return { status: \"valid\", value: input.data };\n  }\n  get value() {\n    return this._def.value;\n  }\n};\nZodLiteral.create = (value, params) => {\n  return new ZodLiteral({\n    value,\n    typeName: ZodFirstPartyTypeKind.ZodLiteral,\n    ...processCreateParams(params)\n  });\n};\nfunction createZodEnum(values, params) {\n  return new ZodEnum({\n    values,\n    typeName: ZodFirstPartyTypeKind.ZodEnum,\n    ...processCreateParams(params)\n  });\n}\nvar ZodEnum = class _ZodEnum extends ZodType {\n  constructor() {\n    super(...arguments);\n    _ZodEnum_cache.set(this, void 0);\n  }\n  _parse(input) {\n    if (typeof input.data !== \"string\") {\n      const ctx = this._getOrReturnCtx(input);\n      const expectedValues = this._def.values;\n      addIssueToContext(ctx, {\n        expected: util.joinValues(expectedValues),\n        received: ctx.parsedType,\n        code: ZodIssueCode.invalid_type\n      });\n      return INVALID;\n    }\n    if (!__classPrivateFieldGet(this, _ZodEnum_cache, \"f\")) {\n      __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), \"f\");\n    }\n    if (!__classPrivateFieldGet(this, _ZodEnum_cache, \"f\").has(input.data)) {\n      const ctx = this._getOrReturnCtx(input);\n      const expectedValues = this._def.values;\n      addIssueToContext(ctx, {\n        received: ctx.data,\n        code: ZodIssueCode.invalid_enum_value,\n        options: expectedValues\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n  get options() {\n    return this._def.values;\n  }\n  get enum() {\n    const enumValues = {};\n    for (const val of this._def.values) {\n      enumValues[val] = val;\n    }\n    return enumValues;\n  }\n  get Values() {\n    const enumValues = {};\n    for (const val of this._def.values) {\n      enumValues[val] = val;\n    }\n    return enumValues;\n  }\n  get Enum() {\n    const enumValues = {};\n    for (const val of this._def.values) {\n      enumValues[val] = val;\n    }\n    return enumValues;\n  }\n  extract(values, newDef = this._def) {\n    return _ZodEnum.create(values, {\n      ...this._def,\n      ...newDef\n    });\n  }\n  exclude(values, newDef = this._def) {\n    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {\n      ...this._def,\n      ...newDef\n    });\n  }\n};\n_ZodEnum_cache = /* @__PURE__ */ new WeakMap();\nZodEnum.create = createZodEnum;\nvar ZodNativeEnum = class extends ZodType {\n  constructor() {\n    super(...arguments);\n    _ZodNativeEnum_cache.set(this, void 0);\n  }\n  _parse(input) {\n    const nativeEnumValues = util.getValidEnumValues(this._def.values);\n    const ctx = this._getOrReturnCtx(input);\n    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {\n      const expectedValues = util.objectValues(nativeEnumValues);\n      addIssueToContext(ctx, {\n        expected: util.joinValues(expectedValues),\n        received: ctx.parsedType,\n        code: ZodIssueCode.invalid_type\n      });\n      return INVALID;\n    }\n    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, \"f\")) {\n      __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)), \"f\");\n    }\n    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, \"f\").has(input.data)) {\n      const expectedValues = util.objectValues(nativeEnumValues);\n      addIssueToContext(ctx, {\n        received: ctx.data,\n        code: ZodIssueCode.invalid_enum_value,\n        options: expectedValues\n      });\n      return INVALID;\n    }\n    return OK(input.data);\n  }\n  get enum() {\n    return this._def.values;\n  }\n};\n_ZodNativeEnum_cache = /* @__PURE__ */ new WeakMap();\nZodNativeEnum.create = (values, params) => {\n  return new ZodNativeEnum({\n    values,\n    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,\n    ...processCreateParams(params)\n  });\n};\nvar ZodPromise = class extends ZodType {\n  unwrap() {\n    return this._def.type;\n  }\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.promise,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);\n    return OK(promisified.then((data) => {\n      return this._def.type.parseAsync(data, {\n        path: ctx.path,\n        errorMap: ctx.common.contextualErrorMap\n      });\n    }));\n  }\n};\nZodPromise.create = (schema, params) => {\n  return new ZodPromise({\n    type: schema,\n    typeName: ZodFirstPartyTypeKind.ZodPromise,\n    ...processCreateParams(params)\n  });\n};\nvar ZodEffects = class extends ZodType {\n  innerType() {\n    return this._def.schema;\n  }\n  sourceType() {\n    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;\n  }\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    const effect = this._def.effect || null;\n    const checkCtx = {\n      addIssue: (arg) => {\n        addIssueToContext(ctx, arg);\n        if (arg.fatal) {\n          status.abort();\n        } else {\n          status.dirty();\n        }\n      },\n      get path() {\n        return ctx.path;\n      }\n    };\n    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);\n    if (effect.type === \"preprocess\") {\n      const processed = effect.transform(ctx.data, checkCtx);\n      if (ctx.common.async) {\n        return Promise.resolve(processed).then(async (processed2) => {\n          if (status.value === \"aborted\")\n            return INVALID;\n          const result = await this._def.schema._parseAsync({\n            data: processed2,\n            path: ctx.path,\n            parent: ctx\n          });\n          if (result.status === \"aborted\")\n            return INVALID;\n          if (result.status === \"dirty\")\n            return DIRTY(result.value);\n          if (status.value === \"dirty\")\n            return DIRTY(result.value);\n          return result;\n        });\n      } else {\n        if (status.value === \"aborted\")\n          return INVALID;\n        const result = this._def.schema._parseSync({\n          data: processed,\n          path: ctx.path,\n          parent: ctx\n        });\n        if (result.status === \"aborted\")\n          return INVALID;\n        if (result.status === \"dirty\")\n          return DIRTY(result.value);\n        if (status.value === \"dirty\")\n          return DIRTY(result.value);\n        return result;\n      }\n    }\n    if (effect.type === \"refinement\") {\n      const executeRefinement = (acc) => {\n        const result = effect.refinement(acc, checkCtx);\n        if (ctx.common.async) {\n          return Promise.resolve(result);\n        }\n        if (result instanceof Promise) {\n          throw new Error(\"Async refinement encountered during synchronous parse operation. Use .parseAsync instead.\");\n        }\n        return acc;\n      };\n      if (ctx.common.async === false) {\n        const inner = this._def.schema._parseSync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: ctx\n        });\n        if (inner.status === \"aborted\")\n          return INVALID;\n        if (inner.status === \"dirty\")\n          status.dirty();\n        executeRefinement(inner.value);\n        return { status: status.value, value: inner.value };\n      } else {\n        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {\n          if (inner.status === \"aborted\")\n            return INVALID;\n          if (inner.status === \"dirty\")\n            status.dirty();\n          return executeRefinement(inner.value).then(() => {\n            return { status: status.value, value: inner.value };\n          });\n        });\n      }\n    }\n    if (effect.type === \"transform\") {\n      if (ctx.common.async === false) {\n        const base = this._def.schema._parseSync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: ctx\n        });\n        if (!isValid(base))\n          return base;\n        const result = effect.transform(base.value, checkCtx);\n        if (result instanceof Promise) {\n          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);\n        }\n        return { status: status.value, value: result };\n      } else {\n        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {\n          if (!isValid(base))\n            return base;\n          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));\n        });\n      }\n    }\n    util.assertNever(effect);\n  }\n};\nZodEffects.create = (schema, effect, params) => {\n  return new ZodEffects({\n    schema,\n    typeName: ZodFirstPartyTypeKind.ZodEffects,\n    effect,\n    ...processCreateParams(params)\n  });\n};\nZodEffects.createWithPreprocess = (preprocess, schema, params) => {\n  return new ZodEffects({\n    schema,\n    effect: { type: \"preprocess\", transform: preprocess },\n    typeName: ZodFirstPartyTypeKind.ZodEffects,\n    ...processCreateParams(params)\n  });\n};\nvar ZodOptional = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType === ZodParsedType.undefined) {\n      return OK(void 0);\n    }\n    return this._def.innerType._parse(input);\n  }\n  unwrap() {\n    return this._def.innerType;\n  }\n};\nZodOptional.create = (type, params) => {\n  return new ZodOptional({\n    innerType: type,\n    typeName: ZodFirstPartyTypeKind.ZodOptional,\n    ...processCreateParams(params)\n  });\n};\nvar ZodNullable = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType === ZodParsedType.null) {\n      return OK(null);\n    }\n    return this._def.innerType._parse(input);\n  }\n  unwrap() {\n    return this._def.innerType;\n  }\n};\nZodNullable.create = (type, params) => {\n  return new ZodNullable({\n    innerType: type,\n    typeName: ZodFirstPartyTypeKind.ZodNullable,\n    ...processCreateParams(params)\n  });\n};\nvar ZodDefault = class extends ZodType {\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    let data = ctx.data;\n    if (ctx.parsedType === ZodParsedType.undefined) {\n      data = this._def.defaultValue();\n    }\n    return this._def.innerType._parse({\n      data,\n      path: ctx.path,\n      parent: ctx\n    });\n  }\n  removeDefault() {\n    return this._def.innerType;\n  }\n};\nZodDefault.create = (type, params) => {\n  return new ZodDefault({\n    innerType: type,\n    typeName: ZodFirstPartyTypeKind.ZodDefault,\n    defaultValue: typeof params.default === \"function\" ? params.default : () => params.default,\n    ...processCreateParams(params)\n  });\n};\nvar ZodCatch = class extends ZodType {\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    const newCtx = {\n      ...ctx,\n      common: {\n        ...ctx.common,\n        issues: []\n      }\n    };\n    const result = this._def.innerType._parse({\n      data: newCtx.data,\n      path: newCtx.path,\n      parent: {\n        ...newCtx\n      }\n    });\n    if (isAsync(result)) {\n      return result.then((result2) => {\n        return {\n          status: \"valid\",\n          value: result2.status === \"valid\" ? result2.value : this._def.catchValue({\n            get error() {\n              return new ZodError(newCtx.common.issues);\n            },\n            input: newCtx.data\n          })\n        };\n      });\n    } else {\n      return {\n        status: \"valid\",\n        value: result.status === \"valid\" ? result.value : this._def.catchValue({\n          get error() {\n            return new ZodError(newCtx.common.issues);\n          },\n          input: newCtx.data\n        })\n      };\n    }\n  }\n  removeCatch() {\n    return this._def.innerType;\n  }\n};\nZodCatch.create = (type, params) => {\n  return new ZodCatch({\n    innerType: type,\n    typeName: ZodFirstPartyTypeKind.ZodCatch,\n    catchValue: typeof params.catch === \"function\" ? params.catch : () => params.catch,\n    ...processCreateParams(params)\n  });\n};\nvar ZodNaN = class extends ZodType {\n  _parse(input) {\n    const parsedType = this._getType(input);\n    if (parsedType !== ZodParsedType.nan) {\n      const ctx = this._getOrReturnCtx(input);\n      addIssueToContext(ctx, {\n        code: ZodIssueCode.invalid_type,\n        expected: ZodParsedType.nan,\n        received: ctx.parsedType\n      });\n      return INVALID;\n    }\n    return { status: \"valid\", value: input.data };\n  }\n};\nZodNaN.create = (params) => {\n  return new ZodNaN({\n    typeName: ZodFirstPartyTypeKind.ZodNaN,\n    ...processCreateParams(params)\n  });\n};\nvar BRAND = Symbol(\"zod_brand\");\nvar ZodBranded = class extends ZodType {\n  _parse(input) {\n    const { ctx } = this._processInputParams(input);\n    const data = ctx.data;\n    return this._def.type._parse({\n      data,\n      path: ctx.path,\n      parent: ctx\n    });\n  }\n  unwrap() {\n    return this._def.type;\n  }\n};\nvar ZodPipeline = class _ZodPipeline extends ZodType {\n  _parse(input) {\n    const { status, ctx } = this._processInputParams(input);\n    if (ctx.common.async) {\n      const handleAsync = async () => {\n        const inResult = await this._def.in._parseAsync({\n          data: ctx.data,\n          path: ctx.path,\n          parent: ctx\n        });\n        if (inResult.status === \"aborted\")\n          return INVALID;\n        if (inResult.status === \"dirty\") {\n          status.dirty();\n          return DIRTY(inResult.value);\n        } else {\n          return this._def.out._parseAsync({\n            data: inResult.value,\n            path: ctx.path,\n            parent: ctx\n          });\n        }\n      };\n      return handleAsync();\n    } else {\n      const inResult = this._def.in._parseSync({\n        data: ctx.data,\n        path: ctx.path,\n        parent: ctx\n      });\n      if (inResult.status === \"aborted\")\n        return INVALID;\n      if (inResult.status === \"dirty\") {\n        status.dirty();\n        return {\n          status: \"dirty\",\n          value: inResult.value\n        };\n      } else {\n        return this._def.out._parseSync({\n          data: inResult.value,\n          path: ctx.path,\n          parent: ctx\n        });\n      }\n    }\n  }\n  static create(a, b) {\n    return new _ZodPipeline({\n      in: a,\n      out: b,\n      typeName: ZodFirstPartyTypeKind.ZodPipeline\n    });\n  }\n};\nvar ZodReadonly = class extends ZodType {\n  _parse(input) {\n    const result = this._def.innerType._parse(input);\n    const freeze = (data) => {\n      if (isValid(data)) {\n        data.value = Object.freeze(data.value);\n      }\n      return data;\n    };\n    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);\n  }\n  unwrap() {\n    return this._def.innerType;\n  }\n};\nZodReadonly.create = (type, params) => {\n  return new ZodReadonly({\n    innerType: type,\n    typeName: ZodFirstPartyTypeKind.ZodReadonly,\n    ...processCreateParams(params)\n  });\n};\nfunction cleanParams(params, data) {\n  const p = typeof params === \"function\" ? params(data) : typeof params === \"string\" ? { message: params } : params;\n  const p2 = typeof p === \"string\" ? { message: p } : p;\n  return p2;\n}\nfunction custom(check, _params = {}, fatal) {\n  if (check)\n    return ZodAny.create().superRefine((data, ctx) => {\n      var _a, _b;\n      const r = check(data);\n      if (r instanceof Promise) {\n        return r.then((r2) => {\n          var _a2, _b2;\n          if (!r2) {\n            const params = cleanParams(_params, data);\n            const _fatal = (_b2 = (_a2 = params.fatal) !== null && _a2 !== void 0 ? _a2 : fatal) !== null && _b2 !== void 0 ? _b2 : true;\n            ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n          }\n        });\n      }\n      if (!r) {\n        const params = cleanParams(_params, data);\n        const _fatal = (_b = (_a = params.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;\n        ctx.addIssue({ code: \"custom\", ...params, fatal: _fatal });\n      }\n      return;\n    });\n  return ZodAny.create();\n}\nvar late = {\n  object: ZodObject.lazycreate\n};\nvar ZodFirstPartyTypeKind;\n(function(ZodFirstPartyTypeKind2) {\n  ZodFirstPartyTypeKind2[\"ZodString\"] = \"ZodString\";\n  ZodFirstPartyTypeKind2[\"ZodNumber\"] = \"ZodNumber\";\n  ZodFirstPartyTypeKind2[\"ZodNaN\"] = \"ZodNaN\";\n  ZodFirstPartyTypeKind2[\"ZodBigInt\"] = \"ZodBigInt\";\n  ZodFirstPartyTypeKind2[\"ZodBoolean\"] = \"ZodBoolean\";\n  ZodFirstPartyTypeKind2[\"ZodDate\"] = \"ZodDate\";\n  ZodFirstPartyTypeKind2[\"ZodSymbol\"] = \"ZodSymbol\";\n  ZodFirstPartyTypeKind2[\"ZodUndefined\"] = \"ZodUndefined\";\n  ZodFirstPartyTypeKind2[\"ZodNull\"] = \"ZodNull\";\n  ZodFirstPartyTypeKind2[\"ZodAny\"] = \"ZodAny\";\n  ZodFirstPartyTypeKind2[\"ZodUnknown\"] = \"ZodUnknown\";\n  ZodFirstPartyTypeKind2[\"ZodNever\"] = \"ZodNever\";\n  ZodFirstPartyTypeKind2[\"ZodVoid\"] = \"ZodVoid\";\n  ZodFirstPartyTypeKind2[\"ZodArray\"] = \"ZodArray\";\n  ZodFirstPartyTypeKind2[\"ZodObject\"] = \"ZodObject\";\n  ZodFirstPartyTypeKind2[\"ZodUnion\"] = \"ZodUnion\";\n  ZodFirstPartyTypeKind2[\"ZodDiscriminatedUnion\"] = \"ZodDiscriminatedUnion\";\n  ZodFirstPartyTypeKind2[\"ZodIntersection\"] = \"ZodIntersection\";\n  ZodFirstPartyTypeKind2[\"ZodTuple\"] = \"ZodTuple\";\n  ZodFirstPartyTypeKind2[\"ZodRecord\"] = \"ZodRecord\";\n  ZodFirstPartyTypeKind2[\"ZodMap\"] = \"ZodMap\";\n  ZodFirstPartyTypeKind2[\"ZodSet\"] = \"ZodSet\";\n  ZodFirstPartyTypeKind2[\"ZodFunction\"] = \"ZodFunction\";\n  ZodFirstPartyTypeKind2[\"ZodLazy\"] = \"ZodLazy\";\n  ZodFirstPartyTypeKind2[\"ZodLiteral\"] = \"ZodLiteral\";\n  ZodFirstPartyTypeKind2[\"ZodEnum\"] = \"ZodEnum\";\n  ZodFirstPartyTypeKind2[\"ZodEffects\"] = \"ZodEffects\";\n  ZodFirstPartyTypeKind2[\"ZodNativeEnum\"] = \"ZodNativeEnum\";\n  ZodFirstPartyTypeKind2[\"ZodOptional\"] = \"ZodOptional\";\n  ZodFirstPartyTypeKind2[\"ZodNullable\"] = \"ZodNullable\";\n  ZodFirstPartyTypeKind2[\"ZodDefault\"] = \"ZodDefault\";\n  ZodFirstPartyTypeKind2[\"ZodCatch\"] = \"ZodCatch\";\n  ZodFirstPartyTypeKind2[\"ZodPromise\"] = \"ZodPromise\";\n  ZodFirstPartyTypeKind2[\"ZodBranded\"] = \"ZodBranded\";\n  ZodFirstPartyTypeKind2[\"ZodPipeline\"] = \"ZodPipeline\";\n  ZodFirstPartyTypeKind2[\"ZodReadonly\"] = \"ZodReadonly\";\n})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));\nvar instanceOfType = (cls, params = {\n  message: `Input not instance of ${cls.name}`\n}) => custom((data) => data instanceof cls, params);\nvar stringType = ZodString.create;\nvar numberType = ZodNumber.create;\nvar nanType = ZodNaN.create;\nvar bigIntType = ZodBigInt.create;\nvar booleanType = ZodBoolean.create;\nvar dateType = ZodDate.create;\nvar symbolType = ZodSymbol.create;\nvar undefinedType = ZodUndefined.create;\nvar nullType = ZodNull.create;\nvar anyType = ZodAny.create;\nvar unknownType = ZodUnknown.create;\nvar neverType = ZodNever.create;\nvar voidType = ZodVoid.create;\nvar arrayType = ZodArray.create;\nvar objectType = ZodObject.create;\nvar strictObjectType = ZodObject.strictCreate;\nvar unionType = ZodUnion.create;\nvar discriminatedUnionType = ZodDiscriminatedUnion.create;\nvar intersectionType = ZodIntersection.create;\nvar tupleType = ZodTuple.create;\nvar recordType = ZodRecord.create;\nvar mapType = ZodMap.create;\nvar setType = ZodSet.create;\nvar functionType = ZodFunction.create;\nvar lazyType = ZodLazy.create;\nvar literalType = ZodLiteral.create;\nvar enumType = ZodEnum.create;\nvar nativeEnumType = ZodNativeEnum.create;\nvar promiseType = ZodPromise.create;\nvar effectsType = ZodEffects.create;\nvar optionalType = ZodOptional.create;\nvar nullableType = ZodNullable.create;\nvar preprocessType = ZodEffects.createWithPreprocess;\nvar pipelineType = ZodPipeline.create;\nvar ostring = () => stringType().optional();\nvar onumber = () => numberType().optional();\nvar oboolean = () => booleanType().optional();\nvar coerce = {\n  string: (arg) => ZodString.create({ ...arg, coerce: true }),\n  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),\n  boolean: (arg) => ZodBoolean.create({\n    ...arg,\n    coerce: true\n  }),\n  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),\n  date: (arg) => ZodDate.create({ ...arg, coerce: true })\n};\nvar NEVER = INVALID;\nvar z = /* @__PURE__ */ Object.freeze({\n  __proto__: null,\n  defaultErrorMap: errorMap,\n  setErrorMap,\n  getErrorMap,\n  makeIssue,\n  EMPTY_PATH,\n  addIssueToContext,\n  ParseStatus,\n  INVALID,\n  DIRTY,\n  OK,\n  isAborted,\n  isDirty,\n  isValid,\n  isAsync,\n  get util() {\n    return util;\n  },\n  get objectUtil() {\n    return objectUtil;\n  },\n  ZodParsedType,\n  getParsedType,\n  ZodType,\n  datetimeRegex,\n  ZodString,\n  ZodNumber,\n  ZodBigInt,\n  ZodBoolean,\n  ZodDate,\n  ZodSymbol,\n  ZodUndefined,\n  ZodNull,\n  ZodAny,\n  ZodUnknown,\n  ZodNever,\n  ZodVoid,\n  ZodArray,\n  ZodObject,\n  ZodUnion,\n  ZodDiscriminatedUnion,\n  ZodIntersection,\n  ZodTuple,\n  ZodRecord,\n  ZodMap,\n  ZodSet,\n  ZodFunction,\n  ZodLazy,\n  ZodLiteral,\n  ZodEnum,\n  ZodNativeEnum,\n  ZodPromise,\n  ZodEffects,\n  ZodTransformer: ZodEffects,\n  ZodOptional,\n  ZodNullable,\n  ZodDefault,\n  ZodCatch,\n  ZodNaN,\n  BRAND,\n  ZodBranded,\n  ZodPipeline,\n  ZodReadonly,\n  custom,\n  Schema: ZodType,\n  ZodSchema: ZodType,\n  late,\n  get ZodFirstPartyTypeKind() {\n    return ZodFirstPartyTypeKind;\n  },\n  coerce,\n  any: anyType,\n  array: arrayType,\n  bigint: bigIntType,\n  boolean: booleanType,\n  date: dateType,\n  discriminatedUnion: discriminatedUnionType,\n  effect: effectsType,\n  \"enum\": enumType,\n  \"function\": functionType,\n  \"instanceof\": instanceOfType,\n  intersection: intersectionType,\n  lazy: lazyType,\n  literal: literalType,\n  map: mapType,\n  nan: nanType,\n  nativeEnum: nativeEnumType,\n  never: neverType,\n  \"null\": nullType,\n  nullable: nullableType,\n  number: numberType,\n  object: objectType,\n  oboolean,\n  onumber,\n  optional: optionalType,\n  ostring,\n  pipeline: pipelineType,\n  preprocess: preprocessType,\n  promise: promiseType,\n  record: recordType,\n  set: setType,\n  strictObject: strictObjectType,\n  string: stringType,\n  symbol: symbolType,\n  transformer: effectsType,\n  tuple: tupleType,\n  \"undefined\": undefinedType,\n  union: unionType,\n  unknown: unknownType,\n  \"void\": voidType,\n  NEVER,\n  ZodIssueCode,\n  quotelessJson,\n  ZodError\n});\n\n// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js\nvar LATEST_PROTOCOL_VERSION = \"2025-06-18\";\nvar DEFAULT_NEGOTIATED_PROTOCOL_VERSION = \"2025-03-26\";\nvar SUPPORTED_PROTOCOL_VERSIONS = [\n  LATEST_PROTOCOL_VERSION,\n  \"2025-03-26\",\n  \"2024-11-05\",\n  \"2024-10-07\"\n];\nvar JSONRPC_VERSION = \"2.0\";\nvar ProgressTokenSchema = z.union([z.string(), z.number().int()]);\nvar CursorSchema = z.string();\nvar RequestMetaSchema = z.object({\n  /**\n   * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.\n   */\n  progressToken: z.optional(ProgressTokenSchema)\n}).passthrough();\nvar BaseRequestParamsSchema = z.object({\n  _meta: z.optional(RequestMetaSchema)\n}).passthrough();\nvar RequestSchema = z.object({\n  method: z.string(),\n  params: z.optional(BaseRequestParamsSchema)\n});\nvar BaseNotificationParamsSchema = z.object({\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar NotificationSchema = z.object({\n  method: z.string(),\n  params: z.optional(BaseNotificationParamsSchema)\n});\nvar ResultSchema = z.object({\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar RequestIdSchema = z.union([z.string(), z.number().int()]);\nvar JSONRPCRequestSchema = z.object({\n  jsonrpc: z.literal(JSONRPC_VERSION),\n  id: RequestIdSchema\n}).merge(RequestSchema).strict();\nvar isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;\nvar JSONRPCNotificationSchema = z.object({\n  jsonrpc: z.literal(JSONRPC_VERSION)\n}).merge(NotificationSchema).strict();\nvar JSONRPCResponseSchema = z.object({\n  jsonrpc: z.literal(JSONRPC_VERSION),\n  id: RequestIdSchema,\n  result: ResultSchema\n}).strict();\nvar isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;\nvar ErrorCode;\n(function(ErrorCode2) {\n  ErrorCode2[ErrorCode2[\"ConnectionClosed\"] = -32e3] = \"ConnectionClosed\";\n  ErrorCode2[ErrorCode2[\"RequestTimeout\"] = -32001] = \"RequestTimeout\";\n  ErrorCode2[ErrorCode2[\"ParseError\"] = -32700] = \"ParseError\";\n  ErrorCode2[ErrorCode2[\"InvalidRequest\"] = -32600] = \"InvalidRequest\";\n  ErrorCode2[ErrorCode2[\"MethodNotFound\"] = -32601] = \"MethodNotFound\";\n  ErrorCode2[ErrorCode2[\"InvalidParams\"] = -32602] = \"InvalidParams\";\n  ErrorCode2[ErrorCode2[\"InternalError\"] = -32603] = \"InternalError\";\n})(ErrorCode || (ErrorCode = {}));\nvar JSONRPCErrorSchema = z.object({\n  jsonrpc: z.literal(JSONRPC_VERSION),\n  id: RequestIdSchema,\n  error: z.object({\n    /**\n     * The error type that occurred.\n     */\n    code: z.number().int(),\n    /**\n     * A short description of the error. The message SHOULD be limited to a concise single sentence.\n     */\n    message: z.string(),\n    /**\n     * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).\n     */\n    data: z.optional(z.unknown())\n  })\n}).strict();\nvar isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;\nvar JSONRPCMessageSchema = z.union([\n  JSONRPCRequestSchema,\n  JSONRPCNotificationSchema,\n  JSONRPCResponseSchema,\n  JSONRPCErrorSchema\n]);\nvar EmptyResultSchema = ResultSchema.strict();\nvar CancelledNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/cancelled\"),\n  params: BaseNotificationParamsSchema.extend({\n    /**\n     * The ID of the request to cancel.\n     *\n     * This MUST correspond to the ID of a request previously issued in the same direction.\n     */\n    requestId: RequestIdSchema,\n    /**\n     * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.\n     */\n    reason: z.string().optional()\n  })\n});\nvar BaseMetadataSchema = z.object({\n  /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */\n  name: z.string(),\n  /**\n  * Intended for UI and end-user contexts \u2014 optimized to be human-readable and easily understood,\n  * even by those unfamiliar with domain-specific terminology.\n  *\n  * If not provided, the name should be used for display (except for Tool,\n  * where `annotations.title` should be given precedence over using `name`,\n  * if present).\n  */\n  title: z.optional(z.string())\n}).passthrough();\nvar ImplementationSchema = BaseMetadataSchema.extend({\n  version: z.string()\n});\nvar ClientCapabilitiesSchema = z.object({\n  /**\n   * Experimental, non-standard capabilities that the client supports.\n   */\n  experimental: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the client supports sampling from an LLM.\n   */\n  sampling: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the client supports eliciting user input.\n   */\n  elicitation: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the client supports listing roots.\n   */\n  roots: z.optional(z.object({\n    /**\n     * Whether the client supports issuing notifications for changes to the roots list.\n     */\n    listChanged: z.optional(z.boolean())\n  }).passthrough())\n}).passthrough();\nvar InitializeRequestSchema = RequestSchema.extend({\n  method: z.literal(\"initialize\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.\n     */\n    protocolVersion: z.string(),\n    capabilities: ClientCapabilitiesSchema,\n    clientInfo: ImplementationSchema\n  })\n});\nvar isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;\nvar ServerCapabilitiesSchema = z.object({\n  /**\n   * Experimental, non-standard capabilities that the server supports.\n   */\n  experimental: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the server supports sending log messages to the client.\n   */\n  logging: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the server supports sending completions to the client.\n   */\n  completions: z.optional(z.object({}).passthrough()),\n  /**\n   * Present if the server offers any prompt templates.\n   */\n  prompts: z.optional(z.object({\n    /**\n     * Whether this server supports issuing notifications for changes to the prompt list.\n     */\n    listChanged: z.optional(z.boolean())\n  }).passthrough()),\n  /**\n   * Present if the server offers any resources to read.\n   */\n  resources: z.optional(z.object({\n    /**\n     * Whether this server supports clients subscribing to resource updates.\n     */\n    subscribe: z.optional(z.boolean()),\n    /**\n     * Whether this server supports issuing notifications for changes to the resource list.\n     */\n    listChanged: z.optional(z.boolean())\n  }).passthrough()),\n  /**\n   * Present if the server offers any tools to call.\n   */\n  tools: z.optional(z.object({\n    /**\n     * Whether this server supports issuing notifications for changes to the tool list.\n     */\n    listChanged: z.optional(z.boolean())\n  }).passthrough())\n}).passthrough();\nvar InitializeResultSchema = ResultSchema.extend({\n  /**\n   * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.\n   */\n  protocolVersion: z.string(),\n  capabilities: ServerCapabilitiesSchema,\n  serverInfo: ImplementationSchema,\n  /**\n   * Instructions describing how to use the server and its features.\n   *\n   * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a \"hint\" to the model. For example, this information MAY be added to the system prompt.\n   */\n  instructions: z.optional(z.string())\n});\nvar InitializedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/initialized\")\n});\nvar PingRequestSchema = RequestSchema.extend({\n  method: z.literal(\"ping\")\n});\nvar ProgressSchema = z.object({\n  /**\n   * The progress thus far. This should increase every time progress is made, even if the total is unknown.\n   */\n  progress: z.number(),\n  /**\n   * Total number of items to process (or total progress required), if known.\n   */\n  total: z.optional(z.number()),\n  /**\n   * An optional message describing the current progress.\n   */\n  message: z.optional(z.string())\n}).passthrough();\nvar ProgressNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/progress\"),\n  params: BaseNotificationParamsSchema.merge(ProgressSchema).extend({\n    /**\n     * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.\n     */\n    progressToken: ProgressTokenSchema\n  })\n});\nvar PaginatedRequestSchema = RequestSchema.extend({\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * An opaque token representing the current pagination position.\n     * If provided, the server should return results starting after this cursor.\n     */\n    cursor: z.optional(CursorSchema)\n  }).optional()\n});\nvar PaginatedResultSchema = ResultSchema.extend({\n  /**\n   * An opaque token representing the pagination position after the last returned result.\n   * If present, there may be more results available.\n   */\n  nextCursor: z.optional(CursorSchema)\n});\nvar ResourceContentsSchema = z.object({\n  /**\n   * The URI of this resource.\n   */\n  uri: z.string(),\n  /**\n   * The MIME type of this resource, if known.\n   */\n  mimeType: z.optional(z.string()),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar TextResourceContentsSchema = ResourceContentsSchema.extend({\n  /**\n   * The text of the item. This must only be set if the item can actually be represented as text (not binary data).\n   */\n  text: z.string()\n});\nvar Base64Schema = z.string().refine((val) => {\n  try {\n    atob(val);\n    return true;\n  } catch (_a) {\n    return false;\n  }\n}, { message: \"Invalid Base64 string\" });\nvar BlobResourceContentsSchema = ResourceContentsSchema.extend({\n  /**\n   * A base64-encoded string representing the binary data of the item.\n   */\n  blob: Base64Schema\n});\nvar ResourceSchema = BaseMetadataSchema.extend({\n  /**\n   * The URI of this resource.\n   */\n  uri: z.string(),\n  /**\n   * A description of what this resource represents.\n   *\n   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a \"hint\" to the model.\n   */\n  description: z.optional(z.string()),\n  /**\n   * The MIME type of this resource, if known.\n   */\n  mimeType: z.optional(z.string()),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n});\nvar ResourceTemplateSchema = BaseMetadataSchema.extend({\n  /**\n   * A URI template (according to RFC 6570) that can be used to construct resource URIs.\n   */\n  uriTemplate: z.string(),\n  /**\n   * A description of what this template is for.\n   *\n   * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a \"hint\" to the model.\n   */\n  description: z.optional(z.string()),\n  /**\n   * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.\n   */\n  mimeType: z.optional(z.string()),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n});\nvar ListResourcesRequestSchema = PaginatedRequestSchema.extend({\n  method: z.literal(\"resources/list\")\n});\nvar ListResourcesResultSchema = PaginatedResultSchema.extend({\n  resources: z.array(ResourceSchema)\n});\nvar ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({\n  method: z.literal(\"resources/templates/list\")\n});\nvar ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({\n  resourceTemplates: z.array(ResourceTemplateSchema)\n});\nvar ReadResourceRequestSchema = RequestSchema.extend({\n  method: z.literal(\"resources/read\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.\n     */\n    uri: z.string()\n  })\n});\nvar ReadResourceResultSchema = ResultSchema.extend({\n  contents: z.array(z.union([TextResourceContentsSchema, BlobResourceContentsSchema]))\n});\nvar ResourceListChangedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/resources/list_changed\")\n});\nvar SubscribeRequestSchema = RequestSchema.extend({\n  method: z.literal(\"resources/subscribe\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.\n     */\n    uri: z.string()\n  })\n});\nvar UnsubscribeRequestSchema = RequestSchema.extend({\n  method: z.literal(\"resources/unsubscribe\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The URI of the resource to unsubscribe from.\n     */\n    uri: z.string()\n  })\n});\nvar ResourceUpdatedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/resources/updated\"),\n  params: BaseNotificationParamsSchema.extend({\n    /**\n     * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.\n     */\n    uri: z.string()\n  })\n});\nvar PromptArgumentSchema = z.object({\n  /**\n   * The name of the argument.\n   */\n  name: z.string(),\n  /**\n   * A human-readable description of the argument.\n   */\n  description: z.optional(z.string()),\n  /**\n   * Whether this argument must be provided.\n   */\n  required: z.optional(z.boolean())\n}).passthrough();\nvar PromptSchema = BaseMetadataSchema.extend({\n  /**\n   * An optional description of what this prompt provides\n   */\n  description: z.optional(z.string()),\n  /**\n   * A list of arguments to use for templating the prompt.\n   */\n  arguments: z.optional(z.array(PromptArgumentSchema)),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n});\nvar ListPromptsRequestSchema = PaginatedRequestSchema.extend({\n  method: z.literal(\"prompts/list\")\n});\nvar ListPromptsResultSchema = PaginatedResultSchema.extend({\n  prompts: z.array(PromptSchema)\n});\nvar GetPromptRequestSchema = RequestSchema.extend({\n  method: z.literal(\"prompts/get\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The name of the prompt or prompt template.\n     */\n    name: z.string(),\n    /**\n     * Arguments to use for templating the prompt.\n     */\n    arguments: z.optional(z.record(z.string()))\n  })\n});\nvar TextContentSchema = z.object({\n  type: z.literal(\"text\"),\n  /**\n   * The text content of the message.\n   */\n  text: z.string(),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar ImageContentSchema = z.object({\n  type: z.literal(\"image\"),\n  /**\n   * The base64-encoded image data.\n   */\n  data: Base64Schema,\n  /**\n   * The MIME type of the image. Different providers may support different image types.\n   */\n  mimeType: z.string(),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar AudioContentSchema = z.object({\n  type: z.literal(\"audio\"),\n  /**\n   * The base64-encoded audio data.\n   */\n  data: Base64Schema,\n  /**\n   * The MIME type of the audio. Different providers may support different audio types.\n   */\n  mimeType: z.string(),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar EmbeddedResourceSchema = z.object({\n  type: z.literal(\"resource\"),\n  resource: z.union([TextResourceContentsSchema, BlobResourceContentsSchema]),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar ResourceLinkSchema = ResourceSchema.extend({\n  type: z.literal(\"resource_link\")\n});\nvar ContentBlockSchema = z.union([\n  TextContentSchema,\n  ImageContentSchema,\n  AudioContentSchema,\n  ResourceLinkSchema,\n  EmbeddedResourceSchema\n]);\nvar PromptMessageSchema = z.object({\n  role: z.enum([\"user\", \"assistant\"]),\n  content: ContentBlockSchema\n}).passthrough();\nvar GetPromptResultSchema = ResultSchema.extend({\n  /**\n   * An optional description for the prompt.\n   */\n  description: z.optional(z.string()),\n  messages: z.array(PromptMessageSchema)\n});\nvar PromptListChangedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/prompts/list_changed\")\n});\nvar ToolAnnotationsSchema = z.object({\n  /**\n   * A human-readable title for the tool.\n   */\n  title: z.optional(z.string()),\n  /**\n   * If true, the tool does not modify its environment.\n   *\n   * Default: false\n   */\n  readOnlyHint: z.optional(z.boolean()),\n  /**\n   * If true, the tool may perform destructive updates to its environment.\n   * If false, the tool performs only additive updates.\n   *\n   * (This property is meaningful only when `readOnlyHint == false`)\n   *\n   * Default: true\n   */\n  destructiveHint: z.optional(z.boolean()),\n  /**\n   * If true, calling the tool repeatedly with the same arguments\n   * will have no additional effect on the its environment.\n   *\n   * (This property is meaningful only when `readOnlyHint == false`)\n   *\n   * Default: false\n   */\n  idempotentHint: z.optional(z.boolean()),\n  /**\n   * If true, this tool may interact with an \"open world\" of external\n   * entities. If false, the tool's domain of interaction is closed.\n   * For example, the world of a web search tool is open, whereas that\n   * of a memory tool is not.\n   *\n   * Default: true\n   */\n  openWorldHint: z.optional(z.boolean())\n}).passthrough();\nvar ToolSchema = BaseMetadataSchema.extend({\n  /**\n   * A human-readable description of the tool.\n   */\n  description: z.optional(z.string()),\n  /**\n   * A JSON Schema object defining the expected parameters for the tool.\n   */\n  inputSchema: z.object({\n    type: z.literal(\"object\"),\n    properties: z.optional(z.object({}).passthrough()),\n    required: z.optional(z.array(z.string()))\n  }).passthrough(),\n  /**\n   * An optional JSON Schema object defining the structure of the tool's output returned in\n   * the structuredContent field of a CallToolResult.\n   */\n  outputSchema: z.optional(z.object({\n    type: z.literal(\"object\"),\n    properties: z.optional(z.object({}).passthrough()),\n    required: z.optional(z.array(z.string()))\n  }).passthrough()),\n  /**\n   * Optional additional tool information.\n   */\n  annotations: z.optional(ToolAnnotationsSchema),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n});\nvar ListToolsRequestSchema = PaginatedRequestSchema.extend({\n  method: z.literal(\"tools/list\")\n});\nvar ListToolsResultSchema = PaginatedResultSchema.extend({\n  tools: z.array(ToolSchema)\n});\nvar CallToolResultSchema = ResultSchema.extend({\n  /**\n   * A list of content objects that represent the result of the tool call.\n   *\n   * If the Tool does not define an outputSchema, this field MUST be present in the result.\n   * For backwards compatibility, this field is always present, but it may be empty.\n   */\n  content: z.array(ContentBlockSchema).default([]),\n  /**\n   * An object containing structured tool output.\n   *\n   * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.\n   */\n  structuredContent: z.object({}).passthrough().optional(),\n  /**\n   * Whether the tool call ended in an error.\n   *\n   * If not set, this is assumed to be false (the call was successful).\n   *\n   * Any errors that originate from the tool SHOULD be reported inside the result\n   * object, with `isError` set to true, _not_ as an MCP protocol-level error\n   * response. Otherwise, the LLM would not be able to see that an error occurred\n   * and self-correct.\n   *\n   * However, any errors in _finding_ the tool, an error indicating that the\n   * server does not support tool calls, or any other exceptional conditions,\n   * should be reported as an MCP error response.\n   */\n  isError: z.optional(z.boolean())\n});\nvar CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({\n  toolResult: z.unknown()\n}));\nvar CallToolRequestSchema = RequestSchema.extend({\n  method: z.literal(\"tools/call\"),\n  params: BaseRequestParamsSchema.extend({\n    name: z.string(),\n    arguments: z.optional(z.record(z.unknown()))\n  })\n});\nvar ToolListChangedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/tools/list_changed\")\n});\nvar LoggingLevelSchema = z.enum([\n  \"debug\",\n  \"info\",\n  \"notice\",\n  \"warning\",\n  \"error\",\n  \"critical\",\n  \"alert\",\n  \"emergency\"\n]);\nvar SetLevelRequestSchema = RequestSchema.extend({\n  method: z.literal(\"logging/setLevel\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.\n     */\n    level: LoggingLevelSchema\n  })\n});\nvar LoggingMessageNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/message\"),\n  params: BaseNotificationParamsSchema.extend({\n    /**\n     * The severity of this log message.\n     */\n    level: LoggingLevelSchema,\n    /**\n     * An optional name of the logger issuing this message.\n     */\n    logger: z.optional(z.string()),\n    /**\n     * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.\n     */\n    data: z.unknown()\n  })\n});\nvar ModelHintSchema = z.object({\n  /**\n   * A hint for a model name.\n   */\n  name: z.string().optional()\n}).passthrough();\nvar ModelPreferencesSchema = z.object({\n  /**\n   * Optional hints to use for model selection.\n   */\n  hints: z.optional(z.array(ModelHintSchema)),\n  /**\n   * How much to prioritize cost when selecting a model.\n   */\n  costPriority: z.optional(z.number().min(0).max(1)),\n  /**\n   * How much to prioritize sampling speed (latency) when selecting a model.\n   */\n  speedPriority: z.optional(z.number().min(0).max(1)),\n  /**\n   * How much to prioritize intelligence and capabilities when selecting a model.\n   */\n  intelligencePriority: z.optional(z.number().min(0).max(1))\n}).passthrough();\nvar SamplingMessageSchema = z.object({\n  role: z.enum([\"user\", \"assistant\"]),\n  content: z.union([TextContentSchema, ImageContentSchema, AudioContentSchema])\n}).passthrough();\nvar CreateMessageRequestSchema = RequestSchema.extend({\n  method: z.literal(\"sampling/createMessage\"),\n  params: BaseRequestParamsSchema.extend({\n    messages: z.array(SamplingMessageSchema),\n    /**\n     * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.\n     */\n    systemPrompt: z.optional(z.string()),\n    /**\n     * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.\n     */\n    includeContext: z.optional(z.enum([\"none\", \"thisServer\", \"allServers\"])),\n    temperature: z.optional(z.number()),\n    /**\n     * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.\n     */\n    maxTokens: z.number().int(),\n    stopSequences: z.optional(z.array(z.string())),\n    /**\n     * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.\n     */\n    metadata: z.optional(z.object({}).passthrough()),\n    /**\n     * The server's preferences for which model to select.\n     */\n    modelPreferences: z.optional(ModelPreferencesSchema)\n  })\n});\nvar CreateMessageResultSchema = ResultSchema.extend({\n  /**\n   * The name of the model that generated the message.\n   */\n  model: z.string(),\n  /**\n   * The reason why sampling stopped.\n   */\n  stopReason: z.optional(z.enum([\"endTurn\", \"stopSequence\", \"maxTokens\"]).or(z.string())),\n  role: z.enum([\"user\", \"assistant\"]),\n  content: z.discriminatedUnion(\"type\", [\n    TextContentSchema,\n    ImageContentSchema,\n    AudioContentSchema\n  ])\n});\nvar BooleanSchemaSchema = z.object({\n  type: z.literal(\"boolean\"),\n  title: z.optional(z.string()),\n  description: z.optional(z.string()),\n  default: z.optional(z.boolean())\n}).passthrough();\nvar StringSchemaSchema = z.object({\n  type: z.literal(\"string\"),\n  title: z.optional(z.string()),\n  description: z.optional(z.string()),\n  minLength: z.optional(z.number()),\n  maxLength: z.optional(z.number()),\n  format: z.optional(z.enum([\"email\", \"uri\", \"date\", \"date-time\"]))\n}).passthrough();\nvar NumberSchemaSchema = z.object({\n  type: z.enum([\"number\", \"integer\"]),\n  title: z.optional(z.string()),\n  description: z.optional(z.string()),\n  minimum: z.optional(z.number()),\n  maximum: z.optional(z.number())\n}).passthrough();\nvar EnumSchemaSchema = z.object({\n  type: z.literal(\"string\"),\n  title: z.optional(z.string()),\n  description: z.optional(z.string()),\n  enum: z.array(z.string()),\n  enumNames: z.optional(z.array(z.string()))\n}).passthrough();\nvar PrimitiveSchemaDefinitionSchema = z.union([\n  BooleanSchemaSchema,\n  StringSchemaSchema,\n  NumberSchemaSchema,\n  EnumSchemaSchema\n]);\nvar ElicitRequestSchema = RequestSchema.extend({\n  method: z.literal(\"elicitation/create\"),\n  params: BaseRequestParamsSchema.extend({\n    /**\n     * The message to present to the user.\n     */\n    message: z.string(),\n    /**\n     * The schema for the requested user input.\n     */\n    requestedSchema: z.object({\n      type: z.literal(\"object\"),\n      properties: z.record(z.string(), PrimitiveSchemaDefinitionSchema),\n      required: z.optional(z.array(z.string()))\n    }).passthrough()\n  })\n});\nvar ElicitResultSchema = ResultSchema.extend({\n  /**\n   * The user's response action.\n   */\n  action: z.enum([\"accept\", \"decline\", \"cancel\"]),\n  /**\n   * The collected user input content (only present if action is \"accept\").\n   */\n  content: z.optional(z.record(z.string(), z.unknown()))\n});\nvar ResourceTemplateReferenceSchema = z.object({\n  type: z.literal(\"ref/resource\"),\n  /**\n   * The URI or URI template of the resource.\n   */\n  uri: z.string()\n}).passthrough();\nvar PromptReferenceSchema = z.object({\n  type: z.literal(\"ref/prompt\"),\n  /**\n   * The name of the prompt or prompt template\n   */\n  name: z.string()\n}).passthrough();\nvar CompleteRequestSchema = RequestSchema.extend({\n  method: z.literal(\"completion/complete\"),\n  params: BaseRequestParamsSchema.extend({\n    ref: z.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),\n    /**\n     * The argument's information\n     */\n    argument: z.object({\n      /**\n       * The name of the argument\n       */\n      name: z.string(),\n      /**\n       * The value of the argument to use for completion matching.\n       */\n      value: z.string()\n    }).passthrough(),\n    context: z.optional(z.object({\n      /**\n       * Previously-resolved variables in a URI template or prompt.\n       */\n      arguments: z.optional(z.record(z.string(), z.string()))\n    }))\n  })\n});\nvar CompleteResultSchema = ResultSchema.extend({\n  completion: z.object({\n    /**\n     * An array of completion values. Must not exceed 100 items.\n     */\n    values: z.array(z.string()).max(100),\n    /**\n     * The total number of completion options available. This can exceed the number of values actually sent in the response.\n     */\n    total: z.optional(z.number().int()),\n    /**\n     * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.\n     */\n    hasMore: z.optional(z.boolean())\n  }).passthrough()\n});\nvar RootSchema = z.object({\n  /**\n   * The URI identifying the root. This *must* start with file:// for now.\n   */\n  uri: z.string().startsWith(\"file://\"),\n  /**\n   * An optional name for the root.\n   */\n  name: z.optional(z.string()),\n  /**\n   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)\n   * for notes on _meta usage.\n   */\n  _meta: z.optional(z.object({}).passthrough())\n}).passthrough();\nvar ListRootsRequestSchema = RequestSchema.extend({\n  method: z.literal(\"roots/list\")\n});\nvar ListRootsResultSchema = ResultSchema.extend({\n  roots: z.array(RootSchema)\n});\nvar RootsListChangedNotificationSchema = NotificationSchema.extend({\n  method: z.literal(\"notifications/roots/list_changed\")\n});\nvar ClientRequestSchema = z.union([\n  PingRequestSchema,\n  InitializeRequestSchema,\n  CompleteRequestSchema,\n  SetLevelRequestSchema,\n  GetPromptRequestSchema,\n  ListPromptsRequestSchema,\n  ListResourcesRequestSchema,\n  ListResourceTemplatesRequestSchema,\n  ReadResourceRequestSchema,\n  SubscribeRequestSchema,\n  UnsubscribeRequestSchema,\n  CallToolRequestSchema,\n  ListToolsRequestSchema\n]);\nvar ClientNotificationSchema = z.union([\n  CancelledNotificationSchema,\n  ProgressNotificationSchema,\n  InitializedNotificationSchema,\n  RootsListChangedNotificationSchema\n]);\nvar ClientResultSchema = z.union([\n  EmptyResultSchema,\n  CreateMessageResultSchema,\n  ElicitResultSchema,\n  ListRootsResultSchema\n]);\nvar ServerRequestSchema = z.union([\n  PingRequestSchema,\n  CreateMessageRequestSchema,\n  ElicitRequestSchema,\n  ListRootsRequestSchema\n]);\nvar ServerNotificationSchema = z.union([\n  CancelledNotificationSchema,\n  ProgressNotificationSchema,\n  LoggingMessageNotificationSchema,\n  ResourceUpdatedNotificationSchema,\n  ResourceListChangedNotificationSchema,\n  ToolListChangedNotificationSchema,\n  PromptListChangedNotificationSchema\n]);\nvar ServerResultSchema = z.union([\n  EmptyResultSchema,\n  InitializeResultSchema,\n  CompleteResultSchema,\n  GetPromptResultSchema,\n  ListPromptsResultSchema,\n  ListResourcesResultSchema,\n  ListResourceTemplatesResultSchema,\n  ReadResourceResultSchema,\n  CallToolResultSchema,\n  ListToolsResultSchema\n]);\n\n// node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js\nvar import_raw_body = __toESM(require_raw_body(), 1);\nvar import_content_type = __toESM(require_content_type(), 1);\nvar import_node_crypto = require(\"node:crypto\");\nvar MAXIMUM_MESSAGE_SIZE = \"4mb\";\nvar StreamableHTTPServerTransport = class {\n  constructor(options) {\n    var _a, _b;\n    this._started = false;\n    this._streamMapping = /* @__PURE__ */ new Map();\n    this._requestToStreamMapping = /* @__PURE__ */ new Map();\n    this._requestResponseMap = /* @__PURE__ */ new Map();\n    this._initialized = false;\n    this._enableJsonResponse = false;\n    this._standaloneSseStreamId = \"_GET_stream\";\n    this.sessionIdGenerator = options.sessionIdGenerator;\n    this._enableJsonResponse = (_a = options.enableJsonResponse) !== null && _a !== void 0 ? _a : false;\n    this._eventStore = options.eventStore;\n    this._onsessioninitialized = options.onsessioninitialized;\n    this._onsessionclosed = options.onsessionclosed;\n    this._allowedHosts = options.allowedHosts;\n    this._allowedOrigins = options.allowedOrigins;\n    this._enableDnsRebindingProtection = (_b = options.enableDnsRebindingProtection) !== null && _b !== void 0 ? _b : false;\n  }\n  /**\n   * Starts the transport. This is required by the Transport interface but is a no-op\n   * for the Streamable HTTP transport as connections are managed per-request.\n   */\n  async start() {\n    if (this._started) {\n      throw new Error(\"Transport already started\");\n    }\n    this._started = true;\n  }\n  /**\n   * Validates request headers for DNS rebinding protection.\n   * @returns Error message if validation fails, undefined if validation passes.\n   */\n  validateRequestHeaders(req) {\n    if (!this._enableDnsRebindingProtection) {\n      return void 0;\n    }\n    if (this._allowedHosts && this._allowedHosts.length > 0) {\n      const hostHeader = req.headers.host;\n      if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {\n        return `Invalid Host header: ${hostHeader}`;\n      }\n    }\n    if (this._allowedOrigins && this._allowedOrigins.length > 0) {\n      const originHeader = req.headers.origin;\n      if (!originHeader || !this._allowedOrigins.includes(originHeader)) {\n        return `Invalid Origin header: ${originHeader}`;\n      }\n    }\n    return void 0;\n  }\n  /**\n   * Handles an incoming HTTP request, whether GET or POST\n   */\n  async handleRequest(req, res, parsedBody) {\n    var _a;\n    const validationError = this.validateRequestHeaders(req);\n    if (validationError) {\n      res.writeHead(403).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: validationError\n        },\n        id: null\n      }));\n      (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(validationError));\n      return;\n    }\n    if (req.method === \"POST\") {\n      await this.handlePostRequest(req, res, parsedBody);\n    } else if (req.method === \"GET\") {\n      await this.handleGetRequest(req, res);\n    } else if (req.method === \"DELETE\") {\n      await this.handleDeleteRequest(req, res);\n    } else {\n      await this.handleUnsupportedRequest(res);\n    }\n  }\n  /**\n   * Handles GET requests for SSE stream\n   */\n  async handleGetRequest(req, res) {\n    const acceptHeader = req.headers.accept;\n    if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes(\"text/event-stream\"))) {\n      res.writeHead(406).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Not Acceptable: Client must accept text/event-stream\"\n        },\n        id: null\n      }));\n      return;\n    }\n    if (!this.validateSession(req, res)) {\n      return;\n    }\n    if (!this.validateProtocolVersion(req, res)) {\n      return;\n    }\n    if (this._eventStore) {\n      const lastEventId = req.headers[\"last-event-id\"];\n      if (lastEventId) {\n        await this.replayEvents(lastEventId, res);\n        return;\n      }\n    }\n    const headers = {\n      \"Content-Type\": \"text/event-stream\",\n      \"Cache-Control\": \"no-cache, no-transform\",\n      Connection: \"keep-alive\"\n    };\n    if (this.sessionId !== void 0) {\n      headers[\"mcp-session-id\"] = this.sessionId;\n    }\n    if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {\n      res.writeHead(409).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Conflict: Only one SSE stream is allowed per session\"\n        },\n        id: null\n      }));\n      return;\n    }\n    res.writeHead(200, headers).flushHeaders();\n    this._streamMapping.set(this._standaloneSseStreamId, res);\n    res.on(\"close\", () => {\n      this._streamMapping.delete(this._standaloneSseStreamId);\n    });\n  }\n  /**\n   * Replays events that would have been sent after the specified event ID\n   * Only used when resumability is enabled\n   */\n  async replayEvents(lastEventId, res) {\n    var _a, _b;\n    if (!this._eventStore) {\n      return;\n    }\n    try {\n      const headers = {\n        \"Content-Type\": \"text/event-stream\",\n        \"Cache-Control\": \"no-cache, no-transform\",\n        Connection: \"keep-alive\"\n      };\n      if (this.sessionId !== void 0) {\n        headers[\"mcp-session-id\"] = this.sessionId;\n      }\n      res.writeHead(200, headers).flushHeaders();\n      const streamId = await ((_a = this._eventStore) === null || _a === void 0 ? void 0 : _a.replayEventsAfter(lastEventId, {\n        send: async (eventId, message) => {\n          var _a2;\n          if (!this.writeSSEEvent(res, message, eventId)) {\n            (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, new Error(\"Failed replay events\"));\n            res.end();\n          }\n        }\n      }));\n      this._streamMapping.set(streamId, res);\n    } catch (error) {\n      (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);\n    }\n  }\n  /**\n   * Writes an event to the SSE stream with proper formatting\n   */\n  writeSSEEvent(res, message, eventId) {\n    let eventData = `event: message\n`;\n    if (eventId) {\n      eventData += `id: ${eventId}\n`;\n    }\n    eventData += `data: ${JSON.stringify(message)}\n\n`;\n    return res.write(eventData);\n  }\n  /**\n   * Handles unsupported requests (PUT, PATCH, etc.)\n   */\n  async handleUnsupportedRequest(res) {\n    res.writeHead(405, {\n      \"Allow\": \"GET, POST, DELETE\"\n    }).end(JSON.stringify({\n      jsonrpc: \"2.0\",\n      error: {\n        code: -32e3,\n        message: \"Method not allowed.\"\n      },\n      id: null\n    }));\n  }\n  /**\n   * Handles POST requests containing JSON-RPC messages\n   */\n  async handlePostRequest(req, res, parsedBody) {\n    var _a, _b, _c, _d, _e;\n    try {\n      const acceptHeader = req.headers.accept;\n      if (!(acceptHeader === null || acceptHeader === void 0 ? void 0 : acceptHeader.includes(\"application/json\")) || !acceptHeader.includes(\"text/event-stream\")) {\n        res.writeHead(406).end(JSON.stringify({\n          jsonrpc: \"2.0\",\n          error: {\n            code: -32e3,\n            message: \"Not Acceptable: Client must accept both application/json and text/event-stream\"\n          },\n          id: null\n        }));\n        return;\n      }\n      const ct = req.headers[\"content-type\"];\n      if (!ct || !ct.includes(\"application/json\")) {\n        res.writeHead(415).end(JSON.stringify({\n          jsonrpc: \"2.0\",\n          error: {\n            code: -32e3,\n            message: \"Unsupported Media Type: Content-Type must be application/json\"\n          },\n          id: null\n        }));\n        return;\n      }\n      const authInfo = req.auth;\n      const requestInfo = { headers: req.headers };\n      let rawMessage;\n      if (parsedBody !== void 0) {\n        rawMessage = parsedBody;\n      } else {\n        const parsedCt = import_content_type.default.parse(ct);\n        const body = await (0, import_raw_body.default)(req, {\n          limit: MAXIMUM_MESSAGE_SIZE,\n          encoding: (_a = parsedCt.parameters.charset) !== null && _a !== void 0 ? _a : \"utf-8\"\n        });\n        rawMessage = JSON.parse(body.toString());\n      }\n      let messages;\n      if (Array.isArray(rawMessage)) {\n        messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));\n      } else {\n        messages = [JSONRPCMessageSchema.parse(rawMessage)];\n      }\n      const isInitializationRequest = messages.some(isInitializeRequest);\n      if (isInitializationRequest) {\n        if (this._initialized && this.sessionId !== void 0) {\n          res.writeHead(400).end(JSON.stringify({\n            jsonrpc: \"2.0\",\n            error: {\n              code: -32600,\n              message: \"Invalid Request: Server already initialized\"\n            },\n            id: null\n          }));\n          return;\n        }\n        if (messages.length > 1) {\n          res.writeHead(400).end(JSON.stringify({\n            jsonrpc: \"2.0\",\n            error: {\n              code: -32600,\n              message: \"Invalid Request: Only one initialization request is allowed\"\n            },\n            id: null\n          }));\n          return;\n        }\n        this.sessionId = (_b = this.sessionIdGenerator) === null || _b === void 0 ? void 0 : _b.call(this);\n        this._initialized = true;\n        if (this.sessionId && this._onsessioninitialized) {\n          await Promise.resolve(this._onsessioninitialized(this.sessionId));\n        }\n      }\n      if (!isInitializationRequest) {\n        if (!this.validateSession(req, res)) {\n          return;\n        }\n        if (!this.validateProtocolVersion(req, res)) {\n          return;\n        }\n      }\n      const hasRequests = messages.some(isJSONRPCRequest);\n      if (!hasRequests) {\n        res.writeHead(202).end();\n        for (const message of messages) {\n          (_c = this.onmessage) === null || _c === void 0 ? void 0 : _c.call(this, message, { authInfo, requestInfo });\n        }\n      } else if (hasRequests) {\n        const streamId = (0, import_node_crypto.randomUUID)();\n        if (!this._enableJsonResponse) {\n          const headers = {\n            \"Content-Type\": \"text/event-stream\",\n            \"Cache-Control\": \"no-cache\",\n            Connection: \"keep-alive\"\n          };\n          if (this.sessionId !== void 0) {\n            headers[\"mcp-session-id\"] = this.sessionId;\n          }\n          res.writeHead(200, headers);\n        }\n        for (const message of messages) {\n          if (isJSONRPCRequest(message)) {\n            this._streamMapping.set(streamId, res);\n            this._requestToStreamMapping.set(message.id, streamId);\n          }\n        }\n        res.on(\"close\", () => {\n          this._streamMapping.delete(streamId);\n        });\n        for (const message of messages) {\n          (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, message, { authInfo, requestInfo });\n        }\n      }\n    } catch (error) {\n      res.writeHead(400).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32700,\n          message: \"Parse error\",\n          data: String(error)\n        },\n        id: null\n      }));\n      (_e = this.onerror) === null || _e === void 0 ? void 0 : _e.call(this, error);\n    }\n  }\n  /**\n   * Handles DELETE requests to terminate sessions\n   */\n  async handleDeleteRequest(req, res) {\n    var _a;\n    if (!this.validateSession(req, res)) {\n      return;\n    }\n    if (!this.validateProtocolVersion(req, res)) {\n      return;\n    }\n    await Promise.resolve((_a = this._onsessionclosed) === null || _a === void 0 ? void 0 : _a.call(this, this.sessionId));\n    await this.close();\n    res.writeHead(200).end();\n  }\n  /**\n   * Validates session ID for non-initialization requests\n   * Returns true if the session is valid, false otherwise\n   */\n  validateSession(req, res) {\n    if (this.sessionIdGenerator === void 0) {\n      return true;\n    }\n    if (!this._initialized) {\n      res.writeHead(400).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Bad Request: Server not initialized\"\n        },\n        id: null\n      }));\n      return false;\n    }\n    const sessionId = req.headers[\"mcp-session-id\"];\n    if (!sessionId) {\n      res.writeHead(400).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Bad Request: Mcp-Session-Id header is required\"\n        },\n        id: null\n      }));\n      return false;\n    } else if (Array.isArray(sessionId)) {\n      res.writeHead(400).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Bad Request: Mcp-Session-Id header must be a single value\"\n        },\n        id: null\n      }));\n      return false;\n    } else if (sessionId !== this.sessionId) {\n      res.writeHead(404).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32001,\n          message: \"Session not found\"\n        },\n        id: null\n      }));\n      return false;\n    }\n    return true;\n  }\n  validateProtocolVersion(req, res) {\n    var _a;\n    let protocolVersion = (_a = req.headers[\"mcp-protocol-version\"]) !== null && _a !== void 0 ? _a : DEFAULT_NEGOTIATED_PROTOCOL_VERSION;\n    if (Array.isArray(protocolVersion)) {\n      protocolVersion = protocolVersion[protocolVersion.length - 1];\n    }\n    if (!SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {\n      res.writeHead(400).end(JSON.stringify({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: `Bad Request: Unsupported protocol version (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(\", \")})`\n        },\n        id: null\n      }));\n      return false;\n    }\n    return true;\n  }\n  async close() {\n    var _a;\n    this._streamMapping.forEach((response) => {\n      response.end();\n    });\n    this._streamMapping.clear();\n    this._requestResponseMap.clear();\n    (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);\n  }\n  async send(message, options) {\n    let requestId = options === null || options === void 0 ? void 0 : options.relatedRequestId;\n    if (isJSONRPCResponse(message) || isJSONRPCError(message)) {\n      requestId = message.id;\n    }\n    if (requestId === void 0) {\n      if (isJSONRPCResponse(message) || isJSONRPCError(message)) {\n        throw new Error(\"Cannot send a response on a standalone SSE stream unless resuming a previous client request\");\n      }\n      const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);\n      if (standaloneSse === void 0) {\n        return;\n      }\n      let eventId;\n      if (this._eventStore) {\n        eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);\n      }\n      this.writeSSEEvent(standaloneSse, message, eventId);\n      return;\n    }\n    const streamId = this._requestToStreamMapping.get(requestId);\n    const response = this._streamMapping.get(streamId);\n    if (!streamId) {\n      throw new Error(`No connection established for request ID: ${String(requestId)}`);\n    }\n    if (!this._enableJsonResponse) {\n      let eventId;\n      if (this._eventStore) {\n        eventId = await this._eventStore.storeEvent(streamId, message);\n      }\n      if (response) {\n        this.writeSSEEvent(response, message, eventId);\n      }\n    }\n    if (isJSONRPCResponse(message) || isJSONRPCError(message)) {\n      this._requestResponseMap.set(requestId, message);\n      const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_2, streamId2]) => this._streamMapping.get(streamId2) === response).map(([id]) => id);\n      const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));\n      if (allResponsesReady) {\n        if (!response) {\n          throw new Error(`No connection established for request ID: ${String(requestId)}`);\n        }\n        if (this._enableJsonResponse) {\n          const headers = {\n            \"Content-Type\": \"application/json\"\n          };\n          if (this.sessionId !== void 0) {\n            headers[\"mcp-session-id\"] = this.sessionId;\n          }\n          const responses = relatedIds.map((id) => this._requestResponseMap.get(id));\n          response.writeHead(200, headers);\n          if (responses.length === 1) {\n            response.end(JSON.stringify(responses[0]));\n          } else {\n            response.end(JSON.stringify(responses));\n          }\n        } else {\n          response.end();\n        }\n        for (const id of relatedIds) {\n          this._requestResponseMap.delete(id);\n          this._requestToStreamMapping.delete(id);\n        }\n      }\n    }\n  }\n};\n\n// node_modules/@smithery/sdk/dist/server/stateful.js\nvar import_express = __toESM(require_express2(), 1);\nvar import_node_crypto2 = require(\"node:crypto\");\n\n// node_modules/@smithery/sdk/dist/shared/config.js\nvar import_lodash = __toESM(require_lodash(), 1);\n\n// node_modules/okay-error/dist/index.js\nfunction ok(value) {\n  return { ok: true, value };\n}\nfunction err(typeOrPayload, payload) {\n  if (payload !== void 0) {\n    return { ok: false, error: { type: typeOrPayload, ...payload } };\n  }\n  return { ok: false, error: typeOrPayload };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/Options.js\nvar ignoreOverride = Symbol(\"Let zodToJsonSchema decide on which parser to use\");\nvar defaultOptions = {\n  name: void 0,\n  $refStrategy: \"root\",\n  basePath: [\"#\"],\n  effectStrategy: \"input\",\n  pipeStrategy: \"all\",\n  dateStrategy: \"format:date-time\",\n  mapStrategy: \"entries\",\n  removeAdditionalStrategy: \"passthrough\",\n  definitionPath: \"definitions\",\n  target: \"jsonSchema7\",\n  strictUnions: false,\n  definitions: {},\n  errorMessages: false,\n  markdownDescription: false,\n  patternStrategy: \"escape\",\n  applyRegexFlags: false,\n  emailStrategy: \"format:email\",\n  base64Strategy: \"contentEncoding:base64\",\n  nameStrategy: \"ref\"\n};\nvar getDefaultOptions = (options) => typeof options === \"string\" ? {\n  ...defaultOptions,\n  name: options\n} : {\n  ...defaultOptions,\n  ...options\n};\n\n// node_modules/zod-to-json-schema/dist/esm/Refs.js\nvar getRefs = (options) => {\n  const _options = getDefaultOptions(options);\n  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;\n  return {\n    ..._options,\n    currentPath,\n    propertyPath: void 0,\n    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [\n      def._def,\n      {\n        def: def._def,\n        path: [..._options.basePath, _options.definitionPath, name],\n        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.\n        jsonSchema: void 0\n      }\n    ]))\n  };\n};\n\n// node_modules/zod-to-json-schema/dist/esm/errorMessages.js\nfunction addErrorMessage(res, key, errorMessage, refs) {\n  if (!refs?.errorMessages)\n    return;\n  if (errorMessage) {\n    res.errorMessage = {\n      ...res.errorMessage,\n      [key]: errorMessage\n    };\n  }\n}\nfunction setResponseValueAndErrors(res, key, value, errorMessage, refs) {\n  res[key] = value;\n  addErrorMessage(res, key, errorMessage, refs);\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/any.js\nfunction parseAnyDef() {\n  return {};\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/array.js\nfunction parseArrayDef(def, refs) {\n  const res = {\n    type: \"array\"\n  };\n  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {\n    res.items = parseDef(def.type._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"items\"]\n    });\n  }\n  if (def.minLength) {\n    setResponseValueAndErrors(res, \"minItems\", def.minLength.value, def.minLength.message, refs);\n  }\n  if (def.maxLength) {\n    setResponseValueAndErrors(res, \"maxItems\", def.maxLength.value, def.maxLength.message, refs);\n  }\n  if (def.exactLength) {\n    setResponseValueAndErrors(res, \"minItems\", def.exactLength.value, def.exactLength.message, refs);\n    setResponseValueAndErrors(res, \"maxItems\", def.exactLength.value, def.exactLength.message, refs);\n  }\n  return res;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js\nfunction parseBigintDef(def, refs) {\n  const res = {\n    type: \"integer\",\n    format: \"int64\"\n  };\n  if (!def.checks)\n    return res;\n  for (const check of def.checks) {\n    switch (check.kind) {\n      case \"min\":\n        if (refs.target === \"jsonSchema7\") {\n          if (check.inclusive) {\n            setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n          } else {\n            setResponseValueAndErrors(res, \"exclusiveMinimum\", check.value, check.message, refs);\n          }\n        } else {\n          if (!check.inclusive) {\n            res.exclusiveMinimum = true;\n          }\n          setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n        }\n        break;\n      case \"max\":\n        if (refs.target === \"jsonSchema7\") {\n          if (check.inclusive) {\n            setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n          } else {\n            setResponseValueAndErrors(res, \"exclusiveMaximum\", check.value, check.message, refs);\n          }\n        } else {\n          if (!check.inclusive) {\n            res.exclusiveMaximum = true;\n          }\n          setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n        }\n        break;\n      case \"multipleOf\":\n        setResponseValueAndErrors(res, \"multipleOf\", check.value, check.message, refs);\n        break;\n    }\n  }\n  return res;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js\nfunction parseBooleanDef() {\n  return {\n    type: \"boolean\"\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/branded.js\nfunction parseBrandedDef(_def, refs) {\n  return parseDef(_def.type._def, refs);\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/catch.js\nvar parseCatchDef = (def, refs) => {\n  return parseDef(def.innerType._def, refs);\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/date.js\nfunction parseDateDef(def, refs, overrideDateStrategy) {\n  const strategy = overrideDateStrategy ?? refs.dateStrategy;\n  if (Array.isArray(strategy)) {\n    return {\n      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))\n    };\n  }\n  switch (strategy) {\n    case \"string\":\n    case \"format:date-time\":\n      return {\n        type: \"string\",\n        format: \"date-time\"\n      };\n    case \"format:date\":\n      return {\n        type: \"string\",\n        format: \"date\"\n      };\n    case \"integer\":\n      return integerDateParser(def, refs);\n  }\n}\nvar integerDateParser = (def, refs) => {\n  const res = {\n    type: \"integer\",\n    format: \"unix-time\"\n  };\n  if (refs.target === \"openApi3\") {\n    return res;\n  }\n  for (const check of def.checks) {\n    switch (check.kind) {\n      case \"min\":\n        setResponseValueAndErrors(\n          res,\n          \"minimum\",\n          check.value,\n          // This is in milliseconds\n          check.message,\n          refs\n        );\n        break;\n      case \"max\":\n        setResponseValueAndErrors(\n          res,\n          \"maximum\",\n          check.value,\n          // This is in milliseconds\n          check.message,\n          refs\n        );\n        break;\n    }\n  }\n  return res;\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/default.js\nfunction parseDefaultDef(_def, refs) {\n  return {\n    ...parseDef(_def.innerType._def, refs),\n    default: _def.defaultValue()\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/effects.js\nfunction parseEffectsDef(_def, refs) {\n  return refs.effectStrategy === \"input\" ? parseDef(_def.schema._def, refs) : {};\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/enum.js\nfunction parseEnumDef(def) {\n  return {\n    type: \"string\",\n    enum: Array.from(def.values)\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js\nvar isJsonSchema7AllOfType = (type) => {\n  if (\"type\" in type && type.type === \"string\")\n    return false;\n  return \"allOf\" in type;\n};\nfunction parseIntersectionDef(def, refs) {\n  const allOf = [\n    parseDef(def.left._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"allOf\", \"0\"]\n    }),\n    parseDef(def.right._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"allOf\", \"1\"]\n    })\n  ].filter((x) => !!x);\n  let unevaluatedProperties = refs.target === \"jsonSchema2019-09\" ? { unevaluatedProperties: false } : void 0;\n  const mergedAllOf = [];\n  allOf.forEach((schema) => {\n    if (isJsonSchema7AllOfType(schema)) {\n      mergedAllOf.push(...schema.allOf);\n      if (schema.unevaluatedProperties === void 0) {\n        unevaluatedProperties = void 0;\n      }\n    } else {\n      let nestedSchema = schema;\n      if (\"additionalProperties\" in schema && schema.additionalProperties === false) {\n        const { additionalProperties, ...rest } = schema;\n        nestedSchema = rest;\n      } else {\n        unevaluatedProperties = void 0;\n      }\n      mergedAllOf.push(nestedSchema);\n    }\n  });\n  return mergedAllOf.length ? {\n    allOf: mergedAllOf,\n    ...unevaluatedProperties\n  } : void 0;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/literal.js\nfunction parseLiteralDef(def, refs) {\n  const parsedType = typeof def.value;\n  if (parsedType !== \"bigint\" && parsedType !== \"number\" && parsedType !== \"boolean\" && parsedType !== \"string\") {\n    return {\n      type: Array.isArray(def.value) ? \"array\" : \"object\"\n    };\n  }\n  if (refs.target === \"openApi3\") {\n    return {\n      type: parsedType === \"bigint\" ? \"integer\" : parsedType,\n      enum: [def.value]\n    };\n  }\n  return {\n    type: parsedType === \"bigint\" ? \"integer\" : parsedType,\n    const: def.value\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/string.js\nvar emojiRegex2 = void 0;\nvar zodPatterns = {\n  /**\n   * `c` was changed to `[cC]` to replicate /i flag\n   */\n  cuid: /^[cC][^\\s-]{8,}$/,\n  cuid2: /^[0-9a-z]+$/,\n  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,\n  /**\n   * `a-z` was added to replicate /i flag\n   */\n  email: /^(?!\\.)(?!.*\\.\\.)([a-zA-Z0-9_'+\\-\\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\\-]*\\.)+[a-zA-Z]{2,}$/,\n  /**\n   * Constructed a valid Unicode RegExp\n   *\n   * Lazily instantiate since this type of regex isn't supported\n   * in all envs (e.g. React Native).\n   *\n   * See:\n   * https://github.com/colinhacks/zod/issues/2433\n   * Fix in Zod:\n   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b\n   */\n  emoji: () => {\n    if (emojiRegex2 === void 0) {\n      emojiRegex2 = RegExp(\"^(\\\\p{Extended_Pictographic}|\\\\p{Emoji_Component})+$\", \"u\");\n    }\n    return emojiRegex2;\n  },\n  /**\n   * Unused\n   */\n  uuid: /^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$/,\n  /**\n   * Unused\n   */\n  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,\n  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\/(3[0-2]|[12]?[0-9])$/,\n  /**\n   * Unused\n   */\n  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,\n  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,\n  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,\n  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,\n  nanoid: /^[a-zA-Z0-9_-]{21}$/,\n  jwt: /^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$/\n};\nfunction parseStringDef(def, refs) {\n  const res = {\n    type: \"string\"\n  };\n  if (def.checks) {\n    for (const check of def.checks) {\n      switch (check.kind) {\n        case \"min\":\n          setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);\n          break;\n        case \"max\":\n          setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);\n          break;\n        case \"email\":\n          switch (refs.emailStrategy) {\n            case \"format:email\":\n              addFormat(res, \"email\", check.message, refs);\n              break;\n            case \"format:idn-email\":\n              addFormat(res, \"idn-email\", check.message, refs);\n              break;\n            case \"pattern:zod\":\n              addPattern(res, zodPatterns.email, check.message, refs);\n              break;\n          }\n          break;\n        case \"url\":\n          addFormat(res, \"uri\", check.message, refs);\n          break;\n        case \"uuid\":\n          addFormat(res, \"uuid\", check.message, refs);\n          break;\n        case \"regex\":\n          addPattern(res, check.regex, check.message, refs);\n          break;\n        case \"cuid\":\n          addPattern(res, zodPatterns.cuid, check.message, refs);\n          break;\n        case \"cuid2\":\n          addPattern(res, zodPatterns.cuid2, check.message, refs);\n          break;\n        case \"startsWith\":\n          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);\n          break;\n        case \"endsWith\":\n          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);\n          break;\n        case \"datetime\":\n          addFormat(res, \"date-time\", check.message, refs);\n          break;\n        case \"date\":\n          addFormat(res, \"date\", check.message, refs);\n          break;\n        case \"time\":\n          addFormat(res, \"time\", check.message, refs);\n          break;\n        case \"duration\":\n          addFormat(res, \"duration\", check.message, refs);\n          break;\n        case \"length\":\n          setResponseValueAndErrors(res, \"minLength\", typeof res.minLength === \"number\" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);\n          setResponseValueAndErrors(res, \"maxLength\", typeof res.maxLength === \"number\" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);\n          break;\n        case \"includes\": {\n          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);\n          break;\n        }\n        case \"ip\": {\n          if (check.version !== \"v6\") {\n            addFormat(res, \"ipv4\", check.message, refs);\n          }\n          if (check.version !== \"v4\") {\n            addFormat(res, \"ipv6\", check.message, refs);\n          }\n          break;\n        }\n        case \"base64url\":\n          addPattern(res, zodPatterns.base64url, check.message, refs);\n          break;\n        case \"jwt\":\n          addPattern(res, zodPatterns.jwt, check.message, refs);\n          break;\n        case \"cidr\": {\n          if (check.version !== \"v6\") {\n            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);\n          }\n          if (check.version !== \"v4\") {\n            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);\n          }\n          break;\n        }\n        case \"emoji\":\n          addPattern(res, zodPatterns.emoji(), check.message, refs);\n          break;\n        case \"ulid\": {\n          addPattern(res, zodPatterns.ulid, check.message, refs);\n          break;\n        }\n        case \"base64\": {\n          switch (refs.base64Strategy) {\n            case \"format:binary\": {\n              addFormat(res, \"binary\", check.message, refs);\n              break;\n            }\n            case \"contentEncoding:base64\": {\n              setResponseValueAndErrors(res, \"contentEncoding\", \"base64\", check.message, refs);\n              break;\n            }\n            case \"pattern:zod\": {\n              addPattern(res, zodPatterns.base64, check.message, refs);\n              break;\n            }\n          }\n          break;\n        }\n        case \"nanoid\": {\n          addPattern(res, zodPatterns.nanoid, check.message, refs);\n        }\n        case \"toLowerCase\":\n        case \"toUpperCase\":\n        case \"trim\":\n          break;\n        default:\n          /* @__PURE__ */ ((_2) => {\n          })(check);\n      }\n    }\n  }\n  return res;\n}\nfunction escapeLiteralCheckValue(literal, refs) {\n  return refs.patternStrategy === \"escape\" ? escapeNonAlphaNumeric(literal) : literal;\n}\nvar ALPHA_NUMERIC = new Set(\"ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789\");\nfunction escapeNonAlphaNumeric(source) {\n  let result = \"\";\n  for (let i = 0; i < source.length; i++) {\n    if (!ALPHA_NUMERIC.has(source[i])) {\n      result += \"\\\\\";\n    }\n    result += source[i];\n  }\n  return result;\n}\nfunction addFormat(schema, value, message, refs) {\n  if (schema.format || schema.anyOf?.some((x) => x.format)) {\n    if (!schema.anyOf) {\n      schema.anyOf = [];\n    }\n    if (schema.format) {\n      schema.anyOf.push({\n        format: schema.format,\n        ...schema.errorMessage && refs.errorMessages && {\n          errorMessage: { format: schema.errorMessage.format }\n        }\n      });\n      delete schema.format;\n      if (schema.errorMessage) {\n        delete schema.errorMessage.format;\n        if (Object.keys(schema.errorMessage).length === 0) {\n          delete schema.errorMessage;\n        }\n      }\n    }\n    schema.anyOf.push({\n      format: value,\n      ...message && refs.errorMessages && { errorMessage: { format: message } }\n    });\n  } else {\n    setResponseValueAndErrors(schema, \"format\", value, message, refs);\n  }\n}\nfunction addPattern(schema, regex, message, refs) {\n  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {\n    if (!schema.allOf) {\n      schema.allOf = [];\n    }\n    if (schema.pattern) {\n      schema.allOf.push({\n        pattern: schema.pattern,\n        ...schema.errorMessage && refs.errorMessages && {\n          errorMessage: { pattern: schema.errorMessage.pattern }\n        }\n      });\n      delete schema.pattern;\n      if (schema.errorMessage) {\n        delete schema.errorMessage.pattern;\n        if (Object.keys(schema.errorMessage).length === 0) {\n          delete schema.errorMessage;\n        }\n      }\n    }\n    schema.allOf.push({\n      pattern: stringifyRegExpWithFlags(regex, refs),\n      ...message && refs.errorMessages && { errorMessage: { pattern: message } }\n    });\n  } else {\n    setResponseValueAndErrors(schema, \"pattern\", stringifyRegExpWithFlags(regex, refs), message, refs);\n  }\n}\nfunction stringifyRegExpWithFlags(regex, refs) {\n  if (!refs.applyRegexFlags || !regex.flags) {\n    return regex.source;\n  }\n  const flags = {\n    i: regex.flags.includes(\"i\"),\n    m: regex.flags.includes(\"m\"),\n    s: regex.flags.includes(\"s\")\n    // `.` matches newlines\n  };\n  const source = flags.i ? regex.source.toLowerCase() : regex.source;\n  let pattern = \"\";\n  let isEscaped = false;\n  let inCharGroup = false;\n  let inCharRange = false;\n  for (let i = 0; i < source.length; i++) {\n    if (isEscaped) {\n      pattern += source[i];\n      isEscaped = false;\n      continue;\n    }\n    if (flags.i) {\n      if (inCharGroup) {\n        if (source[i].match(/[a-z]/)) {\n          if (inCharRange) {\n            pattern += source[i];\n            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();\n            inCharRange = false;\n          } else if (source[i + 1] === \"-\" && source[i + 2]?.match(/[a-z]/)) {\n            pattern += source[i];\n            inCharRange = true;\n          } else {\n            pattern += `${source[i]}${source[i].toUpperCase()}`;\n          }\n          continue;\n        }\n      } else if (source[i].match(/[a-z]/)) {\n        pattern += `[${source[i]}${source[i].toUpperCase()}]`;\n        continue;\n      }\n    }\n    if (flags.m) {\n      if (source[i] === \"^\") {\n        pattern += `(^|(?<=[\\r\n]))`;\n        continue;\n      } else if (source[i] === \"$\") {\n        pattern += `($|(?=[\\r\n]))`;\n        continue;\n      }\n    }\n    if (flags.s && source[i] === \".\") {\n      pattern += inCharGroup ? `${source[i]}\\r\n` : `[${source[i]}\\r\n]`;\n      continue;\n    }\n    pattern += source[i];\n    if (source[i] === \"\\\\\") {\n      isEscaped = true;\n    } else if (inCharGroup && source[i] === \"]\") {\n      inCharGroup = false;\n    } else if (!inCharGroup && source[i] === \"[\") {\n      inCharGroup = true;\n    }\n  }\n  try {\n    new RegExp(pattern);\n  } catch {\n    console.warn(`Could not convert regex pattern at ${refs.currentPath.join(\"/\")} to a flag-independent form! Falling back to the flag-ignorant source`);\n    return regex.source;\n  }\n  return pattern;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/record.js\nfunction parseRecordDef(def, refs) {\n  if (refs.target === \"openAi\") {\n    console.warn(\"Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.\");\n  }\n  if (refs.target === \"openApi3\" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {\n    return {\n      type: \"object\",\n      required: def.keyType._def.values,\n      properties: def.keyType._def.values.reduce((acc, key) => ({\n        ...acc,\n        [key]: parseDef(def.valueType._def, {\n          ...refs,\n          currentPath: [...refs.currentPath, \"properties\", key]\n        }) ?? {}\n      }), {}),\n      additionalProperties: false\n    };\n  }\n  const schema = {\n    type: \"object\",\n    additionalProperties: parseDef(def.valueType._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"additionalProperties\"]\n    }) ?? {}\n  };\n  if (refs.target === \"openApi3\") {\n    return schema;\n  }\n  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {\n    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);\n    return {\n      ...schema,\n      propertyNames: keyType\n    };\n  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {\n    return {\n      ...schema,\n      propertyNames: {\n        enum: def.keyType._def.values\n      }\n    };\n  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {\n    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);\n    return {\n      ...schema,\n      propertyNames: keyType\n    };\n  }\n  return schema;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/map.js\nfunction parseMapDef(def, refs) {\n  if (refs.mapStrategy === \"record\") {\n    return parseRecordDef(def, refs);\n  }\n  const keys = parseDef(def.keyType._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"items\", \"items\", \"0\"]\n  }) || {};\n  const values = parseDef(def.valueType._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"items\", \"items\", \"1\"]\n  }) || {};\n  return {\n    type: \"array\",\n    maxItems: 125,\n    items: {\n      type: \"array\",\n      items: [keys, values],\n      minItems: 2,\n      maxItems: 2\n    }\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js\nfunction parseNativeEnumDef(def) {\n  const object = def.values;\n  const actualKeys = Object.keys(def.values).filter((key) => {\n    return typeof object[object[key]] !== \"number\";\n  });\n  const actualValues = actualKeys.map((key) => object[key]);\n  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));\n  return {\n    type: parsedTypes.length === 1 ? parsedTypes[0] === \"string\" ? \"string\" : \"number\" : [\"string\", \"number\"],\n    enum: actualValues\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/never.js\nfunction parseNeverDef() {\n  return {\n    not: {}\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/null.js\nfunction parseNullDef(refs) {\n  return refs.target === \"openApi3\" ? {\n    enum: [\"null\"],\n    nullable: true\n  } : {\n    type: \"null\"\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/union.js\nvar primitiveMappings = {\n  ZodString: \"string\",\n  ZodNumber: \"number\",\n  ZodBigInt: \"integer\",\n  ZodBoolean: \"boolean\",\n  ZodNull: \"null\"\n};\nfunction parseUnionDef(def, refs) {\n  if (refs.target === \"openApi3\")\n    return asAnyOf(def, refs);\n  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;\n  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {\n    const types = options.reduce((types2, x) => {\n      const type = primitiveMappings[x._def.typeName];\n      return type && !types2.includes(type) ? [...types2, type] : types2;\n    }, []);\n    return {\n      type: types.length > 1 ? types : types[0]\n    };\n  } else if (options.every((x) => x._def.typeName === \"ZodLiteral\" && !x.description)) {\n    const types = options.reduce((acc, x) => {\n      const type = typeof x._def.value;\n      switch (type) {\n        case \"string\":\n        case \"number\":\n        case \"boolean\":\n          return [...acc, type];\n        case \"bigint\":\n          return [...acc, \"integer\"];\n        case \"object\":\n          if (x._def.value === null)\n            return [...acc, \"null\"];\n        case \"symbol\":\n        case \"undefined\":\n        case \"function\":\n        default:\n          return acc;\n      }\n    }, []);\n    if (types.length === options.length) {\n      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);\n      return {\n        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],\n        enum: options.reduce((acc, x) => {\n          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];\n        }, [])\n      };\n    }\n  } else if (options.every((x) => x._def.typeName === \"ZodEnum\")) {\n    return {\n      type: \"string\",\n      enum: options.reduce((acc, x) => [\n        ...acc,\n        ...x._def.values.filter((x2) => !acc.includes(x2))\n      ], [])\n    };\n  }\n  return asAnyOf(def, refs);\n}\nvar asAnyOf = (def, refs) => {\n  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"anyOf\", `${i}`]\n  })).filter((x) => !!x && (!refs.strictUnions || typeof x === \"object\" && Object.keys(x).length > 0));\n  return anyOf.length ? { anyOf } : void 0;\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js\nfunction parseNullableDef(def, refs) {\n  if ([\"ZodString\", \"ZodNumber\", \"ZodBigInt\", \"ZodBoolean\", \"ZodNull\"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {\n    if (refs.target === \"openApi3\") {\n      return {\n        type: primitiveMappings[def.innerType._def.typeName],\n        nullable: true\n      };\n    }\n    return {\n      type: [\n        primitiveMappings[def.innerType._def.typeName],\n        \"null\"\n      ]\n    };\n  }\n  if (refs.target === \"openApi3\") {\n    const base2 = parseDef(def.innerType._def, {\n      ...refs,\n      currentPath: [...refs.currentPath]\n    });\n    if (base2 && \"$ref\" in base2)\n      return { allOf: [base2], nullable: true };\n    return base2 && { ...base2, nullable: true };\n  }\n  const base = parseDef(def.innerType._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"anyOf\", \"0\"]\n  });\n  return base && { anyOf: [base, { type: \"null\" }] };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/number.js\nfunction parseNumberDef(def, refs) {\n  const res = {\n    type: \"number\"\n  };\n  if (!def.checks)\n    return res;\n  for (const check of def.checks) {\n    switch (check.kind) {\n      case \"int\":\n        res.type = \"integer\";\n        addErrorMessage(res, \"type\", check.message, refs);\n        break;\n      case \"min\":\n        if (refs.target === \"jsonSchema7\") {\n          if (check.inclusive) {\n            setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n          } else {\n            setResponseValueAndErrors(res, \"exclusiveMinimum\", check.value, check.message, refs);\n          }\n        } else {\n          if (!check.inclusive) {\n            res.exclusiveMinimum = true;\n          }\n          setResponseValueAndErrors(res, \"minimum\", check.value, check.message, refs);\n        }\n        break;\n      case \"max\":\n        if (refs.target === \"jsonSchema7\") {\n          if (check.inclusive) {\n            setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n          } else {\n            setResponseValueAndErrors(res, \"exclusiveMaximum\", check.value, check.message, refs);\n          }\n        } else {\n          if (!check.inclusive) {\n            res.exclusiveMaximum = true;\n          }\n          setResponseValueAndErrors(res, \"maximum\", check.value, check.message, refs);\n        }\n        break;\n      case \"multipleOf\":\n        setResponseValueAndErrors(res, \"multipleOf\", check.value, check.message, refs);\n        break;\n    }\n  }\n  return res;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/object.js\nfunction decideAdditionalProperties(def, refs) {\n  if (refs.removeAdditionalStrategy === \"strict\") {\n    return def.catchall._def.typeName === \"ZodNever\" ? def.unknownKeys !== \"strict\" : parseDef(def.catchall._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"additionalProperties\"]\n    }) ?? true;\n  } else {\n    return def.catchall._def.typeName === \"ZodNever\" ? def.unknownKeys === \"passthrough\" : parseDef(def.catchall._def, {\n      ...refs,\n      currentPath: [...refs.currentPath, \"additionalProperties\"]\n    }) ?? true;\n  }\n}\nfunction parseObjectDef(def, refs) {\n  const forceOptionalIntoNullable = refs.target === \"openAi\";\n  const result = {\n    type: \"object\",\n    ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => {\n      if (propDef === void 0 || propDef._def === void 0)\n        return acc;\n      let propOptional = propDef.isOptional();\n      if (propOptional && forceOptionalIntoNullable) {\n        if (propDef instanceof ZodOptional) {\n          propDef = propDef._def.innerType;\n        }\n        if (!propDef.isNullable()) {\n          propDef = propDef.nullable();\n        }\n        propOptional = false;\n      }\n      const parsedDef = parseDef(propDef._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"properties\", propName],\n        propertyPath: [...refs.currentPath, \"properties\", propName]\n      });\n      if (parsedDef === void 0)\n        return acc;\n      return {\n        properties: { ...acc.properties, [propName]: parsedDef },\n        required: propOptional ? acc.required : [...acc.required, propName]\n      };\n    }, { properties: {}, required: [] }),\n    additionalProperties: decideAdditionalProperties(def, refs)\n  };\n  if (!result.required.length)\n    delete result.required;\n  return result;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/optional.js\nvar parseOptionalDef = (def, refs) => {\n  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {\n    return parseDef(def.innerType._def, refs);\n  }\n  const innerSchema = parseDef(def.innerType._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"anyOf\", \"1\"]\n  });\n  return innerSchema ? {\n    anyOf: [\n      {\n        not: {}\n      },\n      innerSchema\n    ]\n  } : {};\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js\nvar parsePipelineDef = (def, refs) => {\n  if (refs.pipeStrategy === \"input\") {\n    return parseDef(def.in._def, refs);\n  } else if (refs.pipeStrategy === \"output\") {\n    return parseDef(def.out._def, refs);\n  }\n  const a = parseDef(def.in._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"allOf\", \"0\"]\n  });\n  const b = parseDef(def.out._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"allOf\", a ? \"1\" : \"0\"]\n  });\n  return {\n    allOf: [a, b].filter((x) => x !== void 0)\n  };\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/promise.js\nfunction parsePromiseDef(def, refs) {\n  return parseDef(def.type._def, refs);\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/set.js\nfunction parseSetDef(def, refs) {\n  const items = parseDef(def.valueType._def, {\n    ...refs,\n    currentPath: [...refs.currentPath, \"items\"]\n  });\n  const schema = {\n    type: \"array\",\n    uniqueItems: true,\n    items\n  };\n  if (def.minSize) {\n    setResponseValueAndErrors(schema, \"minItems\", def.minSize.value, def.minSize.message, refs);\n  }\n  if (def.maxSize) {\n    setResponseValueAndErrors(schema, \"maxItems\", def.maxSize.value, def.maxSize.message, refs);\n  }\n  return schema;\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js\nfunction parseTupleDef(def, refs) {\n  if (def.rest) {\n    return {\n      type: \"array\",\n      minItems: def.items.length,\n      items: def.items.map((x, i) => parseDef(x._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"items\", `${i}`]\n      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),\n      additionalItems: parseDef(def.rest._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"additionalItems\"]\n      })\n    };\n  } else {\n    return {\n      type: \"array\",\n      minItems: def.items.length,\n      maxItems: def.items.length,\n      items: def.items.map((x, i) => parseDef(x._def, {\n        ...refs,\n        currentPath: [...refs.currentPath, \"items\", `${i}`]\n      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])\n    };\n  }\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js\nfunction parseUndefinedDef() {\n  return {\n    not: {}\n  };\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js\nfunction parseUnknownDef() {\n  return {};\n}\n\n// node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js\nvar parseReadonlyDef = (def, refs) => {\n  return parseDef(def.innerType._def, refs);\n};\n\n// node_modules/zod-to-json-schema/dist/esm/selectParser.js\nvar selectParser = (def, typeName, refs) => {\n  switch (typeName) {\n    case ZodFirstPartyTypeKind.ZodString:\n      return parseStringDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNumber:\n      return parseNumberDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodObject:\n      return parseObjectDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBigInt:\n      return parseBigintDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBoolean:\n      return parseBooleanDef();\n    case ZodFirstPartyTypeKind.ZodDate:\n      return parseDateDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUndefined:\n      return parseUndefinedDef();\n    case ZodFirstPartyTypeKind.ZodNull:\n      return parseNullDef(refs);\n    case ZodFirstPartyTypeKind.ZodArray:\n      return parseArrayDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodUnion:\n    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:\n      return parseUnionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodIntersection:\n      return parseIntersectionDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodTuple:\n      return parseTupleDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodRecord:\n      return parseRecordDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLiteral:\n      return parseLiteralDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodEnum:\n      return parseEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNativeEnum:\n      return parseNativeEnumDef(def);\n    case ZodFirstPartyTypeKind.ZodNullable:\n      return parseNullableDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodOptional:\n      return parseOptionalDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodMap:\n      return parseMapDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodSet:\n      return parseSetDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodLazy:\n      return () => def.getter()._def;\n    case ZodFirstPartyTypeKind.ZodPromise:\n      return parsePromiseDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodNaN:\n    case ZodFirstPartyTypeKind.ZodNever:\n      return parseNeverDef();\n    case ZodFirstPartyTypeKind.ZodEffects:\n      return parseEffectsDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodAny:\n      return parseAnyDef();\n    case ZodFirstPartyTypeKind.ZodUnknown:\n      return parseUnknownDef();\n    case ZodFirstPartyTypeKind.ZodDefault:\n      return parseDefaultDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodBranded:\n      return parseBrandedDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodReadonly:\n      return parseReadonlyDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodCatch:\n      return parseCatchDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodPipeline:\n      return parsePipelineDef(def, refs);\n    case ZodFirstPartyTypeKind.ZodFunction:\n    case ZodFirstPartyTypeKind.ZodVoid:\n    case ZodFirstPartyTypeKind.ZodSymbol:\n      return void 0;\n    default:\n      return /* @__PURE__ */ ((_2) => void 0)(typeName);\n  }\n};\n\n// node_modules/zod-to-json-schema/dist/esm/parseDef.js\nfunction parseDef(def, refs, forceResolution = false) {\n  const seenItem = refs.seen.get(def);\n  if (refs.override) {\n    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);\n    if (overrideResult !== ignoreOverride) {\n      return overrideResult;\n    }\n  }\n  if (seenItem && !forceResolution) {\n    const seenSchema = get$ref(seenItem, refs);\n    if (seenSchema !== void 0) {\n      return seenSchema;\n    }\n  }\n  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };\n  refs.seen.set(def, newItem);\n  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);\n  const jsonSchema = typeof jsonSchemaOrGetter === \"function\" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;\n  if (jsonSchema) {\n    addMeta(def, refs, jsonSchema);\n  }\n  newItem.jsonSchema = jsonSchema;\n  return jsonSchema;\n}\nvar get$ref = (item, refs) => {\n  switch (refs.$refStrategy) {\n    case \"root\":\n      return { $ref: item.path.join(\"/\") };\n    case \"relative\":\n      return { $ref: getRelativePath(refs.currentPath, item.path) };\n    case \"none\":\n    case \"seen\": {\n      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {\n        console.warn(`Recursive reference detected at ${refs.currentPath.join(\"/\")}! Defaulting to any`);\n        return {};\n      }\n      return refs.$refStrategy === \"seen\" ? {} : void 0;\n    }\n  }\n};\nvar getRelativePath = (pathA, pathB) => {\n  let i = 0;\n  for (; i < pathA.length && i < pathB.length; i++) {\n    if (pathA[i] !== pathB[i])\n      break;\n  }\n  return [(pathA.length - i).toString(), ...pathB.slice(i)].join(\"/\");\n};\nvar addMeta = (def, refs, jsonSchema) => {\n  if (def.description) {\n    jsonSchema.description = def.description;\n    if (refs.markdownDescription) {\n      jsonSchema.markdownDescription = def.description;\n    }\n  }\n  return jsonSchema;\n};\n\n// node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js\nvar zodToJsonSchema = (schema, options) => {\n  const refs = getRefs(options);\n  const definitions = typeof options === \"object\" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({\n    ...acc,\n    [name2]: parseDef(schema2._def, {\n      ...refs,\n      currentPath: [...refs.basePath, refs.definitionPath, name2]\n    }, true) ?? {}\n  }), {}) : void 0;\n  const name = typeof options === \"string\" ? options : options?.nameStrategy === \"title\" ? void 0 : options?.name;\n  const main = parseDef(schema._def, name === void 0 ? refs : {\n    ...refs,\n    currentPath: [...refs.basePath, refs.definitionPath, name]\n  }, false) ?? {};\n  const title = typeof options === \"object\" && options.name !== void 0 && options.nameStrategy === \"title\" ? options.name : void 0;\n  if (title !== void 0) {\n    main.title = title;\n  }\n  const combined = name === void 0 ? definitions ? {\n    ...main,\n    [refs.definitionPath]: definitions\n  } : main : {\n    $ref: [\n      ...refs.$refStrategy === \"relative\" ? [] : refs.basePath,\n      refs.definitionPath,\n      name\n    ].join(\"/\"),\n    [refs.definitionPath]: {\n      ...definitions,\n      [name]: main\n    }\n  };\n  if (refs.target === \"jsonSchema7\") {\n    combined.$schema = \"http://json-schema.org/draft-07/schema#\";\n  } else if (refs.target === \"jsonSchema2019-09\" || refs.target === \"openAi\") {\n    combined.$schema = \"https://json-schema.org/draft/2019-09/schema#\";\n  }\n  if (refs.target === \"openAi\" && (\"anyOf\" in combined || \"oneOf\" in combined || \"allOf\" in combined || \"type\" in combined && Array.isArray(combined.type))) {\n    console.warn(\"Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.\");\n  }\n  return combined;\n};\n\n// node_modules/@smithery/sdk/dist/shared/config.js\nfunction parseExpressRequestConfig(req) {\n  return JSON.parse(Buffer.from(req.query.config, \"base64\").toString());\n}\nfunction parseAndValidateConfig(req, schema) {\n  let config = {};\n  if (req.query.config) {\n    try {\n      config = parseExpressRequestConfig(req);\n    } catch (configError) {\n      return err({\n        title: \"Invalid config parameter\",\n        status: 400,\n        detail: \"Failed to parse config parameter\",\n        instance: req.originalUrl\n      });\n    }\n  }\n  for (const [key, value] of Object.entries(req.query)) {\n    if (key === \"config\" || key === \"api_key\" || key === \"profile\")\n      continue;\n    const pathParts = key.split(\".\");\n    const rawValue = Array.isArray(value) ? value[0] : value;\n    if (typeof rawValue !== \"string\")\n      continue;\n    let parsedValue = rawValue;\n    try {\n      parsedValue = JSON.parse(rawValue);\n    } catch {\n    }\n    import_lodash.default.set(config, pathParts, parsedValue);\n  }\n  if (schema) {\n    const result = schema.safeParse(config);\n    if (!result.success) {\n      const jsonSchema = zodToJsonSchema(schema);\n      const errors = result.error.issues.map((issue) => {\n        let received = config;\n        for (const key of issue.path) {\n          if (received && typeof received === \"object\" && key in received) {\n            received = received[key];\n          } else {\n            received = void 0;\n            break;\n          }\n        }\n        return {\n          param: issue.path.join(\".\") || \"root\",\n          pointer: `/${issue.path.join(\"/\")}`,\n          reason: issue.message,\n          received\n        };\n      });\n      return err({\n        title: \"Invalid configuration parameters\",\n        status: 422,\n        detail: \"One or more config parameters are invalid.\",\n        instance: req.originalUrl,\n        configSchema: jsonSchema,\n        errors\n      });\n    }\n    return ok(result.data);\n  }\n  return ok(config);\n}\n\n// node_modules/@smithery/sdk/dist/server/session.js\nvar createLRUStore = (max = 1e3) => {\n  const cache = /* @__PURE__ */ new Map();\n  return {\n    get: (id) => {\n      const t = cache.get(id);\n      if (!t)\n        return void 0;\n      cache.delete(id);\n      cache.set(id, t);\n      return t;\n    },\n    set: (id, transport) => {\n      if (cache.has(id)) {\n        cache.delete(id);\n      } else if (cache.size >= max) {\n        const [lruId, lruTransport] = cache.entries().next().value;\n        lruTransport.close?.();\n        cache.delete(lruId);\n      }\n      cache.set(id, transport);\n    },\n    delete: (id) => cache.delete(id)\n  };\n};\n\n// node_modules/@smithery/sdk/dist/server/stateful.js\nfunction createStatefulServer(createMcpServer, options) {\n  const app = options?.app ?? (0, import_express.default)();\n  app.use(\"/mcp\", import_express.default.json());\n  const sessionStore = options?.sessionStore ?? createLRUStore();\n  app.post(\"/mcp\", async (req, res) => {\n    const sessionId = req.headers[\"mcp-session-id\"];\n    let transport;\n    if (sessionId && sessionStore.get(sessionId)) {\n      transport = sessionStore.get(sessionId);\n    } else if (!sessionId && isInitializeRequest(req.body)) {\n      const newSessionId = (0, import_node_crypto2.randomUUID)();\n      transport = new StreamableHTTPServerTransport({\n        sessionIdGenerator: () => newSessionId,\n        onsessioninitialized: (sessionId2) => {\n          sessionStore.set(sessionId2, transport);\n        }\n      });\n      transport.onclose = () => {\n        if (transport.sessionId) {\n          sessionStore.delete?.(transport.sessionId);\n        }\n      };\n      const configResult = parseAndValidateConfig(req, options?.schema);\n      if (!configResult.ok) {\n        const status = configResult.error.status || 400;\n        res.status(status).json(configResult.error);\n        return;\n      }\n      const config = configResult.value;\n      try {\n        const server = createMcpServer({\n          sessionId: newSessionId,\n          config\n        });\n        await server.connect(transport);\n      } catch (error) {\n        console.error(\"Error initializing server:\", error);\n        res.status(500).json({\n          jsonrpc: \"2.0\",\n          error: {\n            code: -32603,\n            message: \"Error initializing server.\"\n          },\n          id: null\n        });\n        return;\n      }\n    } else {\n      res.status(400).json({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Session not found or expired\"\n        },\n        id: null\n      });\n      return;\n    }\n    await transport.handleRequest(req, res, req.body);\n  });\n  app.get(\"/.well-known/mcp-config\", (req, res) => {\n    res.set(\"Content-Type\", \"application/schema+json; charset=utf-8\");\n    const baseSchema = options?.schema ? zodToJsonSchema(options.schema) : {\n      type: \"object\",\n      properties: {},\n      required: []\n    };\n    const configSchema = {\n      $schema: \"https://json-schema.org/draft/2020-12/schema\",\n      $id: `${req.protocol}://${req.get(\"host\")}/.well-known/mcp-config`,\n      title: \"MCP Session Configuration\",\n      description: \"Schema for the /mcp endpoint configuration\",\n      \"x-mcp-version\": \"1.0\",\n      \"x-query-style\": \"dot+bracket\",\n      ...baseSchema\n    };\n    res.json(configSchema);\n  });\n  app.get(\"/mcp\", async (req, res) => {\n    const sessionId = req.headers[\"mcp-session-id\"];\n    if (!sessionId || !sessionStore.get(sessionId)) {\n      res.status(400).send(\"Invalid or expired session ID\");\n      return;\n    }\n    const transport = sessionStore.get(sessionId);\n    await transport.handleRequest(req, res);\n  });\n  app.delete(\"/mcp\", async (req, res) => {\n    const sessionId = req.headers[\"mcp-session-id\"];\n    if (!sessionId) {\n      res.status(400).json({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32600,\n          message: \"Missing mcp-session-id header\"\n        },\n        id: null\n      });\n      return;\n    }\n    const transport = sessionStore.get(sessionId);\n    if (!transport) {\n      res.status(404).json({\n        jsonrpc: \"2.0\",\n        error: {\n          code: -32e3,\n          message: \"Session not found or expired\"\n        },\n        id: null\n      });\n      return;\n    }\n    transport.close?.();\n    res.status(204).end();\n  });\n  return { app };\n}\n\n// node_modules/@smithery/sdk/dist/server/stateless.js\nvar import_express2 = __toESM(require_express2(), 1);\nfunction createStatelessServer(createMcpServer, options) {\n  const app = options?.app ?? (0, import_express2.default)();\n  app.use(\"/mcp\", import_express2.default.json());\n  app.post(\"/mcp\", async (req, res) => {\n    try {\n      const configResult = parseAndValidateConfig(req, options?.schema);\n      if (!configResult.ok) {\n        const status = configResult.error.status || 400;\n        res.status(status).json(configResult.error);\n        return;\n      }\n      const config = configResult.value;\n      const server = createMcpServer({\n        config\n      });\n      const transport = new StreamableHTTPServerTransport({\n        sessionIdGenerator: void 0\n      });\n      res.on(\"close\", () => {\n        transport.close();\n        server.close();\n      });\n      await server.connect(transport);\n      await transport.handleRequest(req, res, req.body);\n    } catch (error) {\n      console.error(\"Error handling MCP request:\", error);\n      if (!res.headersSent) {\n        res.status(500).json({\n          jsonrpc: \"2.0\",\n          error: {\n            code: -32603,\n            message: \"Internal server error\"\n          },\n          id: null\n        });\n      }\n    }\n  });\n  app.get(\"/mcp\", async (_req, res) => {\n    res.status(405).json({\n      jsonrpc: \"2.0\",\n      error: {\n        code: -32e3,\n        message: \"Method not allowed.\"\n      },\n      id: null\n    });\n  });\n  app.delete(\"/mcp\", async (_req, res) => {\n    res.status(405).json({\n      jsonrpc: \"2.0\",\n      error: {\n        code: -32e3,\n        message: \"Method not allowed.\"\n      },\n      id: null\n    });\n  });\n  app.get(\"/.well-known/mcp-config\", (req, res) => {\n    res.set(\"Content-Type\", \"application/schema+json; charset=utf-8\");\n    const baseSchema = options?.schema ? zodToJsonSchema(options.schema) : {\n      type: \"object\",\n      properties: {},\n      required: []\n    };\n    const configSchema = {\n      $schema: \"https://json-schema.org/draft/2020-12/schema\",\n      $id: `${req.protocol}://${req.get(\"host\")}/.well-known/mcp-config`,\n      title: \"MCP Session Configuration\",\n      description: \"Schema for the /mcp endpoint configuration\",\n      \"x-mcp-version\": \"1.0\",\n      \"x-query-style\": \"dot+bracket\",\n      ...baseSchema\n    };\n    res.json(configSchema);\n  });\n  return { app };\n}\n\n// src/runtime/shttp-bootstrap.ts\nvar import_chalk = __toESM(require_source());\nvar import_cors = __toESM(require_lib4());\nvar import_express3 = __toESM(require_express2());\nvar _entry = __toESM(require(\"/Users/b.c.nims/glassBead-MASTER/Claude-Code-Stuff/agentic-script-factory/github-publication/waldzell-deployment/repos/model-enhancement-servers/src/analogical-reasoning/index.ts\"));\nvar entry = _entry;\nasync function startMcpServer() {\n  try {\n    const port = process.env.PORT || \"8181\";\n    console.log(\n      `${import_chalk.default.blue(\"[smithery]\")} Starting MCP server on port ${port}`\n    );\n    let server;\n    const app = (0, import_express3.default)();\n    if (process.env.NODE_ENV !== \"production\") {\n      console.log(`${import_chalk.default.blue(\"[smithery]\")} Injecting cors middleware`);\n      app.use(\n        (0, import_cors.default)({\n          exposedHeaders: [\"mcp-session-id\"]\n        })\n      );\n    }\n    if (entry.default && typeof entry.default === \"function\") {\n      console.log(\n        `${import_chalk.default.blue(\"[smithery]\")} Setting up ${entry.stateless ? \"stateless\" : \"stateful\"} server`\n      );\n      if (entry.stateless) {\n        server = createStatelessServer(\n          entry.default,\n          {\n            schema: entry.configSchema,\n            app\n          }\n        );\n      } else {\n        server = createStatefulServer(entry.default, {\n          schema: entry.configSchema,\n          app\n        });\n      }\n    } else {\n      throw new Error(\n        \"No valid server export found. Please export:\\n- export default function({ sessionId, config }) { ... } (stateful)\\n- export default function({ config }) { ... } (stateless)\"\n      );\n    }\n    server.app.listen(Number.parseInt(port));\n    console.log(\n      `${import_chalk.default.green(\"[smithery]\")} MCP server started successfully on port ${port}`\n    );\n  } catch (error) {\n    console.error(\n      `${import_chalk.default.red(\"[smithery]\")} Failed to start MCP server:`,\n      error\n    );\n    process.exit(1);\n  }\n}\nstartMcpServer();\n/*! Bundled license information:\n\nbytes/index.js:\n  (*!\n   * bytes\n   * Copyright(c) 2012-2014 TJ Holowaychuk\n   * Copyright(c) 2015 Jed Watson\n   * MIT Licensed\n   *)\n\ndepd/index.js:\n  (*!\n   * depd\n   * Copyright(c) 2014-2018 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nstatuses/index.js:\n  (*!\n   * statuses\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\ntoidentifier/index.js:\n  (*!\n   * toidentifier\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nhttp-errors/index.js:\n  (*!\n   * http-errors\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nunpipe/index.js:\n  (*!\n   * unpipe\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nraw-body/index.js:\n  (*!\n   * raw-body\n   * Copyright(c) 2013-2014 Jonathan Ong\n   * Copyright(c) 2014-2022 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\ncontent-type/index.js:\n  (*!\n   * content-type\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nee-first/index.js:\n  (*!\n   * ee-first\n   * Copyright(c) 2014 Jonathan Ong\n   * MIT Licensed\n   *)\n\non-finished/index.js:\n  (*!\n   * on-finished\n   * Copyright(c) 2013 Jonathan Ong\n   * Copyright(c) 2014 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nbody-parser/lib/read.js:\nbody-parser/lib/types/raw.js:\nbody-parser/lib/types/text.js:\nbody-parser/index.js:\n  (*!\n   * body-parser\n   * Copyright(c) 2014-2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nmime-db/index.js:\nmime-db/index.js:\nmime-db/index.js:\nmime-db/index.js:\n  (*!\n   * mime-db\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2015-2022 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nmime-types/index.js:\nmime-types/index.js:\nmime-types/index.js:\nmime-types/index.js:\n  (*!\n   * mime-types\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nmedia-typer/index.js:\n  (*!\n   * media-typer\n   * Copyright(c) 2014-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\ntype-is/index.js:\n  (*!\n   * type-is\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2014-2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nbody-parser/lib/types/json.js:\nbody-parser/lib/types/urlencoded.js:\n  (*!\n   * body-parser\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2014-2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nencodeurl/index.js:\n  (*!\n   * encodeurl\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nescape-html/index.js:\n  (*!\n   * escape-html\n   * Copyright(c) 2012-2013 TJ Holowaychuk\n   * Copyright(c) 2015 Andreas Lubbe\n   * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n   * MIT Licensed\n   *)\n\nparseurl/index.js:\n  (*!\n   * parseurl\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2014-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nfinalhandler/index.js:\n  (*!\n   * finalhandler\n   * Copyright(c) 2014-2022 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nexpress/lib/view.js:\nexpress/lib/application.js:\nexpress/lib/request.js:\nexpress/lib/express.js:\nexpress/index.js:\n  (*!\n   * express\n   * Copyright(c) 2009-2013 TJ Holowaychuk\n   * Copyright(c) 2013 Roman Shtylman\n   * Copyright(c) 2014-2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\netag/index.js:\n  (*!\n   * etag\n   * Copyright(c) 2014-2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nforwarded/index.js:\n  (*!\n   * forwarded\n   * Copyright(c) 2014-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nproxy-addr/index.js:\n  (*!\n   * proxy-addr\n   * Copyright(c) 2014-2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nexpress/lib/utils.js:\nexpress/lib/response.js:\n  (*!\n   * express\n   * Copyright(c) 2009-2013 TJ Holowaychuk\n   * Copyright(c) 2014-2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nrouter/lib/layer.js:\nrouter/lib/route.js:\nrouter/index.js:\n  (*!\n   * router\n   * Copyright(c) 2013 Roman Shtylman\n   * Copyright(c) 2014-2022 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nnegotiator/index.js:\n  (*!\n   * negotiator\n   * Copyright(c) 2012 Federico Romero\n   * Copyright(c) 2012-2014 Isaac Z. Schlueter\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\naccepts/index.js:\n  (*!\n   * accepts\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nfresh/index.js:\n  (*!\n   * fresh\n   * Copyright(c) 2012 TJ Holowaychuk\n   * Copyright(c) 2016-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nrange-parser/index.js:\n  (*!\n   * range-parser\n   * Copyright(c) 2012-2014 TJ Holowaychuk\n   * Copyright(c) 2015-2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nsafe-buffer/index.js:\n  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n\ncontent-disposition/index.js:\n  (*!\n   * content-disposition\n   * Copyright(c) 2014-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\ncookie/index.js:\n  (*!\n   * cookie\n   * Copyright(c) 2012-2014 Roman Shtylman\n   * Copyright(c) 2015 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nsend/index.js:\n  (*!\n   * send\n   * Copyright(c) 2012 TJ Holowaychuk\n   * Copyright(c) 2014-2022 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nvary/index.js:\n  (*!\n   * vary\n   * Copyright(c) 2014-2017 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nserve-static/index.js:\n  (*!\n   * serve-static\n   * Copyright(c) 2010 Sencha Inc.\n   * Copyright(c) 2011 TJ Holowaychuk\n   * Copyright(c) 2014-2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n\nlodash/lodash.js:\n  (**\n   * @license\n   * Lodash <https://lodash.com/>\n   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n   * Released under MIT license <https://lodash.com/license>\n   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n   *)\n\nobject-assign/index.js:\n  (*\n  object-assign\n  (c) Sindre Sorhus\n  @license MIT\n  *)\n*/\n"],
  "mappings": "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AA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sCAAsC;AAAA,MAC/C,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sdAAs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AO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,SAAS,CAAC,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OA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C,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QA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,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,oTAAoT;AAAA,MAC7T,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,sjBAAsjB;AAAA,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AAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA4X;AAAA,MACrY,CAAC,QAAQ,sjBAAsjB;AAAA,MAC/jB,CAAC,QAAQ,4XAA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AQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,QAAQ;AAAA;AAAA,QAER,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QACV,UAAU;AAAA,QA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",
  "names": ["util", "objectUtil", "_ZodError", "_ParseStatus", "errorUtil", "errorMap", "r", "err", "_ZodString", "ctx", "_ZodNumber", "_ZodBigInt", "_ZodDate", "_ZodArray", "result", "_ZodObject", "issues", "_ZodDiscriminatedUnion", "_ZodTuple", "_ZodRecord", "_ZodSet", "elements", "_ZodFunction", "_ZodEnum", "processed", "_ZodPipeline", "ZodFirstPartyTypeKind", "init_types", "ErrorCode", "init_types", "_a", "jsonrpcNotification", "merge", "sets", "length", "slice", "xl", "x", "join", "subexp", "str", "typeOf", "o", "undefined", "Object", "prototype", "toString", "call", "split", "pop", "shift", "toLowerCase", "toUpperCase", "toArray", "obj", "Array", "setInterval", "assign", "target", "source", "key", "buildExps", "isIRI", "ALPHA$$", "CR$", "DIGIT$$", "DQUOTE$$", "HEXDIG$$", "SP$$", "PCT_ENCODED$", "SUB_DELIMS$$", "RESERVED$$", "GEN_DELIMS$$", "UCSCHAR$$", "SCHEME$", "USERINFO$", "UNRESERVED$$", "DEC_OCTET$", "DEC_OCTET_RELAXED$", "H16$", "LS32$", "IPV4ADDRESS$", "IPV6ADDRESS1$", "IPV6ADDRESS2$", "IPV6ADDRESS3$", "IPV6ADDRESS4$", "IPV6ADDRESS5$", "IPV6ADDRESS6$", "IPV6ADDRESS7$", "IPV6ADDRESS8$", "IPV6ADDRESS9$", "ZONEID$", "IPV6ADDRESS$", "IP_LITERAL$", "IPV6ADDRZ_RELAXED$", "IPVFUTURE$", "HOST$", "REG_NAME$", "PORT$", "AUTHORITY$", "PCHAR$", "SEGMENT$", "SEGMENT_NZ$", "SEGMENT_NZ_NC$", "PATH_ABEMPTY$", "PATH_ABSOLUTE$", "PATH$", "PATH_NOSCHEME$", "PATH_ROOTLESS$", "PATH_EMPTY$", "QUERY$", "IPRIVATE$$", "FRAGMENT$", "HIER_PART$", "URI$", "RELATIVE_PART$", "RELATIVE$", "URI_REFERENCE$", "ABSOLUTE_URI$", "GENERIC_REF$", "RELATIVE_REF$", "ABSOLUTE_REF$", "SAMEDOC_REF$", "AUTHORITY_REF$", "RegExp", "maxInt", "base", "tMin", "tMax", "skew", "damp", "initialBias", "initialN", "delimiter", "regexPunycode", "regexNonASCII", "regexSeparators", "errors", "baseMinusTMin", "floor", "Math", "stringFromCharCode", "String", "fromCharCode", "error", "type", "RangeError", "map", "array", "fn", "result", "mapDomain", "string", "parts", "replace", "labels", "encoded", "ucs2decode", "output", "counter", "value", "charCodeAt", "extra", "push", "ucs2encode", "fromCodePoint", "basicToDigit", "codePoint", "digitToBasic", "digit", "flag", "adapt", "delta", "numPoints", "firstTime", "k", "decode", "input", "inputLength", "i", "n", "bias", "basic", "lastIndexOf", "j", "index", "oldi", "w", "t", "baseMinusT", "out", "splice", "encode", "currentValue", "basicLength", "handledCPCount", "m", "handledCPCountPlusOne", "q", "qMinusT", "toUnicode", "test", "toASCII", "punycode", "SCHEMES", "pctEncChar", "chr", "c", "e", "pctDecChars", "newStr", "il", "parseInt", "substr", "c2", "c3", "_normalizeComponentEncoding", "components", "protocol", "decodeUnreserved", "decStr", "match", "UNRESERVED", "scheme", "PCT_ENCODED", "NOT_SCHEME", "userinfo", "NOT_USERINFO", "host", "NOT_HOST", "path", "NOT_PATH", "NOT_PATH_NOSCHEME", "query", "NOT_QUERY", "fragment", "NOT_FRAGMENT", "_stripLeadingZeros", "_normalizeIPv4", "matches", "IPV4ADDRESS", "address", "_normalizeIPv6", "IPV6ADDRESS", "zone", "reverse", "last", "first", "firstFields", "lastFields", "isLastFieldIPv4Address", "fieldCount", "lastFieldsStart", "fields", "allZeroFields", "reduce", "acc", "field", "lastLongest", "longestZeroFields", "sort", "a", "b", "newHost", "newFirst", "newLast", "URI_PARSE", "NO_MATCH_IS_UNDEFINED", "parse", "uriString", "options", "iri", "IRI_PROTOCOL", "URI_PROTOCOL", "reference", "port", "isNaN", "indexOf", "schemeHandler", "unicodeSupport", "domainHost", "_recomposeAuthority", "uriTokens", "_", "$1", "$2", "RDS1", "RDS2", "RDS3", "RDS5", "removeDotSegments", "im", "s", "Error", "serialize", "authority", "charAt", "absolutePath", "resolveComponents", "relative", "skipNormalization", "tolerant", "resolve", "baseURI", "relativeURI", "schemelessOptions", "normalize", "uri", "equal", "uriA", "uriB", "escapeComponent", "ESCAPE", "unescapeComponent", "handler", "secure", "http", "isSecure", "wsComponents", "resourceName", "ws", "O", "ATEXT$$", "QTEXT$$", "VCHAR$$", "SOME_DELIMS$$", "NOT_LOCAL_PART", "NOT_HFNAME", "NOT_HFVALUE", "mailtoComponents", "to", "unknownHeaders", "headers", "hfields", "hfield", "toAddrs", "subject", "body", "addr", "toAddr", "atIdx", "localPart", "domain", "name", "URN_PARSE", "urnComponents", "nid", "nss", "urnScheme", "uriComponents", "UUID", "uuidComponents", "uuid", "https", "wss", "mailto", "urn", "exports", "module", "exports", "module", "exports", "module", "OK", "exports", "module", "util", "exports", "module", "exports", "module", "util", "self", "exports", "module", "exports", "module", "exports", "module", "$rulesGroup", "$rule", "exports", "module", "util", "self", "localRefs", "baseId", "v", "refVal", "schema", "compile", "exports", "module", "Cache", "exports", "module", "util", "URL", "exports", "module", "exports", "module", "exports", "module", "$sch", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "self", "ref", "exports", "module", "exports", "module", "exports", "module", "exports", "module", "keyword", "dataType", "definition", "i", "require_data", "exports", "module", "exports", "module", "util", "Ajv", "addFormat", "self", "init_types", "_a", "Ajv", "isValid", "emojiRegex", "types", "x", "base", "name", "schema", "process", "os", "tty", "styles", "chalk", "self", "init_types", "limitations", "__create", "__defProp", "__getOwnPropDesc", "__getOwnPropNames", "__getProtoOf", "__hasOwnProp", "__commonJS", "__copyProps", "__toESM", "proto", "util2", "base64Regex2", "env", "coerce2", "os", "tty", "hasFlag", "translateLevel", "supportsColor", "require_ref", "require_formats", "setTimeout", "clearTimeout", "wrapAnsi16", "wrapAnsi256", "wrapAnsi16m", "styles", "assembleStyles", "require_util", "stringReplaceAll", "stringEncaseCRLFWithFirstIndex", "styles2", "ansiStyles", "stdoutColor", "stderrColor", "levelMapping", "applyOptions", "chalkFactory", "createBuilder", "createStyler", "usedModels", "applyStyle", "util", "objectUtil", "objectUtil2", "ZodParsedType", "getParsedType", "ZodIssueCode", "quotelessJson", "ZodError", "errorMap", "overrideErrorMap", "setErrorMap", "getErrorMap", "makeIssue", "EMPTY_PATH", "addIssueToContext", "ParseStatus", "INVALID", "DIRTY", "OK", "isAborted", "isDirty", "isValid", "isAsync", "errorUtil", "errorUtil2", "ParseInputLazyPath", "handleResult", "processCreateParams", "errorMap2", "ZodType", "ZodEffects", "ZodFirstPartyTypeKind", "ZodOptional", "ZodNullable", "ZodArray", "ZodPromise", "ZodUnion", "ZodIntersection", "ZodDefault", "ZodBranded", "ZodCatch", "ZodPipeline", "ZodReadonly", "cuidRegex", "cuid2Regex", "ulidRegex", "uuidRegex", "nanoidRegex", "jwtRegex", "durationRegex", "emailRegex", "_emojiRegex", "emojiRegex", "ipv4Regex", "ipv4CidrRegex", "ipv6Regex", "ipv6CidrRegex", "base64Regex", "base64urlRegex", "dateRegexSource", "dateRegex", "timeRegexSource", "timeRegex", "datetimeRegex", "isValidIP", "isValidJWT", "isValidCidr", "ZodString", "floatSafeRemainder", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodDate", "ZodSymbol", "ZodUndefined", "ZodNull", "ZodAny", "ZodUnknown", "ZodNever", "ZodVoid", "deepPartialify", "ZodObject", "ZodTuple", "createZodEnum", "getDiscriminator", "ZodLazy", "ZodLiteral", "ZodEnum", "ZodNativeEnum", "ZodDiscriminatedUnion", "mergeValues", "ZodRecord", "ZodMap", "ZodSet", "ZodFunction", "ZodNaN", "BRAND", "cleanParams", "custom", "late", "ZodFirstPartyTypeKind2", "instanceOfType", "stringType", "numberType", "nanType", "bigIntType", "booleanType", "dateType", "symbolType", "undefinedType", "nullType", "anyType", "unknownType", "neverType", "voidType", "arrayType", "objectType", "strictObjectType", "unionType", "discriminatedUnionType", "intersectionType", "tupleType", "recordType", "mapType", "setType", "functionType", "lazyType", "literalType", "enumType", "nativeEnumType", "promiseType", "effectsType", "optionalType", "nullableType", "preprocessType", "pipelineType", "ostring", "onumber", "oboolean", "coerce", "NEVER", "LATEST_PROTOCOL_VERSION", "SUPPORTED_PROTOCOL_VERSIONS", "JSONRPC_VERSION", "ProgressTokenSchema", "CursorSchema", "RequestMetaSchema", "BaseRequestParamsSchema", "RequestSchema", "BaseNotificationParamsSchema", "NotificationSchema", "ResultSchema", "RequestIdSchema", "JSONRPCRequestSchema", "isJSONRPCRequest", "JSONRPCNotificationSchema", "JSONRPCResponseSchema", "isJSONRPCResponse", "ErrorCode", "ErrorCode2", "JSONRPCErrorSchema", "isJSONRPCError", "JSONRPCMessageSchema", "EmptyResultSchema", "CancelledNotificationSchema", "BaseMetadataSchema", "ImplementationSchema", "ClientCapabilitiesSchema", "InitializeRequestSchema", "ServerCapabilitiesSchema", "InitializeResultSchema", "InitializedNotificationSchema", "PingRequestSchema", "ProgressSchema", "ProgressNotificationSchema", "PaginatedRequestSchema", "PaginatedResultSchema", "ResourceContentsSchema", "TextResourceContentsSchema", "Base64Schema", "BlobResourceContentsSchema", "ResourceSchema", "ResourceTemplateSchema", "ListResourcesRequestSchema", "ListResourcesResultSchema", "ListResourceTemplatesRequestSchema", "ListResourceTemplatesResultSchema", "ReadResourceRequestSchema", "ReadResourceResultSchema", "ResourceListChangedNotificationSchema", "SubscribeRequestSchema", "UnsubscribeRequestSchema", "ResourceUpdatedNotificationSchema", "PromptArgumentSchema", "PromptSchema", "ListPromptsRequestSchema", "ListPromptsResultSchema", "GetPromptRequestSchema", "TextContentSchema", "ImageContentSchema", "AudioContentSchema", "EmbeddedResourceSchema", "ResourceLinkSchema", "ContentBlockSchema", "PromptMessageSchema", "GetPromptResultSchema", "PromptListChangedNotificationSchema", "ToolAnnotationsSchema", "ToolSchema", "ListToolsRequestSchema", "ListToolsResultSchema", "CallToolResultSchema", "CompatibilityCallToolResultSchema", "CallToolRequestSchema", "ToolListChangedNotificationSchema", "LoggingLevelSchema", "SetLevelRequestSchema", "LoggingMessageNotificationSchema", "ModelHintSchema", "ModelPreferencesSchema", "SamplingMessageSchema", "CreateMessageRequestSchema", "CreateMessageResultSchema", "BooleanSchemaSchema", "StringSchemaSchema", "NumberSchemaSchema", "EnumSchemaSchema", "PrimitiveSchemaDefinitionSchema", "ElicitRequestSchema", "ElicitResultSchema", "ResourceTemplateReferenceSchema", "PromptReferenceSchema", "CompleteRequestSchema", "CompleteResultSchema", "RootSchema", "ListRootsRequestSchema", "ListRootsResultSchema", "RootsListChangedNotificationSchema", "ClientRequestSchema", "ClientNotificationSchema", "ClientResultSchema", "ServerRequestSchema", "ServerNotificationSchema", "ServerResultSchema", "ignoreOverride", "defaultOptions", "getDefaultOptions", "getRefs", "addErrorMessage", "setResponseValueAndErrors", "parseAnyDef", "parseArrayDef", "parseDef", "parseBigintDef", "parseBooleanDef", "parseBrandedDef", "parseCatchDef", "parseDateDef", "integerDateParser", "parseDefaultDef", "parseEffectsDef", "parseEnumDef", "isJsonSchema7AllOfType", "parseIntersectionDef", "parseLiteralDef", "emojiRegex2", "zodPatterns", "parseStringDef", "addFormat", "addPattern", "escapeLiteralCheckValue", "escapeNonAlphaNumeric", "ALPHA_NUMERIC", "stringifyRegExpWithFlags", "parseRecordDef", "parseMapDef", "parseNativeEnumDef", "parseNeverDef", "parseNullDef", "primitiveMappings", "parseUnionDef", "asAnyOf", "parseNullableDef", "parseNumberDef", "decideAdditionalProperties", "parseObjectDef", "parseOptionalDef", "parsePipelineDef", "parsePromiseDef", "parseSetDef", "parseTupleDef", "parseUndefinedDef", "parseUnknownDef", "parseReadonlyDef", "selectParser", "get$ref", "addMeta", "getRelativePath", "zodToJsonSchema", "configSchema", "import_chalk"]
}
 diff --git a/src/analogical-reasoning/dist/index.d.ts b/src/analogical-reasoning/dist/index.d.ts index b798801..b419838 100644 --- a/src/analogical-reasoning/dist/index.d.ts +++ b/src/analogical-reasoning/dist/index.d.ts @@ -1,2 +1,28 @@ #!/usr/bin/env node -export {}; +import { z } from "zod"; +export declare const configSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>; +export default function createServer({ config, }: { + config: z.infer; +}): import("@modelcontextprotocol/sdk/server").Server<{ + method: string; + params?: { + [x: string]: unknown; + _meta?: { + [x: string]: unknown; + progressToken?: string | number | undefined; + } | undefined; + } | undefined; +}, { + method: string; + params?: { + [x: string]: unknown; + _meta?: { + [x: string]: unknown; + } | undefined; + } | undefined; +}, { + [x: string]: unknown; + _meta?: { + [x: string]: unknown; + } | undefined; +}>; diff --git a/src/analogical-reasoning/dist/index.js b/src/analogical-reasoning/dist/index.js index 544ed27..3b42e29 100755 --- a/src/analogical-reasoning/dist/index.js +++ b/src/analogical-reasoning/dist/index.js @@ -1,8 +1,10 @@ #!/usr/bin/env node -import { Server } from "@modelcontextprotocol/sdk/server/index.js"; +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; -import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"; +import { z } from "zod"; import chalk from 'chalk'; +// Define session configuration schema (optional - this server doesn't need config) +export const configSchema = z.object({}); // Type guard for DomainElement type const allowedElementTypes = ["entity", "attribute", "relation", "process"]; function isValidElementType(type) { @@ -368,247 +370,91 @@ class AnalogicalReasoningServer { } } } -const ANALOGICAL_REASONING_TOOL = { - name: "analogicalReasoning", - description: `A detailed tool for analogical thinking between source and target domains. +// Tool input schema using Zod +const analogicalReasoningInputSchema = z.object({ + sourceDomain: z.object({ + name: z.string().describe("Name of the source domain"), + elements: z.array(z.object({ + id: z.string().optional(), + name: z.string(), + type: z.enum(["entity", "attribute", "relation", "process"]), + description: z.string() + })) + }), + targetDomain: z.object({ + name: z.string().describe("Name of the target domain"), + elements: z.array(z.object({ + id: z.string().optional(), + name: z.string(), + type: z.enum(["entity", "attribute", "relation", "process"]), + description: z.string() + })) + }), + mappings: z.array(z.object({ + sourceElement: z.string(), + targetElement: z.string(), + mappingStrength: z.number().min(0).max(1), + justification: z.string(), + limitations: z.array(z.string()).optional() + })), + analogyId: z.string(), + purpose: z.enum(["explanation", "prediction", "problem-solving", "creative-generation"]), + confidence: z.number().min(0).max(1), + iteration: z.number().int().min(0), + strengths: z.array(z.string()), + limitations: z.array(z.string()), + inferences: z.array(z.object({ + statement: z.string(), + confidence: z.number().min(0).max(1), + basedOnMappings: z.array(z.string()) + })), + nextOperationNeeded: z.boolean(), + suggestedOperations: z.array(z.enum(["add-mapping", "revise-mapping", "draw-inference", "evaluate-limitation", "try-new-source"])).optional() +}); +// Export createServer function for Smithery CLI +export default function createServer({ config, }) { + const server = new McpServer({ + name: "analogical-reasoning-server", + version: "0.1.3", + }); + const analogicalReasoningServer = new AnalogicalReasoningServer(); + // Register the analogical reasoning tool + server.registerTool("analogicalReasoning", { + title: "Analogical Reasoning", + description: `A detailed tool for analogical thinking between source and target domains. This tool helps models structure analogies systematically to improve understanding and reasoning. It facilitates explicit mapping between domains, inference generation, and analogy evaluation. -When to use this tool: -- Understanding new concepts through analogies to familiar domains -- Problem-solving by transferring insights between domains -- Creative thinking by establishing connections between different fields -- Explaining complex concepts through structured comparisons -- Evaluating analogies for their strengths and limitations - -Key features: -- Explicit domain structure representation -- Systematic mapping between domains -- Inference generation and evaluation -- Visual representation of analogical mappings -- Tracking of analogy strengths and limitations`, - inputSchema: { - type: "object", - properties: { - sourceDomain: { - type: "object", - description: "The familiar domain used as the basis for the analogy", - properties: { - name: { - type: "string", - description: "The name of the source domain" - }, - elements: { - type: "array", - description: "Elements in the source domain", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the element" - }, - name: { - type: "string", - description: "Name of the element" - }, - type: { - type: "string", - enum: ["entity", "attribute", "relation", "process"], - description: "Type of element" - }, - description: { - type: "string", - description: "Description of the element" - } - }, - required: ["name", "type", "description"] - } - } - }, - required: ["name", "elements"] - }, - targetDomain: { - type: "object", - description: "The domain being understood through the analogy", - properties: { - name: { - type: "string", - description: "The name of the target domain" - }, - elements: { - type: "array", - description: "Elements in the target domain", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the element" - }, - name: { - type: "string", - description: "Name of the element" - }, - type: { - type: "string", - enum: ["entity", "attribute", "relation", "process"], - description: "Type of element" - }, - description: { - type: "string", - description: "Description of the element" - } - }, - required: ["name", "type", "description"] - } - } - }, - required: ["name", "elements"] - }, - mappings: { - type: "array", - description: "Mappings between source and target domain elements", - items: { - type: "object", - properties: { - sourceElement: { - type: "string", - description: "ID of the source domain element" - }, - targetElement: { - type: "string", - description: "ID of the target domain element" - }, - mappingStrength: { - type: "number", - minimum: 0, - maximum: 1, - description: "Strength of the mapping (0.0-1.0)" - }, - justification: { - type: "string", - description: "Justification for the mapping" - }, - limitations: { - type: "array", - description: "Limitations of this specific mapping", - items: { - type: "string" - } - } - }, - required: ["sourceElement", "targetElement", "mappingStrength", "justification"] - } - }, - analogyId: { - type: "string", - description: "Unique identifier for this analogy" - }, - purpose: { - type: "string", - enum: ["explanation", "prediction", "problem-solving", "creative-generation"], - description: "The purpose of the analogy" - }, - confidence: { - type: "number", - minimum: 0, - maximum: 1, - description: "Confidence in the overall analogy (0.0-1.0)" - }, - iteration: { - type: "number", - minimum: 0, - description: "Current iteration of the analogy" - }, - strengths: { - type: "array", - description: "Strengths of the analogy", - items: { - type: "string" - } - }, - limitations: { - type: "array", - description: "Limitations of the analogy", - items: { - type: "string" - } - }, - inferences: { - type: "array", - description: "Inferences drawn from the analogy", - items: { - type: "object", - properties: { - statement: { - type: "string", - description: "The inference statement" - }, - confidence: { - type: "number", - minimum: 0, - maximum: 1, - description: "Confidence in the inference (0.0-1.0)" - }, - basedOnMappings: { - type: "array", - description: "IDs of mappings supporting this inference", - items: { - type: "string" - } - } - }, - required: ["statement", "confidence", "basedOnMappings"] - } - }, - nextOperationNeeded: { - type: "boolean", - description: "Whether another operation is needed" - }, - suggestedOperations: { - type: "array", - description: "Suggested next operations", - items: { - type: "string", - enum: ["add-mapping", "revise-mapping", "draw-inference", "evaluate-limitation", "try-new-source"] - } - } +Use this tool to: +- Map concepts between familiar and unfamiliar domains +- Draw insights through structural alignment +- Generate predictions based on analogical transfer +- Solve problems by applying known solutions to new contexts`, + inputSchema: { + data: analogicalReasoningInputSchema }, - required: ["sourceDomain", "targetDomain", "analogyId", "purpose", "confidence", "iteration", "nextOperationNeeded"] - } -}; -const server = new Server({ - name: "analogical-reasoning-server", - version: "0.1.2", -}, { - capabilities: { - tools: {}, - }, -}); -const analogicalReasoningServer = new AnalogicalReasoningServer(); -server.setRequestHandler(ListToolsRequestSchema, async () => ({ - tools: [ANALOGICAL_REASONING_TOOL], -})); -server.setRequestHandler(CallToolRequestSchema, async (request) => { - if (request.params.name === "analogicalReasoning") { - return analogicalReasoningServer.processAnalogicalReasoning(request.params.arguments); - } - return { - content: [{ - type: "text", - text: `Unknown tool: ${request.params.name}` - }], - isError: true - }; -}); -async function runServer() { + }, async ({ data }) => { + // Validate and process the input + const result = await analogicalReasoningServer.processAnalogicalReasoning(data); + return result; + }); + return server.server; +} +// Maintain STDIO compatibility for backward compatibility +async function main() { + // Create server with empty configuration (no config needed for this server) + const server = createServer({ + config: {}, + }); const transport = new StdioServerTransport(); await server.connect(transport); - console.error("Analogical Reasoning MCP Server running on stdio"); + console.error("Analogical Reasoning MCP Server running in stdio mode"); +} +// Only run main if this file is executed directly (not imported) +if (import.meta.url === `file://${process.argv[1]}`) { + main().catch((error) => { + console.error("Fatal error running server:", error); + process.exit(1); + }); } -runServer().catch((error) => { - console.error("Fatal error running server:", error); - process.exit(1); -}); //# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/src/analogical-reasoning/dist/index.js.map b/src/analogical-reasoning/dist/index.js.map index c46520e..dbcb247 100644 --- a/src/analogical-reasoning/dist/index.js.map +++ b/src/analogical-reasoning/dist/index.js.map @@ -1 +1 @@ -{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/src/analogical-reasoning/index.ts b/src/analogical-reasoning/index.ts index 324fec4..450564b 100644 --- a/src/analogical-reasoning/index.ts +++ b/src/analogical-reasoning/index.ts @@ -1,15 +1,17 @@ -#!/usr/bin/env node - import { Server } from "@modelcontextprotocol/sdk/server/index.js"; -import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; import { CallToolRequestSchema, ListToolsRequestSchema, - Tool, - CallToolRequest + McpError, + ErrorCode } from "@modelcontextprotocol/sdk/types.js"; +import { z } from "zod"; +import { zodToJsonSchema } from "zod-to-json-schema"; import chalk from 'chalk'; +// Define session configuration schema (optional - this server doesn't need config) +export const configSchema = z.object({}); + // Types interface DomainElement { id: string; @@ -454,7 +456,7 @@ class AnalogicalReasoningServer { return output; } - public processAnalogicalReasoning(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } { + public processAnalogicalReasoning(input: unknown): { content: Array<{ type: "text"; text: string }>; isError?: boolean } { try { const validatedInput = this.validateAnalogicalReasoningData(input); @@ -468,7 +470,7 @@ class AnalogicalReasoningServer { // Return the analysis result return { content: [{ - type: "text", + type: "text" as const, text: JSON.stringify({ analogyId: validatedInput.analogyId, purpose: validatedInput.purpose, @@ -485,7 +487,7 @@ class AnalogicalReasoningServer { } catch (error) { return { content: [{ - type: "text", + type: "text" as const, text: JSON.stringify({ error: error instanceof Error ? error.message : String(error), status: 'failed' @@ -497,257 +499,109 @@ class AnalogicalReasoningServer { } } -const ANALOGICAL_REASONING_TOOL: Tool = { - name: "analogicalReasoning", - description: `A detailed tool for analogical thinking between source and target domains. -This tool helps models structure analogies systematically to improve understanding and reasoning. -It facilitates explicit mapping between domains, inference generation, and analogy evaluation. - -When to use this tool: -- Understanding new concepts through analogies to familiar domains -- Problem-solving by transferring insights between domains -- Creative thinking by establishing connections between different fields -- Explaining complex concepts through structured comparisons -- Evaluating analogies for their strengths and limitations - -Key features: -- Explicit domain structure representation -- Systematic mapping between domains -- Inference generation and evaluation -- Visual representation of analogical mappings -- Tracking of analogy strengths and limitations`, +// Tool input schema using Zod +const AnalogicalReasoningSchema = z.object({ + sourceDomain: z.object({ + name: z.string(), + elements: z.array(z.object({ + id: z.string().optional(), + name: z.string(), + type: z.enum(["entity", "attribute", "relation", "process"]), + description: z.string() + })) + }), + targetDomain: z.object({ + name: z.string(), + elements: z.array(z.object({ + id: z.string().optional(), + name: z.string(), + type: z.enum(["entity", "attribute", "relation", "process"]), + description: z.string() + })) + }), + mappings: z.array(z.object({ + sourceElement: z.string(), + targetElement: z.string(), + mappingStrength: z.number().min(0).max(1), + justification: z.string(), + limitations: z.array(z.string()).optional() + })), + analogyId: z.string(), + purpose: z.enum(["explanation", "prediction", "problem-solving", "creative-generation"]), + confidence: z.number().min(0).max(1), + iteration: z.number().int().min(0), + strengths: z.array(z.string()), + limitations: z.array(z.string()), + inferences: z.array(z.object({ + statement: z.string(), + confidence: z.number().min(0).max(1), + basedOnMappings: z.array(z.string()) + })), + nextOperationNeeded: z.boolean(), + suggestedOperations: z.array( + z.enum(["add-mapping", "revise-mapping", "draw-inference", "evaluate-limitation", "try-new-source"]) + ).optional() +}); - inputSchema: { - type: "object", - properties: { - sourceDomain: { - type: "object", - description: "The familiar domain used as the basis for the analogy", - properties: { - name: { - type: "string", - description: "The name of the source domain" - }, - elements: { - type: "array", - description: "Elements in the source domain", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the element" - }, - name: { - type: "string", - description: "Name of the element" - }, - type: { - type: "string", - enum: ["entity", "attribute", "relation", "process"], - description: "Type of element" - }, - description: { - type: "string", - description: "Description of the element" - } - }, - required: ["name", "type", "description"] - } - } - }, - required: ["name", "elements"] - }, - targetDomain: { - type: "object", - description: "The domain being understood through the analogy", - properties: { - name: { - type: "string", - description: "The name of the target domain" - }, - elements: { - type: "array", - description: "Elements in the target domain", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the element" - }, - name: { - type: "string", - description: "Name of the element" - }, - type: { - type: "string", - enum: ["entity", "attribute", "relation", "process"], - description: "Type of element" - }, - description: { - type: "string", - description: "Description of the element" - } - }, - required: ["name", "type", "description"] - } - } - }, - required: ["name", "elements"] - }, - mappings: { - type: "array", - description: "Mappings between source and target domain elements", - items: { - type: "object", - properties: { - sourceElement: { - type: "string", - description: "ID of the source domain element" - }, - targetElement: { - type: "string", - description: "ID of the target domain element" - }, - mappingStrength: { - type: "number", - minimum: 0, - maximum: 1, - description: "Strength of the mapping (0.0-1.0)" - }, - justification: { - type: "string", - description: "Justification for the mapping" - }, - limitations: { - type: "array", - description: "Limitations of this specific mapping", - items: { - type: "string" - } - } - }, - required: ["sourceElement", "targetElement", "mappingStrength", "justification"] - } - }, - analogyId: { - type: "string", - description: "Unique identifier for this analogy" - }, - purpose: { - type: "string", - enum: ["explanation", "prediction", "problem-solving", "creative-generation"], - description: "The purpose of the analogy" - }, - confidence: { - type: "number", - minimum: 0, - maximum: 1, - description: "Confidence in the overall analogy (0.0-1.0)" - }, - iteration: { - type: "number", - minimum: 0, - description: "Current iteration of the analogy" - }, - strengths: { - type: "array", - description: "Strengths of the analogy", - items: { - type: "string" - } - }, - limitations: { - type: "array", - description: "Limitations of the analogy", - items: { - type: "string" - } - }, - inferences: { - type: "array", - description: "Inferences drawn from the analogy", - items: { - type: "object", - properties: { - statement: { - type: "string", - description: "The inference statement" - }, - confidence: { - type: "number", - minimum: 0, - maximum: 1, - description: "Confidence in the inference (0.0-1.0)" - }, - basedOnMappings: { - type: "array", - description: "IDs of mappings supporting this inference", - items: { - type: "string" - } - } - }, - required: ["statement", "confidence", "basedOnMappings"] - } - }, - nextOperationNeeded: { - type: "boolean", - description: "Whether another operation is needed" - }, - suggestedOperations: { - type: "array", - description: "Suggested next operations", - items: { - type: "string", - enum: ["add-mapping", "revise-mapping", "draw-inference", "evaluate-limitation", "try-new-source"] - } - } +// Export createServer function for Smithery CLI +export default function createServer({ + config, +}: { + config: z.infer; +}): Server { + // Create a low-level Server instance + const server = new Server( + { + name: "analogical-reasoning-server", + version: "0.1.3", }, - required: ["sourceDomain", "targetDomain", "analogyId", "purpose", "confidence", "iteration", "nextOperationNeeded"] - } -}; + { + capabilities: { + tools: {}, + }, + } + ); -const server = new Server( - { - name: "analogical-reasoning-server", - version: "0.1.2", - }, - { - capabilities: { - tools: {}, - }, - } -); + const analogicalReasoningServer = new AnalogicalReasoningServer(); -const analogicalReasoningServer = new AnalogicalReasoningServer(); + // Register handlers + server.setRequestHandler(ListToolsRequestSchema, async () => ({ + tools: [ + { + name: "analogicalReasoning", + title: "Analogical Reasoning", + description: `A detailed tool for analogical thinking between source and target domains. +This tool helps models structure analogies systematically to improve understanding and reasoning. +It facilitates explicit mapping between domains, inference generation, and analogy evaluation. -server.setRequestHandler(ListToolsRequestSchema, async () => ({ - tools: [ANALOGICAL_REASONING_TOOL], -})); +Use this tool to: +- Map concepts between familiar and unfamiliar domains +- Draw insights through structural alignment +- Generate predictions based on analogical transfer +- Solve problems by applying known solutions to new contexts`, + inputSchema: zodToJsonSchema(AnalogicalReasoningSchema) as any, + }, + ], + })); -server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest) => { - if (request.params.name === "analogicalReasoning") { - return analogicalReasoningServer.processAnalogicalReasoning(request.params.arguments); - } + server.setRequestHandler(CallToolRequestSchema, async (request) => { + const { name, arguments: toolArgs } = request.params; - return { - content: [{ - type: "text", - text: `Unknown tool: ${request.params.name}` - }], - isError: true - }; -}); + if (name === "analogicalReasoning") { + const parsed = AnalogicalReasoningSchema.safeParse(toolArgs); + if (!parsed.success) { + throw new McpError( + ErrorCode.InvalidParams, + `Invalid arguments: ${parsed.error.message}` + ); + } -async function runServer() { - const transport = new StdioServerTransport(); - await server.connect(transport); - console.error("Analogical Reasoning MCP Server running on stdio"); -} + const result = await analogicalReasoningServer.processAnalogicalReasoning(parsed.data); + return result; + } + + throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`); + }); -runServer().catch((error) => { - console.error("Fatal error running server:", error); - process.exit(1); -}); \ No newline at end of file + return server; +} \ No newline at end of file diff --git a/src/analogical-reasoning/package-lock.json b/src/analogical-reasoning/package-lock.json new file mode 100644 index 0000000..a6ceee5 --- /dev/null +++ b/src/analogical-reasoning/package-lock.json @@ -0,0 +1,2056 @@ +{ + "name": "@waldzellai/analogical-reasoning", + "version": "0.1.3", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@waldzellai/analogical-reasoning", + "version": "0.1.3", + "license": "MIT", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.10.2", + "chalk": "^5.3.0", + "yargs": "^17.7.2", + "zod": "^3.25.76", + "zod-to-json-schema": "^3.24.6" + }, + "bin": { + "mcp-server-analogical-reasoning": "dist/index.js" + }, + "devDependencies": { + "@types/node": "^22", + "@types/yargs": "^17.0.32", + "shx": "^0.3.4", + "tsx": "^4.20.5", + "typescript": "^5.3.3" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.9.tgz", + "integrity": "sha512-OaGtL73Jck6pBKjNIe24BnFE6agGl+6KxDtTfHhy1HmhthfKouEcOhqpSL64K4/0WCtbKFLOdzD/44cJ4k9opA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.9.tgz", + "integrity": "sha512-5WNI1DaMtxQ7t7B6xa572XMXpHAaI/9Hnhk8lcxF4zVN4xstUgTlvuGDorBguKEnZO70qwEcLpfifMLoxiPqHQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.9.tgz", + "integrity": "sha512-IDrddSmpSv51ftWslJMvl3Q2ZT98fUSL2/rlUXuVqRXHCs5EUF1/f+jbjF5+NG9UffUDMCiTyh8iec7u8RlTLg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.9.tgz", + "integrity": "sha512-I853iMZ1hWZdNllhVZKm34f4wErd4lMyeV7BLzEExGEIZYsOzqDWDf+y082izYUE8gtJnYHdeDpN/6tUdwvfiw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.9.tgz", + "integrity": "sha512-XIpIDMAjOELi/9PB30vEbVMs3GV1v2zkkPnuyRRURbhqjyzIINwj+nbQATh4H9GxUgH1kFsEyQMxwiLFKUS6Rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.9.tgz", + "integrity": "sha512-jhHfBzjYTA1IQu8VyrjCX4ApJDnH+ez+IYVEoJHeqJm9VhG9Dh2BYaJritkYK3vMaXrf7Ogr/0MQ8/MeIefsPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.9.tgz", + "integrity": "sha512-z93DmbnY6fX9+KdD4Ue/H6sYs+bhFQJNCPZsi4XWJoYblUqT06MQUdBCpcSfuiN72AbqeBFu5LVQTjfXDE2A6Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.9.tgz", + "integrity": "sha512-mrKX6H/vOyo5v71YfXWJxLVxgy1kyt1MQaD8wZJgJfG4gq4DpQGpgTB74e5yBeQdyMTbgxp0YtNj7NuHN0PoZg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.9.tgz", + "integrity": "sha512-HBU2Xv78SMgaydBmdor38lg8YDnFKSARg1Q6AT0/y2ezUAKiZvc211RDFHlEZRFNRVhcMamiToo7bDx3VEOYQw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.9.tgz", + "integrity": "sha512-BlB7bIcLT3G26urh5Dmse7fiLmLXnRlopw4s8DalgZ8ef79Jj4aUcYbk90g8iCa2467HX8SAIidbL7gsqXHdRw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.9.tgz", + "integrity": "sha512-e7S3MOJPZGp2QW6AK6+Ly81rC7oOSerQ+P8L0ta4FhVi+/j/v2yZzx5CqqDaWjtPFfYz21Vi1S0auHrap3Ma3A==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.9.tgz", + "integrity": "sha512-Sbe10Bnn0oUAB2AalYztvGcK+o6YFFA/9829PhOCUS9vkJElXGdphz0A3DbMdP8gmKkqPmPcMJmJOrI3VYB1JQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.9.tgz", + "integrity": "sha512-YcM5br0mVyZw2jcQeLIkhWtKPeVfAerES5PvOzaDxVtIyZ2NUBZKNLjC5z3/fUlDgT6w89VsxP2qzNipOaaDyA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.9.tgz", + "integrity": "sha512-++0HQvasdo20JytyDpFvQtNrEsAgNG2CY1CLMwGXfFTKGBGQT3bOeLSYE2l1fYdvML5KUuwn9Z8L1EWe2tzs1w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.9.tgz", + "integrity": "sha512-uNIBa279Y3fkjV+2cUjx36xkx7eSjb8IvnL01eXUKXez/CBHNRw5ekCGMPM0BcmqBxBcdgUWuUXmVWwm4CH9kg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.9.tgz", + "integrity": "sha512-Mfiphvp3MjC/lctb+7D287Xw1DGzqJPb/J2aHHcHxflUo+8tmN/6d4k6I2yFR7BVo5/g7x2Monq4+Yew0EHRIA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.9.tgz", + "integrity": "sha512-iSwByxzRe48YVkmpbgoxVzn76BXjlYFXC7NvLYq+b+kDjyyk30J0JY47DIn8z1MO3K0oSl9fZoRmZPQI4Hklzg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.9.tgz", + "integrity": "sha512-9jNJl6FqaUG+COdQMjSCGW4QiMHH88xWbvZ+kRVblZsWrkXlABuGdFJ1E9L7HK+T0Yqd4akKNa/lO0+jDxQD4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.9.tgz", + "integrity": "sha512-RLLdkflmqRG8KanPGOU7Rpg829ZHu8nFy5Pqdi9U01VYtG9Y0zOG6Vr2z4/S+/3zIyOxiK6cCeYNWOFR9QP87g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.9.tgz", + "integrity": "sha512-YaFBlPGeDasft5IIM+CQAhJAqS3St3nJzDEgsgFixcfZeyGPCd6eJBWzke5piZuZ7CtL656eOSYKk4Ls2C0FRQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.9.tgz", + "integrity": "sha512-1MkgTCuvMGWuqVtAvkpkXFmtL8XhWy+j4jaSO2wxfJtilVCi0ZE37b8uOdMItIHz4I6z1bWWtEX4CJwcKYLcuA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.9.tgz", + "integrity": "sha512-4Xd0xNiMVXKh6Fa7HEJQbrpP3m3DDn43jKxMjxLLRjWnRsfxjORYJlXPO4JNcXtOyfajXorRKY9NkOpTHptErg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.9.tgz", + "integrity": "sha512-WjH4s6hzo00nNezhp3wFIAfmGZ8U7KtrJNlFMRKxiI9mxEK1scOMAaa9i4crUtu+tBr+0IN6JCuAcSBJZfnphw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.9.tgz", + "integrity": "sha512-mGFrVJHmZiRqmP8xFOc6b84/7xa5y5YvR1x8djzXpJBSv/UsNK6aqec+6JDjConTgvvQefdGhFDAs2DLAds6gQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.9.tgz", + "integrity": "sha512-b33gLVU2k11nVx1OhX3C8QQP6UHQK4ZtN56oFWvVXvz2VkDoe6fbG8TOgHFxEvqeqohmRnIHe5A1+HADk4OQww==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.9.tgz", + "integrity": "sha512-PPOl1mi6lpLNQxnGoyAfschAodRFYXJ+9fs6WHXz7CSWKbOqiMZsubC+BQsVKuul+3vKLuwTHsS2c2y9EoKwxQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@modelcontextprotocol/sdk": { + "version": "1.17.5", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.17.5.tgz", + "integrity": "sha512-QakrKIGniGuRVfWBdMsDea/dx1PNE739QJ7gCM41s9q+qaCYTHCdsIBXQVVXry3mfWAiaM9kT22Hyz53Uw8mfg==", + "license": "MIT", + "dependencies": { + "ajv": "^6.12.6", + "content-type": "^1.0.5", + "cors": "^2.8.5", + "cross-spawn": "^7.0.5", + "eventsource": "^3.0.2", + "eventsource-parser": "^3.0.0", + "express": "^5.0.1", + "express-rate-limit": "^7.5.0", + "pkce-challenge": "^5.0.0", + "raw-body": "^3.0.0", + "zod": "^3.23.8", + "zod-to-json-schema": "^3.24.1" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@types/node": { + "version": "22.18.0", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.18.0.tgz", + "integrity": "sha512-m5ObIqwsUp6BZzyiy4RdZpzWGub9bqLJMvZDD0QMXhxjqMHMENlj+SqF5QxoUwaQNFe+8kz8XM8ZQhqkQPTgMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/yargs": { + "version": "17.0.33", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz", + "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.3", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz", + "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/accepts": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", + "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/body-parser": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz", + "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==", + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^1.0.5", + "debug": "^4.4.0", + "http-errors": "^2.0.0", + "iconv-lite": "^0.6.3", + "on-finished": "^2.4.1", + "qs": "^6.14.0", + "raw-body": "^3.0.0", + "type-is": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/chalk": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.0.tgz", + "integrity": "sha512-46QrSQFyVSEyYAgQ22hQ+zDa60YHA4fBstHmtSApj1Y5vKtG27fWowW03jCk5KcbXEWPZUIR894aARCA/G1kfQ==", + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/content-disposition": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz", + "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/cors": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz", + "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debug": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", + "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.9.tgz", + "integrity": "sha512-CRbODhYyQx3qp7ZEwzxOk4JBqmD/seJrzPa/cGjY1VtIn5E09Oi9/dB4JwctnfZ8Q8iT7rioVv5k/FNT/uf54g==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.9", + "@esbuild/android-arm": "0.25.9", + "@esbuild/android-arm64": "0.25.9", + "@esbuild/android-x64": "0.25.9", + "@esbuild/darwin-arm64": "0.25.9", + "@esbuild/darwin-x64": "0.25.9", + "@esbuild/freebsd-arm64": "0.25.9", + "@esbuild/freebsd-x64": "0.25.9", + "@esbuild/linux-arm": "0.25.9", + "@esbuild/linux-arm64": "0.25.9", + "@esbuild/linux-ia32": "0.25.9", + "@esbuild/linux-loong64": "0.25.9", + "@esbuild/linux-mips64el": "0.25.9", + "@esbuild/linux-ppc64": "0.25.9", + "@esbuild/linux-riscv64": "0.25.9", + "@esbuild/linux-s390x": "0.25.9", + "@esbuild/linux-x64": "0.25.9", + "@esbuild/netbsd-arm64": "0.25.9", + "@esbuild/netbsd-x64": "0.25.9", + "@esbuild/openbsd-arm64": "0.25.9", + "@esbuild/openbsd-x64": "0.25.9", + "@esbuild/openharmony-arm64": "0.25.9", + "@esbuild/sunos-x64": "0.25.9", + "@esbuild/win32-arm64": "0.25.9", + "@esbuild/win32-ia32": "0.25.9", + "@esbuild/win32-x64": "0.25.9" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventsource": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz", + "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==", + "license": "MIT", + "dependencies": { + "eventsource-parser": "^3.0.1" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/eventsource-parser": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz", + "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==", + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/express": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz", + "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==", + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.0", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "engines": { + "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express-rate-limit": { + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz", + "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==", + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://github.com/sponsors/express-rate-limit" + }, + "peerDependencies": { + "express": ">= 4.11" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "license": "MIT" + }, + "node_modules/finalhandler": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz", + "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", + "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-tsconfig": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz", + "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "license": "MIT", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/http-errors/node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/interpret": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-promise": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "license": "MIT" + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", + "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", + "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mime-db": { + "version": "1.54.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", + "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz", + "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==", + "license": "MIT", + "dependencies": { + "mime-db": "^1.54.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", + "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-to-regexp": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz", + "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==", + "license": "MIT", + "engines": { + "node": ">=16" + } + }, + "node_modules/pkce-challenge": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz", + "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==", + "license": "MIT", + "engines": { + "node": ">=16.20.0" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz", + "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.6.3", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", + "dev": true, + "dependencies": { + "resolve": "^1.1.6" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.10", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/router": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", + "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "license": "MIT", + "dependencies": { + "debug": "^4.4.0", + "depd": "^2.0.0", + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/send": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz", + "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==", + "license": "MIT", + "dependencies": { + "debug": "^4.3.5", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "mime-types": "^3.0.1", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/serve-static": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz", + "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==", + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.2.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/shelljs": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz", + "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + }, + "bin": { + "shjs": "bin/shjs" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/shx": { + "version": "0.3.4", + "resolved": "https://registry.npmjs.org/shx/-/shx-0.3.4.tgz", + "integrity": "sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimist": "^1.2.3", + "shelljs": "^0.8.5" + }, + "bin": { + "shx": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tsx": { + "version": "4.20.5", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.5.tgz", + "integrity": "sha512-+wKjMNU9w/EaQayHXb7WA7ZaHY6hN8WgfvHNQ3t1PnU91/7O8TcTnIhCDYTZwnt8JsO9IBqZ30Ln1r7pPF52Aw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.25.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/type-is": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz", + "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==", + "license": "MIT", + "dependencies": { + "content-type": "^1.0.5", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typescript": { + "version": "5.9.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz", + "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==", + "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.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "license": "MIT", + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/zod": { + "version": "3.25.76", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", + "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-to-json-schema": { + "version": "3.24.6", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz", + "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==", + "license": "ISC", + "peerDependencies": { + "zod": "^3.24.1" + } + } + } +} diff --git a/src/analogical-reasoning/package.json b/src/analogical-reasoning/package.json index 193330c..1e59c66 100644 --- a/src/analogical-reasoning/package.json +++ b/src/analogical-reasoning/package.json @@ -4,6 +4,7 @@ "description": "MCP server for diagrammatic thinking and spatial representation", "license": "MIT", "type": "module", + "module": "index.ts", "repository": { "type": "git", "url": "https://github.com/waldzellai/model-enhancement-servers.git", @@ -27,19 +28,22 @@ "dist" ], "scripts": { - "build": "tsc && shx chmod +x dist/*.js", - "prepare": "npm run build", - "watch": "tsc --watch" + "dev": "npx @smithery/cli dev", + "build": "npx @smithery/cli build", + "start": "node .smithery/index.cjs" }, "dependencies": { "@modelcontextprotocol/sdk": "^1.10.2", "chalk": "^5.3.0", - "yargs": "^17.7.2" + "yargs": "^17.7.2", + "zod": "^3.25.76", + "zod-to-json-schema": "^3.24.6" }, "devDependencies": { "@types/node": "^22", "@types/yargs": "^17.0.32", "shx": "^0.3.4", + "tsx": "^4.20.5", "typescript": "^5.3.3" } } diff --git a/src/analogical-reasoning/smithery.yaml b/src/analogical-reasoning/smithery.yaml index 6f2c0c5..ebede50 100644 --- a/src/analogical-reasoning/smithery.yaml +++ b/src/analogical-reasoning/smithery.yaml @@ -1,14 +1 @@ -build: - dockerBuildPath: ../../ - dockerfile: src/analogical-reasoning/Dockerfile -startCommand: - type: stdio - configSchema: - type: object - properties: {} - commandFunction: | - (config) => ({ - command: 'node', - args: ['dist/index.js'], - env: {} - }) \ No newline at end of file +runtime: typescript \ No newline at end of file diff --git a/src/focus-group/Dockerfile b/src/focus-group/Dockerfile deleted file mode 100644 index 720e229..0000000 --- a/src/focus-group/Dockerfile +++ /dev/null @@ -1,20 +0,0 @@ -FROM node:18-alpine - -WORKDIR /app - -# Copy package files and install dependencies -COPY package*.json ./ -RUN npm ci --omit=dev - -# Copy tsconfig.json and source code -COPY tsconfig.json ./ -COPY *.ts ./ - -# Build TypeScript code -RUN npm run build - -# Set user to non-root -USER node - -# Set entrypoint to the server -ENTRYPOINT ["node", "dist/index.js"] \ No newline at end of file diff --git a/src/focus-group/README.md b/src/focus-group/README.md deleted file mode 100644 index fe88463..0000000 --- a/src/focus-group/README.md +++ /dev/null @@ -1,88 +0,0 @@ -# Focus Group MCP Server - -An MCP server for simulating focus groups with different LLM user personas to evaluate and critique other MCP servers. - -## Overview - -The Focus Group MCP server allows language models to: - -- Simulate multiple LLM user personas with different needs and expectations -- Provide structured feedback on MCP servers from diverse perspectives -- Analyze specific focus areas like API design, usability, and documentation -- Generate actionable recommendations for server improvements -- Prioritize enhancements based on user impact - -This server is particularly valuable during the development process of MCP servers to ensure they meet the needs of various types of LLM users. - -## Installation - -```bash -npm install -npm run build -``` - -## Usage - -The Focus Group server can be run using: - -```bash -node dist/index.js -``` - -As an MCP server, it communicates using stdin/stdout according to the MCP protocol. - -## Key Features - -- Multi-persona simulation for diverse user perspectives -- Structured feedback collection process -- Focus area analysis for targeted improvements -- Feedback categorization to make input actionable -- Recommendation generation and prioritization - -For complete documentation, see [focus-group-server.md](./docs/focus-group-server.md). - -## Example - -Here's a simplified example of invoking the Focus Group tool: - -```json -{ - "targetServer": "scientific-method-server", - "personas": [ - { - "id": "novice-llm", - "name": "Novice LLM", - "userType": "beginner", - "usageScenario": "First-time use of MCP tools", - "expectations": ["Clear instructions", "Simple API"], - "priorities": ["Ease of use", "Good error messages"], - "constraints": ["Limited tool experience", "Needs guidance"], - "communication": { - "style": "direct", - "tone": "casual" - } - }, - { - "id": "expert-llm", - "name": "Expert LLM", - "userType": "advanced", - "usageScenario": "Complex reasoning tasks", - "expectations": ["Flexible API", "Advanced features"], - "priorities": ["Power", "Efficiency"], - "constraints": ["Needs optimal workflows"], - "communication": { - "style": "analytical", - "tone": "professional" - } - } - ], - "feedback": [], - "stage": "introduction", - "activePersonaId": "novice-llm", - "sessionId": "session-123", - "iteration": 0, - "nextFeedbackNeeded": true -} -``` - -The Focus Group server would process this data, set up the participants, and begin the evaluation process, managing the turn-taking and feedback integration to produce useful insights for improving the target server. \ No newline at end of file diff --git a/src/focus-group/dist/index.d.ts b/src/focus-group/dist/index.d.ts deleted file mode 100644 index dc1ec89..0000000 --- a/src/focus-group/dist/index.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env node -export {}; -//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/src/focus-group/dist/index.d.ts.map b/src/focus-group/dist/index.d.ts.map deleted file mode 100644 index 1be7a7a..0000000 --- a/src/focus-group/dist/index.d.ts.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/src/focus-group/dist/index.js b/src/focus-group/dist/index.js deleted file mode 100644 index 0f30db1..0000000 --- a/src/focus-group/dist/index.js +++ /dev/null @@ -1,603 +0,0 @@ -#!/usr/bin/env node -import { Server } from "@modelcontextprotocol/sdk/server/index.js"; -import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; -import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js"; -import chalk from 'chalk'; -class FocusGroupServer { - constructor() { - this.personaRegistry = {}; - this.feedbackHistory = {}; - this.focusAreaTracker = {}; - this.sessionHistory = {}; - } - validateFocusGroupData(input) { - const data = input; - // Validate required fields - if (!data.targetServer || typeof data.targetServer !== 'string') { - throw new Error('Invalid targetServer: must be a string'); - } - if (!Array.isArray(data.personas)) { - throw new Error('Invalid personas: must be an array'); - } - if (!Array.isArray(data.feedback)) { - throw new Error('Invalid feedback: must be an array'); - } - if (!data.stage || typeof data.stage !== 'string') { - throw new Error('Invalid stage: must be a string'); - } - if (!data.activePersonaId || typeof data.activePersonaId !== 'string') { - throw new Error('Invalid activePersonaId: must be a string'); - } - if (!data.sessionId || typeof data.sessionId !== 'string') { - throw new Error('Invalid sessionId: must be a string'); - } - if (typeof data.iteration !== 'number' || data.iteration < 0) { - throw new Error('Invalid iteration: must be a non-negative number'); - } - if (typeof data.nextFeedbackNeeded !== 'boolean') { - throw new Error('Invalid nextFeedbackNeeded: must be a boolean'); - } - // TODO: Add detailed validation for personas, feedback, and focusAreaAnalyses - // similar to the collaborative-reasoning server - // For now, return the data with minimal validation - return data; - } - updateRegistries(data) { - const sessionId = data.sessionId; - // Update persona registry - if (!this.personaRegistry[sessionId]) { - this.personaRegistry[sessionId] = {}; - } - for (const persona of data.personas) { - this.personaRegistry[sessionId][persona.id] = persona; - } - // Update feedback history - if (!this.feedbackHistory[sessionId]) { - this.feedbackHistory[sessionId] = []; - } - for (const feedback of data.feedback) { - // Only add new feedback - const exists = this.feedbackHistory[sessionId].some(f => f.personaId === feedback.personaId && f.content === feedback.content); - if (!exists) { - this.feedbackHistory[sessionId].push(feedback); - } - } - // Update focus area tracker - if (data.focusAreaAnalyses && data.focusAreaAnalyses.length > 0) { - if (!this.focusAreaTracker[sessionId]) { - this.focusAreaTracker[sessionId] = []; - } - for (const analysis of data.focusAreaAnalyses) { - // Check if this focus area already exists - const existingIndex = this.focusAreaTracker[sessionId].findIndex(a => a.area === analysis.area); - if (existingIndex >= 0) { - // Update existing analysis - this.focusAreaTracker[sessionId][existingIndex] = analysis; - } - else { - // Add new analysis - this.focusAreaTracker[sessionId].push(analysis); - } - } - } - } - updateSessionHistory(data) { - let historyEntry = this.sessionHistory[data.sessionId]; - if (!historyEntry) { - historyEntry = []; - this.sessionHistory[data.sessionId] = historyEntry; - } - historyEntry.push(data); - this.updateRegistries(data); - } - selectNextPersona(data) { - // If nextPersonaId is already set, use it - if (data.nextPersonaId) { - return data.nextPersonaId; - } - // Otherwise, select the next persona in rotation - if (!data.personas || data.personas.length === 0) { - throw new Error("Cannot determine next persona: No personas defined in session."); - } - const personaIds = data.personas.map(p => p.id); - const currentIndex = personaIds.indexOf(data.activePersonaId); - // If active persona not found (shouldn't happen ideally), default to first - const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % personaIds.length; - return personaIds[nextIndex]; - } - getPersonaColor(index) { - const colors = [ - chalk.blue, - chalk.green, - chalk.yellow, - chalk.magenta, - chalk.cyan, - chalk.red - ]; - return colors[index % colors.length]; - } - getFeedbackTypeColor(type) { - switch (type) { - case 'praise': return chalk.green; - case 'confusion': return chalk.yellow; - case 'suggestion': return chalk.blue; - case 'usability': return chalk.magenta; - case 'feature': return chalk.cyan; - case 'bug': return chalk.red; - case 'summary': return chalk.white; - default: return chalk.white; - } - } - getSeverityBar(severity) { - const barLength = 20; - const filledLength = Math.round(severity * barLength); - const emptyLength = barLength - filledLength; - let bar = '['; - // Choose color based on severity level - let color; - if (severity >= 0.8) { - color = chalk.red; - } - else if (severity >= 0.5) { - color = chalk.yellow; - } - else { - color = chalk.green; - } - bar += color('='.repeat(filledLength)); - bar += ' '.repeat(emptyLength); - bar += `] ${(severity * 100).toFixed(0)}%`; - return bar; - } - visualizeFocusGroup(data) { - let output = `\n${chalk.bold(`FOCUS GROUP: ${data.targetServer}`)} (ID: ${data.sessionId})\n\n`; - // Stage and iteration - output += `${chalk.cyan('Stage:')} ${data.stage}\n`; - output += `${chalk.cyan('Iteration:')} ${data.iteration}\n\n`; - // Personas - output += `${chalk.bold('PERSONAS:')}\n`; - for (let i = 0; i < data.personas.length; i++) { - const persona = data.personas[i]; - const color = this.getPersonaColor(i); - output += `${color(`${persona.name} (${persona.id})`)}\n`; - output += ` User Type: ${persona.userType}\n`; - output += ` Scenario: ${persona.usageScenario}\n`; - output += ` Priorities: ${persona.priorities.join(', ')}\n`; - // Highlight active persona - if (persona.id === data.activePersonaId) { - output += ` ${chalk.bgGreen(chalk.black(' ACTIVE '))}\n`; - } - output += '\n'; - } - // Feedback - if (data.feedback.length > 0) { - output += `${chalk.bold('FEEDBACK:')}\n\n`; - for (const feedback of data.feedback) { - // Find persona - const persona = data.personas.find(p => p.id === feedback.personaId); - if (!persona) - continue; - // Get persona color - const personaIndex = data.personas.findIndex(p => p.id === feedback.personaId); - const personaColor = this.getPersonaColor(personaIndex); - // Get feedback type color - const typeColor = this.getFeedbackTypeColor(feedback.type); - output += `${personaColor(`[${persona.name}]`)} ${typeColor(`[${feedback.type}]`)}${feedback.targetComponent ? ` on ${feedback.targetComponent}` : ''}\n`; - output += `${feedback.content}\n`; - output += `Severity: ${this.getSeverityBar(feedback.severity)}\n`; - if (feedback.referenceIds && feedback.referenceIds.length > 0) { - output += `References: ${feedback.referenceIds.join(', ')}\n`; - } - output += '\n'; - } - } - // Focus Area Analyses - if (data.focusAreaAnalyses && data.focusAreaAnalyses.length > 0) { - output += `${chalk.bold('FOCUS AREA ANALYSES:')}\n\n`; - for (const analysis of data.focusAreaAnalyses) { - output += `${chalk.cyan('Area:')} ${analysis.area}\n\n`; - for (const finding of analysis.findings) { - // Find persona - const persona = data.personas.find(p => p.id === finding.personaId); - if (!persona) - continue; - // Get persona color - const personaIndex = data.personas.findIndex(p => p.id === finding.personaId); - const personaColor = this.getPersonaColor(personaIndex); - output += `${personaColor(`[${persona.name}]`)} Finding: ${finding.finding}\n`; - output += ` Impact: ${finding.impact}\n`; - if (finding.suggestion) { - output += ` Suggestion: ${finding.suggestion}\n`; - } - output += '\n'; - } - if (analysis.resolution) { - output += `${chalk.green('Resolution:')} ${analysis.resolution.type}\n`; - output += `${analysis.resolution.description}\n\n`; - } - else { - output += `${chalk.yellow('Status:')} Unresolved\n\n`; - } - } - } - // Analysis output - if (data.keyStrengths && data.keyStrengths.length > 0) { - output += `${chalk.bold('KEY STRENGTHS:')}\n`; - for (const strength of data.keyStrengths) { - output += ` - ${strength}\n`; - } - output += '\n'; - } - if (data.keyWeaknesses && data.keyWeaknesses.length > 0) { - output += `${chalk.bold('KEY WEAKNESSES:')}\n`; - for (const weakness of data.keyWeaknesses) { - output += ` - ${weakness}\n`; - } - output += '\n'; - } - if (data.topRecommendations && data.topRecommendations.length > 0) { - output += `${chalk.bold('TOP RECOMMENDATIONS:')}\n`; - for (const recommendation of data.topRecommendations) { - output += ` - ${recommendation}\n`; - } - output += '\n'; - } - if (data.unanimousPoints && data.unanimousPoints.length > 0) { - output += `${chalk.bold('UNANIMOUS POINTS:')}\n`; - for (const point of data.unanimousPoints) { - output += ` - ${point}\n`; - } - output += '\n'; - } - // Next steps - if (data.nextFeedbackNeeded) { - const nextPersonaId = this.selectNextPersona(data); - const nextPersona = data.personas.find(p => p.id === nextPersonaId); - if (nextPersona) { - output += `${chalk.blue('NEXT FEEDBACK:')}\n`; - output += ` Next persona: ${nextPersona.name}\n`; - if (data.suggestedFeedbackTypes && data.suggestedFeedbackTypes.length > 0) { - output += ` Suggested feedback types: ${data.suggestedFeedbackTypes.join(', ')}\n`; - } - if (data.suggestedFocusArea) { - output += ` Suggested focus area: ${data.suggestedFocusArea}\n`; - } - } - } - return output; - } - processFocusGroup(input) { - try { - const validatedInput = this.validateFocusGroupData(input); - // Update the next persona if not specified - if (!validatedInput.nextPersonaId && validatedInput.nextFeedbackNeeded) { - validatedInput.nextPersonaId = this.selectNextPersona(validatedInput); - } - // Update session state - this.updateSessionHistory(validatedInput); - // Generate visualization - const visualization = this.visualizeFocusGroup(validatedInput); - console.error(visualization); - // Return the focus group result - return { - content: [{ - type: "text", - text: JSON.stringify({ - sessionId: validatedInput.sessionId, - targetServer: validatedInput.targetServer, - stage: validatedInput.stage, - iteration: validatedInput.iteration, - personaCount: validatedInput.personas.length, - feedbackCount: validatedInput.feedback.length, - focusAreaCount: validatedInput.focusAreaAnalyses?.length || 0, - activePersonaId: validatedInput.activePersonaId, - nextPersonaId: validatedInput.nextPersonaId, - nextFeedbackNeeded: validatedInput.nextFeedbackNeeded, - suggestedFeedbackTypes: validatedInput.suggestedFeedbackTypes, - suggestedFocusArea: validatedInput.suggestedFocusArea - }, null, 2) - }] - }; - } - catch (error) { - return { - content: [{ - type: "text", - text: JSON.stringify({ - error: error instanceof Error ? error.message : String(error), - status: 'failed' - }, null, 2) - }], - isError: true - }; - } - } -} -const FOCUS_GROUP_TOOL = { - name: "focusGroup", - description: `A specialized tool for conducting LLM-based focus groups to evaluate MCP servers. -This tool helps models analyze MCP servers from multiple user perspectives. -It provides a framework for structured evaluation, feedback collection, and recommendation generation. - -When to use this tool: -- When evaluating a new or updated MCP server -- To identify usability issues from different LLM user perspectives -- To gather diverse feedback on API design and functionality -- To prioritize improvements based on user needs -- When seeking to understand how different types of users might interact with your MCP server - -Key features: -- Multi-persona simulation of different LLM users -- Structured feedback collection process -- Focus area analysis for targeted improvements -- Synthesis of findings across user types -- Actionable recommendation generation`, - inputSchema: { - type: "object", - properties: { - targetServer: { - type: "string", - description: "The name of the MCP server being evaluated" - }, - personas: { - type: "array", - description: "The user personas participating in the focus group", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the persona" - }, - name: { - type: "string", - description: "Name of the persona" - }, - userType: { - type: "string", - description: "Type of LLM user (e.g., novice, expert, enterprise, developer)" - }, - usageScenario: { - type: "string", - description: "Typical use case scenario for this user type" - }, - expectations: { - type: "array", - description: "What this user expects from an MCP server", - items: { - type: "string" - } - }, - priorities: { - type: "array", - description: "What aspects of the server are most important to this user", - items: { - type: "string" - } - }, - constraints: { - type: "array", - description: "Limitations or constraints this user operates under", - items: { - type: "string" - } - }, - communication: { - type: "object", - description: "Communication style of the persona", - properties: { - style: { - type: "string", - description: "Communication style (e.g., direct, analytical, narrative)" - }, - tone: { - type: "string", - description: "Tone of communication (e.g., formal, casual, enthusiastic)" - } - }, - required: ["style", "tone"] - } - }, - required: ["id", "name", "userType", "usageScenario", "expectations", "priorities", "constraints", "communication"] - } - }, - feedback: { - type: "array", - description: "Feedback from the personas", - items: { - type: "object", - properties: { - personaId: { - type: "string", - description: "ID of the providing persona" - }, - content: { - type: "string", - description: "Content of the feedback" - }, - type: { - type: "string", - enum: ["praise", "confusion", "suggestion", "usability", "feature", "bug", "summary"], - description: "Type of feedback" - }, - targetComponent: { - type: "string", - description: "The component or aspect of the server this feedback relates to" - }, - severity: { - type: "number", - minimum: 0, - maximum: 1, - description: "Severity or importance of this feedback (0.0-1.0)" - }, - referenceIds: { - type: "array", - description: "IDs of previous feedback this builds upon", - items: { - type: "string" - } - } - }, - required: ["personaId", "content", "type", "severity"] - } - }, - focusAreaAnalyses: { - type: "array", - description: "Analysis of specific focus areas", - items: { - type: "object", - properties: { - area: { - type: "string", - description: "Focus area being analyzed" - }, - findings: { - type: "array", - description: "Findings about this focus area", - items: { - type: "object", - properties: { - personaId: { - type: "string", - description: "ID of the persona making this finding" - }, - finding: { - type: "string", - description: "Description of the finding" - }, - impact: { - type: "string", - description: "Impact of this finding on users" - }, - suggestion: { - type: "string", - description: "Suggested improvement" - } - }, - required: ["personaId", "finding", "impact"] - } - }, - resolution: { - type: "object", - description: "Resolution of the findings, if any", - properties: { - type: { - type: "string", - enum: ["implemented", "considered", "rejected", "deferred"], - description: "Type of resolution" - }, - description: { - type: "string", - description: "Description of the resolution" - } - }, - required: ["type", "description"] - } - }, - required: ["area", "findings"] - } - }, - stage: { - type: "string", - enum: ["introduction", "initial-impressions", "deep-dive", "synthesis", "recommendations", "prioritization"], - description: "Current stage of the focus group process" - }, - activePersonaId: { - type: "string", - description: "ID of the currently active persona" - }, - nextPersonaId: { - type: "string", - description: "ID of the persona that should provide feedback next" - }, - keyStrengths: { - type: "array", - description: "Key strengths identified in the server", - items: { - type: "string" - } - }, - keyWeaknesses: { - type: "array", - description: "Key weaknesses or pain points identified", - items: { - type: "string" - } - }, - topRecommendations: { - type: "array", - description: "Top recommendations for improvement", - items: { - type: "string" - } - }, - unanimousPoints: { - type: "array", - description: "Points on which all personas agree", - items: { - type: "string" - } - }, - sessionId: { - type: "string", - description: "Unique identifier for this focus group session" - }, - iteration: { - type: "number", - minimum: 0, - description: "Current iteration of the focus group" - }, - nextFeedbackNeeded: { - type: "boolean", - description: "Whether another round of feedback is needed" - }, - suggestedFeedbackTypes: { - type: "array", - description: "Suggested types for the next feedback", - items: { - type: "string", - enum: ["praise", "confusion", "suggestion", "usability", "feature", "bug", "summary"] - } - }, - suggestedFocusArea: { - type: "string", - description: "Suggested focus area for the next round of feedback" - } - }, - required: ["targetServer", "personas", "feedback", "stage", "activePersonaId", "sessionId", "iteration", "nextFeedbackNeeded"] - } -}; -const server = new Server({ - name: "focus-group-server", - version: "0.1.0", -}, { - capabilities: { - tools: {}, - }, -}); -const focusGroupServer = new FocusGroupServer(); -server.setRequestHandler(ListToolsRequestSchema, async () => ({ - tools: [FOCUS_GROUP_TOOL], -})); -server.setRequestHandler(CallToolRequestSchema, async (request) => { - if (request.params.name === "focusGroup") { - return focusGroupServer.processFocusGroup(request.params.arguments); - } - return { - content: [{ - type: "text", - text: `Unknown tool: ${request.params.name}` - }], - isError: true - }; -}); -async function runServer() { - const transport = new StdioServerTransport(); - await server.connect(transport); - console.error("Focus Group MCP Server running on stdio"); -} -runServer().catch((error) => { - console.error("Fatal error running server:", error); - process.exit(1); -}); -//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/src/focus-group/dist/index.js.map b/src/focus-group/dist/index.js.map deleted file mode 100644 index abdcc18..0000000 --- a/src/focus-group/dist/index.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/src/focus-group/docs/focus-group-server.md b/src/focus-group/docs/focus-group-server.md deleted file mode 100644 index ebdad71..0000000 --- a/src/focus-group/docs/focus-group-server.md +++ /dev/null @@ -1,232 +0,0 @@ -# Focus Group MCP Server - -## Motivation - -When developing MCP servers for use by large language models (LLMs), it can be challenging to anticipate how different types of LLM users might interact with, perceive, and experience your server. While developers may have a clear understanding of their API design, actual LLM users might: - -1. Find the server's API confusing or unintuitive -2. Miss opportunities for more effective interaction patterns -3. Experience usability issues that weren't apparent during development -4. Have needs that weren't considered in the original design -5. Use the server in ways the developers hadn't anticipated - -The Focus Group Server addresses these challenges by creating a structured environment for simulating multiple LLM user personas to evaluate and critique MCP servers. By externalizing the evaluation process, models can systematically analyze servers from diverse user perspectives and provide structured, actionable feedback. - -## Technical Specification - -### Tool Interface - -```typescript -interface FocusGroupPersona { - id: string; - name: string; - userType: string; // e.g., novice, expert, enterprise, developer - usageScenario: string; // typical use case scenario - expectations: string[]; - priorities: string[]; - constraints: string[]; - communication: { - style: string; - tone: string; - }; -} - -interface Feedback { - personaId: string; - content: string; - type: "praise" | "confusion" | "suggestion" | "usability" | "feature" | "bug" | "summary"; - targetComponent?: string; // which aspect of the server this feedback relates to - severity: number; // 0.0-1.0, how important this feedback is - referenceIds?: string[]; // IDs of previous feedback this builds upon -} - -interface FocusAreaAnalysis { - area: string; // e.g., "API Design", "Documentation", "Error Handling" - findings: Array<{ - personaId: string; - finding: string; - impact: string; - suggestion?: string; - }>; - resolution?: { - type: "implemented" | "considered" | "rejected" | "deferred"; - description: string; - }; -} - -interface FocusGroupData { - // Core focus group components - targetServer: string; // The MCP server being analyzed - personas: FocusGroupPersona[]; - feedback: Feedback[]; - focusAreaAnalyses?: FocusAreaAnalysis[]; - - // Process structure - stage: "introduction" | "initial-impressions" | "deep-dive" | "synthesis" | "recommendations" | "prioritization"; - activePersonaId: string; - nextPersonaId?: string; - - // Analysis output - keyStrengths?: string[]; - keyWeaknesses?: string[]; - topRecommendations?: string[]; - unanimousPoints?: string[]; - - // Process metadata - sessionId: string; - iteration: number; - - // Next steps - nextFeedbackNeeded: boolean; - suggestedFeedbackTypes?: string[]; - suggestedFocusArea?: string; -} -``` - -### Server Implementation - -The server maintains: - -1. A `personaRegistry` storing defined LLM user personas -2. A `feedbackHistory` tracking all feedback across sessions -3. A `focusAreaTracker` for documenting focused analyses of server aspects -4. Facilitation logic to manage the focus group process - -For each focus group operation, the server: - -1. Validates the input data structure -2. Updates the focus group state -3. Manages persona transitions and facilitation -4. Returns the updated state with suggested next steps - -### Process Flow - -```mermaid -sequenceDiagram - participant Model - participant FocusServer as Focus Group Server - participant State as Focus Group State - - Model->>FocusServer: Define target server and user personas - FocusServer->>State: Initialize focus group with personas - FocusServer-->>Model: Return initial state with first active persona - - Model->>FocusServer: Submit feedback as Persona A - FocusServer->>State: Store feedback - FocusServer-->>Model: Return updated state with next persona prompt - - Model->>FocusServer: Submit feedback as Persona B - FocusServer->>State: Store feedback, identify focus areas - FocusServer-->>Model: Return updated state highlighting focus areas - - Model->>FocusServer: Submit deep-dive analysis on specific focus area - FocusServer->>State: Store analysis, update focus area tracker - FocusServer-->>Model: Return updated state - - Model->>FocusServer: Submit synthesis of all feedback - FocusServer->>State: Store synthesis, update key findings - FocusServer-->>Model: Return updated state - - Model->>FocusServer: Generate prioritized recommendations - FocusServer->>State: Store recommendations with multi-perspective justification - FocusServer-->>Model: Return final focus group output -``` - -## Key Features - -### 1. Multi-Persona Simulation - -The server enables creation and management of diverse LLM user personas: -- **User types**: Different LLM user profiles (novice, expert, enterprise, developer) -- **Usage scenarios**: Typical use cases for each user type -- **Expectations and priorities**: What each user type values most -- **Constraints**: Limitations each user type operates under -- **Communication styles**: Consistent voice for each persona - -### 2. Structured Evaluation Process - -The server guides a systematic evaluation process: -- **Introduction**: Framing the server's purpose and target audience -- **Initial impressions**: First reactions from different user types -- **Deep-dive**: Detailed exploration of specific aspects -- **Synthesis**: Integrating diverse feedback -- **Recommendations**: Generating actionable improvements -- **Prioritization**: Ranking recommendations by impact and effort - -### 3. Focus Area Analysis - -The server provides mechanisms for targeted evaluation: -- **Focus area tracking**: Explicitly documenting server aspects needing attention -- **Impact assessment**: Evaluating how issues affect different user types -- **Resolution tracking**: Methods for addressing identified issues -- **Suggestion management**: Tracking improvement ideas - -### 4. Feedback Categorization - -The server classifies feedback to make it more actionable: -- **Praise**: Positive aspects worth preserving or expanding -- **Confusion**: Areas that are unclear or counterintuitive -- **Suggestion**: Ideas for improvements -- **Usability**: How the server feels to use -- **Feature**: New capabilities to consider -- **Bug**: Problems that need fixing -- **Summary**: High-level observations - -### 5. Visual Representation - -The server visualizes the focus group process: -- Persona profiles showing diverse user perspectives -- Feedback streams showing reactions by feedback type -- Focus area analyses highlighting priorities -- Strength/weakness assessments showing consensus views - -## Usage Examples - -### New Server Evaluation -When developing a new MCP server, use the focus group server to simulate how different LLM users would experience your API design and functionality. - -### Server Refinement -For existing servers, use the focus group server to identify pain points and opportunities for improvement across different user types. - -### Competitive Analysis -Compare multiple server approaches by running separate focus groups and analyzing which designs work best for which user types. - -### Documentation Improvement -Identify gaps in documentation by examining where confusion arises among different user personas. - -## Implementation Notes - -The server is implemented using TypeScript with: -- A core FocusGroupServer class -- Persona management system -- Feedback and focus area tracking -- Visualization capabilities for the evaluation process -- Standard MCP server connection via stdin/stdout - -This server enhances the development process for MCP servers by providing diverse user perspectives, structured feedback, and actionable recommendations, allowing for more user-centered design and improved usability. - -## Example Persona Types - -Here are some example persona types to consider including in your focus groups: - -1. **Novice LLM**: New to using tools, learning how to integrate external capabilities -2. **Expert LLM**: Sophisticated in tool use, needs efficient APIs -3. **Enterprise LLM**: Concerned with security, reliability, and scale -4. **Developer-focused LLM**: Building applications integrating with tools -5. **Specialized-domain LLM**: Focused on specific industry needs -6. **Multi-step Reasoning LLM**: Needs tools that support complex workflows -7. **Educational LLM**: Using tools to enhance learning experiences -8. **Creative LLM**: Focused on tools for creative tasks - -## Recommended Focus Areas - -Common focus areas to analyze for MCP servers: - -1. **API Design**: Clarity, consistency, and intuitiveness of the API -2. **Documentation**: Completeness, clarity, and helpfulness -3. **Error Handling**: Quality of error messages and recovery options -4. **Performance**: Speed and efficiency of operations -5. **Flexibility**: Adaptability to different use cases -6. **Integration**: Ease of incorporating into workflows -7. **Input/Output Format**: Clarity and usefulness of data formats -8. **Feedback Mechanisms**: How the server communicates its state and results \ No newline at end of file diff --git a/src/focus-group/index.ts b/src/focus-group/index.ts deleted file mode 100644 index 6307cc5..0000000 --- a/src/focus-group/index.ts +++ /dev/null @@ -1,750 +0,0 @@ -#!/usr/bin/env node - -import { Server } from "@modelcontextprotocol/sdk/server/index.js"; -import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; -import { - CallToolRequestSchema, - ListToolsRequestSchema, - Tool, -} from "@modelcontextprotocol/sdk/types.js"; -import chalk from 'chalk'; - -// Types -interface FocusGroupPersona { - id: string; - name: string; - userType: string; // e.g., novice, expert, enterprise, developer - usageScenario: string; // typical use case scenario - expectations: string[]; - priorities: string[]; - constraints: string[]; - communication: { - style: string; - tone: string; - }; -} - -interface Feedback { - personaId: string; - content: string; - type: "praise" | "confusion" | "suggestion" | "usability" | "feature" | "bug" | "summary"; - targetComponent?: string; // which aspect of the server this feedback relates to - severity: number; // 0.0-1.0, how important this feedback is - referenceIds?: string[]; // IDs of previous feedback this builds upon -} - -interface FocusAreaAnalysis { - area: string; // e.g., "API Design", "Documentation", "Error Handling" - findings: Array<{ - personaId: string; - finding: string; - impact: string; - suggestion?: string; - }>; - resolution?: { - type: "implemented" | "considered" | "rejected" | "deferred"; - description: string; - }; -} - -interface FocusGroupData { - // Core focus group components - targetServer: string; // The MCP server being analyzed - personas: FocusGroupPersona[]; - feedback: Feedback[]; - focusAreaAnalyses?: FocusAreaAnalysis[]; - - // Process structure - stage: "introduction" | "initial-impressions" | "deep-dive" | "synthesis" | "recommendations" | "prioritization"; - activePersonaId: string; - nextPersonaId?: string; - - // Analysis output - keyStrengths?: string[]; - keyWeaknesses?: string[]; - topRecommendations?: string[]; - unanimousPoints?: string[]; - - // Process metadata - sessionId: string; - iteration: number; - - // Next steps - nextFeedbackNeeded: boolean; - suggestedFeedbackTypes?: string[]; - suggestedFocusArea?: string; -} - -class FocusGroupServer { - private personaRegistry: Record> = {}; - private feedbackHistory: Record = {}; - private focusAreaTracker: Record = {}; - private sessionHistory: Record = {}; - - private validateFocusGroupData(input: unknown): FocusGroupData { - const data = input as Record; - - // Validate required fields - if (!data.targetServer || typeof data.targetServer !== 'string') { - throw new Error('Invalid targetServer: must be a string'); - } - - if (!Array.isArray(data.personas)) { - throw new Error('Invalid personas: must be an array'); - } - - if (!Array.isArray(data.feedback)) { - throw new Error('Invalid feedback: must be an array'); - } - - if (!data.stage || typeof data.stage !== 'string') { - throw new Error('Invalid stage: must be a string'); - } - - if (!data.activePersonaId || typeof data.activePersonaId !== 'string') { - throw new Error('Invalid activePersonaId: must be a string'); - } - - if (!data.sessionId || typeof data.sessionId !== 'string') { - throw new Error('Invalid sessionId: must be a string'); - } - - if (typeof data.iteration !== 'number' || data.iteration < 0) { - throw new Error('Invalid iteration: must be a non-negative number'); - } - - if (typeof data.nextFeedbackNeeded !== 'boolean') { - throw new Error('Invalid nextFeedbackNeeded: must be a boolean'); - } - - // TODO: Add detailed validation for personas, feedback, and focusAreaAnalyses - // similar to the collaborative-reasoning server - - // For now, return the data with minimal validation - return data as unknown as FocusGroupData; - } - - private updateRegistries(data: FocusGroupData): void { - const sessionId = data.sessionId; - - // Update persona registry - if (!this.personaRegistry[sessionId]) { - this.personaRegistry[sessionId] = {}; - } - - for (const persona of data.personas) { - this.personaRegistry[sessionId][persona.id] = persona; - } - - // Update feedback history - if (!this.feedbackHistory[sessionId]) { - this.feedbackHistory[sessionId] = []; - } - - for (const feedback of data.feedback) { - // Only add new feedback - const exists = this.feedbackHistory[sessionId].some( - f => f.personaId === feedback.personaId && f.content === feedback.content - ); - - if (!exists) { - this.feedbackHistory[sessionId].push(feedback); - } - } - - // Update focus area tracker - if (data.focusAreaAnalyses && data.focusAreaAnalyses.length > 0) { - if (!this.focusAreaTracker[sessionId]) { - this.focusAreaTracker[sessionId] = []; - } - - for (const analysis of data.focusAreaAnalyses) { - // Check if this focus area already exists - const existingIndex = this.focusAreaTracker[sessionId].findIndex( - a => a.area === analysis.area - ); - - if (existingIndex >= 0) { - // Update existing analysis - this.focusAreaTracker[sessionId][existingIndex] = analysis; - } else { - // Add new analysis - this.focusAreaTracker[sessionId].push(analysis); - } - } - } - } - - private updateSessionHistory(data: FocusGroupData): void { - let historyEntry = this.sessionHistory[data.sessionId]; - if (!historyEntry) { - historyEntry = []; - this.sessionHistory[data.sessionId] = historyEntry; - } - - historyEntry.push(data); - this.updateRegistries(data); - } - - private selectNextPersona(data: FocusGroupData): string { - // If nextPersonaId is already set, use it - if (data.nextPersonaId) { - return data.nextPersonaId; - } - - // Otherwise, select the next persona in rotation - if (!data.personas || data.personas.length === 0) { - throw new Error("Cannot determine next persona: No personas defined in session."); - } - - const personaIds = data.personas.map(p => p.id); - const currentIndex = personaIds.indexOf(data.activePersonaId); - // If active persona not found (shouldn't happen ideally), default to first - const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % personaIds.length; - - return personaIds[nextIndex]; - } - - private getPersonaColor(index: number): (text: string) => string { - const colors = [ - chalk.blue, - chalk.green, - chalk.yellow, - chalk.magenta, - chalk.cyan, - chalk.red - ]; - - return colors[index % colors.length]; - } - - private getFeedbackTypeColor(type: string): (text: string) => string { - switch (type) { - case 'praise': return chalk.green; - case 'confusion': return chalk.yellow; - case 'suggestion': return chalk.blue; - case 'usability': return chalk.magenta; - case 'feature': return chalk.cyan; - case 'bug': return chalk.red; - case 'summary': return chalk.white; - default: return chalk.white; - } - } - - private getSeverityBar(severity: number): string { - const barLength = 20; - const filledLength = Math.round(severity * barLength); - const emptyLength = barLength - filledLength; - - let bar = '['; - - // Choose color based on severity level - let color: (text: string) => string; - if (severity >= 0.8) { - color = chalk.red; - } else if (severity >= 0.5) { - color = chalk.yellow; - } else { - color = chalk.green; - } - - bar += color('='.repeat(filledLength)); - bar += ' '.repeat(emptyLength); - bar += `] ${(severity * 100).toFixed(0)}%`; - - return bar; - } - - private visualizeFocusGroup(data: FocusGroupData): string { - let output = `\n${chalk.bold(`FOCUS GROUP: ${data.targetServer}`)} (ID: ${data.sessionId})\n\n`; - - // Stage and iteration - output += `${chalk.cyan('Stage:')} ${data.stage}\n`; - output += `${chalk.cyan('Iteration:')} ${data.iteration}\n\n`; - - // Personas - output += `${chalk.bold('PERSONAS:')}\n`; - for (let i = 0; i < data.personas.length; i++) { - const persona = data.personas[i]; - const color = this.getPersonaColor(i); - - output += `${color(`${persona.name} (${persona.id})`)}\n`; - output += ` User Type: ${persona.userType}\n`; - output += ` Scenario: ${persona.usageScenario}\n`; - output += ` Priorities: ${persona.priorities.join(', ')}\n`; - - // Highlight active persona - if (persona.id === data.activePersonaId) { - output += ` ${chalk.bgGreen(chalk.black(' ACTIVE '))}\n`; - } - - output += '\n'; - } - - // Feedback - if (data.feedback.length > 0) { - output += `${chalk.bold('FEEDBACK:')}\n\n`; - - for (const feedback of data.feedback) { - // Find persona - const persona = data.personas.find(p => p.id === feedback.personaId); - if (!persona) continue; - - // Get persona color - const personaIndex = data.personas.findIndex(p => p.id === feedback.personaId); - const personaColor = this.getPersonaColor(personaIndex); - - // Get feedback type color - const typeColor = this.getFeedbackTypeColor(feedback.type); - - output += `${personaColor(`[${persona.name}]`)} ${typeColor(`[${feedback.type}]`)}${ - feedback.targetComponent ? ` on ${feedback.targetComponent}` : '' - }\n`; - output += `${feedback.content}\n`; - output += `Severity: ${this.getSeverityBar(feedback.severity)}\n`; - - if (feedback.referenceIds && feedback.referenceIds.length > 0) { - output += `References: ${feedback.referenceIds.join(', ')}\n`; - } - - output += '\n'; - } - } - - // Focus Area Analyses - if (data.focusAreaAnalyses && data.focusAreaAnalyses.length > 0) { - output += `${chalk.bold('FOCUS AREA ANALYSES:')}\n\n`; - - for (const analysis of data.focusAreaAnalyses) { - output += `${chalk.cyan('Area:')} ${analysis.area}\n\n`; - - for (const finding of analysis.findings) { - // Find persona - const persona = data.personas.find(p => p.id === finding.personaId); - if (!persona) continue; - - // Get persona color - const personaIndex = data.personas.findIndex(p => p.id === finding.personaId); - const personaColor = this.getPersonaColor(personaIndex); - - output += `${personaColor(`[${persona.name}]`)} Finding: ${finding.finding}\n`; - output += ` Impact: ${finding.impact}\n`; - if (finding.suggestion) { - output += ` Suggestion: ${finding.suggestion}\n`; - } - output += '\n'; - } - - if (analysis.resolution) { - output += `${chalk.green('Resolution:')} ${analysis.resolution.type}\n`; - output += `${analysis.resolution.description}\n\n`; - } else { - output += `${chalk.yellow('Status:')} Unresolved\n\n`; - } - } - } - - // Analysis output - if (data.keyStrengths && data.keyStrengths.length > 0) { - output += `${chalk.bold('KEY STRENGTHS:')}\n`; - for (const strength of data.keyStrengths) { - output += ` - ${strength}\n`; - } - output += '\n'; - } - - if (data.keyWeaknesses && data.keyWeaknesses.length > 0) { - output += `${chalk.bold('KEY WEAKNESSES:')}\n`; - for (const weakness of data.keyWeaknesses) { - output += ` - ${weakness}\n`; - } - output += '\n'; - } - - if (data.topRecommendations && data.topRecommendations.length > 0) { - output += `${chalk.bold('TOP RECOMMENDATIONS:')}\n`; - for (const recommendation of data.topRecommendations) { - output += ` - ${recommendation}\n`; - } - output += '\n'; - } - - if (data.unanimousPoints && data.unanimousPoints.length > 0) { - output += `${chalk.bold('UNANIMOUS POINTS:')}\n`; - for (const point of data.unanimousPoints) { - output += ` - ${point}\n`; - } - output += '\n'; - } - - // Next steps - if (data.nextFeedbackNeeded) { - const nextPersonaId = this.selectNextPersona(data); - const nextPersona = data.personas.find(p => p.id === nextPersonaId); - - if (nextPersona) { - output += `${chalk.blue('NEXT FEEDBACK:')}\n`; - output += ` Next persona: ${nextPersona.name}\n`; - - if (data.suggestedFeedbackTypes && data.suggestedFeedbackTypes.length > 0) { - output += ` Suggested feedback types: ${data.suggestedFeedbackTypes.join(', ')}\n`; - } - - if (data.suggestedFocusArea) { - output += ` Suggested focus area: ${data.suggestedFocusArea}\n`; - } - } - } - - return output; - } - - public processFocusGroup(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } { - try { - const validatedInput = this.validateFocusGroupData(input); - - // Update the next persona if not specified - if (!validatedInput.nextPersonaId && validatedInput.nextFeedbackNeeded) { - validatedInput.nextPersonaId = this.selectNextPersona(validatedInput); - } - - // Update session state - this.updateSessionHistory(validatedInput); - - // Generate visualization - const visualization = this.visualizeFocusGroup(validatedInput); - console.error(visualization); - - // Return the focus group result - return { - content: [{ - type: "text", - text: JSON.stringify({ - sessionId: validatedInput.sessionId, - targetServer: validatedInput.targetServer, - stage: validatedInput.stage, - iteration: validatedInput.iteration, - personaCount: validatedInput.personas.length, - feedbackCount: validatedInput.feedback.length, - focusAreaCount: validatedInput.focusAreaAnalyses?.length || 0, - activePersonaId: validatedInput.activePersonaId, - nextPersonaId: validatedInput.nextPersonaId, - nextFeedbackNeeded: validatedInput.nextFeedbackNeeded, - suggestedFeedbackTypes: validatedInput.suggestedFeedbackTypes, - suggestedFocusArea: validatedInput.suggestedFocusArea - }, null, 2) - }] - }; - } catch (error) { - return { - content: [{ - type: "text", - text: JSON.stringify({ - error: error instanceof Error ? error.message : String(error), - status: 'failed' - }, null, 2) - }], - isError: true - }; - } - } -} - -const FOCUS_GROUP_TOOL: Tool = { - name: "focusGroup", - description: `A specialized tool for conducting LLM-based focus groups to evaluate MCP servers. -This tool helps models analyze MCP servers from multiple user perspectives. -It provides a framework for structured evaluation, feedback collection, and recommendation generation. - -When to use this tool: -- When evaluating a new or updated MCP server -- To identify usability issues from different LLM user perspectives -- To gather diverse feedback on API design and functionality -- To prioritize improvements based on user needs -- When seeking to understand how different types of users might interact with your MCP server - -Key features: -- Multi-persona simulation of different LLM users -- Structured feedback collection process -- Focus area analysis for targeted improvements -- Synthesis of findings across user types -- Actionable recommendation generation`, - - inputSchema: { - type: "object", - properties: { - targetServer: { - type: "string", - description: "The name of the MCP server being evaluated" - }, - personas: { - type: "array", - description: "The user personas participating in the focus group", - items: { - type: "object", - properties: { - id: { - type: "string", - description: "Unique identifier for the persona" - }, - name: { - type: "string", - description: "Name of the persona" - }, - userType: { - type: "string", - description: "Type of LLM user (e.g., novice, expert, enterprise, developer)" - }, - usageScenario: { - type: "string", - description: "Typical use case scenario for this user type" - }, - expectations: { - type: "array", - description: "What this user expects from an MCP server", - items: { - type: "string" - } - }, - priorities: { - type: "array", - description: "What aspects of the server are most important to this user", - items: { - type: "string" - } - }, - constraints: { - type: "array", - description: "Limitations or constraints this user operates under", - items: { - type: "string" - } - }, - communication: { - type: "object", - description: "Communication style of the persona", - properties: { - style: { - type: "string", - description: "Communication style (e.g., direct, analytical, narrative)" - }, - tone: { - type: "string", - description: "Tone of communication (e.g., formal, casual, enthusiastic)" - } - }, - required: ["style", "tone"] - } - }, - required: ["id", "name", "userType", "usageScenario", "expectations", "priorities", "constraints", "communication"] - } - }, - feedback: { - type: "array", - description: "Feedback from the personas", - items: { - type: "object", - properties: { - personaId: { - type: "string", - description: "ID of the providing persona" - }, - content: { - type: "string", - description: "Content of the feedback" - }, - type: { - type: "string", - enum: ["praise", "confusion", "suggestion", "usability", "feature", "bug", "summary"], - description: "Type of feedback" - }, - targetComponent: { - type: "string", - description: "The component or aspect of the server this feedback relates to" - }, - severity: { - type: "number", - minimum: 0, - maximum: 1, - description: "Severity or importance of this feedback (0.0-1.0)" - }, - referenceIds: { - type: "array", - description: "IDs of previous feedback this builds upon", - items: { - type: "string" - } - } - }, - required: ["personaId", "content", "type", "severity"] - } - }, - focusAreaAnalyses: { - type: "array", - description: "Analysis of specific focus areas", - items: { - type: "object", - properties: { - area: { - type: "string", - description: "Focus area being analyzed" - }, - findings: { - type: "array", - description: "Findings about this focus area", - items: { - type: "object", - properties: { - personaId: { - type: "string", - description: "ID of the persona making this finding" - }, - finding: { - type: "string", - description: "Description of the finding" - }, - impact: { - type: "string", - description: "Impact of this finding on users" - }, - suggestion: { - type: "string", - description: "Suggested improvement" - } - }, - required: ["personaId", "finding", "impact"] - } - }, - resolution: { - type: "object", - description: "Resolution of the findings, if any", - properties: { - type: { - type: "string", - enum: ["implemented", "considered", "rejected", "deferred"], - description: "Type of resolution" - }, - description: { - type: "string", - description: "Description of the resolution" - } - }, - required: ["type", "description"] - } - }, - required: ["area", "findings"] - } - }, - stage: { - type: "string", - enum: ["introduction", "initial-impressions", "deep-dive", "synthesis", "recommendations", "prioritization"], - description: "Current stage of the focus group process" - }, - activePersonaId: { - type: "string", - description: "ID of the currently active persona" - }, - nextPersonaId: { - type: "string", - description: "ID of the persona that should provide feedback next" - }, - keyStrengths: { - type: "array", - description: "Key strengths identified in the server", - items: { - type: "string" - } - }, - keyWeaknesses: { - type: "array", - description: "Key weaknesses or pain points identified", - items: { - type: "string" - } - }, - topRecommendations: { - type: "array", - description: "Top recommendations for improvement", - items: { - type: "string" - } - }, - unanimousPoints: { - type: "array", - description: "Points on which all personas agree", - items: { - type: "string" - } - }, - sessionId: { - type: "string", - description: "Unique identifier for this focus group session" - }, - iteration: { - type: "number", - minimum: 0, - description: "Current iteration of the focus group" - }, - nextFeedbackNeeded: { - type: "boolean", - description: "Whether another round of feedback is needed" - }, - suggestedFeedbackTypes: { - type: "array", - description: "Suggested types for the next feedback", - items: { - type: "string", - enum: ["praise", "confusion", "suggestion", "usability", "feature", "bug", "summary"] - } - }, - suggestedFocusArea: { - type: "string", - description: "Suggested focus area for the next round of feedback" - } - }, - required: ["targetServer", "personas", "feedback", "stage", "activePersonaId", "sessionId", "iteration", "nextFeedbackNeeded"] - } -}; - -const server = new Server( - { - name: "focus-group-server", - version: "0.1.0", - }, - { - capabilities: { - tools: {}, - }, - } -); - -const focusGroupServer = new FocusGroupServer(); - -server.setRequestHandler(ListToolsRequestSchema, async () => ({ - tools: [FOCUS_GROUP_TOOL], -})); - -server.setRequestHandler(CallToolRequestSchema, async (request) => { - if (request.params.name === "focusGroup") { - return focusGroupServer.processFocusGroup(request.params.arguments); - } - - return { - content: [{ - type: "text", - text: `Unknown tool: ${request.params.name}` - }], - isError: true - }; -}); - -async function runServer() { - const transport = new StdioServerTransport(); - await server.connect(transport); - console.error("Focus Group MCP Server running on stdio"); -} - -runServer().catch((error) => { - console.error("Fatal error running server:", error); - process.exit(1); -}); \ No newline at end of file diff --git a/src/focus-group/package.json b/src/focus-group/package.json deleted file mode 100644 index d14a0d8..0000000 --- a/src/focus-group/package.json +++ /dev/null @@ -1,27 +0,0 @@ -{ - "name": "focus-group-server", - "version": "0.1.0", - "description": "MCP server for LLM focus groups to analyze and critique other MCP servers", - "main": "index.js", - "type": "module", - "scripts": { - "build": "tsc", - "start": "node dist/index.js", - "prepare": "tsc", - "watch": "tsc -w" - }, - "keywords": [ - "mcp", - "focus-group", - "server-analysis", - "llm-evaluation" - ], - "dependencies": { - "@modelcontextprotocol/sdk": "^1.0.6", - "chalk": "^5.2.0" - }, - "devDependencies": { - "typescript": "^5.0.2", - "@types/node": "^18.15.5" - } -} diff --git a/src/focus-group/smithery.yaml b/src/focus-group/smithery.yaml deleted file mode 100644 index 3eaaa9d..0000000 --- a/src/focus-group/smithery.yaml +++ /dev/null @@ -1,61 +0,0 @@ -schema: 1 -name: focus-group -version: 0.1.0 -description: MCP server for LLM focus groups to analyze and critique other MCP servers -license: MIT -repository: https://github.com/your-username/focus-group-server -tools: - - name: focusGroup - description: A specialized tool for conducting LLM-based focus groups to evaluate MCP servers - type: custom - inputSchema: - type: object - properties: - targetServer: - type: string - description: The name of the MCP server being evaluated - personas: - type: array - description: The user personas participating in the focus group - items: - type: object - feedback: - type: array - description: Feedback from the personas - items: - type: object - stage: - type: string - enum: - - introduction - - initial-impressions - - deep-dive - - synthesis - - recommendations - - prioritization - description: Current stage of the focus group process - activePersonaId: - type: string - description: ID of the currently active persona - sessionId: - type: string - description: Unique identifier for this focus group session - iteration: - type: number - description: Current iteration of the focus group - nextFeedbackNeeded: - type: boolean - description: Whether another round of feedback is needed - required: - - targetServer - - personas - - feedback - - stage - - activePersonaId - - sessionId - - iteration - - nextFeedbackNeeded -mcp: - server: - type: stdio - path: dist/index.js \ No newline at end of file diff --git a/src/focus-group/tsconfig.json b/src/focus-group/tsconfig.json deleted file mode 100644 index e9fe16c..0000000 --- a/src/focus-group/tsconfig.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "compilerOptions": { - "target": "ES2020", - "module": "NodeNext", - "moduleResolution": "NodeNext", - "esModuleInterop": true, - "strict": true, - "skipLibCheck": true, - "outDir": "dist", - "sourceMap": true, - "declaration": true, - "declarationMap": true - }, - "include": [ - "*.ts" - ], - "exclude": [ - "node_modules", - "dist" - ] -} diff --git a/src/transaction-manager/Dockerfile b/src/transaction-manager/Dockerfile deleted file mode 100644 index 3697149..0000000 --- a/src/transaction-manager/Dockerfile +++ /dev/null @@ -1,36 +0,0 @@ -FROM node:20-alpine AS build - -WORKDIR /app - -# Copy root package.json for workspace context during install -COPY package.json ./ - -# Copy server-specific files needed for install/build -COPY src/transaction-manager/package.json ./src/transaction-manager/ -COPY src/transaction-manager/tsconfig.json ./src/transaction-manager/ -COPY src/transaction-manager/*.ts ./src/transaction-manager/ - -# Install dependencies (needs root package.json) -RUN npm install - -# Copy root tsconfig.json *just before* build command needs it -COPY tsconfig.json ./ - -# Build the server (needs root tsconfig.json) -RUN npm run build --workspace=@waldzellai/transaction-manager - -FROM node:20-alpine AS runtime - -WORKDIR /app - -# Copy built artifacts and package information -COPY --from=build /app/src/transaction-manager/dist ./dist -COPY --from=build /app/src/transaction-manager/package.json ./ - -ENV NODE_ENV=production - -# Install only production dependencies -RUN npm ci --omit=dev --ignore-scripts - -# Set up entrypoint -ENTRYPOINT ["node", "dist/index.js"] diff --git a/src/transaction-manager/README.md b/src/transaction-manager/README.md deleted file mode 100644 index bb9288d..0000000 --- a/src/transaction-manager/README.md +++ /dev/null @@ -1,208 +0,0 @@ -# Transaction MCP Server - -## Motivation - -Language models fundamentally operate on text, which limits their ability to reason through problems that humans typically solve using spatial, diagrammatic, or visual thinking. Current models struggle with: - -1. Maintaining and manipulating complex spatial relationships -2. Visualizing multi-step transformations or processes -3. Creating and updating visual representations of abstract concepts -4. Reasoning about systems with many interconnected components -5. Identifying patterns that are obvious in visual form but obscure in text - -The Visual Reasoning Server provides models with the ability to create, manipulate, and reason with explicit visual representations. By externalizing visual thinking, models can solve complex problems that benefit from diagrammatic reasoning, much like how mathematical notation extends human calculation abilities beyond plain text. - -## Technical Specification - -### Tool Interface - -```typescript -interface VisualElement { - id: string; - type: "node" | "edge" | "container" | "annotation"; - label?: string; - properties: { - [key: string]: any; // Position, size, color, etc. - }; - // For edges - source?: string; // ID of source element - target?: string; // ID of target element - // For containers - contains?: string[]; // IDs of contained elements -} - -interface VisualOperationData { - // Operation details - operation: "create" | "update" | "delete" | "transform" | "observe"; - elements?: VisualElement[]; - transformationType?: "rotate" | "move" | "resize" | "recolor" | "regroup"; - - // Visual diagram metadata - diagramId: string; - diagramType: "graph" | "flowchart" | "stateDiagram" | "conceptMap" | "treeDiagram" | "custom"; - iteration: number; - - // Reasoning about the diagram - observation?: string; - insight?: string; - hypothesis?: string; - - // Next steps - nextOperationNeeded: boolean; -} -``` - -### Process Flow - -```mermaid -sequenceDiagram - participant Model - participant VisServer as Visual Reasoning Server - participant State as Visual State - - Model->>VisServer: Create initial nodes (operation=create) - VisServer->>State: Initialize visual representation - VisServer-->>Model: Return visual rendering + state - - Model->>VisServer: Add connections (operation=create, type=edge) - VisServer->>State: Update with new edges - VisServer-->>Model: Return updated visual + state - - Model->>VisServer: Group related elements (operation=transform, type=regroup) - VisServer->>State: Update with new grouping - VisServer-->>Model: Return updated visual + state - - Model->>VisServer: Make observation about pattern (operation=observe) - VisServer->>State: Record observation with current state - VisServer-->>Model: Return visual with observation - - Model->>VisServer: Update based on insight (operation=update) - VisServer->>State: Modify visual elements - VisServer-->>Model: Return final visual + state -``` - -## Key Features - -### 1. Multi-Modal Representation System - -The server supports different visual representation types: -- **Graphs**: For relationship networks and connection patterns -- **Flowcharts**: For processes and sequential operations -- **State Diagrams**: For system states and transitions -- **Concept Maps**: For knowledge organization and relationships -- **Tree Diagrams**: For hierarchical structures - -### 2. Abstract Visual Element Manipulation - -Models can manipulate visual elements through operations: -- **Create**: Add new elements to the visual space -- **Update**: Modify existing elements -- **Delete**: Remove elements -- **Transform**: Apply operations to multiple elements (regrouping, restructuring) -- **Observe**: Make and record observations about visual patterns - -### 3. Iterative Refinement - -The server tracks iteration history, allowing models to: -- See how their visual representation evolved -- Revert to previous states if needed -- Compare different visualization approaches - -### 4. Visual-Verbal Integration - -The server enables bidirectional translation between: -- Verbal descriptions and visual representations -- Visual patterns and verbal insights -- Diagrammatic reasoning and textual conclusions - -### 5. Visual Output - -The server provides multiple representations: -- ASCII art for terminal-based visualization -- SVG or DOT format for more complex diagrams -- Textual descriptions of the visual state for accessibility - -## Usage Examples - -### System Architecture Design -Models can create and manipulate component diagrams showing data flow, dependencies, and interactions between system components. - -### Algorithm Visualization -When designing or explaining algorithms, models can create flowcharts, state diagrams, or visual traces of execution. - -### Concept Mapping -For organizing complex domains of knowledge, models can create and refine concept maps showing relationships between ideas. - -### Pattern Recognition -When analyzing data, models can create visual representations to identify patterns that might be difficult to detect in text. - -## Implementation - -The server is implemented using TypeScript with: -- A core VisualReasoningServer class -- A flexible visual element representation system -- Multiple rendering backends (ASCII, SVG, DOT) -- State history tracking for iterative refinement -- Standard MCP server connection via stdin/stdout - -The implementation leverages existing graph visualization libraries (like Graphviz for DOT output or custom ASCII art generation) to provide rich visual feedback within the constraints of text-based interfaces. - -This server significantly enhances model capabilities for domains where visual or spatial thinking provides a natural advantage over purely textual reasoning. - -## Tool - -### visualReasoning - -Facilitates visual thinking through creating and manipulating diagram elements. - -## Configuration - -### Usage with Claude Desktop - -Add this to your `claude_desktop_config.json`: - -#### npx - -```json -{ - "mcpServers": { - "visual-reasoning": { - "command": "npx", - "args": [ - "-y", - "@waldzellai/visual-reasoning" - ] - } - } -} -``` - -#### docker - -```json -{ - "mcpServers": { - "visual-reasoning": { - "command": "docker", - "args": [ - "run", - "--rm", - "-i", - "cognitive-enhancement-mcp/visual-reasoning" - ] - } - } -} -``` - -## Building - -Docker: - -```bash -docker build -t cognitive-enhancement-mcp/visual-reasoning -f packages/visual-reasoning/Dockerfile . -``` - -## License - -This MCP server is licensed under the MIT License. \ No newline at end of file diff --git a/src/transaction-manager/dist/index.d.ts b/src/transaction-manager/dist/index.d.ts deleted file mode 100644 index b798801..0000000 --- a/src/transaction-manager/dist/index.d.ts +++ /dev/null @@ -1,2 +0,0 @@ -#!/usr/bin/env node -export {}; diff --git a/src/transaction-manager/dist/index.js b/src/transaction-manager/dist/index.js deleted file mode 100755 index 2f0d960..0000000 --- a/src/transaction-manager/dist/index.js +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env node -import yargs from 'yargs'; -import { hideBin } from 'yargs/helpers'; -import { runServer } from './server.js'; -const argv = yargs(hideBin(process.argv)) - .option('port', { - alias: 'p', - type: 'number', - description: 'Port number for the server to listen on', - default: 3000, // Default port -}) - .option('verbose', { - alias: 'v', - type: 'boolean', - description: 'Run with verbose logging', - default: false, -}) - .help() - .alias('help', 'h') - .parseSync(); -runServer().catch((error) => { - console.error('Failed to start server:', error); - process.exit(1); -}); -//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/src/transaction-manager/dist/index.js.map b/src/transaction-manager/dist/index.js.map deleted file mode 100644 index 89a0939..0000000 --- a/src/transaction-manager/dist/index.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;KACtC,MAAM,CAAC,MAAM,EAAE;IACd,KAAK,EAAE,GAAG;IACV,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,yCAAyC;IACtD,OAAO,EAAE,IAAI,EAAE,eAAe;CAC/B,CAAC;KACD,MAAM,CAAC,SAAS,EAAE;IACjB,KAAK,EAAE,GAAG;IACV,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,0BAA0B;IACvC,OAAO,EAAE,KAAK;CACf,CAAC;KACD,IAAI,EAAE;KACN,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC;KAClB,SAAS,EAAE,CAAC;AAEf,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;IACxB,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;IAChD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC,CAAC,CAAC"} \ No newline at end of file diff --git a/src/transaction-manager/dist/lib/redis-helper.d.ts b/src/transaction-manager/dist/lib/redis-helper.d.ts deleted file mode 100644 index 6e2f103..0000000 --- a/src/transaction-manager/dist/lib/redis-helper.d.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { Redis } from 'ioredis'; -export declare const redisClient: Redis; -/** - * Set a key with a value and an expiry time (TTL) in seconds. - * Handles JSON serialization. - */ -export declare function setWithTTL(key: string, value: unknown, ttlSeconds: number): Promise; -/** - * Get the value of a key. Handles JSON deserialization. - * Returns null if key doesn't exist or on error. - */ -export declare function get(key: string): Promise; -/** - * Delete a key. - * Returns the number of keys deleted (0 or 1). - */ -export declare function del(key: string): Promise; -/** - * Set the expiry time (TTL) in seconds for an existing key. - */ -export declare function expire(key: string, ttlSeconds: number): Promise; diff --git a/src/transaction-manager/dist/lib/redis-helper.js b/src/transaction-manager/dist/lib/redis-helper.js deleted file mode 100644 index 335cac4..0000000 --- a/src/transaction-manager/dist/lib/redis-helper.js +++ /dev/null @@ -1,111 +0,0 @@ -import { Redis } from 'ioredis'; -import chalk from 'chalk'; -const REDIS_URL = process.env.REDIS_URL; -if (!REDIS_URL) { - console.error(chalk.red('Error: REDIS_URL environment variable is not set.')); - process.exit(1); -} -const redisOptions = { - maxRetriesPerRequest: 3, - enableReadyCheck: true, - retryStrategy(times) { - const delay = Math.min(times * 50, 2000); // Exponential backoff capped at 2s - console.warn(chalk.yellow(`Redis connection lost. Retrying in ${delay}ms... (Attempt ${times})`)); - return delay; - }, -}; -export const redisClient = new Redis(REDIS_URL, redisOptions); -redisClient.on('connect', () => { - console.log(chalk.green('Connected to Redis server.')); -}); -redisClient.on('ready', () => { - console.log(chalk.cyan('Redis client is ready.')); -}); -redisClient.on('error', (err) => { - console.error(chalk.red('Redis client error:'), err); - // Depending on the error, you might want to implement more specific handling - // For critical errors (like auth failure), you might want to exit. - // if (err.message.includes('AUTH')) { process.exit(1); } -}); -redisClient.on('close', () => { - console.log(chalk.magenta('Redis connection closed.')); -}); -redisClient.on('reconnecting', (timeToReconnect) => { - console.log(chalk.yellow(`Redis reconnecting in ${timeToReconnect}ms...`)); -}); -redisClient.on('end', () => { - console.log(chalk.gray('Redis client connection has ended. (No more reconnections will be attempted)')); -}); -// Wrapper functions for common operations with error handling -/** - * Set a key with a value and an expiry time (TTL) in seconds. - * Handles JSON serialization. - */ -export async function setWithTTL(key, value, ttlSeconds) { - try { - const serializedValue = JSON.stringify(value); - const result = await redisClient.set(key, serializedValue, 'EX', ttlSeconds); - return result === 'OK'; - } - catch (error) { // Catch Redis errors and serialization errors - console.error(chalk.red(`Error setting key ${key} with TTL ${ttlSeconds}s:`), error); - return false; - } -} -/** - * Get the value of a key. Handles JSON deserialization. - * Returns null if key doesn't exist or on error. - */ -export async function get(key) { - try { - const result = await redisClient.get(key); - if (result === null) { - return null; // Key doesn't exist or expired - } - return JSON.parse(result); - } - catch (error) { // Catch Redis errors and deserialization errors - console.error(chalk.red(`Error getting key ${key}:`), error); - return null; - } -} -/** - * Delete a key. - * Returns the number of keys deleted (0 or 1). - */ -export async function del(key) { - try { - return await redisClient.del(key); - } - catch (error) { - console.error(chalk.red(`Error deleting key ${key}:`), error); - return 0; // Indicate failure - } -} -/** - * Set the expiry time (TTL) in seconds for an existing key. - */ -export async function expire(key, ttlSeconds) { - try { - const result = await redisClient.expire(key, ttlSeconds); - return result === 1; - } - catch (error) { - console.error(chalk.red(`Error setting expiry for key ${key}:`), error); - return false; - } -} -// Graceful shutdown -process.on('SIGINT', async () => { - console.log(chalk.blue('\nGracefully shutting down Redis client...')); - await redisClient.quit(); - console.log(chalk.blue('Redis client disconnected.')); - process.exit(0); -}); -process.on('SIGTERM', async () => { - console.log(chalk.blue('Received SIGTERM. Gracefully shutting down Redis client...')); - await redisClient.quit(); - console.log(chalk.blue('Redis client disconnected.')); - process.exit(0); -}); -//# sourceMappingURL=redis-helper.js.map \ No newline at end of file diff --git a/src/transaction-manager/dist/lib/redis-helper.js.map b/src/transaction-manager/dist/lib/redis-helper.js.map deleted file mode 100644 index 62d3f0b..0000000 --- a/src/transaction-manager/dist/lib/redis-helper.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"redis-helper.js","sourceRoot":"","sources":["../../lib/redis-helper.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/src/transaction-manager/dist/server.d.ts b/src/transaction-manager/dist/server.d.ts deleted file mode 100644 index 0608796..0000000 --- a/src/transaction-manager/dist/server.d.ts +++ /dev/null @@ -1,9 +0,0 @@ -export type TxnAction = 'start' | 'resume' | 'close'; -export type TxnResponse = { - status: 'pending' | 'complete' | 'closed' | 'error'; - token: string; - payload?: unknown; - expiresAt?: string | null; - error?: string; -}; -export declare function runServer(): Promise; diff --git a/src/transaction-manager/dist/server.js b/src/transaction-manager/dist/server.js deleted file mode 100755 index ee8d2a1..0000000 --- a/src/transaction-manager/dist/server.js +++ /dev/null @@ -1,159 +0,0 @@ -import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; -import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; -import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"; -import { z } from 'zod'; -import chalk from 'chalk'; -import { v4 as uuidv4 } from 'uuid'; -import { setWithTTL, get, del, expire } from './lib/redis-helper.js'; -// -- Zod Schema for Input Validation -- -const TxnRequestSchema = z.object({ - action: z.enum(['start', 'resume', 'close']), - token: z.string().optional(), - payload: z.any().optional(), // Keep as any for flexibility - ttlSeconds: z.number().int().positive().optional(), -}); -// -- Constants (unchanged) -- -const DEFAULT_TTL_SECONDS = 3600; // 1 hour -const MAX_TTL_SECONDS = 86400; // 24 hours -const TOKEN_PREFIX = 'txn:'; -// -- Helper Functions (unchanged) -- -function generateToken() { - return TOKEN_PREFIX + uuidv4(); -} -function calculateExpiry(ttlSeconds) { - return new Date(Date.now() + ttlSeconds * 1000).toISOString(); -} -// -- Main Handler Logic (Refactored) -- -async function handleTransactionCallback(args) { - const { action, token: requestToken, payload, ttlSeconds: requestTtl } = args; - let effectiveTtl = Math.min(requestTtl ?? DEFAULT_TTL_SECONDS, MAX_TTL_SECONDS); - if (effectiveTtl <= 0) - effectiveTtl = DEFAULT_TTL_SECONDS; - try { - let responsePayload; - switch (action) { - case 'start': { - // Validation (moved from generic handler) - if (requestToken) { - throw new McpError(ErrorCode.InvalidParams, 'Token should not be provided for the "start" action.'); - } - const newToken = generateToken(); - const setResult = await setWithTTL(newToken, payload ?? {}, effectiveTtl); - if (!setResult) - throw new Error('Failed to set initial state in Redis.'); - responsePayload = { - status: 'pending', - token: newToken, - payload: payload ?? {}, - expiresAt: calculateExpiry(effectiveTtl), - }; - break; - } - case 'resume': { - if (!requestToken) { - // This validation is technically covered by McpServer if schema requires it, - // but explicit check remains useful if schema makes token optional. - throw new McpError(ErrorCode.InvalidParams, 'Token is required for the "resume" action.'); - } - const currentPayload = await get(requestToken); - if (currentPayload === null) { - throw new McpError(ErrorCode.InvalidParams, `Transaction token "${requestToken}" not found or expired.`); - } - let finalPayload = currentPayload; - if (payload !== undefined) { - await setWithTTL(requestToken, payload, effectiveTtl); - finalPayload = payload; - } - else { - await expire(requestToken, effectiveTtl); - } - responsePayload = { - status: 'pending', - token: requestToken, - payload: finalPayload, - expiresAt: calculateExpiry(effectiveTtl), - }; - break; - } - case 'close': { - if (!requestToken) { - throw new McpError(ErrorCode.InvalidParams, 'Token is required for the "close" action.'); - } - const deleteResult = await del(requestToken); - if (deleteResult === 0) { - console.warn(chalk.yellow(`Attempted to close non-existent or already closed token: ${requestToken}`)); - } - responsePayload = { - status: 'closed', - token: requestToken, - payload: undefined, - expiresAt: null, - }; - break; - } - // No default needed as zod schema handles invalid actions - } - // Return successful result - return { - content: [{ type: 'text', text: JSON.stringify(responsePayload) }] - }; - } - catch (error) { - console.error(chalk.red('Error handling transaction:'), error); - // Return error result - const errorPayload = { - status: 'error', - token: requestToken ?? 'unknown', - error: error instanceof McpError ? error.message : (error.message || 'An unexpected server error occurred.'), - expiresAt: null, - }; - const errorMessage = errorPayload.error; - return { - content: [{ - type: 'text', - text: JSON.stringify(errorPayload) - }, { - type: 'text', // Also include plain text error - text: errorMessage ?? 'Unknown error' // Ensure text is always string - }], - isError: true, - }; - } -} -// -- Server Initialization (Refactored) -- -export async function runServer() { - const mcpServer = new McpServer({ - name: 'transaction-manager', - version: '0.1.1', // Updated version - }); - // Register the single tool - mcpServer.tool("transaction", "Manages simple stateful transactions (start, resume, close)", TxnRequestSchema.shape, // Pass the shape for Zod validation - handleTransactionCallback); - // Connect using stdio - const transport = new StdioServerTransport(); - try { - await mcpServer.connect(transport); - console.error(chalk.green('Transaction Manager MCP Server running on stdio.')); // Use console.error for logs - } - catch (error) { - console.error(chalk.red('Failed to connect Transaction Manager server:'), error); - process.exit(1); - } -} -// Optional: Add main execution block if this file is run directly -// Example using yargs (ensure yargs is installed and imported) -/* -import yargs from 'yargs'; -import { hideBin } from 'yargs/helpers'; - -if (require.main === module) { // Check if running as main script - const argv = yargs(hideBin(process.argv)) - .parseSync(); - - runServer().catch((error) => { - console.error(chalk.red("Fatal error running server:"), error); - process.exit(1); - }); -} -*/ -//# sourceMappingURL=server.js.map \ No newline at end of file diff --git a/src/transaction-manager/dist/server.js.map b/src/transaction-manager/dist/server.js.map deleted file mode 100644 index 1ad76d7..0000000 --- a/src/transaction-manager/dist/server.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"server.js","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/src/transaction-manager/index.ts b/src/transaction-manager/index.ts deleted file mode 100644 index a8552b8..0000000 --- a/src/transaction-manager/index.ts +++ /dev/null @@ -1,27 +0,0 @@ -#!/usr/bin/env node - -import yargs from 'yargs'; -import { hideBin } from 'yargs/helpers'; -import { runServer } from './server.js'; - -const argv = yargs(hideBin(process.argv)) - .option('port', { - alias: 'p', - type: 'number', - description: 'Port number for the server to listen on', - default: 3000, // Default port - }) - .option('verbose', { - alias: 'v', - type: 'boolean', - description: 'Run with verbose logging', - default: false, - }) - .help() - .alias('help', 'h') - .parseSync(); - -runServer().catch((error) => { - console.error('Failed to start server:', error); - process.exit(1); -}); diff --git a/src/transaction-manager/lib/redis-helper.ts b/src/transaction-manager/lib/redis-helper.ts deleted file mode 100644 index 8b15d8c..0000000 --- a/src/transaction-manager/lib/redis-helper.ts +++ /dev/null @@ -1,123 +0,0 @@ -import { Redis, RedisOptions } from 'ioredis'; -import chalk from 'chalk'; - -const REDIS_URL = process.env.REDIS_URL; - -if (!REDIS_URL) { - console.error(chalk.red('Error: REDIS_URL environment variable is not set.')); - process.exit(1); -} - -const redisOptions: RedisOptions = { - maxRetriesPerRequest: 3, - enableReadyCheck: true, - retryStrategy(times: number): number | null { - const delay = Math.min(times * 50, 2000); // Exponential backoff capped at 2s - console.warn(chalk.yellow(`Redis connection lost. Retrying in ${delay}ms... (Attempt ${times})`)); - return delay; - }, -}; - -export const redisClient = new Redis(REDIS_URL, redisOptions); - -redisClient.on('connect', () => { - console.log(chalk.green('Connected to Redis server.')); -}); - -redisClient.on('ready', () => { - console.log(chalk.cyan('Redis client is ready.')); -}); - -redisClient.on('error', (err: Error) => { - console.error(chalk.red('Redis client error:'), err); - // Depending on the error, you might want to implement more specific handling - // For critical errors (like auth failure), you might want to exit. - // if (err.message.includes('AUTH')) { process.exit(1); } -}); - -redisClient.on('close', () => { - console.log(chalk.magenta('Redis connection closed.')); -}); - -redisClient.on('reconnecting', (timeToReconnect: number) => { - console.log(chalk.yellow(`Redis reconnecting in ${timeToReconnect}ms...`)); -}); - -redisClient.on('end', () => { - console.log(chalk.gray('Redis client connection has ended. (No more reconnections will be attempted)')); -}); - -// Wrapper functions for common operations with error handling - -/** - * Set a key with a value and an expiry time (TTL) in seconds. - * Handles JSON serialization. - */ -export async function setWithTTL(key: string, value: unknown, ttlSeconds: number): Promise { - try { - const serializedValue = JSON.stringify(value); - const result = await redisClient.set(key, serializedValue, 'EX', ttlSeconds); - return result === 'OK'; - } catch (error) { // Catch Redis errors and serialization errors - console.error(chalk.red(`Error setting key ${key} with TTL ${ttlSeconds}s:`), error); - return false; - } -} - -/** - * Get the value of a key. Handles JSON deserialization. - * Returns null if key doesn't exist or on error. - */ -export async function get(key: string): Promise { - try { - const result = await redisClient.get(key); - if (result === null) { - return null; // Key doesn't exist or expired - } - return JSON.parse(result); - } catch (error) { // Catch Redis errors and deserialization errors - console.error(chalk.red(`Error getting key ${key}:`), error); - return null; - } -} - -/** - * Delete a key. - * Returns the number of keys deleted (0 or 1). - */ -export async function del(key: string): Promise { - try { - return await redisClient.del(key); - } catch (error) { - console.error(chalk.red(`Error deleting key ${key}:`), error); - return 0; // Indicate failure - } -} - -/** - * Set the expiry time (TTL) in seconds for an existing key. - */ -export async function expire(key: string, ttlSeconds: number): Promise { - try { - const result = await redisClient.expire(key, ttlSeconds); - return result === 1; - } catch (error) { - console.error(chalk.red(`Error setting expiry for key ${key}:`), error); - return false; - } -} - -// Graceful shutdown -process.on('SIGINT', async () => { - console.log(chalk.blue('\nGracefully shutting down Redis client...')); - await redisClient.quit(); - console.log(chalk.blue('Redis client disconnected.')); - process.exit(0); -}); - -process.on('SIGTERM', async () => { - console.log(chalk.blue('Received SIGTERM. Gracefully shutting down Redis client...')); - await redisClient.quit(); - console.log(chalk.blue('Redis client disconnected.')); - process.exit(0); -}); diff --git a/src/transaction-manager/package.json b/src/transaction-manager/package.json deleted file mode 100644 index 36d12ff..0000000 --- a/src/transaction-manager/package.json +++ /dev/null @@ -1,49 +0,0 @@ -{ - "name": "@waldzellai/transaction-manager", - "version": "0.1.0", - "description": "MCP meta-server for managing stateful interactions via transaction tokens", - "license": "MIT", - "type": "module", - "repository": { - "type": "git", - "url": "https://github.com/waldzellai/model-enhancement-servers.git", - "directory": "src/transaction-manager" - }, - "publishConfig": { - "access": "public" - }, - "homepage": "https://github.com/waldzellai/model-enhancement-servers/tree/main/src/transaction-manager", - "author": "glassBead", - "keywords": [ - "mcp", - "model-context-protocol", - "transaction-manager", - "stateful", - "redis" - ], - "bin": { - "mcp-server-transaction-manager": "dist/index.js" - }, - "files": [ - "dist" - ], - "scripts": { - "build": "tsc && shx chmod +x dist/*.js", - "watch": "tsc --watch" - }, - "dependencies": { - "@modelcontextprotocol/sdk": "^1.10.2", - "chalk": "^5.3.0", - "ioredis": "^5.4.1", - "redis-server": "^1.2.2", - "uuid": "^9.0.1", - "yargs": "^17.7.2" - }, - "devDependencies": { - "@types/node": "^22", - "@types/uuid": "^9.0.8", - "@types/yargs": "^17.0.32", - "shx": "^0.3.4", - "typescript": "^5.3.3" - } -} diff --git a/src/transaction-manager/server.ts b/src/transaction-manager/server.ts deleted file mode 100644 index 38a4adf..0000000 --- a/src/transaction-manager/server.ts +++ /dev/null @@ -1,196 +0,0 @@ -import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; -import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; -import { CallToolResult, McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"; -import { z } from 'zod'; -import chalk from 'chalk'; -import { v4 as uuidv4 } from 'uuid'; -import { redisClient, setWithTTL, get, del, expire } from './lib/redis-helper.js'; - -// -- Zod Schema for Input Validation -- -const TxnRequestSchema = z.object({ - action: z.enum(['start', 'resume', 'close']), - token: z.string().optional(), - payload: z.any().optional(), // Keep as any for flexibility - ttlSeconds: z.number().int().positive().optional(), -}); - -// Infer the type from the Zod schema -type TxnRequestArgs = z.infer; - -// -- Types for Response Payload (unchanged) -- - -export type TxnAction = 'start' | 'resume' | 'close'; // Keep for clarity if used elsewhere - -export type TxnResponse = { - status: 'pending' | 'complete' | 'closed' | 'error'; - token: string; - payload?: unknown; - expiresAt?: string | null; - error?: string; -}; - -// -- Constants (unchanged) -- - -const DEFAULT_TTL_SECONDS = 3600; // 1 hour -const MAX_TTL_SECONDS = 86400; // 24 hours -const TOKEN_PREFIX = 'txn:'; - -// -- Helper Functions (unchanged) -- - -function generateToken(): string { - return TOKEN_PREFIX + uuidv4(); -} - -function calculateExpiry(ttlSeconds: number): string { - return new Date(Date.now() + ttlSeconds * 1000).toISOString(); -} - -// -- Main Handler Logic (Refactored) -- - -async function handleTransactionCallback(args: TxnRequestArgs): Promise { - const { action, token: requestToken, payload, ttlSeconds: requestTtl } = args; - let effectiveTtl = Math.min(requestTtl ?? DEFAULT_TTL_SECONDS, MAX_TTL_SECONDS); - if (effectiveTtl <= 0) effectiveTtl = DEFAULT_TTL_SECONDS; - - try { - let responsePayload: TxnResponse; - - switch (action) { - case 'start': { - // Validation (moved from generic handler) - if (requestToken) { - throw new McpError(ErrorCode.InvalidParams, 'Token should not be provided for the "start" action.'); - } - const newToken = generateToken(); - const setResult = await setWithTTL(newToken, payload ?? {}, effectiveTtl); - if (!setResult) throw new Error('Failed to set initial state in Redis.'); - responsePayload = { - status: 'pending', - token: newToken, - payload: payload ?? {}, - expiresAt: calculateExpiry(effectiveTtl), - }; - break; - } - - case 'resume': { - if (!requestToken) { - // This validation is technically covered by McpServer if schema requires it, - // but explicit check remains useful if schema makes token optional. - throw new McpError(ErrorCode.InvalidParams, 'Token is required for the "resume" action.'); - } - const currentPayload = await get(requestToken); - if (currentPayload === null) { - throw new McpError(ErrorCode.InvalidParams, `Transaction token "${requestToken}" not found or expired.`); - } - - let finalPayload = currentPayload; - if (payload !== undefined) { - await setWithTTL(requestToken, payload, effectiveTtl); - finalPayload = payload; - } else { - await expire(requestToken, effectiveTtl); - } - - responsePayload = { - status: 'pending', - token: requestToken, - payload: finalPayload, - expiresAt: calculateExpiry(effectiveTtl), - }; - break; - } - - case 'close': { - if (!requestToken) { - throw new McpError(ErrorCode.InvalidParams, 'Token is required for the "close" action.'); - } - const deleteResult = await del(requestToken); - if (deleteResult === 0) { - console.warn(chalk.yellow(`Attempted to close non-existent or already closed token: ${requestToken}`)); - } - responsePayload = { - status: 'closed', - token: requestToken, - payload: undefined, - expiresAt: null, - }; - break; - } - - // No default needed as zod schema handles invalid actions - } - - // Return successful result - return { - content: [{ type: 'text', text: JSON.stringify(responsePayload) }] - }; - - } catch (error: any) { - console.error(chalk.red('Error handling transaction:'), error); - // Return error result - const errorPayload: TxnResponse = { - status: 'error', - token: requestToken ?? 'unknown', - error: error instanceof McpError ? error.message : (error.message || 'An unexpected server error occurred.'), - expiresAt: null, - }; - const errorMessage = errorPayload.error; - return { - content: [{ - type: 'text', - text: JSON.stringify(errorPayload) - }, { - type: 'text', // Also include plain text error - text: errorMessage ?? 'Unknown error' // Ensure text is always string - }], - isError: true, - }; - } -} - -// -- Server Initialization (Refactored) -- - -export async function runServer(): Promise { - const mcpServer = new McpServer( - { - name: 'transaction-manager', - version: '0.1.1', // Updated version - } - ); - - // Register the single tool - mcpServer.tool( - "transaction", - "Manages simple stateful transactions (start, resume, close)", - TxnRequestSchema.shape, // Pass the shape for Zod validation - handleTransactionCallback - ); - - // Connect using stdio - const transport = new StdioServerTransport(); - try { - await mcpServer.connect(transport); - console.error(chalk.green('Transaction Manager MCP Server running on stdio.')); // Use console.error for logs - } catch (error) { - console.error(chalk.red('Failed to connect Transaction Manager server:'), error); - process.exit(1); - } -} - -// Optional: Add main execution block if this file is run directly -// Example using yargs (ensure yargs is installed and imported) -/* -import yargs from 'yargs'; -import { hideBin } from 'yargs/helpers'; - -if (require.main === module) { // Check if running as main script - const argv = yargs(hideBin(process.argv)) - .parseSync(); - - runServer().catch((error) => { - console.error(chalk.red("Fatal error running server:"), error); - process.exit(1); - }); -} -*/ diff --git a/src/transaction-manager/tsconfig.json b/src/transaction-manager/tsconfig.json deleted file mode 100644 index 4f34a90..0000000 --- a/src/transaction-manager/tsconfig.json +++ /dev/null @@ -1,27 +0,0 @@ -{ - "extends": "../../tsconfig.json", - "compilerOptions": { - "baseUrl": "../..", - "paths": { - "@modelcontextprotocol/sdk": [ - "node_modules/@modelcontextprotocol/sdk/dist/index.d.ts" - ], - "@modelcontextprotocol/sdk/*": [ - "node_modules/@modelcontextprotocol/sdk/dist/*" - ] - }, - // "moduleResolution": "Node", // Removed override - "outDir": "./dist", - "rootDir": ".", - "skipLibCheck": true - }, - "include": [ - "index.ts", - "server.ts", - "lib/**/*.ts" - ], - "exclude": [ - "node_modules", - "dist" - ] -} diff --git a/ulysses-protocol-walkthrough.md b/ulysses-protocol-walkthrough.md new file mode 100644 index 0000000..c426e31 --- /dev/null +++ b/ulysses-protocol-walkthrough.md @@ -0,0 +1,38 @@ +### Ulysses Protocol walkthrough + +State Step 0 + + - Make a plan for State Step 1 and State Step 2 + - Set an expectation for each state step's outcomes + - if State Step 1 goes how we expect, the codebase state we would expect is...[] + - if State Step 1 does not go how we expect, and we move to Step 2, the codebase state we would expect is...[] + +State Step 1 + + - Put SS1 plan into action --> + - Evaluate our outcome + - if State Step 1 outcome == expectation --> SS1 = SS0 + - if State Step 1 outcome != expectation --> SS2 + +State Step 2 + + - Put SS2 plan into action --> + - Evaluate our outcome + - if SS2 outcome == expectation --> SS2 = SS0 + - if SS2 outcome != expectation --> PAUSE -> ORIGINAL SS0 + +PAUSE + + - CONSIDERATION (reasoning about why our outcomes did not match expectation) + - theorize about why previous turn of 2 steps was not successful + - add an entry to state documenting the 2 steps that did not work + - make a new plan for State Step 1 and State Step 2 + - if State Step 1 goes how we expect, the codebase state we would expect is...[] + - if State Step 1 does not go how we expect, and we move to Step 2, the codebase state we would expect is...[] + +CHECKPOINTS + + - are spots in the stepwise Ulysses workflow that human user/agent infer are good places to come back to if failure happens later in the workflow. + - example: after a full subtask is completed, after a stubborn bug is overcome, etc. + - these are stored in JSON state object + - agent/user can come back to these points at any time if a PAUSE is reached \ No newline at end of file